Chrome-Cookies als JSON exportieren

TL;DR: Um Chrome-Cookies als JSON zu exportieren, installiere CookieVault Editor, klicke auf Export und wähle JSON (oder Netscape cookies.txt für curl/wget). Chrome DevTools haben keine eingebaute Export-Funktion. Für automatisierte Exporte in CI/CD nutze Puppeteers page.cookies() oder Playwrights context.cookies().

Chrome-Cookies als JSON zu exportieren ist der Prozess, den Cookie-Speicher des Browsers in eine strukturierte Datei zu serialisieren, die gesichert, geteilt, in ein anderes Browser-Profil importiert oder an Kommandozeilen-Werkzeuge wie curl und wget übergeben werden kann. Das Application-Panel der Chrome-DevTools lässt dich Cookies ansehen und bearbeiten, bietet aber keine Export-Schaltfläche — für den strukturierten Export ist eine Manifest-V3-Erweiterung oder ein Headless-Browser-Skript erforderlich¹. Diese Anleitung deckt drei Methoden in der Reihenfolge ihrer Praktikabilität für unterschiedliche Abläufe ab.

Schnellvergleich: Exportmethoden

Kurz gesagt: Nutze eine Manifest-V3-Erweiterung für interaktive Ein-Klick-Exporte. Nutze Puppeteer oder Playwright für automatisierte Exporte in CI/CD-Pipelines. Nutze die DevTools-Konsole für schnelle einmalige Zugriffe, wenn du keine Erweiterung installieren kannst — bedenke, dass HttpOnly-Cookies dann fehlen.

Laut Chrome-DevTools-Dokumentation ist die Cookie-Tabelle des Application-Panels für Inspektion und Bearbeitung entworfen, nicht für den Datenexport¹. Das Network-Panel kann vollständige Request-Archive als HAR-Dateien exportieren, die Cookie-Header enthalten, aber das Extrahieren einzelner Cookies aus HAR erfordert Nachverarbeitung.

Methode 1: CookieVault Editor (empfohlen)

Kurz gesagt: CookieVault Editor exportiert Cookies aus einem Symbolleisten-Popup in drei Formaten — JSON für strukturierte Daten, Netscape cookies.txt für curl/wget und HAR für vollständige Request-Archive. Ein Klick pro Export, einschließlich HttpOnly-Cookies.

Der achtstufige Export-Workflow:

1. Entscheiden, welche Cookies exportiert werden sollen — bestimme, ob du einen Export einer einzelnen Domain (z. B. staging.example.com) oder einen vollständigen Browser-Export brauchst. Exporte einer einzelnen Domain sind kleiner und sicherer zu teilen; vollständige Exporte erfassen deinen gesamten Sitzungszustand.
2. Exportformat wählen — JSON für programmatische Nutzung und Re-Import. Netscape cookies.txt für curl -b und wget --load-cookies. HAR für vollständige Request-Archive einschließlich Header und Response-Bodies.
3. CookieVault Editor installieren — aus dem Chrome Web Store. Die Erweiterung fragt die cookies-Berechtigung an, um Zugriff auf den vollständigen Cookie-Speicher zu erhalten, einschließlich HttpOnly-Cookies.
4. Erweiterungs-Popup öffnen — klicke auf das CookieVault-Editor-Symbol in der Symbolleiste. Das Popup zeigt alle Cookies für die aktuelle Domain. Klicke auf “All cookies”, um jedes Cookie im Browser zu sehen.
5. Auf Export klicken — die Format-Auswahl erscheint. Wähle JSON, Netscape cookies.txt oder HAR.
6. Datei speichern — Chrome öffnet einen Dialog zum Speichern der Datei. Wähle einen Ort und einen Dateinamen.
7. Export überprüfen — öffne die Datei in einem Texteditor oder JSON-Viewer. Bestätige, dass die erwarteten Cookies vorhanden sind und dass HttpOnly-Cookies eingeschlossen sind.
8. Exportdatei nutzen — übergib sie an dein nachgelagertes Werkzeug: curl -b cookies.txt, Playwrights context.addCookies() oder die Import-Funktion von CookieVault Editor für die Sitzungsübertragung über Profile hinweg.

Wichtig: Exportierte Cookie-Dateien enthalten Authentifizierungs-Tokens. Behandle sie wie Passwörter — committe sie nicht in Versionskontrolle, teile sie nicht über unverschlüsselte Kanäle und lösche sie, wenn nicht mehr gebraucht.

Methode 2: Puppeteer oder Playwright (automatisiert)

Kurz gesagt: Für CI/CD-Pipelines, das Erzeugen von Test-Fixtures und skriptbasierte Abläufe geben Puppeteers page.cookies() und Playwrights context.cookies() das Cookie-Array als JSON zurück. Beide enthalten HttpOnly-Cookies. Schreibe die Ausgabe mit JSON.stringify in eine Datei.

Ein minimales Puppeteer-Export-Skript:

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');
  // Authentifizieren bei Bedarf (page.type, page.click usw.)
  const cookies = await page.cookies();
  fs.writeFileSync('cookies.json', JSON.stringify(cookies, null, 2));
  await browser.close();
})();

Der äquivalente Playwright-Ansatz:

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

Beide Methoden geben ein Array von Cookie-Objekten mit typisierten Feldern zurück: name, value, domain, path, expires (Unix-Zeitstempel), httpOnly, secure, sameSite. Die Ausgabe ist direkt kompatibel mit context.addCookies() für den Re-Import.

Methode 3: DevTools-Konsole (eingeschränkt)

Kurz gesagt: document.cookie in der DevTools-Konsole ausführen gibt einen mit Semikolon getrennten String von Cookie-Name=Wert-Paaren für die aktuelle Domain zurück. Diese Methode ist schnell, aber unvollständig — HttpOnly-Cookies werden ausgeschlossen und Metadaten (Ablauf, Flags, Pfad) gehen verloren.

Der document.cookie-Ansatz funktioniert als schneller Notbehelf, wenn du keine Erweiterung installieren kannst:

1. Öffne die DevTools (F12) → Konsolen-Tab
2. Gib document.cookie ein und drücke Enter
3. Kopiere den ausgegebenen String
4. Parse manuell oder nutze ein Skript, um an ; und dann an = zu splitten

Diese Methode hat drei wesentliche Einschränkungen:

• HttpOnly-Cookies sind für JavaScript unsichtbar — sie werden aus document.cookie ausgeschlossen
• Cookie-Metadaten (Ablauf, SameSite, Secure, HttpOnly, Pfad, Domain) sind nicht enthalten
• Drittanbieter-Cookies, die von anderen Domains gesetzt wurden, sind aus dem JavaScript-Kontext der aktuellen Seite nicht zugänglich

Für alles, was über eine schnelle Plausibilitätsprüfung hinausgeht, nutze Methode 1 oder Methode 2.

Referenz der Exportformate

Kurz gesagt: JSON und Netscape sind die zwei häufigsten Exportformate. JSON bewahrt alle Metadaten und ist re-importierbar. Netscape ist ein Legacy-Format, das für die curl/wget-Kompatibilität entworfen wurde. HAR ist ein vollständiges Request-Archiv, das Cookies als Teil der HTTP-Header enthält.

JSON-Format

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

JSON-Vorteile:

• Typisierte Felder (Boolean für Flags, Number für Ablauf)
• Direkt kompatibel mit Puppeteer/Playwright addCookies()
• Schema-validierbar
• Menschenlesbar und diffbar
• Unterstützt verschachtelte Strukturen zur Gruppierung nach Domain

Netscape-cookies.txt-Format

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

Jede Zeile hat sieben tab-separierte Felder: Domain, Subdomains einschließen (TRUE/FALSE), Pfad, Secure (TRUE/FALSE), Ablauf (Unix-Zeitstempel), Name, Wert.

Netscape-Vorteile:

• Direkte Kompatibilität mit curl -b und wget --load-cookies
• Kompakte Dateigröße
• Wird von praktisch jedem Kommandozeilen-HTTP-Werkzeug unterstützt
• Einfach mit Shell-Skripten (awk, cut) zu parsen

Wann welches Format

Sicherheitsüberlegungen für exportierte Cookies

Kurz gesagt: Cookie-Exportdateien sind Anmeldedaten-äquivalente Artefakte. Eine geleakte Sitzungs-Cookie-Datei gibt jedem vollen Zugriff auf deine authentifizierten Sitzungen. Behandle sie mit derselben Sorgfalt wie Passwörter und API-Schlüssel.

Sechs Sicherheitsregeln für den Umgang mit exportierten Cookie-Dateien:

• Committe Cookie-Exportdateien niemals in Versionskontrolle — füge *.cookies.json und cookies.txt der .gitignore hinzu
• Teile Exporte nicht über unverschlüsselte Kanäle (E-Mail, Slack-DMs ohne E2E-Verschlüsselung, öffentliches Pastebin)
• Lösche Exportdateien, wenn nicht mehr gebraucht — Sitzungs-Cookies in einer Datei bleiben gültig, bis der Server die Sitzung ablaufen lässt
• Schränke die Dateiberechtigungen auf geteilten Entwicklungs-Maschinen ein (chmod 600 cookies.json unter Linux/Mac)
• Beim Teilen von Test-Fixtures ersetze echte Sitzungswerte durch Platzhalter-Tokens und dokumentiere die Ersetzung
• Wenn eine Exportdatei versehentlich geleakt wird, mache alle betroffenen Sitzungen sofort ungültig, indem du dich von den Websites abmeldest und die Passwörter änderst

Diese Vorsichtsmaßnahmen gelten gleichermaßen für JSON-, Netscape- und HAR-Formate — alle drei enthalten die rohen Cookie-Werte, die deine Sitzungen authentifizieren.

Siehe auch

• Cookies in Chrome löschen — Cookies nach dem Export als Sicherung löschen
• Cookies in Chrome bearbeiten — Cookie-Werte ändern, ohne sie zu löschen
• Cookies löschen, aber angemeldet bleiben — geschützte Sitzungen exportieren, dann alles andere löschen
• Cookies in Chrome auf die Whitelist setzen — bestimmte Cookies vor dem Löschen schützen
• CookieVault Editor — die quelloffene Manifest-V3-Erweiterung zum Ansehen, Bearbeiten und Exportieren von Cookies
• CookieVault Guardian — automatisierte Bereinigung mit Whitelist-Unterstützung