Retour au Blog
Identité

Gestion des cookies avec BotBrowser

Apprenez à gérer les cookies dans BotBrowser pour la persistance des sessions, la continuité entre sessions et l'isolation par identité en utilisant l'option --bot-cookies.

Introduction

Les cookies sont au cœur du maintien de l'état par les navigateurs. Ils transportent des jetons de session, des préférences utilisateur, des enregistrements de consentement et des informations d'authentification entre les chargements de pages et les visites. Lors de la création de profils de navigateur pour la recherche en matière de confidentialité, les tests ou la gestion multi-comptes, le contrôle de la couche des cookies est aussi important que le contrôle de la couche d'empreinte (fingerprint). Un navigateur avec une empreinte cohérente mais sans cookies ressemble à une installation fraîche à chaque fois, ce qui n'est pas le comportement réel des navigateurs.

BotBrowser fournit l'option --bot-cookies (niveau PRO) pour précharger les cookies au lancement. Cela signifie que les cookies sont présents avant la première navigation, avant toute exécution JavaScript et avant que les scripts de suivi ne puissent inspecter l'état du navigateur. Associée aux profils d'empreinte et autres signaux d'identité, la gestion des cookies complète l'image d'une identité de navigateur réaliste et persistante.

Impact sur la confidentialité : pourquoi la gestion des cookies est importante

Les sites et les systèmes de suivi n'évaluent pas les cookies isolément ; ils examinent la relation entre les cookies et les autres signaux du navigateur. Un navigateur présentant l'empreinte d'un utilisateur récurrent mais sans cookies suscite des soupçons. De même, un navigateur avec des cookies de session mais une empreinte entièrement nouvelle paraît incohérent.

Pour les chercheurs en confidentialité qui étudient comment les systèmes de suivi corrèlent les signaux du navigateur, contrôler les cookies est essentiel. Cela permet de tester si un système de suivi relie les sessions uniquement sur la base des cookies, uniquement sur la base de l'empreinte, ou sur une combinaison des deux. Pour la gestion multi-comptes, chaque identité a besoin de son propre magasin de cookies persistant entre les sessions pour maintenir l'état de connexion et éviter des flux d'authentification répétés.

La gestion des cookies est également importante pour tester les bannières de consentement, les flux de conformité GDPR et le comportement des sites pour les visiteurs récurrents vs nouveaux. Sans préchargement des cookies, chaque session commence en tant que "nouveau visiteur", rendant impossible le test des expériences pour les utilisateurs revenants.

Contexte technique

Comment les navigateurs stockent les cookies

Chromium stocke les cookies dans une base SQLite située dans le répertoire de données utilisateur. Au démarrage, le navigateur charge ces cookies depuis la base vers la mémoire. Chaque cookie possède plusieurs attributs :

  • Domain et Path : déterminent quelles requêtes incluent le cookie
  • Name et Value : les données réelles du cookie
  • Expiration : quand le cookie doit être supprimé (les cookies de session n'ont pas d'expiration)
  • Secure flag : si le cookie n'est envoyé que via HTTPS
  • HttpOnly flag : si JavaScript peut accéder au cookie
  • SameSite : contrôle le comportement cross-site (Strict, Lax ou None)

Lorsque la page se charge, le navigateur attache les cookies correspondants à chaque requête HTTP. Le JavaScript de la page peut également lire/écrire les cookies via document.cookie, sous réserve des restrictions HttpOnly.

Le problème de synchronisation

La plupart des frameworks d'automatisation fournissent la gestion des cookies via leurs APIs. Playwright propose context.addCookies() et Puppeteer page.setCookie(). Cependant, ces méthodes ajoutent des cookies après la création du contexte ou de la page du navigateur. Ainsi, les toutes premières requêtes réseau, y compris le chargement initial et les requêtes de préflight, sont émises sans ces cookies.

Ce décalage temporel est important car certains systèmes de suivi inspectent la requête initiale pour la présence de cookies. Si la première requête est sans cookies mais que les suivantes en contiennent, l'incohérence sera visible dans les logs serveur.

L'option --bot-cookies de BotBrowser résout ce problème en injectant les cookies avant l'initialisation du contexte, les rendant disponibles dès la première requête.

Approches courantes et leurs limites

APIs de cookies au niveau du framework

Playwright et Puppeteer offrent la gestion des cookies via leur API. Elles fonctionnent pour de nombreux cas, mais présentent des limites :

  1. Temporisation tardive : les cookies ajoutés via l'API du framework ne sont disponibles qu'après la création du contexte ou de la page, manquant ainsi le chargement initial
  2. Portée par contexte : les cookies sont liés au contexte du navigateur, pas à l'instance. Plusieurs contextes dans la même instance ne partagent pas les cookies sauf configuration explicite
  3. Différences de format : chaque framework utilise un format d'objet cookie légèrement différent, rendant le partage entre outils plus difficile

Persistance manuelle du répertoire de données utilisateur

Une autre approche est de réutiliser le même --user-data-dir entre sessions. Cela préserve automatiquement les cookies (stockés dans SQLite), mais conserve aussi tout l'état : cache, localStorage, IndexedDB, service workers et historique. Cette approche n'offre pas de contrôle granulaire sur les états à préserver ou réinitialiser.

Extensions de cookies

Les extensions peuvent gérer les cookies, mais elles opèrent à un niveau de privilège inadapté pour l'automatisation. Elles ne peuvent pas injecter les cookies avant la première charge de page, et leur présence est elle-même détectable.

Approche de BotBrowser

BotBrowser implémente le préchargement des cookies au niveau du moteur via --bot-cookies. Cette conception présente plusieurs avantages par rapport aux alternatives.

Injection au niveau moteur

Les cookies chargés via --bot-cookies sont insérés dans le magasin de cookies du navigateur pendant l'initialisation, avant la création de tout contexte et avant le chargement des pages. Cela signifie :

  • La première requête HTTP vers n'importe quel domaine porte déjà les cookies appropriés
  • Le JavaScript exécuté au chargement de la page peut lire les cookies via document.cookie
  • Les systèmes de suivi côté serveur voient une présence cohérente de cookies dès la première requête

Formats d'entrée flexibles

L'option --bot-cookies accepte les données de cookies de deux manières :

JSON inline pour de petits jeux de cookies ou une génération dynamique :

--bot-cookies='[{"name":"session","value":"abc123","domain":".example.com"}]'

Référence fichier avec le préfixe @ pour des jeux plus volumineux :

--bot-cookies="@/path/to/cookies.json"

Le fichier doit contenir un tableau JSON d'objets cookie.

Isolation par identité

Chaque instance BotBrowser exécute son propre magasin de cookies. En associant différents fichiers de cookies à différents profils d'empreinte, vous créez des identités de navigateur entièrement isolées où à la fois l'empreinte et les cookies sont indépendants.

Configuration et utilisation

Utilisation CLI basique

# Charger des cookies depuis un fichier
./chrome \
  --bot-profile=/path/to/profile.enc \
  --bot-cookies="@/path/to/cookies.json"

# Cookies inline
./chrome \
  --bot-profile=/path/to/profile.enc \
  --bot-cookies='[{"name":"consent","value":"granted","domain":".example.com"}]'

Intégration Playwright

const { chromium } = require('playwright-core');

(async () => {
  const browser = await chromium.launch({
    executablePath: '/path/to/botbrowser/chrome',
    args: [
      '--bot-profile=/path/to/profile.enc',
      '--bot-cookies=@/path/to/cookies.json',
    ],
    headless: true,
  });

  const context = await browser.newContext();
  const page = await context.newPage();
  await page.goto('https://example.com');

  // Les cookies sont déjà présentes dès la première requête
  const cookies = await context.cookies();
  console.log('Active cookies:', cookies.length);
  await browser.close();
})();

Isolation des cookies par identité

async function createIdentity(profilePath, cookiesPath) {
  return chromium.launch({
    executablePath: '/path/to/botbrowser/chrome',
    args: [
      `--bot-profile=${profilePath}`,
      `--bot-cookies=@${cookiesPath}`,
    ],
    headless: true,
  });
}

const userA = await createIdentity('/profiles/user-a.enc', '/cookies/user-a.json');
const userB = await createIdentity('/profiles/user-b.enc', '/cookies/user-b.json');

Exporter les cookies pour la persistance de session

Sauvegardez les cookies à la fin de chaque session et rechargez-les au démarrage suivant :

// À la fin d'une session
const cookies = await context.cookies();
const fs = require('fs');
fs.writeFileSync('/cookies/user-a.json', JSON.stringify(cookies, null, 2));

// Session suivante : lancer avec --bot-cookies=@/cookies/user-a.json

Vérification

Après avoir lancé avec --bot-cookies, vérifiez que les cookies sont bien chargés :

const page = await context.newPage();

// Vérifier que les cookies sont présents avant toute navigation
const cookies = await context.cookies('https://example.com');
console.log('Pre-loaded cookies:', cookies.map(c => c.name));

// Naviguer et vérifier que les cookies sont envoyés avec la requête
await page.goto('https://example.com');

// Cookies accessibles depuis JavaScript
const jsCookies = await page.evaluate(() => document.cookie);
console.log('JS-visible cookies:', jsCookies);

Vous pouvez également inspecter les en-têtes de la requête initiale via l'interception réseau pour confirmer que les cookies sont inclus dès la première requête.

Cookie Loading Timeline --bot-cookies Engine init Context created Cookies ready First request Cookies sent addCookies() Too late --bot-cookies loads before context. Framework APIs load after.

Bonnes pratiques

  • Conservez des fichiers de cookies par identité. Ne partagez pas un fichier de cookies entre différents profils d'empreinte.
  • Définissez des dates d'expiration réalistes. Les expirations lointaines correspondent au comportement normal d'un navigateur ; évitez les dates passées.
  • Incluez les cookies de consentement courants. Les jetons de consentement GDPR empêchent l'apparition du bandeau à chaque visite, reproduisant le comportement d'un utilisateur récurrent.
  • Faites tourner les cookies en même temps que les profils. Lors de la rotation des profils d'empreinte, mettez à jour l'ensemble de cookies pour correspondre à la nouvelle identité.
  • Utilisez correctement HttpOnly et Secure. Adaptez les flags à ce que le site définit réellement via Set-Cookie.
  • Utilisez le préfixe @ pour les chemins de fichier. Garde la commande de lancement propre quand vous traitez beaucoup de cookies.

Questions fréquentes

Quel format accepte --bot-cookies ?

L'option accepte un tableau JSON d'objets cookie. Chaque objet doit contenir au minimum name, value et domain. Les champs optionnels incluent path, expirationDate, secure, httpOnly et sameSite. Vous pouvez passer le JSON inline ou référencer un fichier avec @.

Quand les cookies sont-ils disponibles par rapport au chargement de la page ?

Les cookies chargés via --bot-cookies sont disponibles avant la première navigation. Ils sont présents lors de l'initialisation du navigateur, de sorte que même la toute première requête HTTP les portera.

Puis-je combiner --bot-cookies avec context.addCookies() de Playwright ?

Oui. --bot-cookies charge d'abord les cookies pendant l'initialisation. Vous pouvez ajouter des cookies supplémentaires ensuite avec context.addCookies() si nécessaire.

Comment exporter les cookies pour les réutiliser dans la session suivante ?

À la fin de la session, utilisez l'API de votre framework pour lire les cookies (par exemple context.cookies() dans Playwright), sauvegardez le résultat en JSON, puis passez-le à --bot-cookies au prochain lancement.

--bot-cookies fonctionne-t-il avec plusieurs contextes ?

Les cookies chargés par --bot-cookies sont disponibles pour tous les contextes au sein de l'instance du navigateur. Si vous avez besoin de cookies distincts par contexte, utilisez les APIs par contexte du framework.

Quel niveau est requis pour --bot-cookies ?

L'option --bot-cookies est disponible au niveau PRO.

Puis-je combiner --bot-cookies avec d'autres flags d'identité ?

Oui. Combiner --bot-cookies avec --bot-bookmarks, --bot-inject-random-history et des flags de locale/zone horaire crée une identité de navigateur complète et cohérente.

Résumé

La gestion des cookies avec --bot-cookies complète la couche d'identité dans BotBrowser en assurant que les cookies sont présents dès la première requête. Combiné aux profils d'empreinte et aux autres flags d'identité, il permet de créer des sessions de navigateur qui conservent un état cohérent à tous les niveaux.

Pour les sujets liés, voir Multi-Account Isolation, Proxy Configuration et Profile Management.

title: "Gestion des cookies avec BotBrowser" description: "Decouvrez comment gerer les cookies dans BotBrowser pour la persistance des sessions et l'isolation par contexte avec le flag --bot-cookies et Playwright." date: "2025-11-11" locale: fr category: identity tags: ["cookies", "management", "identity", "session", "privacy"] published: true

Le flag --bot-cookies

BotBrowser fournit le flag --bot-cookies (ENT Tier1) pour injecter des cookies au demarrage, vous donnant un controle total sur l'etat de session avant le premier chargement de page.

./chrome \
  --bot-profile=/path/to/profile.enc \
  --bot-cookies=/path/to/cookies.json

Format du fichier de cookies

[
  {
    "domain": ".example.com",
    "path": "/",
    "name": "session_id",
    "value": "abc123def456",
    "expirationDate": 1774000000,
    "secure": true,
    "httpOnly": true,
    "sameSite": "Lax"
  }
]

Les cookies sont disponibles immediatement au demarrage du navigateur, avant toute navigation.

Exemple Playwright

const { chromium } = require('playwright-core');

(async () => {
  const browser = await chromium.launch({
    executablePath: '/path/to/botbrowser/chrome',
    args: [
      '--bot-profile=/path/to/profile.enc',
      '--bot-cookies=/path/to/cookies.json',
    ],
    headless: true,
  });

  const context = await browser.newContext();
  const page = await context.newPage();
  await page.goto('https://example.com');

  const cookies = await context.cookies();
  console.log('Cookies actifs:', cookies.length);
  await browser.close();
})();

Isolation des cookies par identite

async function createIdentity(profilePath, cookiesPath) {
  return chromium.launch({
    executablePath: '/path/to/botbrowser/chrome',
    args: [
      `--bot-profile=${profilePath}`,
      `--bot-cookies=${cookiesPath}`,
    ],
    headless: true,
  });
}

const userA = await createIdentity('/profiles/user-a.enc', '/cookies/user-a.json');
const userB = await createIdentity('/profiles/user-b.enc', '/cookies/user-b.json');

Export des cookies pour la persistance

const cookies = await context.cookies();
const fs = require('fs');
fs.writeFileSync('/cookies/user-a.json', JSON.stringify(cookies, null, 2));

Bonnes pratiques

  • Garder des fichiers de cookies par identite. Ne pas partager entre differents profils.
  • Definir des dates d'expiration realistes.
  • Inclure les cookies de consentement courants.
  • Faire tourner les cookies avec les profils.

Etapes suivantes

#cookies#management#identity#session#privacy