Réseau25 mars 2026

Per-Context Proxy : une identite reseau independante pour chaque contexte de navigateur

Configurez un proxy et une identite geographique independants par BrowserContext. Executez plusieurs regions dans une seule instance de navigateur avec alignement automatique du fuseau horaire, de la locale et de la langue.

Introduction

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.

Contexte technique

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.

Configuration

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',
    '--proxy-bypass-list=localhost;127.0.0.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.

Routage selectif avec proxy-bypass-rgx

Utilisez --proxy-bypass-rgx pour router des URLs specifiques directement au lieu de passer par le proxy. Cela reduit la bande passante proxy sur les ressources statiques ou les services internes :

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-bypass-list=localhost;127.0.0.1',
    '--proxy-bypass-rgx=\\.(js|css|png|jpg|svg)(\\?|$)',
  ],
});

--proxy-bypass-list utilise la liste d'hotes standard Chromium separee par des points-virgules. --proxy-bypass-rgx utilise la syntaxe regex RE2 et correspond au nom d'hote et au chemin URL.

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 page.createCDPSession();

// 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;
});

Les processus partages economisent les ressources

Per-context proxy au sein d'une seule instance du navigateur partage le processus GPU, le processus du navigateur et les processus utilitaires. Compare au lancement d'instances separees du navigateur pour chaque proxy, cette approche economise :

Ressource	Instances separees (10 proxies)	Per-Context (10 contextes)
Processus navigateur	10	1
Processus GPU	10	1
Processus reseau	10	1
Surcharge memoire de base	~500 Mo	~50 Mo
Temps de creation de contexte	1-3 secondes chacun	Millisecondes chacun

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
}

Verification

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 frequentes

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 ? Il n'y a pas de limite stricte. Chaque contexte consomme de la memoire proportionnellement a ses pages ouvertes et ressources en cache. En pratique, des dizaines ou centaines de contextes peuvent s'executer dans une seule instance du navigateur avec suffisamment de RAM.

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.

Puis-je utiliser des regles de contournement differentes par contexte ? Oui. --proxy-bypass-list et --proxy-bypass-rgx peuvent etre configures par contexte via botbrowserFlags.

Resume

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 et les details de protocole, consultez Configuration Proxy. Pour le changement de proxy en temps reel dans les contextes existants, consultez Changement Dynamique de Proxy. Pour l'isolation complete multi-identite, consultez Isolation Navigateur Multi-Compte. Pour la protection contre les fuites DNS et WebRTC dans tous les contextes, combinez avec Prevention des Fuites DNS et Prevention des Fuites WebRTC.

#proxy#per-context#network#isolation#geographic-identity#multi-region