reCAPTCHA-Cookie- und Sitzungsanforderungen zur Lösung

reCAPTCHA nutzt Cookies zur Sitzungsverfolgung, Risikobewertung und Verwaltung des Herausforderungsstatus. Fehlende oder falsch behandelte Cookies führen zu Lösungsfehlern, niedrigen Punktzahlen und wiederholten Herausforderungen. In diesem Leitfaden werden alle von reCAPTCHA verwendeten Cookies, die Auswirkungen von Sitzungen auf die Bewertung und die praktische Cookie-Verwaltung zur Automatisierung behandelt.

Cookies, die reCAPTCHA setzt und verwendet

reCAPTCHA-spezifische Cookies

Google-Konto-Cookies (beeinflussen den Score)

Von reCAPTCHA verwendete Cookies von Drittanbietern

Wie sich Cookies auf die reCAPTCHA-Bewertung auswirken

Neue Sitzung (keine 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)

Cookie-Management in der Automatisierung

Strategie 1: Dauerhafte Keksdose

Behalten Sie Cookies über alle Anfragen hinweg bei, 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-Weiterleitung 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-Weiterleitung 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();
})();

Sitzungsanforderungen für API-basiertes Lösen

Bei Verwendung von CaptchaAI generiert der Solver Token in seiner eigenen Umgebung. Die Zielwebsite validiert das Token, ohne die Cookies Ihres Browsers zu überprüfen. Einige Implementierungen fügen jedoch eine zusätzliche Validierung hinzu:

Standard-reCAPTCHA (die meisten Websites)

Keine Cookie-Weiterleitung erforderlich. CaptchaAI generiert ein gültiges Token nur unter Verwendung von 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-abhängige Implementierungen

Einige Hochsicherheitsseiten überprüfen, ob die Sitzung, die das Token übermittelt, mit der Sitzung übereinstimmt, die das reCAPTCHA-Widget geladen hat. In diesen Fällen:

1. Laden Sie die Seite in einem echten Browser, um Cookies einzurichten
2. Extrahieren Sie den Sitekey von der geladenen Seite
3. Mit Sitekey und Pageurl an CaptchaAI senden
4. Fügen Sie das zurückgegebene Token in dieselbe Browsersitzung ein
5. Senden Sie das Formular über den Browser (unter Beibehaltung der Cookie-Kette)

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

Auswirkungen der Blockierung von Cookies von Drittanbietern

Einstellung der Drittanbieter-Cookies von Chrome

Chrome stellt Drittanbieter-Cookies schrittweise ein. Dies wirkt sich auf reCAPTCHA aus, da _GRECAPTCHA auf .google.com gesetzt ist und aus dem Kontext eines Drittanbieters gelesen wird.

Antwort von Google:

• reCAPTCHA v3 und Enterprise verwenden die JavaScript-Ausführung eines Erstanbieters
• Cookies werden in den Partitioned (CHIPS)-Speicher überführt
• rc::-Cookies sind bereits Erstanbieter-Cookies (auf der Domäne der Zielseite festgelegt).

Auswirkungen auf die Automatisierung:

• Minimal. Die API-basierte Lösung ist davon nicht betroffen, da CaptchaAI Token serverseitig generiert.
• Bei der browserbasierten Automatisierung kann es zu geringfügigen Änderungen der Bewertung kommen, da Google seine Cookie-Strategie anpasst.

Fehlerbehebung bei Cookies

Häufig gestellte Fragen

Muss ich Cookies an CaptchaAI weitergeben?

Nein. CaptchaAI generiert Token in seiner eigenen optimierten Umgebung und benötigt keine Browser-Cookies. Sie müssen nur sitekey und pageurl angeben. Das generierte Token ist für die Übermittlung durch jeden Client gültig.

Verfallen Cookies und müssen aktualisiert werden?

Ja. _GRECAPTCHA dauert 6 Monate, aber rc::-Sitzungscookies verfallen, wenn der Browser geschlossen wird. Google-Konto-Cookies (SID, HSID) haben eine Lebensdauer von 2 Jahren, können aber von Google ungültig gemacht werden. Behalten Sie Cookies zur Automatisierung auf der Festplatte bei und aktualisieren Sie sie regelmäßig, indem Sie die Zielsite besuchen.

Kann ich Cookies von einem Browser in einem anderen verwenden?

Ja, mit Einschränkungen. Cookies können exportiert (im JSON- oder Netscape-Format) und in Anfragen, Selenium- oder Puppeteer-Sitzungen importiert werden. Der Browser-Signalprofil unterscheidet sich jedoch, was reCAPTCHA möglicherweise erkennt. Die Cookies bieten einen Vertrauensbonus, der jedoch durch die neue Browserumgebung möglicherweise ausgeglichen wird.

Warum macht das Löschen von Cookies reCAPTCHA schwieriger?

Durch das Löschen von Cookies werden das Vertrauenscookie _GRECAPTCHA und die Verhaltensverlaufscookies rc:: entfernt. reCAPTCHA behandelt Sie als völlig neuen Besucher ohne Historie und beginnt mit einer niedrigeren Risikobewertung. Aus diesem Grund löst das Surfen im Inkognito-Modus oft mehr CAPTCHA-Herausforderungen aus.

Zusammenfassung

reCAPTCHA verwendet Cookies für die Sitzungsverfolgung (rc::-Cookies), die cross-site Vertrauensstellung (_GRECAPTCHA) und die Google-Konto-Verknüpfung (SID, HSID). Neue Sitzungen ohne Cookies führen zu niedrigeren Scores und schwieriger Herausforderungen. Für API-basiertes Lösen mit CaptchaAI sind Cookies nicht erforderlich – der Solver generiert gültige Token nur mit Site-Key und Seiten-URL. Für Cookie-abhängige Implementierungen: Seite laden (Cookies setzen), mit CaptchaAI lösen, Token einfügen und aus derselben Browser-Session absenden.

Verwandte Leitfäden

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