Red25 de marzo de 2026

Per-Context Proxy: Identidad de red independiente para cada contexto de navegador

Configura un proxy y una identidad geografica independiente por BrowserContext. Ejecuta multiples regiones en una sola instancia de navegador con alineacion automatica de zona horaria, locale e idioma.

Introduccion

Cuando se ejecutan multiples identidades o flujos de trabajo regionales en un navegador, un unico proxy para toda la sesion no es suficiente. Si cada contexto comparte la misma direccion IP, el trafico de diferentes identidades puede vincularse por esa ruta de red compartida. Los sistemas de seguimiento observan patrones de IP, y dos cuentas que se originan desde la misma direccion en momentos similares son faciles de correlacionar.

Per-context proxy resuelve esto asignando un proxy dedicado a cada BrowserContext. Cada contexto se enruta a traves de un servidor proxy diferente, recibe su propia IP publica y obtiene metadatos geograficos (zona horaria, locale, idioma) derivados de la ubicacion de salida del proxy. Combinado con el aislamiento de huellas digitales por contexto, cada contexto se convierte en una identidad completamente independiente sin senales de red ni huellas compartidas.

Este articulo cubre como funciona per-context proxy en BotBrowser, como configurarlo tanto en Puppeteer como en Playwright, y como optimizar el rendimiento para implementaciones multirregionales.

Impacto en la privacidad

Un unico proxy crea una identidad de red compartida entre todos los contextos. Incluso con diferentes perfiles de huellas digitales, la IP compartida se convierte en un punto de correlacion. Considera estos riesgos:

Correlacion basada en IP: Dos cuentas que acceden al mismo servicio desde la misma IP pueden vincularse, independientemente de las diferencias de huellas
Inconsistencia geografica: Un contexto configurado con un perfil de huella aleman pero enrutado a traves de un proxy de EE.UU. crea una discrepancia obvia entre la ubicacion declarada y el origen de la red
Analisis temporal: Multiples identidades que comparten un proxy pueden correlacionarse por sus patrones de temporalizacion de trafico, ya que todas las solicitudes se originan desde el mismo punto de red

Per-context proxy elimina estos riesgos. Cada contexto tiene su propio proxy, su propia IP publica y sus propios metadatos geograficos. No hay senales de red compartidas entre contextos.

Contexto tecnico

Aislamiento de red a nivel de BrowserContext

En Chromium, un BrowserContext es un entorno de navegacion aislado. Cada contexto tiene su propio contenedor de cookies, localStorage, sessionStorage, IndexedDB y cache. Chromium estandar proporciona este aislamiento de almacenamiento de forma nativa.

BotBrowser extiende este aislamiento a la capa de red. Cuando un BrowserContext recibe su propio proxy, todo el trafico HTTP, HTTPS y WebSocket de ese contexto se enruta a traves del servidor proxy especificado. Otros contextos en la misma instancia del navegador no se ven afectados. Este es un verdadero aislamiento de red a nivel de contexto, no un interceptor a nivel de pagina que puede perder solicitudes tempranas o conexiones WebSocket.

Deteccion geografica automatica

Cuando un contexto se conecta a traves de un proxy, BotBrowser detecta la IP de salida del proxy y deriva automaticamente la configuracion geografica para ese contexto especifico:

Zona horaria: Derivada de la geolocalizacion de la IP del proxy (por ejemplo, America/New_York para un proxy en el este de EE.UU.)
Locale: Coincide con el pais del proxy (por ejemplo, en-US)
Idiomas: Configurados segun la region del proxy (por ejemplo, en-US,en)
Geolocalizacion: Coordenadas aproximadas a partir de la IP

Esto ocurre de forma independiente para cada contexto. Un contexto con proxy de EE.UU. obtiene configuracion geografica estadounidense, mientras que un contexto con proxy aleman en el mismo navegador obtiene configuracion alemana. No es necesaria la configuracion manual de zona horaria, locale o idioma.

Integracion con huellas por contexto

Per-context proxy funciona junto con el aislamiento de huellas por contexto de BotBrowser (ENT Tier3). Cada contexto puede recibir:

Un perfil de huellas unico via --bot-profile
Un proxy e IP publica independientes
Metadatos geograficos coincidentes derivados del proxy
Almacenamiento aislado (cookies, localStorage, IndexedDB)

La combinacion significa que cada contexto es una identidad completamente independiente. No se comparten senales de huellas, rutas de red ni almacenamiento entre contextos.

Configuracion

Puppeteer: Configuracion multirregional

En Puppeteer, per-context proxy se configura a traves de CDP (Chrome DevTools Protocol). Se crea un BrowserContext, se asignan configuraciones de proxy y perfil de huellas via BotBrowser.setBrowserContextFlags, y luego se crean paginas dentro de ese contexto.

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();

// Contexto EE.UU. con proxy de EE.UU.
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();

// Contexto UK con 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();

// Contexto DE con proxy aleman
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();

// Cada contexto navega con su propio proxy e identidad geografica
await Promise.all([
  usPage.goto('https://example.com'),
  ukPage.goto('https://example.com'),
  dePage.goto('https://example.com'),
]);

await browser.close();

Importante: BotBrowser.setBrowserContextFlags debe llamarse antes de crear cualquier pagina en ese contexto. El proceso del renderizador lee sus flags al iniciarse. Si ya existe una pagina, los nuevos flags no tendran efecto.

Puppeteer: Proxy solo via botbrowserFlags

Tambien puedes configurar el proxy completamente a traves de botbrowserFlags, sin pasar 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();

Este enfoque configura todos los parametros del proxy (servidor, IP, reglas de omision) en un solo lugar.

Playwright: Proxy por contexto

Playwright proporciona soporte nativo de proxy por contexto a traves de 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,
});

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

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

// Cada contexto obtiene automaticamente la configuracion geografica de su proxy
const usPage = await usContext.newPage();
const dePage = await deContext.newPage();

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

BotBrowser deriva automaticamente la zona horaria, locale e idioma para cada contexto basandose en la IP de salida de su proxy.

Omitir deteccion de IP con --proxy-ip

El proxy de cada contexto activa una solicitud de deteccion de IP para determinar la configuracion geografica. Si ya conoces la IP de salida del proxy, puedes omitir este paso con --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', // Omitir consulta de IP, usar esta IP para deteccion geo
  ],
});

Esto elimina la latencia de consulta de IP por contexto, lo cual es especialmente beneficioso cuando se crean muchos contextos en secuencia.

Enrutamiento selectivo con proxy-bypass-rgx

Usa --proxy-bypass-rgx para enrutar URLs especificas directamente en lugar de a traves del proxy. Esto reduce el ancho de banda del proxy en activos estaticos o servicios internos:

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 usa la lista de hosts estandar de Chromium separada por punto y coma. --proxy-bypass-rgx usa sintaxis regex RE2 y coincide tanto con el nombre de host como con la ruta URL.

Escenarios comunes

Pruebas multirregionales en un solo navegador

Ejecuta contextos de EE.UU., UK y Alemania simultaneamente dentro de una sola instancia del navegador. Cada contexto obtiene un proxy, perfil de huellas e identidad geografica diferentes:

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');

  // Verificar identidad geografica
  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: Diferente perfil + diferente proxy

Cada contexto puede usar un perfil de huellas completamente diferente. Un perfil de Windows con proxy de EE.UU. y un perfil de macOS con proxy de UK, todo dentro de un navegador:

// Identidad Windows + proxy EE.UU.
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',
  ],
});

// Identidad 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',
  ],
});

Cambio de proxy en tiempo de ejecucion

Para escenarios que requieren cambiar el proxy de un contexto despues de la creacion (por ejemplo, rotacion geografica dentro de una sesion), usa BotBrowser.setBrowserContextProxy (ENT Tier3):

const ctx = await browser.createBrowserContext();
const page = await ctx.newPage();
const client = await page.createCDPSession();

// Comenzar con proxy de EE.UU.
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');

// Cambiar a proxy UK en tiempo de ejecucion
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');

// Cambiar a proxy de Japon
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');

Despues de cada cambio, BotBrowser vuelve a detectar la configuracion geografica y la aplica al contexto. La actualizacion geografica toma efecto en la siguiente navegacion de marco principal.

Optimizacion de rendimiento

Usar --proxy-ip para reducir la sobrecarga de consultas

Cuando conoces la IP de salida de cada proxy, siempre pasa --proxy-ip. Sin ella, BotBrowser realiza una solicitud de deteccion de IP para cada contexto en la primera navegacion. Con mas de 10 contextos, estas consultas se acumulan:

// Sin --proxy-ip: cada contexto hace una solicitud de deteccion de IP
// Con --proxy-ip: la deteccion geo es instantanea, sin solicitud de red
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;
});

Los procesos compartidos ahorran recursos

Per-context proxy dentro de una sola instancia del navegador comparte el proceso GPU, el proceso del navegador y los procesos utilitarios. Comparado con lanzar instancias separadas del navegador para cada proxy, este enfoque ahorra:

Recurso	Instancias separadas (10 proxies)	Per-Context (10 contextos)
Procesos del navegador	10	1
Procesos GPU	10	1
Procesos de red	10	1
Sobrecarga de memoria base	~500 MB	~50 MB
Tiempo de creacion de contexto	1-3 segundos cada uno	Milisegundos cada uno

Combinar con huellas por contexto

Cuando asignas tanto un proxy como un perfil de huellas por contexto, cada contexto se convierte en una identidad completamente independiente sin la sobrecarga de instancias separadas del navegador:

// Una sola instancia del navegador, 3 identidades completas
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}`,
    ],
  });
  // Cada contexto: huella unica + proxy unico + geo unico = completamente independiente
}

Verificacion

Despues de configurar per-context proxy, verifica cada contexto de forma independiente:

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

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

  // Verificar zona horaria
  const tz = await page.evaluate(() =>
    Intl.DateTimeFormat().resolvedOptions().timeZone
  );
  console.log(`[${label}] Zona horaria: ${tz}`);

  // Verificar idioma
  const lang = await page.evaluate(() => navigator.language);
  console.log(`[${label}] Idioma: ${lang}`);

  // Verificar 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');

Confirma que cada contexto muestra una IP, zona horaria y locale diferentes que coinciden con la ubicacion geografica del proxy.

Preguntas frecuentes

Que nivel de licencia se requiere para per-context proxy? Per-context proxy con aislamiento de huellas requiere ENT Tier3. El cambio de proxy en tiempo de ejecucion via BotBrowser.setBrowserContextProxy tambien requiere ENT Tier3.

Puedo usar Playwright para per-context proxy? Si. Playwright soporta nativamente proxy por contexto a traves de browser.newContext({ proxy: ... }). BotBrowser deriva automaticamente la configuracion geografica para cada contexto de Playwright.

setBrowserContextFlags debe llamarse antes de crear una pagina? Si. El proceso del renderizador lee sus flags al iniciarse. Si ya existe una pagina en el contexto, los nuevos flags no se aplicaran. El orden correcto es: createBrowserContext -> setBrowserContextFlags -> newPage.

Puedo cambiar el proxy de un contexto despues de la creacion? Si, via BotBrowser.setBrowserContextProxy (ENT Tier3). Esto permite el cambio de proxy en tiempo de ejecucion sin recrear el contexto. La configuracion geografica se vuelve a derivar en la siguiente navegacion de marco principal.

Que protocolos de proxy se soportan? Todos los protocolos soportados por --proxy-server funcionan por contexto: socks5://, socks5h://, http://, https://. Todos soportan autenticacion integrada (user:pass@host:port).

Cuantos contextos pueden ejecutarse simultaneamente? No hay un limite estricto. Cada contexto consume memoria proporcional a sus paginas abiertas y recursos en cache. En la practica, docenas o cientos de contextos pueden ejecutarse dentro de una sola instancia del navegador con suficiente RAM.

BotBrowser detecta automaticamente la geografia para cada contexto? Si. Cada contexto con un proxy diferente obtiene deteccion geografica independiente. BotBrowser detecta la IP de salida y configura zona horaria, locale e idioma para ese contexto especifico.

Que pasa si no configuro --proxy-ip? BotBrowser realiza una solicitud automatica de deteccion de IP en la primera navegacion de cada contexto. Esto funciona correctamente pero anade una pequena latencia adicional. Configurar --proxy-ip elimina esta consulta.

Puedo usar diferentes reglas de omision por contexto? Si. Tanto --proxy-bypass-list como --proxy-bypass-rgx pueden configurarse por contexto a traves de botbrowserFlags.

Resumen

Per-context proxy proporciona aislamiento de red completo para cada BrowserContext dentro de una sola instancia del navegador. Cada contexto se enruta a traves de su propio proxy, recibe una IP publica independiente y obtiene metadatos geograficos (zona horaria, locale, idioma) derivados automaticamente de la ubicacion de salida del proxy. Combinado con perfiles de huellas por contexto, cada contexto opera como una identidad completamente independiente.

Para fundamentos de proxy y detalles de protocolo, consulta Configuracion de Proxy. Para cambio de proxy en tiempo de ejecucion dentro de contextos existentes, consulta Cambio Dinamico de Proxy. Para aislamiento completo de multiples identidades, consulta Aislamiento de Navegador Multi-Cuenta. Para proteccion contra fugas de DNS y WebRTC en todos los contextos, combina con Prevencion de Fugas DNS y Prevencion de Fugas WebRTC.

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