Per-Context Proxy : reseau independant par navigateur

Propriété réseau par contexte

Lorsque vous executez plusieurs identites ou workflows regionaux dans un navigateur, un seul proxy pour toute la session ne suffit pas. Si chaque contexte partage la meme adresse IP, le trafic de differentes identites peut etre lie par ce chemin reseau partage. Les systemes de suivi observent les motifs IP, et deux comptes provenant de la meme adresse a des moments similaires sont faciles a correler.

Per-context proxy resout ce probleme en assignant un proxy dedie a chaque BrowserContext. Chaque contexte s'achemine via un serveur proxy different, recoit sa propre IP publique et obtient des metadonnees geographiques (fuseau horaire, locale, langue) derivees de l'emplacement de sortie du proxy. Combine avec l'isolation d'empreinte par contexte, chaque contexte devient une identite completement independante sans signaux de reseau ou d'empreinte partages.

Cet article couvre le fonctionnement de per-context proxy dans BotBrowser, comment le configurer dans Puppeteer et Playwright, et comment optimiser les performances pour les deployments multiregionaux.

Impact sur la vie privee

Un seul proxy cree une identite reseau partagee entre tous les contextes. Meme avec des profils d'empreinte differents, l'IP partagee devient un point de correlation. Considerez ces risques :

• Correlation basee sur l'IP : deux comptes accedant au meme service depuis la meme IP peuvent etre lies, independamment des differences d'empreinte
• Inconsistance geographique : un contexte configure avec un profil d'empreinte allemand mais achemine via un proxy americain cree une discordance evidente entre l'emplacement declare et l'origine reseau
• Analyse temporelle : plusieurs identites partageant un proxy peuvent etre correlees par leurs motifs de temporalite de trafic, car toutes les requetes proviennent du meme point de reseau

Per-context proxy elimine ces risques. Chaque contexte a son propre proxy, sa propre IP publique et ses propres metadonnees geographiques. Il n'y a aucun signal reseau partage entre les contextes.

Modèle réseau du contexte

Isolation reseau au niveau BrowserContext

Dans Chromium, un BrowserContext est un environnement de navigation isole. Chaque contexte possede son propre conteneur de cookies, localStorage, sessionStorage, IndexedDB et cache. Chromium standard fournit cette isolation de stockage nativement.

BotBrowser etend cette isolation a la couche reseau. Lorsqu'un BrowserContext recoit son propre proxy, tout le trafic HTTP, HTTPS et WebSocket de ce contexte est achemine via le serveur proxy specifie. Les autres contextes dans la meme instance du navigateur ne sont pas affectes. C'est une veritable isolation reseau au niveau du contexte, pas un intercepteur au niveau de la page qui peut manquer les premieres requetes ou les connexions WebSocket.

Detection geographique automatique

Lorsqu'un contexte se connecte via un proxy, BotBrowser detecte l'IP de sortie du proxy et derive automatiquement les parametres geographiques pour ce contexte specifique :

• Fuseau horaire : derive de la geolocalisation de l'IP du proxy (par exemple, America/New_York pour un proxy sur la cote est des Etats-Unis)
• Locale : correspond au pays du proxy (par exemple, en-US)
• Langues : definies en fonction de la region du proxy (par exemple, en-US,en)
• Geolocalisation : coordonnees approximees a partir de l'IP

Cela se produit independamment pour chaque contexte. Un contexte avec proxy americain recoit des parametres geographiques americains, tandis qu'un contexte avec proxy allemand dans le meme navigateur recoit des parametres allemands. Aucune configuration manuelle du fuseau horaire, de la locale ou de la langue n'est necessaire.

Integration avec l'empreinte par contexte

Per-context proxy fonctionne en combinaison avec l'isolation d'empreinte par contexte de BotBrowser (ENT Tier3). Chaque contexte peut recevoir :

• Un profil d'empreinte unique via --bot-profile
• Un proxy et une IP publique independants
• Des metadonnees geographiques correspondantes derivees du proxy
• Un stockage isole (cookies, localStorage, IndexedDB)

La combinaison signifie que chaque contexte est une identite completement independante. Aucun signal d'empreinte, chemin reseau ou stockage n'est partage entre les contextes.

Attribuer une route

Puppeteer : Configuration multiregionale

Dans Puppeteer, per-context proxy est configure via CDP (Chrome DevTools Protocol). Vous creez un BrowserContext, assignez les parametres proxy et le profil d'empreinte via BotBrowser.setBrowserContextFlags, puis creez des pages dans ce contexte.

const puppeteer = require('puppeteer-core');

const browser = await puppeteer.launch({
  executablePath: process.env.BOTBROWSER_EXEC_PATH,
  headless: true,
  defaultViewport: null,
  args: ['--bot-profile=path/to/default-profile.enc'],
});

const client = await browser.target().createCDPSession();

// Contexte US avec proxy US
const usCtx = await browser.createBrowserContext({
  proxyServer: 'socks5://user:pass@us-proxy.example.com:1080',
});
await client.send('BotBrowser.setBrowserContextFlags', {
  browserContextId: usCtx._contextId,
  botbrowserFlags: [
    '--bot-profile=path/to/us-profile.enc',
    '--proxy-ip=203.0.113.1',
  ],
});
const usPage = await usCtx.newPage();

// Contexte UK avec proxy UK
const ukCtx = await browser.createBrowserContext({
  proxyServer: 'socks5://user:pass@uk-proxy.example.com:1080',
});
await client.send('BotBrowser.setBrowserContextFlags', {
  browserContextId: ukCtx._contextId,
  botbrowserFlags: [
    '--bot-profile=path/to/uk-profile.enc',
    '--proxy-ip=198.51.100.1',
  ],
});
const ukPage = await ukCtx.newPage();

// Contexte DE avec proxy allemand
const deCtx = await browser.createBrowserContext({
  proxyServer: 'socks5://user:pass@de-proxy.example.com:1080',
});
await client.send('BotBrowser.setBrowserContextFlags', {
  browserContextId: deCtx._contextId,
  botbrowserFlags: [
    '--bot-profile=path/to/de-profile.enc',
    '--proxy-ip=192.0.2.1',
  ],
});
const dePage = await deCtx.newPage();

// Chaque contexte navigue avec son propre proxy et identite geographique
await Promise.all([
  usPage.goto('https://example.com'),
  ukPage.goto('https://example.com'),
  dePage.goto('https://example.com'),
]);

await browser.close();

Important : BotBrowser.setBrowserContextFlags doit etre appele avant de creer toute page dans ce contexte. Le processus du rendu lit ses flags au demarrage. Si une page existe deja, les nouveaux flags ne prendront pas effet.

Puppeteer : Proxy uniquement via botbrowserFlags

Vous pouvez egalement configurer le proxy entierement via botbrowserFlags, sans passer proxyServer a createBrowserContext :

const ctx = await browser.createBrowserContext();
await client.send('BotBrowser.setBrowserContextFlags', {
  browserContextId: ctx._contextId,
  botbrowserFlags: [
    '--bot-profile=path/to/profile.enc',
    '--proxy-server=socks5://user:pass@proxy.example.com:1080',
    '--proxy-ip=203.0.113.1',
  ],
});
const page = await ctx.newPage();

Cette approche configure tous les parametres du proxy (serveur, IP, regles de contournement) en un seul endroit.

Playwright : Proxy par contexte

Playwright fournit un support natif de proxy par contexte via browser.newContext() :

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

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

// Contexte US
const usContext = await browser.newContext({
  proxy: { server: 'socks5://us-proxy:1080', username: 'user', password: 'pass' },
});

// Contexte Allemagne
const deContext = await browser.newContext({
  proxy: { server: 'socks5://de-proxy:1080', username: 'user', password: 'pass' },
});

// Chaque contexte obtient automatiquement la config geographique de son proxy
const usPage = await usContext.newPage();
const dePage = await deContext.newPage();

await usPage.goto('https://example.com');
await dePage.goto('https://example.com');

BotBrowser derive automatiquement le fuseau horaire, la locale et la langue pour chaque contexte en fonction de l'IP de sortie de son proxy.

Ignorer la detection IP avec --proxy-ip

Le proxy de chaque contexte declenche une requete de detection IP pour determiner les parametres geographiques. Si vous connaissez deja l'IP de sortie du proxy, vous pouvez sauter cette etape avec --proxy-ip :

await client.send('BotBrowser.setBrowserContextFlags', {
  browserContextId: ctx._contextId,
  botbrowserFlags: [
    '--bot-profile=path/to/profile.enc',
    '--proxy-server=socks5://user:pass@proxy.example.com:1080',
    '--proxy-ip=203.0.113.1', // Ignorer la requete IP, utiliser cette IP pour la detection geo
  ],
});

Cela elimine la latence de requete IP par contexte, ce qui est particulierement benefique lors de la creation de nombreux contextes en sequence.

Paramètres régionaux dans la version actuelle

Chaque paramètre régional est résolu séparément. Un fuseau horaire, une locale, une langue ou une position explicite garde la priorité dans ce contexte. Les paramètres laissés sur auto suivent la route proxy du contexte. Vous pouvez ainsi fixer une valeur requise et garder les autres alignées sur la route.

Conservez l'attribution du proxy et les exceptions régionales dans le même dossier de déploiement. Créez un nouveau contexte après un changement et validez chaque contexte avec son propre plan de route.

Politique UDP par contexte

La politique de transport se décide elle aussi par contexte. --bot-udp-proxy indique si un contexte utilise le proxy UDP et HTTP/3, ce qui permet à plusieurs contextes partageant un profil de conserver des réponses différentes dans la même session :

--bot-udp-proxy=false   # valeur par défaut de la session
--bot-udp-proxy=true    # exception pour un contexte qui a besoin de HTTP/3

L'option sans valeur vaut true. Définissez la valeur par défaut sur la ligne de commande principale, puis remplacez-la pour un contexte donné via l'empreinte par contexte. Un contexte sans valeur propre suit la valeur par défaut, et la politique peut changer après la création du contexte.

Notez deux points dans le dossier de déploiement. La politique reste limitée au contexte qui la définit : restreindre une charge de travail ne retire pas HTTP/3 aux autres. Elle ne s'applique qu'aux profils disposant déjà du droit UDP, elle choisit donc entre des comportements approuvés au lieu d'ouvrir une nouvelle route. La politique UDP par contexte nécessite ENT Tier3.

Scenarios courants

Tests multiregionaux dans un seul navigateur

Executez des contextes US, UK et allemand simultanement dans une seule instance du navigateur. Chaque contexte recoit un proxy, un profil d'empreinte et une identite geographique differents :

const regions = [
  {
    name: 'US',
    proxy: 'socks5://user:pass@us.proxy.example.com:1080',
    ip: '203.0.113.1',
    profile: 'path/to/us-profile.enc',
  },
  {
    name: 'UK',
    proxy: 'socks5://user:pass@uk.proxy.example.com:1080',
    ip: '198.51.100.1',
    profile: 'path/to/uk-profile.enc',
  },
  {
    name: 'DE',
    proxy: 'socks5://user:pass@de.proxy.example.com:1080',
    ip: '192.0.2.1',
    profile: 'path/to/de-profile.enc',
  },
];

const client = await browser.target().createCDPSession();

for (const region of regions) {
  const ctx = await browser.createBrowserContext({
    proxyServer: region.proxy,
  });
  await client.send('BotBrowser.setBrowserContextFlags', {
    browserContextId: ctx._contextId,
    botbrowserFlags: [
      `--bot-profile=${region.profile}`,
      `--proxy-ip=${region.ip}`,
    ],
  });

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

  // Verifier l'identite geographique
  const tz = await page.evaluate(() =>
    Intl.DateTimeFormat().resolvedOptions().timeZone
  );
  const lang = await page.evaluate(() => navigator.language);
  console.log(`${region.name}: timezone=${tz}, language=${lang}`);
}

Per-Context : Profil different + proxy different

Chaque contexte peut utiliser un profil d'empreinte completement different. Un profil Windows avec proxy US et un profil macOS avec proxy UK, le tout dans un seul navigateur :

// Identite Windows + proxy US
const winCtx = await browser.createBrowserContext({
  proxyServer: 'socks5://user:pass@us-proxy.example.com:1080',
});
await client.send('BotBrowser.setBrowserContextFlags', {
  browserContextId: winCtx._contextId,
  botbrowserFlags: [
    '--bot-profile=path/to/windows-profile.enc',
    '--proxy-ip=203.0.113.1',
  ],
});

// Identite macOS + proxy UK
const macCtx = await browser.createBrowserContext({
  proxyServer: 'socks5://user:pass@uk-proxy.example.com:1080',
});
await client.send('BotBrowser.setBrowserContextFlags', {
  browserContextId: macCtx._contextId,
  botbrowserFlags: [
    '--bot-profile=path/to/macos-profile.enc',
    '--proxy-ip=198.51.100.1',
  ],
});

Changement de proxy en temps reel

Pour les scenarios necessitant de changer le proxy d'un contexte apres la creation (par exemple, rotation geographique au sein d'une session), utilisez BotBrowser.setBrowserContextProxy (ENT Tier3) :

const ctx = await browser.createBrowserContext();
const page = await ctx.newPage();
const client = await browser.target().createCDPSession(); // must use browser-level session

// Commencer avec un proxy US
await client.send('BotBrowser.setBrowserContextProxy', {
  browserContextId: ctx._contextId,
  proxyServer: 'socks5://user:pass@us-proxy.example.com:1080',
  proxyIp: '203.0.113.1',
});
await page.goto('https://example.com');

// Basculer vers un proxy UK en temps reel
await client.send('BotBrowser.setBrowserContextProxy', {
  browserContextId: ctx._contextId,
  proxyServer: 'socks5h://user:pass@uk-proxy.example.com:1080',
  proxyIp: '198.51.100.1',
  proxyBypassList: 'localhost;127.0.0.1',
  proxyBypassRgx: 'cdn\\.example\\.com|/static/',
});
await page.goto('https://example.co.uk');

// Basculer vers un proxy japonais
await client.send('BotBrowser.setBrowserContextProxy', {
  browserContextId: ctx._contextId,
  proxyServer: 'socks5://user:pass@jp-proxy.example.com:1080',
  proxyIp: '192.0.2.1',
});
await page.goto('https://example.jp');

Apres chaque changement, BotBrowser re-detecte les parametres geographiques et les applique au contexte. La mise a jour geographique prend effet lors de la prochaine navigation de cadre principal.

Optimisation des performances

Utiliser --proxy-ip pour reduire la surcharge de requetes

Lorsque vous connaissez l'IP de sortie de chaque proxy, passez toujours --proxy-ip. Sans cela, BotBrowser effectue une requete de detection IP pour chaque contexte lors de la premiere navigation. Avec plus de 10 contextes, ces requetes s'accumulent :

// Sans --proxy-ip : chaque contexte fait une requete de detection IP
// Avec --proxy-ip : la detection geo est instantanee, sans requete reseau
const contexts = proxies.map(async (proxy) => {
  const ctx = await browser.createBrowserContext({ proxyServer: proxy.server });
  await client.send('BotBrowser.setBrowserContextFlags', {
    browserContextId: ctx._contextId,
    botbrowserFlags: [
      '--bot-profile=path/to/profile.enc',
      `--proxy-ip=${proxy.knownIp}`,
    ],
  });
  return ctx;
});

Ressources partagées de la session

Les contextes d'une session réutilisent des ressources communes tout en séparant leurs données, leur profil et leur route proxy. Mesurez la capacité sûre avec des pages et des workers représentatifs.

Combiner avec l'empreinte par contexte

Lorsque vous assignez a la fois un proxy et un profil d'empreinte par contexte, chaque contexte devient une identite completement independante sans la surcharge d'instances separees du navigateur :

// Une seule instance du navigateur, 3 identites completes
const identities = [
  { profile: 'profiles/win-us.enc', proxy: 'socks5://us:1080', ip: '203.0.113.1' },
  { profile: 'profiles/mac-uk.enc', proxy: 'socks5://uk:1080', ip: '198.51.100.1' },
  { profile: 'profiles/linux-de.enc', proxy: 'socks5://de:1080', ip: '192.0.2.1' },
];

for (const id of identities) {
  const ctx = await browser.createBrowserContext({ proxyServer: id.proxy });
  await client.send('BotBrowser.setBrowserContextFlags', {
    browserContextId: ctx._contextId,
    botbrowserFlags: [
      `--bot-profile=${id.profile}`,
      `--proxy-ip=${id.ip}`,
    ],
  });
  // Chaque contexte : empreinte unique + proxy unique + geo unique = totalement independant
}

Validation de la version

Apres avoir configure per-context proxy, verifiez chaque contexte independamment :

async function verifyContext(context, label) {
  const page = await context.newPage();

  // Verifier l'IP publique
  await page.goto('https://httpbin.org/ip');
  const ipData = await page.evaluate(() => document.body.textContent);
  console.log(`[${label}] IP : ${ipData.trim()}`);

  // Verifier le fuseau horaire
  const tz = await page.evaluate(() =>
    Intl.DateTimeFormat().resolvedOptions().timeZone
  );
  console.log(`[${label}] Fuseau horaire : ${tz}`);

  // Verifier la langue
  const lang = await page.evaluate(() => navigator.language);
  console.log(`[${label}] Langue : ${lang}`);

  // Verifier la locale
  const locale = await page.evaluate(() =>
    Intl.NumberFormat().resolvedOptions().locale
  );
  console.log(`[${label}] Locale : ${locale}`);

  await page.close();
}

await verifyContext(usCtx, 'US');
await verifyContext(ukCtx, 'UK');
await verifyContext(deCtx, 'DE');

Confirmez que chaque contexte affiche une IP, un fuseau horaire et une locale differents correspondant a l'emplacement geographique du proxy.

Questions opérationnelles

Quel niveau de licence est requis pour per-context proxy ? Per-context proxy avec isolation d'empreinte necessite ENT Tier3. Le changement de proxy en temps reel via BotBrowser.setBrowserContextProxy necessite egalement ENT Tier3.

Puis-je utiliser Playwright pour per-context proxy ? Oui. Playwright supporte nativement le proxy par contexte via browser.newContext({ proxy: ... }). BotBrowser derive automatiquement les parametres geographiques pour chaque contexte Playwright.

setBrowserContextFlags doit-il etre appele avant de creer une page ? Oui. Le processus du rendu lit ses flags au demarrage. Si une page existe deja dans le contexte, les nouveaux flags ne s'appliqueront pas. L'ordre correct est : createBrowserContext -> setBrowserContextFlags -> newPage.

Puis-je changer le proxy d'un contexte apres sa creation ? Oui, via BotBrowser.setBrowserContextProxy (ENT Tier3). Cela permet le changement de proxy en temps reel sans recreer le contexte. Les parametres geographiques sont re-derives lors de la prochaine navigation de cadre principal.

Quels protocoles proxy sont supportes ? Tous les protocoles supportes par --proxy-server fonctionnent par contexte : socks5://, socks5h://, http://, https://. Tous supportent l'authentification integree (user:pass@host:port).

Combien de contextes peuvent s'executer simultanement ? Chaque contexte consomme de la mémoire selon ses pages et ses ressources. Définissez la capacité avec une charge représentative et gardez une réserve pour les pointes de navigation.

BotBrowser detecte-t-il automatiquement la geographie pour chaque contexte ? Oui. Chaque contexte avec un proxy different obtient une detection geographique independante. BotBrowser detecte l'IP de sortie et configure le fuseau horaire, la locale et la langue pour ce contexte specifique.

Que se passe-t-il si je ne configure pas --proxy-ip ? BotBrowser effectue une requete automatique de detection IP lors de la premiere navigation de chaque contexte. Cela fonctionne correctement mais ajoute une petite latence. Configurer --proxy-ip elimine cette requete.

Chaque contexte peut-il utiliser sa propre politique de route ? Oui. Attribuez les paramètres proxy documentés avec la configuration du contexte et validez ce contexte avec son plan de route.

Garder les contextes alignés

Per-context proxy fournit une isolation reseau complete pour chaque BrowserContext au sein d'une seule instance du navigateur. Chaque contexte s'achemine via son propre proxy, recoit une IP publique independante et obtient des metadonnees geographiques (fuseau horaire, locale, langue) automatiquement derivees de l'emplacement de sortie du proxy. Combine avec les profils d'empreinte par contexte, chaque contexte fonctionne comme une identite completement independante.

Pour les fondamentaux proxy, consultez Configuration Proxy. Pour le changement de proxy, consultez Changement Dynamique de Proxy. Pour l'isolation multi-identité, consultez Isolation Navigateur Multi-Compte. Consultez aussi Prevention des Fuites DNS et Prevention des Fuites WebRTC.