Cómo exportar cookies de Chrome a JSON

TL;DR: Para exportar cookies de Chrome a JSON, instala CookieVault Editor, haz clic en Exportar y elige JSON (o Netscape cookies.txt para curl/wget). Las DevTools de Chrome no tienen una función de exportación integrada. Para exportaciones automatizadas en CI/CD, usa page.cookies() de Puppeteer o context.cookies() de Playwright.

Exportar cookies de Chrome a JSON es el proceso de serializar el almacén de cookies del navegador en un archivo estructurado que se puede respaldar, compartir, importar en otro perfil de navegador o alimentar a herramientas de línea de comandos como curl y wget. El panel Application de las DevTools de Chrome te permite ver y editar cookies pero no ofrece un botón de exportar —se requiere una extensión Manifest V3 o un script de navegador headless para una exportación estructurada¹. Esta guía cubre tres métodos en orden de practicidad para distintos flujos.

Comparativa rápida: métodos de exportación

En resumen: Usa una extensión Manifest V3 para exportaciones interactivas en un clic. Usa Puppeteer o Playwright para exportaciones automatizadas en pipelines CI/CD. Usa la consola de DevTools para capturas rápidas puntuales cuando no puedas instalar una extensión, teniendo en cuenta que faltarán las cookies HttpOnly.

Según la documentación de las DevTools de Chrome, la tabla de cookies del panel Application está diseñada para inspección y edición, no para exportación de datos¹. El panel Network puede exportar archivos completos de peticiones como archivos HAR que incluyen cabeceras de cookies, pero extraer cookies individuales de un HAR requiere postprocesamiento.

Método 1: CookieVault Editor (recomendado)

En resumen: CookieVault Editor exporta cookies desde un popup en la barra de herramientas en tres formatos —JSON para datos estructurados, Netscape cookies.txt para curl/wget y HAR para archivos completos de peticiones. Un clic por exportación, incluyendo cookies HttpOnly.

El flujo de exportación en ocho pasos:

1. Decide qué cookies exportar —determina si necesitas una exportación de un solo dominio (por ejemplo, staging.example.com) o una exportación completa del navegador. Las exportaciones de un solo dominio son más pequeñas y más seguras de compartir; las exportaciones completas capturan todo el estado de tu sesión.
2. Elige un formato de exportación —JSON para uso programático y reimportación. Netscape cookies.txt para curl -b y wget --load-cookies. HAR para archivos completos de peticiones incluyendo cabeceras y cuerpos de respuesta.
3. Instala CookieVault Editor —instala desde la Chrome Web Store. La extensión solicita el permiso cookies para acceder al almacén completo de cookies, incluidas las cookies HttpOnly.
4. Abre el popup de la extensión —haz clic en el icono de CookieVault Editor en la barra de herramientas. El popup muestra todas las cookies del dominio actual. Haz clic en “All cookies” para ver cada cookie del navegador.
5. Haz clic en Exportar —aparece el selector de formato. Selecciona JSON, Netscape cookies.txt o HAR.
6. Guarda el archivo —Chrome abre un diálogo de guardado. Elige una ubicación y un nombre de archivo.
7. Verifica la exportación —abre el archivo en un editor de texto o visor JSON. Confirma que las cookies esperadas están presentes y que las cookies HttpOnly están incluidas.
8. Usa el archivo exportado —alimenta a tu herramienta downstream: curl -b cookies.txt, context.addCookies() de Playwright, o la función Importar de CookieVault Editor para transferir sesiones entre perfiles.

Importante: Los archivos de exportación de cookies contienen tokens de autenticación. Trátalos como contraseñas —no los comprometas a control de versiones, no los compartas por canales sin cifrar y elimínalos cuando ya no los necesites.

Método 2: Puppeteer o Playwright (automatizado)

En resumen: Para pipelines CI/CD, generación de fixtures de prueba y flujos scriptados, page.cookies() de Puppeteer y context.cookies() de Playwright devuelven el array de cookies como JSON. Ambos incluyen cookies HttpOnly. Escribe la salida a un archivo con JSON.stringify.

Un script mínimo de exportación con Puppeteer:

const puppeteer = require('puppeteer');
const fs = require('fs');

(async () => {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.goto('https://example.com');
  // Autenticarse si es necesario (page.type, page.click, etc.)
  const cookies = await page.cookies();
  fs.writeFileSync('cookies.json', JSON.stringify(cookies, null, 2));
  await browser.close();
})();

El enfoque equivalente con Playwright:

const { chromium } = require('playwright');
const fs = require('fs');

(async () => {
  const browser = await chromium.launch();
  const context = await browser.newContext();
  const page = await context.newPage();
  await page.goto('https://example.com');
  const cookies = await context.cookies();
  fs.writeFileSync('cookies.json', JSON.stringify(cookies, null, 2));
  await browser.close();
})();

Ambos métodos devuelven un array de objetos cookie con campos tipados: name, value, domain, path, expires (timestamp Unix), httpOnly, secure, sameSite. La salida es directamente compatible con context.addCookies() para reimportación.

Método 3: Consola de DevTools (limitado)

En resumen: Ejecutar document.cookie en la consola de DevTools devuelve una cadena separada por punto y coma de pares nombre=valor de cookies del dominio actual. Este método es rápido pero incompleto —las cookies HttpOnly están excluidas y los metadatos (expiración, marcas, ruta) se pierden.

El enfoque document.cookie funciona como respaldo rápido cuando no puedes instalar una extensión:

1. Abre las DevTools (F12) → pestaña Console
2. Escribe document.cookie y pulsa Enter
3. Copia la cadena de salida
4. Parsea manualmente o usa un script para dividir por ; y luego por =

Este método tiene tres limitaciones significativas:

• Las cookies HttpOnly son invisibles para JavaScript —están excluidas de document.cookie
• Los metadatos de cookie (expiración, SameSite, Secure, HttpOnly, Path, Domain) no están incluidos
• Las cookies de terceros establecidas por otros dominios no son accesibles desde el contexto JavaScript de la página actual

Para cualquier cosa más allá de una comprobación rápida de cordura, usa el Método 1 o el Método 2.

Referencia de formatos de exportación

En resumen: JSON y Netscape son los dos formatos de exportación más comunes. JSON preserva todos los metadatos y es reimportable. Netscape es un formato heredado diseñado para compatibilidad con curl/wget. HAR es un archivo completo de petición que incluye cookies como parte de las cabeceras HTTP.

Formato JSON

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

Ventajas de JSON:

• Campos tipados (booleano para marcas, número para expiración)
• Directamente compatible con addCookies() de Puppeteer/Playwright
• Validable por schema
• Legible por humanos y diffable
• Soporta estructuras anidadas para agrupar por dominio

Formato Netscape cookies.txt

# Netscape HTTP Cookie File
.example.com	TRUE	/	TRUE	1756252800	session_id	abc123def456

Cada línea tiene siete campos separados por tabulaciones: dominio, incluir subdominios (TRUE/FALSE), ruta, secure (TRUE/FALSE), expiración (timestamp Unix), nombre, valor.

Ventajas de Netscape:

• Compatibilidad directa con curl -b y wget --load-cookies
• Tamaño de archivo compacto
• Soportado por prácticamente cualquier herramienta HTTP de línea de comandos
• Sencillo de parsear con scripts de shell (awk, cut)

Cuándo usar cada formato

Consideraciones de seguridad para cookies exportadas

En resumen: Los archivos de exportación de cookies son artefactos equivalentes a credenciales. Un archivo de cookies de sesión filtrado da a cualquiera acceso completo a tus sesiones autenticadas. Manéjalos con el mismo cuidado que las contraseñas y las claves de API.

Seis reglas de seguridad para manejar archivos de cookies exportados:

• Nunca comprometas archivos de exportación de cookies a control de versiones —añade *.cookies.json y cookies.txt a .gitignore
• No compartas exportaciones por canales sin cifrar (correo, mensajes directos de Slack sin cifrado E2E, Pastebin público)
• Elimina los archivos de exportación cuando ya no se necesiten —las cookies de sesión en un archivo siguen siendo válidas hasta que el servidor expira la sesión
• Restringe los permisos de archivo en máquinas de desarrollo compartidas (chmod 600 cookies.json en Linux/Mac)
• Al compartir fixtures de prueba, reemplaza los valores reales de sesión con tokens de marcador de posición y documenta el reemplazo
• Si un archivo de exportación se filtra accidentalmente, invalida todas las sesiones afectadas de inmediato cerrando sesión en los sitios y cambiando las contraseñas

Estas precauciones aplican igualmente a los formatos JSON, Netscape y HAR —los tres contienen los valores brutos de cookie que autentican tus sesiones.

Véase también

• Cómo eliminar cookies en Chrome —elimina cookies tras exportar como copia de seguridad
• Cómo editar cookies en Chrome —modifica valores de cookie sin eliminarlas
• Borrar cookies pero mantener la sesión iniciada —exporta las sesiones protegidas, luego limpia todo lo demás
• Cómo poner cookies en lista blanca en Chrome —protege cookies específicas de la eliminación
• CookieVault Editor —la extensión Manifest V3 de código abierto para ver, editar y exportar cookies
• CookieVault Guardian —limpieza automatizada con soporte de lista blanca