reCAPTCHA-Cookie- und Sitzungsanforderungen zur Lösung

Kurz vorweg: Für das Lösen von reCAPTCHA über die CaptchaAI-API brauchen Sie keine Cookies – der Solver erzeugt gültige Token allein aus sitekey und pageurl. Relevant werden Cookies erst, wenn Sie reCAPTCHA direkt im Browser automatisieren oder eine Seite prüft, ob dieselbe Sitzung das Widget geladen und das Formular abgesendet hat. Dann entscheiden Sitzungscookies über den Risk-Score, über sichtbare Bildabfragen und über die Frage, wie oft eine Challenge wiederkehrt. Dieser Artikel zeigt, wie Cookies den Score verschieben, welche Cookies reCAPTCHA überhaupt setzt und wie Sie Sitzungen in requests, Selenium und Puppeteer sauber verwalten.

Wie Cookies den reCAPTCHA-Score beeinflussen

Frische Sitzung ohne Cookies

New browser session, all cookies cleared
    ↓
reCAPTCHA JavaScript loads
    ↓
No _GRECAPTCHA → First-time visitor signal
No SID/HSID → No Google account trust
No rc:: cookies → No behavioral history
    ↓
Starting risk score: lower baseline (0.3-0.5 for v3)
    ↓
Behavioral analysis must compensate for lack of history
    ↓
Result: More likely to receive visible challenge (v2)
         Lower score (v3)

Wiederkehrende Sitzung mit Cookies

Existing browser session with cookies
    ↓
reCAPTCHA JavaScript loads
    ↓
_GRECAPTCHA found → Returning visitor
SID/HSID found → Google account trust
rc:: cookies found → Previous behavioral data
    ↓
Starting risk score: higher baseline (0.5-0.7 for v3)
    ↓
Behavioral analysis reinforces cookie-based trust
    ↓
Result: More likely to auto-pass (v2)
         Higher score (v3)

Der Unterschied ist spürbar: Ohne Historie startet reCAPTCHA v3 im Bereich 0,3–0,5, mit gepflegten Cookies eher bei 0,5–0,7. Wer etwa einen Scraper auf einem Hetzner- oder netcup-Server betreibt, öffnet für jeden Lauf gern eine völlig cookielose Sitzung aus einem Rechenzentrums-IP-Bereich – genau die Kombination, die reCAPTCHA v3 mit einem niedrigen Score quittiert und bei v2 häufiger die sichtbare Bildabfrage auslöst.

Welche Cookies reCAPTCHA setzt

reCAPTCHA-eigene Cookies

Google-Konto-Cookies (Einfluss auf den Score)

Drittanbieter-Cookies im reCAPTCHA-Kontext

Die rc::-Cookies sind das Kurzzeitgedächtnis einer Sitzung, _GRECAPTCHA trägt das Vertrauen über Seiten und Besuche hinweg, und Google-Konto-Cookies wie SID heben den Ausgangs-Score zusätzlich an.

Cookies in der Automatisierung verwalten

Strategie 1: Persistenter Cookie-Speicher (requests)

Cookies über alle Anfragen hinweg behalten, um Sitzungsvertrauen aufzubauen:

import requests
import pickle
import os

class CookieManager:
    """Manage cookies for reCAPTCHA sessions."""

    def __init__(self, cookie_file="cookies.pkl"):
        self.cookie_file = cookie_file
        self.session = requests.Session()
        self.load_cookies()

    def load_cookies(self):
        """Load cookies from disk if they exist."""
        if os.path.exists(self.cookie_file):
            with open(self.cookie_file, "rb") as f:
                self.session.cookies = pickle.load(f)

    def save_cookies(self):
        """Save cookies to disk for next session."""
        with open(self.cookie_file, "wb") as f:
            pickle.dump(self.session.cookies, f)

    def visit_page(self, url):
        """Visit a page to collect cookies."""
        headers = {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                          "AppleWebKit/537.36 (KHTML, like Gecko) "
                          "Chrome/120.0.0.0 Safari/537.36",
        }
        response = self.session.get(url, headers=headers, timeout=15)
        self.save_cookies()
        return response

    def get_recaptcha_cookies(self):
        """Get cookies relevant to reCAPTCHA."""
        relevant = {}
        for cookie in self.session.cookies:
            if cookie.name in ["_GRECAPTCHA", "SID", "HSID", "SSID", "NID"]:
                relevant[cookie.name] = {
                    "value": cookie.value[:20] + "...",
                    "domain": cookie.domain,
                    "expires": cookie.expires,
                }
            if cookie.name.startswith("rc::"):
                relevant[cookie.name] = {
                    "value": cookie.value[:20] + "...",
                    "domain": cookie.domain,
                }
        return relevant


# Usage
cm = CookieManager("recaptcha_session.pkl")
cm.visit_page("https://example.com/login")  # Build cookies
print(cm.get_recaptcha_cookies())

Strategie 2: Cookie-Übernahme in Selenium

from selenium import webdriver
import json

def setup_cookies(driver, cookie_file="selenium_cookies.json"):
    """Load and apply saved cookies to a Selenium session."""
    if not os.path.exists(cookie_file):
        return

    with open(cookie_file, "r") as f:
        cookies = json.load(f)

    for cookie in cookies:
        # Selenium requires the domain to match current page
        try:
            driver.add_cookie(cookie)
        except Exception:
            pass  # Skip cookies for different domains

def save_cookies(driver, cookie_file="selenium_cookies.json"):
    """Save current cookies for future sessions."""
    cookies = driver.get_cookies()
    with open(cookie_file, "w") as f:
        json.dump(cookies, f)

# Usage
driver = webdriver.Chrome()
driver.get("https://example.com")
setup_cookies(driver)  # Apply saved cookies
driver.refresh()       # Reload with cookies

# After CAPTCHA solving...
save_cookies(driver)   # Save for next run

Strategie 3: Cookie-Übernahme in Puppeteer

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

async function manageCookies(page, cookieFile = "cookies.json") {
    // Load cookies if file exists
    if (fs.existsSync(cookieFile)) {
        const cookies = JSON.parse(fs.readFileSync(cookieFile));
        await page.setCookie(...cookies);
    }

    // Save cookies after page interaction
    const saveCookies = async () => {
        const cookies = await page.cookies();
        fs.writeFileSync(cookieFile, JSON.stringify(cookies, null, 2));
    };

    return { saveCookies };
}

(async () => {
    const browser = await puppeteer.launch({ headless: false });
    const page = await browser.newPage();

    const { saveCookies } = await manageCookies(page);

    await page.goto("https://example.com/login");

    // ... solve CAPTCHA ...

    await saveCookies();
    await browser.close();
})();

Für alle drei Wege gilt derselbe Grundsatz: Cookies zwischen den Läufen ablegen, beim Start wieder einspielen und regelmäßig durch einen echten Seitenbesuch auffrischen – so beginnt nicht jeder Durchlauf beim Nullpunkt.

Was Chromes Cookie-Abschaffung für reCAPTCHA bedeutet

Chrome baut Drittanbieter-Cookies schrittweise ab. Das betrifft reCAPTCHA, weil _GRECAPTCHA auf .google.com gesetzt und aus einem Drittanbieter-Kontext gelesen wird.

Googles Antwort darauf:

• reCAPTCHA v3 und Enterprise führen ihr JavaScript als Erstanbieter aus.
• Cookies wandern in den partitionierten Speicher (Partitioned/CHIPS).
• Die rc::-Cookies sind ohnehin schon Erstanbieter-Cookies, gesetzt auf der Domain der Zielseite.

Folgen für die Automatisierung:

• Gering. API-basiertes Lösen bleibt unberührt, da CaptchaAI die Token serverseitig erzeugt.
• Bei browserbasierter Automatisierung sind kleinere Score-Verschiebungen möglich, während Google seine Cookie-Strategie umstellt.

Ein Hinweis zur Rechtslage: In der EU zählen Cookie-Kennungen und IP-Adressen als personenbezogene Daten. Wer Sitzungen produktiv speichert und wiederverwendet, sollte die eigene Rechtsgrundlage nach DSGVO und die Datenflüsse dokumentieren.

Cookie-Probleme schnell beheben

Sitzungsanforderungen beim API-Lösen

Wenn Sie CaptchaAI nutzen, erzeugt der Solver das Token in seiner eigenen Umgebung. Die Zielseite validiert dieses Token, ohne die Cookies Ihres Browsers zu prüfen. Manche Implementierungen fügen jedoch eine zusätzliche Prüfung hinzu.

Standard-reCAPTCHA (die Mehrheit der Seiten)

Keine Cookie-Übergabe nötig. CaptchaAI erzeugt ein gültiges Token allein aus sitekey und pageurl:

import requests
import time

API_KEY = "YOUR_API_KEY"

# Standard solve — no cookies needed
submit = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "userrecaptcha",
    "googlekey": "SITE_KEY",
    "pageurl": "https://example.com/login",
    "json": 1,
})

Cookie-gebundene Implementierungen

Einige Seiten mit erhöhten Sicherheitsanforderungen prüfen, ob die Sitzung, die das Token absendet, mit der Sitzung übereinstimmt, die das reCAPTCHA-Widget geladen hat. In diesen Fällen gehen Sie so vor:

1. Seite in einem echten Browser laden, damit die Cookies gesetzt werden
2. Sitekey aus der geladenen Seite auslesen
3. Sitekey und Page-URL an CaptchaAI übermitteln
4. Das zurückgegebene Token in dasselbe Formularfeld derselben Browsersitzung eintragen
5. Formular aus dem Browser absenden (Cookie-Kette bleibt erhalten)

from selenium import webdriver
from selenium.webdriver.common.by import By
import requests
import time

API_KEY = "YOUR_API_KEY"

# Step 1: Load page in real browser (establishes cookies)
driver = webdriver.Chrome()
driver.get("https://secure-site.com/login")

# Step 2: Extract sitekey
widget = driver.find_element(By.CSS_SELECTOR, "[data-sitekey]")
sitekey = widget.get_attribute("data-sitekey")

# Step 3: Solve via CaptchaAI
submit = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "userrecaptcha",
    "googlekey": sitekey,
    "pageurl": driver.current_url,
    "json": 1,
})
task_id = submit.json()["request"]

for _ in range(60):
    time.sleep(5)
    result = requests.get("https://ocr.captchaai.com/res.php", params={
        "key": API_KEY,
        "action": "get",
        "id": task_id,
        "json": 1,
    }).json()

    if result.get("status") == 1:
        token = result["request"]
        break

# Step 4: Inject token into browser session (same cookies)
driver.execute_script(
    f'document.getElementById("g-recaptcha-response").value = "{token}";'
)

# Step 5: Submit form from same browser session
driver.find_element(By.CSS_SELECTOR, "form").submit()

Häufige Fragen

Brauche ich Cookies, wenn ich reCAPTCHA über die CaptchaAI-API löse?

Nein. CaptchaAI erzeugt das Token in einer eigenen, optimierten Umgebung und benötigt keine Browser-Cookies. Sie übergeben nur sitekey und pageurl. Das erzeugte Token ist für die Übermittlung durch jeden Client gültig.

Verbessern Google-Konto-Cookies wie SID meinen reCAPTCHA-Score?

Ja, moderat. Cookies einer angemeldeten Google-Sitzung (SID, HSID, NID) heben den Ausgangs-Score an – SID etwa um +0,1 bis +0,3. Sie sind ein Vertrauenssignal unter mehreren; das Verhalten während der Sitzung bleibt der stärkere Faktor.

Warum schlägt ein zuvor gültiges Token beim zweiten Versuch fehl?

Meist stimmen die Sitzungscookies nicht mehr überein. Wenn Sie die Seite in einer Sitzung laden, das Token aber aus einer anderen absenden, bricht die Cookie-Kette. Nutzen Sie für Laden, Eintragen und Absenden durchgehend dieselbe Browsersitzung. Beachten Sie außerdem, dass reCAPTCHA-Token kurzlebig sind – lösen Sie unmittelbar vor dem Absenden.

Was ändert Chromes Abschaffung der Drittanbieter-Cookies für die Automatisierung?

Für API-basiertes Lösen nichts, da die Token serverseitig entstehen. Bei browserbasierter Automatisierung kann sich der Score leicht verschieben, weil _GRECAPTCHA in den partitionierten Speicher (CHIPS) wandert. Die rc::-Cookies sind bereits Erstanbieter und bleiben unverändert.

Kann ich gespeicherte Cookies zwischen Tools wie Selenium und Puppeteer wiederverwenden?

Ja, mit Einschränkungen. Cookies lassen sich als JSON oder im Netscape-Format exportieren und in requests-, Selenium- oder Puppeteer-Sitzungen importieren. Da sich die Browser-Umgebung unterscheidet, gewichtet reCAPTCHA den Vertrauensbonus aus den Cookies aber unter Umständen anders.

Fazit

reCAPTCHA nutzt Cookies für die Sitzungsverfolgung (rc::), für seitenübergreifendes Vertrauen (_GRECAPTCHA) und für die Verknüpfung mit dem Google-Konto (SID, HSID). Frische Sitzungen ohne Cookies bedeuten niedrigere Scores und häufigere Challenges. Für das API-basierte Lösen mit CaptchaAI sind Cookies nicht nötig – der Solver erzeugt gültige Token allein aus Sitekey und Page-URL. Für cookie-gebundene Implementierungen gilt der browserbasierte Weg: Seite laden (Cookies setzen), per CaptchaAI lösen, Token eintragen und aus derselben Browsersitzung absenden.

Verwandte Leitfäden

• reCAPTCHA-Cookie-Anforderungen im Detail
• Der reCAPTCHA-Parameter data-s erklärt
• Warum reCAPTCHA v3 niedrige Scores liefert