Häufige reCAPTCHA Invisible-Fehler und Korrekturen

Unsichtbares reCAPTCHA entfernt das Kontrollkästchen – fügt jedoch neue Fehlermodi zur Automatisierung hinzu. Die größten Probleme sind das unsichtbare Widget überhaupt nicht zu erkennen, das Fehlen der Rückruffunktion, das Senden abgelaufener Token und die Verwendung von v2-Standardparametern, wenn unsichtbare Parameter erforderlich sind.

In diesem Leitfaden werden alle gängigen Fehlermuster mit der genauen Lösung behandelt. Wenn Sie Hintergrundinformationen zur Funktionsweise von unsichtbarem reCAPTCHA benötigen, lesen Sie Wie reCAPTCHA Invisible funktioniert und wie man es löst zuerst.

Schnelle Fehlerreferenz

Fehler 1: Unsichtbares reCAPTCHA wird auf der Seite nicht erkannt

Unsichtbares reCAPTCHA hat kein sichtbares Kontrollkästchen. Wenn Ihr Scraper dies nicht erkennt, scheitern Captcha-geschützte Anfragen stillschweigend mit Formularübermittlungsfehlern oder Weiterleitungen.

So erkennen Sie unsichtbares reCAPTCHA

Suchen Sie im HTML der Seite nach diesen Mustern:

<!-- Pattern 1: div with data-size="invisible" -->
<div class="g-recaptcha" data-sitekey="6LdKlZEU..."
     data-size="invisible"
     data-callback="onSubmit"></div>

<!-- Pattern 2: button with data-sitekey and invisible size -->
<button class="g-recaptcha"
        data-sitekey="6LdKlZEU..."
        data-callback="onSubmit"
        data-action="submit">Submit</button>

<!-- Pattern 3: programmatic render with size: invisible -->
<script>
  grecaptcha.render('submit-btn', {
    sitekey: '6LdKlZEU...',
    callback: onSubmit,
    size: 'invisible'
  });
</script>

Erkennungsskript (Python):

import requests
from bs4 import BeautifulSoup
import re

def detect_invisible_recaptcha(url):
    resp = requests.get(url)
    soup = BeautifulSoup(resp.text, "html.parser")

    # Check for data-size="invisible"
    widget = soup.find("div", {"data-size": "invisible", "class": "g-recaptcha"})
    if widget:
        return {
            "type": "invisible",
            "sitekey": widget.get("data-sitekey"),
            "callback": widget.get("data-callback")
        }

    # Check for programmatic render with invisible
    scripts = soup.find_all("script")
    for script in scripts:
        if script.string and "size" in str(script.string) and "invisible" in str(script.string):
            key_match = re.search(r"sitekey['\"]?\s*[:=]\s*['\"]([^'\"]+)", script.string)
            if key_match:
                return {
                    "type": "invisible-programmatic",
                    "sitekey": key_match.group(1),
                    "callback": "check grecaptcha.render() call"
                }

    return None

Erkennungsskript (Node.js):

const axios = require("axios");
const cheerio = require("cheerio");

async function detectInvisibleRecaptcha(url) {
  const { data } = await axios.get(url);
  const $ = cheerio.load(data);

  // Check for data-size="invisible"
  const widget = $(".g-recaptcha[data-size='invisible']");
  if (widget.length) {
    return {
      type: "invisible",
      sitekey: widget.attr("data-sitekey"),
      callback: widget.attr("data-callback"),
    };
  }

  // Check script tags for programmatic invisible render
  const scriptContent = $("script")
    .map((_, el) => $(el).html())
    .get()
    .join("\n");
  if (scriptContent.includes("invisible")) {
    const keyMatch = scriptContent.match(/sitekey['"]?\s*[:=]\s*['"]([^'"]+)/);
    if (keyMatch) {
      return {
        type: "invisible-programmatic",
        sitekey: keyMatch[1],
        callback: "check grecaptcha.render() call",
      };
    }
  }

  return null;
}

Fehler 2: Falscher Sitekey – ERROR_WRONG_GOOGLEKEY

Dies geschieht, wenn Sie einen Sitekey senden, der nicht mit dem unsichtbaren reCAPTCHA-Widget auf der Zielseite übereinstimmt. Häufige Ursachen:

• Der Sitekey wurde aus einem v2-Kontrollkästchen auf einer anderen Seite kopiert
• Es wurde ein Sitekey von der Anker-URL einer anderen reCAPTCHA-Version verwendet
• Die Seite enthält mehrere reCAPTCHA-Widgets und Sie haben das falsche ausgewählt

Fix: Extrahieren Sie den richtigen unsichtbaren Sitekey

import requests
from bs4 import BeautifulSoup

def get_invisible_sitekey(url):
    resp = requests.get(url)
    soup = BeautifulSoup(resp.text, "html.parser")

    # Priority 1: invisible widget
    widget = soup.find(attrs={"data-size": "invisible", "class": "g-recaptcha"})
    if widget:
        return widget["data-sitekey"]

    # Priority 2: any g-recaptcha div (may be invisible without data-size)
    widget = soup.find(class_="g-recaptcha")
    if widget and widget.get("data-sitekey"):
        return widget["data-sitekey"]

    return None

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

Fehler 3: Rückruf nicht ausgeführt – Formular wird gesendet, aber es passiert nichts

Dies ist der häufigste unsichtbare reCAPTCHA-Fehler, den Entwickler übersehen. Im Gegensatz zum Kontrollkästchen v2, bei dem das Einfügen des Tokens in g-recaptcha-response ausreicht, verwendet unsichtbares reCAPTCHA fast immer eine JavaScript-Rückruffunktion. Wenn Sie das Token einfügen, aber den Rückruf nicht aufrufen, wird das Formular nie verarbeitet.

So funktioniert der Rückrufablauf

1. grecaptcha.execute() löst die unsichtbare Herausforderung aus
2. Nach der Lösung ruft Google die in data-callback angegebene Funktion auf
3. Diese Rückruffunktion sendet das Formular oder führt den API-Aufruf durch

Fix: Suchen Sie den Rückruf und führen Sie ihn aus

Schritt 1 – Identifizieren Sie den Rückrufnamen:

# From HTML: data-callback="onSubmit"
# From JS: callback: onSubmit
# From grecaptcha.render: second argument with callback property

Schritt 2 – Token einfügen UND Rückruf aufrufen (Selenium):

from selenium import webdriver
import requests
import time

driver = webdriver.Chrome()
driver.get("https://example.com/form")

# Get sitekey
sitekey = driver.find_element("css selector", ".g-recaptcha").get_attribute("data-sitekey")
callback_name = driver.find_element("css selector", ".g-recaptcha").get_attribute("data-callback")

# Mit CaptchaAI lösen
task_id = requests.get("https://ocr.captchaai.com/in.php", params={
    "key": "YOUR_API_KEY",
    "method": "userrecaptcha",
    "googlekey": sitekey,
    "pageurl": driver.current_url,
    "invisible": 1
}).text.split("|")[1]

# Poll for result
token = None
for _ in range(60):
    time.sleep(5)
    resp = requests.get("https://ocr.captchaai.com/res.php", params={
        "key": "YOUR_API_KEY",
        "action": "get",
        "id": task_id
    }).text
    if resp.startswith("OK|"):
        token = resp.split("|")[1]
        break

# Inject token into the response field
driver.execute_script(
    f'document.getElementById("g-recaptcha-response").value = "{token}";'
)

# CRITICAL: Call the callback function
driver.execute_script(f'{callback_name}("{token}");')

Schritt 2 – Token einfügen UND Rückruf aufrufen (Puppeteer):

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

(async () => {
  const browser = await puppeteer.launch({ headless: "new" });
  const page = await browser.newPage();
  await page.goto("https://example.com/form");

  // Get sitekey and callback
  const { sitekey, callback } = await page.evaluate(() => {
    const el = document.querySelector(".g-recaptcha[data-size='invisible']");
    return {
      sitekey: el?.getAttribute("data-sitekey"),
      callback: el?.getAttribute("data-callback"),
    };
  });

  // Submit to CaptchaAI
  const submitResp = await axios.get("https://ocr.captchaai.com/in.php", {
    params: {
      key: "YOUR_API_KEY",
      method: "userrecaptcha",
      googlekey: sitekey,
      pageurl: page.url(),
      invisible: 1,
    },
  });
  const taskId = submitResp.data.split("|")[1];

  // Poll for result
  let token;
  for (let i = 0; i < 60; i++) {
    await new Promise((r) => setTimeout(r, 5000));
    const result = await axios.get("https://ocr.captchaai.com/res.php", {
      params: { key: "YOUR_API_KEY", action: "get", id: taskId },
    });
    if (result.data.startsWith("OK|")) {
      token = result.data.split("|")[1];
      break;
    }
  }

  // Inject token and fire callback
  await page.evaluate(
    (tok, cb) => {
      document.getElementById("g-recaptcha-response").value = tok;
      if (cb && typeof window[cb] === "function") {
        window[cb](tok);
      }
    },
    token,
    callback,
  );

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

Fehler 4: Fehlender Parameter invisible=1

Wenn Sie unsichtbares reCAPTCHA über CaptchaAI lösen, müssen Sie invisible=1 in Ihre Anfrage aufnehmen. Ohne sie behandelt der Solver die Aufgabe als Standard-Kontrollkästchen-Herausforderung der Version 2, was zu ERROR_CAPTCHA_UNSOLVABLE oder Tokens führen kann, die von der Zielsite abgelehnt werden.

Falsche vs. richtige Anfrage

# WRONG — missing invisible=1
params = {
    "key": "YOUR_API_KEY",
    "method": "userrecaptcha",
    "googlekey": sitekey,
    "pageurl": page_url
}

# CORRECT — includes invisible=1
params = {
    "key": "YOUR_API_KEY",
    "method": "userrecaptcha",
    "googlekey": sitekey,
    "pageurl": page_url,
    "invisible": 1  # Required for invisible reCAPTCHA
}

response = requests.get("https://ocr.captchaai.com/in.php", params=params)

Fehler 5: Token ist vor der Übermittlung abgelaufen

Unsichtbare reCAPTCHA-Tokens verfallen in 120 Sekunden – genau wie beim v2-Standard. Bei unsichtbaren Arbeitsabläufen gibt es jedoch häufig zusätzliche Verarbeitungsschritte zwischen Lösung und Übermittlung, wodurch der Ablauf wahrscheinlicher wird.

Symptome

• Das Formular gibt nach der Token-Injektion einen allgemeinen Fehler zurück
• Serverseitig gibt siteverify timeout-or-duplicate zurück
• Das Token war gültig, es dauerte jedoch zu lange, bis es den Absendeschritt erreichte

Fix: Just-in-Time-Lösung

Fordern Sie die Lösung erst an, wenn Sie bereit sind, sie sofort einzureichen:

import requests
import time

def solve_invisible_recaptcha(api_key, sitekey, page_url):
    # Submit task
    resp = requests.get("https://ocr.captchaai.com/in.php", params={
        "key": api_key,
        "method": "userrecaptcha",
        "googlekey": sitekey,
        "pageurl": page_url,
        "invisible": 1
    })
    if not resp.text.startswith("OK|"):
        raise Exception(f"Submit failed: {resp.text}")
    task_id = resp.text.split("|")[1]

    # Poll for result
    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
        })
        if result.text.startswith("OK|"):
            return result.text.split("|")[1]
        if result.text != "CAPCHA_NOT_READY":
            raise Exception(f"Solve failed: {result.text}")

    raise Exception("Solve timed out after 5 minutes")

# Usage: solve JUST before you need to submit
# 1. Navigate to page and prepare form data first
# 2. THEN solve the captcha
# 3. Inject token and submit immediately
token = solve_invisible_recaptcha("YOUR_API_KEY", sitekey, page_url)
# Submit within 120 seconds of receiving the token

Fehler 6: Token abgelehnt – ERROR_BAD_TOKEN_OR_PAGEURL

Die Zielseite hat das Token bei Google überprüft und ist fehlgeschlagen. Häufige Ursachen:

Debug-Checkliste

def debug_invisible_solve(api_key, sitekey, page_url, proxy=None):
    """Run a diagnostic solve with detailed logging."""
    print(f"Sitekey: {sitekey}")
    print(f"Page URL: {page_url}")
    print(f"Proxy: {proxy or 'none'}")

    params = {
        "key": api_key,
        "method": "userrecaptcha",
        "googlekey": sitekey,
        "pageurl": page_url,
        "invisible": 1
    }
    if proxy:
        params["proxy"] = proxy
        params["proxytype"] = "HTTP"

    # Submit
    resp = requests.get("https://ocr.captchaai.com/in.php", params=params)
    print(f"Submit response: {resp.text}")
    if not resp.text.startswith("OK|"):
        return None

    task_id = resp.text.split("|")[1]
    print(f"Task ID: {task_id}")

    # Poll with timing
    start = time.time()
    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
        })
        elapsed = time.time() - start
        print(f"  [{elapsed:.0f}s] {result.text[:50]}")
        if result.text.startswith("OK|"):
            token = result.text.split("|")[1]
            print(f"Token received after {elapsed:.0f}s")
            print(f"Token length: {len(token)} characters")
            print(f"Token starts with: {token[:30]}...")
            return token
        if result.text != "CAPCHA_NOT_READY":
            print(f"FAILED: {result.text}")
            return None

    print("TIMEOUT after 5 minutes")
    return None

Fehler 7: Mehrere reCAPTCHA-Widgets auf einer Seite

Einige Seiten verfügen sowohl über ein sichtbares v2-Kontrollkästchen als auch über ein unsichtbares reCAPTCHA. Wenn Sie das falsche Problem lösen, ist das Token gültig, stimmt aber nicht mit dem Widget überein, das die von Ihnen benötigte Aktion schützt.

Fix: Zielen Sie auf das richtige Widget

from bs4 import BeautifulSoup

def find_all_recaptcha_widgets(html):
    soup = BeautifulSoup(html, "html.parser")
    widgets = []

    for el in soup.find_all(class_="g-recaptcha"):
        widgets.append({
            "sitekey": el.get("data-sitekey"),
            "size": el.get("data-size", "normal"),
            "callback": el.get("data-callback"),
            "tag": el.name,
            "id": el.get("id")
        })

    return widgets

# Example output:
# [
#   {"sitekey": "6LdA...", "size": "normal", "callback": None, "tag": "div", "id": "recaptcha-login"},
#   {"sitekey": "6LdB...", "size": "invisible", "callback": "onRegister", "tag": "div", "id": "recaptcha-register"}
# ]
# Use the widget with size="invisible" for the invisible solve

Vollständiger unsichtbarer reCAPTCHA-Löser mit Fehlerbehandlung

Dieser produktionsbereite Wrapper behandelt alle oben genannten Fehler:

import requests
import time
import logging

logger = logging.getLogger(__name__)

class InvisibleRecaptchaSolver:
    def __init__(self, api_key, max_retries=3):
        self.api_key = api_key
        self.max_retries = max_retries
        self.base_url = "https://ocr.captchaai.com"

    def solve(self, sitekey, page_url, proxy=None):
        """Solve invisible reCAPTCHA with automatic retry on transient errors."""
        for attempt in range(1, self.max_retries + 1):
            try:
                token = self._attempt_solve(sitekey, page_url, proxy)
                if token:
                    return token
            except Exception as e:
                logger.warning(f"Attempt {attempt} failed: {e}")
                if attempt < self.max_retries:
                    time.sleep(2 ** attempt)
        raise Exception(f"Failed to solve after {self.max_retries} attempts")

    def _attempt_solve(self, sitekey, page_url, proxy):
        params = {
            "key": self.api_key,
            "method": "userrecaptcha",
            "googlekey": sitekey,
            "pageurl": page_url,
            "invisible": 1
        }
        if proxy:
            params["proxy"] = proxy
            params["proxytype"] = "HTTP"

        # Submit task
        resp = requests.get(f"{self.base_url}/in.php", params=params)

        if "ERROR" in resp.text:
            error = resp.text.strip()
            if error in ("ERROR_WRONG_GOOGLEKEY", "ERROR_KEY_DOES_NOT_EXIST"):
                raise Exception(f"Configuration error (do not retry): {error}")
            if error == "ERROR_ZERO_BALANCE":
                raise Exception("Account balance is zero — add funds")
            raise Exception(f"Submit error: {error}")

        if not resp.text.startswith("OK|"):
            raise Exception(f"Unexpected submit response: {resp.text}")

        task_id = resp.text.split("|")[1]

        # Poll for result
        for _ in range(60):
            time.sleep(5)
            result = requests.get(f"{self.base_url}/res.php", params={
                "key": self.api_key,
                "action": "get",
                "id": task_id
            })

            if result.text.startswith("OK|"):
                return result.text.split("|")[1]

            if result.text == "CAPCHA_NOT_READY":
                continue

            if result.text == "ERROR_CAPTCHA_UNSOLVABLE":
                logger.warning("Captcha unsolvable — will retry with new task")
                return None

            raise Exception(f"Poll error: {result.text}")

        raise Exception("Solve timed out after 5 minutes")


# Usage
solver = InvisibleRecaptchaSolver("YOUR_API_KEY")
token = solver.solve(
    sitekey="6LdKlZEU...",
    page_url="https://example.com/login"
)
print(f"Token: {token[:50]}...")

const axios = require("axios");

class InvisibleRecaptchaSolver {
  constructor(apiKey, maxRetries = 3) {
    this.apiKey = apiKey;
    this.maxRetries = maxRetries;
    this.baseUrl = "https://ocr.captchaai.com";
  }

  async solve(sitekey, pageUrl, proxy) {
    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
      try {
        const token = await this._attemptSolve(sitekey, pageUrl, proxy);
        if (token) return token;
      } catch (err) {
        console.warn(`Attempt ${attempt} failed: ${err.message}`);
        if (attempt < this.maxRetries) {
          await new Promise((r) => setTimeout(r, 2 ** attempt * 1000));
        }
      }
    }
    throw new Error(`Failed to solve after ${this.maxRetries} attempts`);
  }

  async _attemptSolve(sitekey, pageUrl, proxy) {
    const params = {
      key: this.apiKey,
      method: "userrecaptcha",
      googlekey: sitekey,
      pageurl: pageUrl,
      invisible: 1,
    };
    if (proxy) {
      params.proxy = proxy;
      params.proxytype = "HTTP";
    }

    // Submit task
    const submitResp = await axios.get(`${this.baseUrl}/in.php`, { params });
    if (submitResp.data.includes("ERROR")) {
      const error = submitResp.data.trim();
      if (["ERROR_WRONG_GOOGLEKEY", "ERROR_KEY_DOES_NOT_EXIST"].includes(error)) {
        throw new Error(`Configuration error (do not retry): ${error}`);
      }
      throw new Error(`Submit error: ${error}`);
    }

    const taskId = submitResp.data.split("|")[1];

    // Poll for result
    for (let i = 0; i < 60; i++) {
      await new Promise((r) => setTimeout(r, 5000));
      const result = await axios.get(`${this.baseUrl}/res.php`, {
        params: { key: this.apiKey, action: "get", id: taskId },
      });

      if (result.data.startsWith("OK|")) {
        return result.data.split("|")[1];
      }
      if (result.data === "CAPCHA_NOT_READY") continue;
      if (result.data === "ERROR_CAPTCHA_UNSOLVABLE") return null;
      throw new Error(`Poll error: ${result.data}`);
    }
    throw new Error("Solve timed out after 5 minutes");
  }
}

// Usage
const solver = new InvisibleRecaptchaSolver("YOUR_API_KEY");
solver.solve("6LdKlZEU...", "https://example.com/login").then((token) => {
  console.log(`Token: ${token.substring(0, 50)}...`);
});

Checkliste zur Fehlerbehebung

Gehen Sie diese Checkliste durch, wenn die unsichtbare reCAPTCHA-Lösung fehlschlägt:

FAQ

Wie unterscheidet sich das unsichtbare reCAPTCHA beim Lösen vom v2-Standard?

Die API-Methode ist dieselbe (method=userrecaptcha), Sie müssen jedoch invisible=1 zu Ihrer Anfrage hinzufügen. Der entscheidende Unterschied liegt auf der Injektionsseite: Unsichtbares reCAPTCHA erfordert fast immer den Aufruf einer JavaScript-Rückruffunktion nach der Injektion des Tokens, während v2-Standard normalerweise nur mit dem versteckten Feld funktioniert.

Warum funktioniert mein Token beim Testen, schlägt jedoch in der Produktion fehl?

Wahrscheinlich liegt eine IP-Nichtübereinstimmung vor. Beim Testen teilen sich der Solver und Ihr Browser möglicherweise ähnliche IPs. In der Produktion unterscheiden sich die IP des Solvers und die IP Ihres Servers. Fügen Sie einen Proxy-Parameter hinzu, der Ihrer Sitzungs-IP entspricht, um dieses Problem zu beheben.

Wie lange dauert die Lösung des unsichtbaren reCAPTCHA?

Typische Lösungszeiten betragen 10–30 Sekunden bis CaptchaAI. Unsichtbare Herausforderungen sind im Allgemeinen schneller als v2-Checkbox-Herausforderungen, da sie keine Bilderkennung erfordern – sie basieren auf einer Risikoanalyse.

Kann ich unsichtbares reCAPTCHA ohne Browser lösen?

Ja. Da die Lösung serverseitig über die API erfolgt, benötigen Sie nur den Sitekey und die Pageurl. Der Browser wird nur benötigt, wenn Sie die Callback-Funktion auf der tatsächlichen Seite ausführen müssen. Extrahieren Sie für reine API-Workflows den Sitekey, lösen Sie ihn über CaptchaAI und senden Sie das Token mit Ihrer HTTP-Anfrage.

Verwandte Leitfäden

• Unsichtbares reCAPTCHA per API lösen
• Unsichtbares reCAPTCHA: Trigger und Erkennung
• Häufige reCAPTCHA v2 Fehler und Korrekturen