reCAPTCHA Invisible: häufige Fehler und Lösungen

Wenn Ihr Invisible-reCAPTCHA-Ablauf scheitert, liegt es fast immer an einer von vier Ursachen:

• Der Callback wird nicht ausgeführt – das Token liegt im Feld, aber niemand ruft die JavaScript-Funktion auf, die das Formular abschickt.
• Der Sitekey ist falsch oder stammt von einer anderen Domain bzw. einem anderen Widget.
• Das Token ist abgelaufen, bevor der Absende-Schritt erreicht wurde.
• Der Parameter invisible=1 fehlt in der Lösungsanfrage.

reCAPTCHA Invisible verzichtet auf das sichtbare Kontrollkästchen und verlagert die Fehlerquellen in den JavaScript-Ablauf – dort sind sie stiller und schwerer zu finden als bei v2-Standard. Braucht Ihr Team zuerst die Grundlagen, lesen Sie So funktioniert reCAPTCHA Invisible und so lösen Sie es per API; dieser Leitfaden geht direkt jedes Fehlermuster mit Fehlercode, Ursache und Korrektur in Python und Node.js durch.

Wo Invisible reCAPTCHA im DACH-Raum auftaucht

Im deutschsprachigen Raum begegnet Ihnen Invisible reCAPTCHA vor allem dort, wo kein Widget zu sehen ist und die Automatisierung deshalb oft ohne klare Fehlermeldung abbricht:

• Termin- und Visa-Portale (BLS) – ein Dauerbrenner für Nutzer in Deutschland, Österreich und der Schweiz.
• Login- und Registrierungsseiten, auf denen der Schutz erst beim Absenden anspringt.
• Kontaktformulare, bei denen der Request scheinbar durchläuft, das Formular aber nicht reagiert.
• Checkout-Strecken von Shopware- oder JTL-Shops in eigenen Test- und Staging-Umgebungen.

Fehler-Schnellübersicht

Fehler 1: reCAPTCHA Invisible wird auf der Seite nicht erkannt

Invisible reCAPTCHA hat kein sichtbares Kontrollkästchen. Übersieht Ihr Scraper es, scheitern CAPTCHA-geschützte Anfragen stillschweigend – mit Formularfehlern oder unerwarteten Weiterleitungen. Diese drei Muster im HTML der Seite verraten das unsichtbare Widget:

• ein div mit class="g-recaptcha" und data-size="invisible",
• ein button mit data-sitekey und Callback-Attribut,
• ein programmatischer grecaptcha.render()-Aufruf mit size: 'invisible'.

Suchen Sie im ausgelieferten HTML gezielt nach diesen Strukturen:

<!-- 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>

Die Erkennung mit Python deckt sowohl das div als auch den programmatischen Render-Aufruf ab:

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

Dieselbe Logik in Node.js mit axios und cheerio:

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

• Der Sitekey stammt aus einem v2-Kontrollkästchen auf einer anderen Seite.
• Verwendet wurde ein Sitekey aus der Anker-URL einer anderen reCAPTCHA-Version.
• Die Seite enthält mehrere reCAPTCHA-Widgets und Sie haben das falsche erwischt.

Lösung: den passenden Invisible-Sitekey extrahieren

Der Fehler tritt auf, wenn der gesendete Sitekey nicht zum Invisible-Widget der Zielseite passt. Priorisieren Sie beim Auslesen deshalb das Invisible-Widget und fallen Sie erst danach auf ein beliebiges g-recaptcha-Element zurück:

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: Callback wird nicht ausgeführt – das Formular tut nichts

Das ist der mit Abstand häufigste Invisible-Fehler, und Entwickler übersehen ihn regelmäßig. Bei v2-Checkbox reicht es, das Token in g-recaptcha-response zu schreiben. Invisible reCAPTCHA nutzt dagegen fast immer eine JavaScript-Callback-Funktion: Fügen Sie das Token ein, ohne den Callback aufzurufen, wird das Formular nie verarbeitet. Der Ablauf läuft in drei Schritten:

1. grecaptcha.execute() löst die unsichtbare Abfrage aus.
2. Nach dem Lösen ruft Google die in data-callback angegebene Funktion auf.
3. Diese Callback-Funktion sendet das Formular ab oder stößt den API-Aufruf an.

Den Callback-Namen finden Sie im HTML- oder JS-Kontext an genau diesen Stellen:

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

Fügen Sie in Selenium das Token ein und rufen Sie den Callback anschließend selbst auf:

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}");')

Derselbe Zwei-Schritt-Ablauf in 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: Der Parameter invisible=1 fehlt

Beim Lösen von Invisible reCAPTCHA über CaptchaAI muss invisible=1 in der Anfrage stehen. Fehlt der Parameter, behandelt der Solver die Aufgabe als normale v2-Checkbox-Abfrage – das führt zu ERROR_CAPTCHA_UNSOLVABLE oder zu Token, die die Zielseite ablehnt. Der Unterschied liegt in einer einzigen Zeile:

# 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 läuft vor dem Absenden ab

Invisible-reCAPTCHA-Token verfallen nach 120 Sekunden – genauso wie bei v2-Standard. Invisible-Abläufe schieben zwischen Lösung und Übermittlung aber oft noch weitere Verarbeitungsschritte ein, sodass der Ablauf des Tokens wahrscheinlicher wird. Daran erkennen Sie ein abgelaufenes Token:

• Das Formular liefert nach dem Einfügen des Tokens einen allgemeinen Fehler.
• Serverseitig gibt siteverify den Wert timeout-or-duplicate zurück.
• Das Token war gültig, brauchte aber zu lange bis zum Absende-Schritt.

Lösung: Just-in-Time lösen

Fordern Sie die Lösung erst an, wenn Sie unmittelbar danach absenden können:

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 geprüft – und eine Ablehnung erhalten. Die häufigsten Ursachen und ihre Korrektur:

Ein Diagnose-Skript mit Protokollierung zeigt, an welchem Punkt die Lösung kippt:

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

Manche Seiten kombinieren ein sichtbares v2-Kontrollkästchen mit einem Invisible reCAPTCHA. Lösen Sie das falsche, ist das Token zwar gültig, passt aber nicht zu dem Widget, das die von Ihnen benötigte Aktion schützt. Listen Sie deshalb erst alle Widgets auf und steuern Sie anschließend gezielt das mit size="invisible" an:

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 Invisible-reCAPTCHA-Solver mit Fehlerbehandlung

Dieser produktionsreife Wrapper fängt alle oben genannten Fehler ab – inklusive Wiederholungslogik mit exponentiellem Backoff und sauberer Trennung zwischen dauerhaften Konfigurationsfehlern und vorübergehenden Problemen:

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 für die Fehlersuche

Arbeiten Sie diese Punkte der Reihe nach ab, wenn das Lösen von Invisible reCAPTCHA scheitert:

1. Widget-Typ prüfen: Ist es wirklich Invisible und nicht v2-Standard? Im Render-Aufruf nach data-size="invisible" oder size: 'invisible' suchen.
2. Sitekey abgleichen: Gezielt mit dem data-sitekey des Invisible-Widgets vergleichen, nicht mit einem beliebigen g-recaptcha-Element.
3. invisible=1 kontrollieren: Steht der Parameter in den in.php-Anfrageparametern?
4. pageurl verifizieren: Die URL aus den Browser-DevTools nutzen, keine Weiterleitungs-URL.
5. Callback-Namen bestimmen: Attribut data-callback oder callback in grecaptcha.render() suchen.
6. Beide Schritte ausführen: Token einfügen UND Callback aufrufen – das Token allein genügt nicht.
7. Aktualität sichern: Das Token innerhalb von 120 Sekunden verwenden.
8. IP testen: Bei strenger Herkunftsprüfung proxy und proxytype ergänzen.

Häufige Fragen

Welcher Invisible-reCAPTCHA-Fehler tritt am häufigsten auf?

Der nicht ausgeführte Callback. Bei v2-Checkbox genügt es, das Token in g-recaptcha-response zu schreiben; Invisible reCAPTCHA erwartet fast immer zusätzlich den Aufruf der JavaScript-Callback-Funktion. Fehlt dieser Aufruf, bleibt das Formular stumm stehen – ganz ohne Fehlermeldung.

Woran erkenne ich, ob eine Seite Invisible reCAPTCHA statt v2-Checkbox nutzt?

Am fehlenden Kontrollkästchen und am Attribut data-size="invisible". Suchen Sie im HTML nach einem g-recaptcha-Element mit diesem Attribut oder nach einem grecaptcha.render()-Aufruf mit size: 'invisible'. Ohne dieses Merkmal behandeln Sie die Abfrage fälschlich als v2-Standard und senden am Ende ein Token, das die Seite ablehnt.

Was bedeutet ERROR_CAPTCHA_UNSOLVABLE bei Invisible reCAPTCHA?

Google hat die Aufgabe als nicht lösbar eingestuft – meist wegen einer verbrannten Proxy-IP, fehlender Cookies oder weil die Seite inzwischen auf reCAPTCHA v3 umgestellt hat. Wiederholen Sie den Versuch mit frischem Proxy und neuer Sitzung und prüfen Sie zusätzlich, ob wirklich noch Invisible und nicht v3 im Einsatz ist.

Brauche ich einen Proxy, damit das Token akzeptiert wird?

Nicht immer, aber oft. Verifiziert eine Seite die Herkunft des Tokens streng, müssen die IP bei der Lösung und beim Absenden zusammenpassen. Ergänzen Sie dann proxy und proxytype in der Anfrage, sodass der Solver dieselbe Sitzungs-IP nutzt wie Ihr Client. Genau hier scheitern viele Abläufe, die im Test funktionieren und in der Produktion abbrechen.

Kann ich Invisible reCAPTCHA rein über die API ohne Browser lösen?

Ja. Die Lösung läuft serverseitig über die API – Sie brauchen nur Sitekey und pageurl. Einen Browser benötigen Sie nur, wenn der Callback auf der echten Seite ausgeführt werden muss. Für reine API-Abläufe extrahieren Sie den Sitekey, lösen über CaptchaAI und senden das Token mit Ihrer HTTP-Anfrage.

Verwandte Leitfäden

• reCAPTCHA Invisible per API lösen
• reCAPTCHA v2 Invisible: Auslöser erkennen
• Häufige reCAPTCHA-v2-Fehler beheben