ERROR_WRONG_GOOGLEKEY: Vollständige Diagnose- und Fehlerbehebungsanleitung

Wenn CaptchaAI ERROR_WRONG_GOOGLEKEY zurückgibt, passt der übermittelte googlekey nicht zu dem Sitekey, den die Zielseite tatsächlich lädt. Fast immer steckt eine von drei Ursachen dahinter: Der Schlüssel stammt aus dem falschen iframe, er ist veraltet, oder die Seite nutzt eine Enterprise- oder unsichtbare reCAPTCHA-Variante, die ohne das passende Flag nicht angenommen wird. Diese Anleitung führt Sie in wenigen Minuten zum richtigen Sitekey.

Was löst ERROR_WRONG_GOOGLEKEY aus?

Der Fehler ist immer ein Parameterproblem – kein Kapazitäts- oder Plan-Thema. Diese Ursachen decken praktisch alle Fälle ab:

Ein typisches DACH-Szenario: Ein Worker auf einem Hetzner-Server prüft automatisiert Termine auf einem BLS-Visa-Portal. Der Sitekey wird dort per JavaScript in einem iframe nachgeladen – wer ihn aus dem statischen HTML zieht, übermittelt einen leeren oder veralteten Wert und erhält prompt ERROR_WRONG_GOOGLEKEY. Die Korrektur liegt dann nicht in der API, sondern in der Extraktion.

Prüfen Sie außerdem, ob die an CaptchaAI übergebene pageurl exakt zur Domain gehört, auf der der Sitekey ausgeliefert wird. Ein Sitekey ist an seine Herkunftsdomain gebunden: Wird er mit einer abweichenden pageurl kombiniert, lehnt Google die Lösung ab und die API meldet ERROR_WRONG_GOOGLEKEY. Gerade bei automatisierten Läufen auf fremden Portalen lohnt zudem ein Blick auf die datenschutzrechtliche Grundlage – IP-Adressen gelten in der EU als personenbezogene Daten, sodass Sie Ihre Datenflüsse und die Rechtsgrundlage vorab dokumentieren sollten.

Den richtigen Sitekey finden

Methode 1: Suche im Seitenquelltext

Liefert eine Seite den Sitekey direkt im HTML aus, genügt ein einzelner Request. Die folgende Funktion prüft die vier gängigsten Muster nacheinander:

import re
import requests


def extract_sitekey(page_url):
    """Extract reCAPTCHA sitekey from page source."""
    resp = requests.get(page_url, timeout=15)
    html = resp.text

    # Pattern 1: data-sitekey attribute
    match = re.search(r'data-sitekey="([^"]+)"', html)
    if match:
        return match.group(1)

    # Pattern 2: grecaptcha.render call
    match = re.search(r"grecaptcha\.render\([^,]+,\s*\{[^}]*sitekey['\"]?\s*:\s*['\"]([^'\"]+)", html)
    if match:
        return match.group(1)

    # Pattern 3: grecaptcha.execute call
    match = re.search(r"grecaptcha\.execute\(['\"]([^'\"]+)", html)
    if match:
        return match.group(1)

    # Pattern 4: reCAPTCHA script src
    match = re.search(r"recaptcha/api\.js\?render=([^&\"]+)", html)
    if match:
        return match.group(1)

    return None


sitekey = extract_sitekey("https://example.com/login")
print(f"Sitekey: {sitekey}")

Methode 2: Browser-DevTools

Findet der reguläre Request keinen Wert, hilft der Blick in die geöffnete Seite:

1. Zielseite in Chrome öffnen
2. F12 drücken → Tab Elemente
3. Strg+F drücken und nach sitekey suchen
4. Attribut data-sitekey="..." lokalisieren
5. Wert kopieren (alphanumerische Zeichenfolge mit rund 40 Zeichen)

Methode 3: Netzwerk-Tab

Bei unsichtbarem reCAPTCHA steht der Schlüssel oft nur in der Anfrage-URL:

1. F12 → Tab Netzwerk öffnen
2. nach recaptcha filtern
3. Anfrage an google.com/recaptcha/api2/anchor suchen
4. Parameter k= in der URL auslesen – das ist der Sitekey

Sitekey vor der Übermittlung validieren

Ein kurzer Format-Check fängt leere oder offensichtlich falsche Werte ab, bevor sie überhaupt an die API gehen:

import re


def validate_sitekey(sitekey):
    """Validate sitekey format before API call."""
    if not sitekey:
        raise ValueError("Sitekey is empty")

    # Standard format: 40 alphanumeric + hyphens/underscores
    if not re.match(r'^[a-zA-Z0-9_-]{20,60}$', sitekey):
        raise ValueError(f"Invalid sitekey format: {sitekey}")

    return True


# Use before solving
sitekey = extract_sitekey("https://example.com/login")
validate_sitekey(sitekey)

reCAPTCHA Enterprise erkennen und behandeln

Enterprise-Sitekeys sehen identisch aus, verlangen aber den Parameter enterprise. Ob eine Seite Enterprise nutzt, verrät die geladene Skriptdatei recaptcha/enterprise.js:

import requests

# Standard reCAPTCHA — loads via recaptcha/api.js
# Enterprise reCAPTCHA — loads via recaptcha/enterprise.js

def detect_enterprise(page_url):
    """Detect if page uses reCAPTCHA Enterprise."""
    resp = requests.get(page_url, timeout=15)
    return "recaptcha/enterprise.js" in resp.text


# Submit with enterprise flag
is_enterprise = detect_enterprise("https://example.com")

data = {
    "key": "YOUR_API_KEY",
    "method": "userrecaptcha",
    "googlekey": sitekey,
    "pageurl": "https://example.com",
    "json": 1,
}

if is_enterprise:
    data["enterprise"] = 1

resp = requests.post("https://ocr.captchaai.com/in.php", data=data)

Unsichtbares reCAPTCHA behandeln

Unsichtbares reCAPTCHA blendet keine sichtbare Box ein und lässt sich an data-size="invisible" oder einem grecaptcha.execute(-Aufruf erkennen. Setzen Sie in diesem Fall invisible=1:

def detect_invisible(html):
    """Detect invisible reCAPTCHA."""
    indicators = [
        'data-size="invisible"',
        "grecaptcha.execute(",
        "recaptcha/api.js?render=",
    ]
    return any(i in html for i in indicators)


# Submit with invisible flag
data = {
    "key": "YOUR_API_KEY",
    "method": "userrecaptcha",
    "googlekey": sitekey,
    "pageurl": "https://example.com",
    "invisible": 1,
    "json": 1,
}

Dynamische Sitekeys per Browser extrahieren

Manche Seiten setzen den Sitekey erst per JavaScript – ein reiner HTTP-Request liefert dann nichts. Hier extrahiert ein Headless-Browser den Wert, notfalls direkt aus dem iframe-Parameter k:

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


def extract_dynamic_sitekey(url):
    """Extract sitekey from JavaScript-rendered page."""
    driver = webdriver.Chrome()
    driver.get(url)

    # Wait for reCAPTCHA to load
    import time
    time.sleep(3)

    # Try data-sitekey attribute
    elements = driver.find_elements(By.CSS_SELECTOR, "[data-sitekey]")
    if elements:
        sitekey = elements[0].get_attribute("data-sitekey")
        driver.quit()
        return sitekey

    # Try iframe src parameter
    iframes = driver.find_elements(By.CSS_SELECTOR, "iframe[src*='recaptcha']")
    for iframe in iframes:
        src = iframe.get_attribute("src")
        import re
        match = re.search(r'[?&]k=([^&]+)', src)
        if match:
            driver.quit()
            return match.group(1)

    driver.quit()
    return None

Schnelle Fehlerbehebung im Überblick

Häufige Fragen

Warum erscheint ERROR_WRONG_GOOGLEKEY, obwohl der Sitekey korrekt aussieht?

Meist fehlt ein Flag: Enterprise-Seiten brauchen enterprise=1, unsichtbares reCAPTCHA invisible=1. Ebenso häufig stammt der Schlüssel aus dem iframe einer anderen Domain und passt deshalb nicht zur pageurl.

Woran erkenne ich, ob eine Seite reCAPTCHA Enterprise nutzt?

An der eingebundenen Skriptdatei: recaptcha/enterprise.js steht für Enterprise, recaptcha/api.js für Standard-reCAPTCHA. Der Sitekey allein verrät die Variante nicht.

Muss ich für jede Anfrage einen neuen Sitekey extrahieren?

Nein. Sie können den Wert für Minuten bis Stunden zwischenspeichern. Rotiert eine Seite ihre Schlüssel oder häufen sich Fehler, extrahieren Sie ihn erneut.

Hilft ein anderer CaptchaAI-Plan gegen diesen Fehler?

Nein. ERROR_WRONG_GOOGLEKEY ist ein Parameterfehler und unabhängig von Plan oder Thread-Anzahl – ein Wechsel von BASIC (15 $/Monat, 5 Threads) auf ein größeres Paket ändert nichts. Korrigieren Sie stattdessen die Sitekey-Extraktion.

Was ist der Unterschied zwischen Sitekey und pageurl?

Der Sitekey identifiziert die reCAPTCHA-Instanz, die pageurl die Seite, auf der sie eingebunden ist. CaptchaAI benötigt beide Angaben korrekt und zueinander passend – stimmt eine davon nicht, schlägt die Lösung mit ERROR_WRONG_GOOGLEKEY fehl.

Verwandte Leitfäden

• API-Antwortformate und Fehlercodes verstehen
• reCAPTCHA-Sitekey-Parameter aus dem Quelltext extrahieren

Den korrekten Sitekey übergeben und reCAPTCHA mit CaptchaAI lösen.