Gestión de cookies con BotBrowser
Aprende a gestionar cookies en BotBrowser para persistencia de sesión, continuidad entre sesiones y aislamiento por identidad usando la opción --bot-cookies.
Introducción
Las cookies son la base de cómo los navegadores mantienen estado. Transportan tokens de sesión, preferencias de usuario, registros de consentimiento y credenciales de autenticación entre cargas de página y visitas. Al crear perfiles de navegador para investigación de privacidad, pruebas o gestión de múltiples cuentas, controlar la capa de cookies es tan importante como controlar la capa de huellas (fingerprint). Un navegador con huella consistente pero sin cookies parece una instalación nueva cada vez, lo que no refleja el comportamiento real de los navegadores.
BotBrowser proporciona la opción --bot-cookies (nivel PRO) para precargar cookies al inicio. Esto hace que las cookies estén presentes antes de la primera navegación, antes de que se ejecute cualquier JavaScript y antes de que los scripts de seguimiento puedan inspeccionar el estado del navegador. Combinadas con perfiles de huella y otras señales de identidad, la gestión de cookies completa la imagen de una identidad de navegador real y persistente.
Impacto en privacidad: por qué importa la gestión de cookies
Los sitios web y los sistemas de seguimiento no evalúan las cookies de forma aislada; observan la relación entre las cookies y otras señales del navegador. Un navegador que presenta la huella de un usuario recurrente pero no tiene cookies genera dudas. De igual forma, un navegador con cookies de sesión pero una huella completamente nueva parece inconsistente.
Para los investigadores de privacidad que estudian cómo los sistemas de seguimiento correlacionan señales del navegador, controlar las cookies es esencial. Permite probar si un sistema de seguimiento vincula sesiones basándose solo en cookies, solo en huellas o en una combinación. Para la gestión de múltiples cuentas, cada identidad necesita su propio almacén de cookies que persista entre sesiones para mantener el estado de sesión y evitar flujos de autenticación repetidos.
La gestión de cookies también es importante para probar banners de consentimiento, flujos de cumplimiento de GDPR y cómo los sitios web se comportan para visitantes recurrentes frente a nuevos visitantes. Sin precarga de cookies, cada sesión comienza como "nuevo visitante", lo que impide probar experiencias de usuarios retornantes.
Antecedentes técnicos
Cómo almacenan las cookies los navegadores
Chromium almacena cookies en una base de datos SQLite dentro del directorio de datos del usuario. Cuando el navegador se inicia, carga las cookies de esta base de datos a la memoria. Cada cookie tiene varios atributos:
- Domain y Path: determinan qué solicitudes incluyen la cookie
- Name y Value: los datos reales de la cookie
- Expiration: cuándo debe eliminarse la cookie (las cookies de sesión no tienen expiración)
- Secure flag: si la cookie se envía solo por HTTPS
- HttpOnly flag: si JavaScript puede acceder a la cookie
- SameSite: controla el comportamiento de cookies entre sitios (Strict, Lax o None)
Cuando una página carga, el navegador adjunta las cookies coincidentes a cada solicitud HTTP. JavaScript en la página también puede leer y escribir cookies a través de document.cookie, sujeto a las restricciones HttpOnly.
El problema de la sincronización
La mayoría de frameworks de automatización ofrecen gestión de cookies mediante sus APIs. Playwright tiene context.addCookies() y Puppeteer tiene page.setCookie(). Sin embargo, estos métodos añaden cookies después de crear el contexto o la página del navegador. Esto significa que las primeras solicitudes de red, incluida la carga inicial de la página y cualquier solicitud de preflight, salen sin esas cookies.
Esta discrepancia temporal importa porque algunos sistemas de seguimiento inspeccionan la solicitud inicial para detectar la presencia de cookies. Si la primera solicitud no tiene cookies pero las siguientes sí, la inconsistencia será visible en los registros del servidor.
La opción --bot-cookies de BotBrowser soluciona esto inyectando cookies antes de que el contexto del navegador se inicialice, haciéndolas disponibles desde la primera solicitud.
Enfoques comunes y sus limitaciones
APIs de cookies a nivel de framework
Playwright y Puppeteer ofrecen gestión de cookies vía API. Funcionan bien para muchos casos, pero tienen limitaciones:
- Temporización posterior: las cookies añadidas por la API del framework solo están disponibles tras la creación del contexto o la página, perdiendo la carga inicial
- Scope por contexto: las cookies están ligadas al contexto del navegador, no a la instancia del navegador. Múltiples contextos en la misma instancia no comparten cookies a menos que lo configures explícitamente
- Diferencias de formato: cada framework usa un formato de objeto de cookie algo distinto, lo que dificulta compartir datos de cookies entre herramientas
Persistencia manual del directorio de datos de usuario
Otra opción es reutilizar el mismo --user-data-dir entre sesiones. Esto preserva las cookies automáticamente, ya que se almacenan en la base de datos SQLite. Sin embargo, también preserva todo el resto del estado: caché, localStorage, IndexedDB, service workers e historial. Este enfoque no permite controlar con granularidad qué estado preservar y qué reiniciar.
Extensiones de cookies
Las extensiones del navegador pueden gestionar cookies, pero operan en un nivel de privilegio inapropiado para la automatización. No pueden inyectar cookies antes de la primera carga de página, y su propia presencia es una señal detectable.
Enfoque de BotBrowser
BotBrowser implementa la precarga de cookies a nivel del motor mediante la opción --bot-cookies. Este diseño tiene varias ventajas respecto a las alternativas.
Inyección a nivel de motor
Las cookies cargadas mediante --bot-cookies se insertan en el almacén de cookies del navegador durante la inicialización, antes de crear cualquier contexto y antes de cargar páginas. Esto significa:
- La primera solicitud HTTP a cualquier dominio ya lleva las cookies adecuadas
- El JavaScript que se ejecuta en la carga de la página puede leer las cookies vía
document.cookie - Los sistemas de seguimiento del lado servidor ven una presencia consistente de cookies desde la primera solicitud
Formatos de entrada flexibles
La opción --bot-cookies acepta datos de cookies en dos formas:
JSON en línea para conjuntos pequeños o generación dinámica:
--bot-cookies='[{"name":"session","value":"abc123","domain":".example.com"}]'
Referencia a archivo con prefijo @ para conjuntos más grandes:
--bot-cookies="@/path/to/cookies.json"
El archivo debe contener un array JSON de objetos cookie.
Aislamiento por identidad
Cada instancia de BotBrowser usa su propio almacén de cookies. Al emparejar distintos archivos de cookies con perfiles de huella distintos, creas identidades de navegador completamente aisladas en las que tanto la capa de huella como la de cookies son independientes.
Configuración y uso
Uso básico en CLI
# Cargar cookies desde un archivo
./chrome \
--bot-profile=/path/to/profile.enc \
--bot-cookies="@/path/to/cookies.json"
# Cookies en línea
./chrome \
--bot-profile=/path/to/profile.enc \
--bot-cookies='[{"name":"consent","value":"granted","domain":".example.com"}]'
Integración con 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');
// Las cookies ya están presentes desde la primera solicitud
const cookies = await context.cookies();
console.log('Active cookies:', cookies.length);
await browser.close();
})();
Aislamiento por identidad para cookies
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');
Exportar cookies para persistencia de sesión
Guarda las cookies al final de cada sesión y recárgalas en el próximo inicio:
// Al final de la sesión
const cookies = await context.cookies();
const fs = require('fs');
fs.writeFileSync('/cookies/user-a.json', JSON.stringify(cookies, null, 2));
// Siguiente sesión: lanzar con --bot-cookies=@/cookies/user-a.json
Verificación
Después de lanzar con --bot-cookies, verifica que las cookies se cargaron correctamente:
const page = await context.newPage();
// Verificar que las cookies están presentes antes de cualquier navegación
const cookies = await context.cookies('https://example.com');
console.log('Pre-loaded cookies:', cookies.map(c => c.name));
// Navegar y verificar que las cookies se envían con la solicitud
await page.goto('https://example.com');
// Cookies visibles desde JavaScript
const jsCookies = await page.evaluate(() => document.cookie);
console.log('JS-visible cookies:', jsCookies);
También puedes inspeccionar las cabeceras de la solicitud inicial usando la intercepción de red de tu framework para confirmar que las cookies están incluidas desde la primera solicitud.
Buenas prácticas
- Mantén archivos de cookies por identidad. No compartas un archivo de cookies entre diferentes perfiles de huella.
- Establece fechas de expiración realistas. Las expiraciones a futuro coinciden con el comportamiento normal del navegador; evita fechas pasadas.
- Incluye cookies de consentimiento comunes. Los tokens de consentimiento GDPR evitan que el banner aparezca en cada visita, simulando el comportamiento de un usuario recurrente.
- Rota cookies junto con los perfiles. Al rotar perfiles de huella, actualiza el conjunto de cookies para que coincida con la nueva identidad.
- Usa correctamente HttpOnly y Secure. Ajusta las banderas para que coincidan con lo que el sitio realmente establece en
Set-Cookie. - Usa el prefijo
@para rutas de archivo. Mantiene el comando de lanzamiento más limpio cuando trabajas con muchos cookies.
Preguntas frecuentes
¿Qué formato acepta --bot-cookies?
La opción acepta un array JSON de objetos cookie. Cada objeto debe tener al menos name, value y domain. Campos opcionales: path, expirationDate, secure, httpOnly, sameSite. Puedes pasar el JSON inline o como referencia de archivo con @.
¿Cuándo están disponibles las cookies respecto a la carga de la página?
Las cookies cargadas por --bot-cookies están disponibles antes de la primera navegación. Se insertan durante la inicialización del navegador, por lo que incluso la primera solicitud HTTP las llevará.
¿Puedo combinar --bot-cookies con context.addCookies() de Playwright?
Sí. --bot-cookies carga primero las cookies durante la inicialización. Puedes añadir cookies adicionales después con context.addCookies() si lo necesitas.
¿Cómo exporto cookies para reutilizarlas en la próxima sesión?
Al final de la sesión, usa la API de tu framework para leer las cookies (por ejemplo, context.cookies() en Playwright), guarda el resultado en JSON y pásalo a --bot-cookies en el siguiente inicio.
¿--bot-cookies funciona con múltiples contextos?
Las cookies cargadas por --bot-cookies están disponibles para todos los contextos dentro de la instancia del navegador. Si necesitas cookies diferentes por contexto, usa las APIs por contexto del framework.
¿Qué nivel requiere --bot-cookies?
La opción --bot-cookies está disponible en el nivel PRO.
¿Puedo combinar --bot-cookies con otros flags de identidad?
Sí. Combinar --bot-cookies con --bot-bookmarks, --bot-inject-random-history y flags de locale/tiempo crea una identidad de navegador completa y coherente.
Resumen
La gestión de cookies con --bot-cookies completa la capa de identidad en BotBrowser al asegurar que las cookies estén presentes desde la primera solicitud. Combinado con perfiles de huella y otros flags de identidad, permite crear sesiones de navegador que mantienen un estado coherente en todas las capas.
Para temas relacionados, consulta Multi-Account Isolation, Proxy Configuration y Profile Management.
title: "Gestion de cookies con BotBrowser" description: "Aprende a gestionar cookies en BotBrowser para persistencia de sesion y aislamiento por contexto usando el flag --bot-cookies y Playwright." date: "2025-11-11" locale: es category: identity tags: ["cookies", "management", "identity", "session", "privacy"] published: true
El flag --bot-cookies
BotBrowser proporciona el flag --bot-cookies (ENT Tier1) para inyectar cookies al inicio, dandote control total sobre el estado de sesion antes de la primera carga de pagina.
./chrome \
--bot-profile=/path/to/profile.enc \
--bot-cookies=/path/to/cookies.json
Formato del archivo de cookies
[
{
"domain": ".example.com",
"path": "/",
"name": "session_id",
"value": "abc123def456",
"expirationDate": 1774000000,
"secure": true,
"httpOnly": true,
"sameSite": "Lax"
}
]
Las cookies estan disponibles inmediatamente cuando el navegador inicia, antes de cualquier navegacion.
Ejemplo con 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 activas:', cookies.length);
await browser.close();
})();
Aislamiento de cookies por identidad
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');
Exportar cookies para persistencia de sesion
const cookies = await context.cookies();
const fs = require('fs');
fs.writeFileSync('/cookies/user-a.json', JSON.stringify(cookies, null, 2));
Mejores practicas
- Mantener archivos de cookies por identidad. No compartir entre diferentes perfiles.
- Establecer fechas de expiracion realistas.
- Incluir cookies de consentimiento comunes.
- Rotar cookies junto con los perfiles.