So lösen Sie den reCAPTCHA v2-Rückruf mithilfe der API

Einige Websites implementieren reCAPTCHA v2 mit einer Rückruffunktion anstelle des standardmäßigen versteckten Felds g-recaptcha-response. Wenn Sie das CAPTCHA lösen und das Token in das versteckte Feld einfügen, passiert nichts – die Seite ignoriert es. Das liegt daran, dass die Site von Ihnen erwartet, dass Sie stattdessen eine JavaScript-Funktion aufrufen mit dem Token.

In dieser Anleitung erfahren Sie, wie Sie rückrufbasiertes reCAPTCHA v2 erkennen, es über die CaptchaAI-API lösen und den Rückruf korrekt aufrufen. Der API-Aufruf ist identisch mit dem Standard-reCAPTCHA v2 – nur der Token-Injection-Schritt ändert sich.

Neu bei reCAPTCHA v2? Beginnen Sie mitSo lösen Sie reCAPTCHA v2 mithilfe der APIfür den Standardablauf, dann kommen Sie hierher für die Rückrufvariante zurück.

Was Sie brauchen, bevor Sie beginnen

So identifizieren Sie eine Callback-Implementierung

Standard reCAPTCHA v2 schreibt das gelöste Token in einen versteckten g-recaptcha-response-Textbereich. Callback-Implementierungen überspringen dies und rufen direkt eine JavaScript-Funktion auf. Hier erfahren Sie, wie Sie den Unterschied erkennen.

Methode 1: Überprüfen Sie das data-callback-Attribut

Überprüfen Sie das reCAPTCHA-Widget-Div in der Seitenquelle:

<div class="g-recaptcha"
     data-sitekey="6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
     data-callback="SubmitToken">
</div>

Wenn data-callback vorhanden ist, verwendet die Site einen Rückruf. Der Wert (SubmitToken) ist der Funktionsname, den Sie benötigen.

Methode 2: Überprüfen Sie die grecaptcha.render()-Aufrufe

Durchsuchen Sie das JavaScript der Seite nach grecaptcha.render:

grecaptcha.render('recaptcha-container', {
  sitekey: '6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-',
  callback: userVerified
});

Die Eigenschaft callback benennt die Funktion. In diesem Fall userVerified.

Methode 3: Überprüfen Sie die interne reCAPTCHA-Konfiguration

Öffnen Sie die Browserkonsole auf der Zielseite und führen Sie Folgendes aus:

___grecaptcha_cfg.clients[0]

Navigieren Sie durch die Objektstruktur, um die Eigenschaft callback zu finden. Der genaue Pfad variiert je nach Site – er kann je nach reCAPTCHA-Version und Minimierung clients[0].aa.l.callback oder etwas anderes lauten. Wenn die Seite über mehrere reCAPTCHA-Instanzen verfügt, überprüfen Sie clients[1], clients[2] usw.

Schnellerkennungsskript

Führen Sie dies in der Browserkonsole aus, um Rückrufnamen automatisch zu finden:

// Check data-callback attributes
document.querySelectorAll('[data-callback]').forEach(el => {
  console.log('data-callback:', el.getAttribute('data-callback'));
});

// Check internal config
if (typeof ___grecaptcha_cfg !== 'undefined') {
  Object.keys(___grecaptcha_cfg.clients).forEach(key => {
    const client = ___grecaptcha_cfg.clients[key];
    console.log(`Client ${key}:`, JSON.stringify(client, null, 2));
  });
}

Wie sich die Callback-Lösung von Standard v2 unterscheidet

Der API-Aufruf an CaptchaAI ist identisch. Der einzige Unterschied besteht darin, was Sie mit dem Token tun, nachdem Sie ihn erhalten haben.

Kritisch: Legen Sie g-recaptcha-response nicht für Callback-basierte Implementierungen fest. Die Seite ignoriert dieses Feld und wartet darauf, dass die Rückruffunktion ausgelöst wird. Wenn Sie das Feld festlegen, ohne den Rückruf aufzurufen, sieht es so aus, als ob das CAPTCHA nie gelöst wurde.

Lösungsfluss

Page → extract sitekey + pageurl + callback name
                    ↓
      POST to in.php (method=userrecaptcha)
                    ↓
           receive captcha ID
                    ↓
         wait 15–20 seconds
                    ↓
      GET res.php (action=get, id=…)
          ↓                    ↓
   CAPCHA_NOT_READY       status=1 → token
    (wait 5s, retry)            ↓
                     invoke callback(token)
                              ↓
               site processes token automatically

Python-Implementierung (Selenium)

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

API_KEY = "YOUR_CAPTCHAAI_API_KEY"
SITEKEY = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
PAGE_URL = "https://example.com/login"
CALLBACK_NAME = "SubmitToken"  # The callback function name from the page

SUBMIT_URL = "https://ocr.captchaai.com/in.php"
RESULT_URL = "https://ocr.captchaai.com/res.php"


def solve_recaptcha_v2(api_key, sitekey, pageurl):
    """Submit a reCAPTCHA v2 task and return the solved token."""

    # Step 1: Submit the captcha
    submit_resp = requests.post(
        SUBMIT_URL,
        data={
            "key": api_key,
            "method": "userrecaptcha",
            "googlekey": sitekey,
            "pageurl": pageurl,
            "json": 1,
        },
        timeout=30,
    )
    submit_resp.raise_for_status()
    submit_data = submit_resp.json()

    if submit_data.get("status") != 1:
        raise RuntimeError(f"Submit failed: {submit_data}")

    captcha_id = submit_data["request"]
    print(f"Task created — captcha ID: {captcha_id}")

    # Step 2: Wait before first poll
    time.sleep(15)

    # Step 3: Poll for result
    for _ in range(60):
        result_resp = requests.get(
            RESULT_URL,
            params={
                "key": api_key,
                "action": "get",
                "id": captcha_id,
                "json": 1,
            },
            timeout=30,
        )
        result_resp.raise_for_status()
        result_data = result_resp.json()

        if result_data.get("request") == "CAPCHA_NOT_READY":
            time.sleep(5)
            continue

        if result_data.get("status") == 1:
            return result_data["request"]

        raise RuntimeError(f"Polling error: {result_data}")

    raise TimeoutError("reCAPTCHA v2 solve timed out")


def detect_callback_name(driver):
    """Detect the reCAPTCHA callback function name from the page."""

    # Try data-callback attribute first
    callback = driver.execute_script("""
        const el = document.querySelector('[data-callback]');
        if (el) return el.getAttribute('data-callback');
        return null;
    """)
    if callback:
        return callback

    # Try internal reCAPTCHA config
    callback = driver.execute_script("""
        if (typeof ___grecaptcha_cfg === 'undefined') return null;
        const clients = ___grecaptcha_cfg.clients;
        for (const key of Object.keys(clients)) {
            const client = clients[key];
            // Walk the object tree to find a callback function
            const json = JSON.stringify(client);
            const match = json.match(/"callback":"(\\w+)"/);
            if (match) return match[1];
        }
        return null;
    """)
    return callback


# Main workflow
driver = webdriver.Chrome()
driver.get(PAGE_URL)

# Detect the callback name (or use the known name)
detected = detect_callback_name(driver)
callback_name = detected or CALLBACK_NAME
print(f"Using callback: {callback_name}")

# Solve the CAPTCHA
token = solve_recaptcha_v2(API_KEY, SITEKEY, PAGE_URL)
print(f"Solved token: {token[:80]}...")

# Invoke the callback with the token
driver.execute_script(f"{callback_name}(arguments[0]);", token)
print("Callback invoked — site should process the token automatically")

# Wait for the page to process
time.sleep(3)
driver.quit()

Was das bewirkt:

1. Sendet den Sitekey und die PageURL an in.php mit method=userrecaptcha – identisch mit Standard v2.
2. Fragt res.php alle 5 Sekunden ab, bis das Token bereit ist.
3. Erkennt den Namen der Callback-Funktion aus dem Seiten-DOM.
4. Ruft die Callback-Funktion mit dem gelösten Token unter Verwendung von execute_script auf.
5. Das eigene JavaScript der Website erledigt den Rest – Formularübermittlung, Validierung oder Seitenumleitung.

Node.js-Implementierung (Puppeteer)

const puppeteer = require("puppeteer");

const API_KEY = "YOUR_CAPTCHAAI_API_KEY";
const SITEKEY = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-";
const PAGE_URL = "https://example.com/login";
const CALLBACK_NAME = "SubmitToken";

const SUBMIT_URL = "https://ocr.captchaai.com/in.php";
const RESULT_URL = "https://ocr.captchaai.com/res.php";

function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

async function solveRecaptchaV2(apiKey, sitekey, pageurl) {
  // Step 1: Submit the captcha
  const submitResp = await fetch(SUBMIT_URL, {
    method: "POST",
    headers: { "Content-Type": "application/x-www-form-urlencoded" },
    body: new URLSearchParams({
      key: apiKey,
      method: "userrecaptcha",
      googlekey: sitekey,
      pageurl: pageurl,
      json: "1",
    }),
  });

  const submitData = await submitResp.json();
  if (submitData.status !== 1) {
    throw new Error(`Submit failed: ${JSON.stringify(submitData)}`);
  }

  const captchaId = submitData.request;
  console.log(`Task created — captcha ID: ${captchaId}`);

  // Step 2: Wait before first poll
  await sleep(15_000);

  // Step 3: Poll for result
  for (let i = 0; i < 60; i++) {
    const resultResp = await fetch(
      `${RESULT_URL}?${new URLSearchParams({
        key: apiKey,
        action: "get",
        id: captchaId,
        json: "1",
      })}`
    );

    const resultData = await resultResp.json();

    if (resultData.request === "CAPCHA_NOT_READY") {
      await sleep(5_000);
      continue;
    }

    if (resultData.status === 1) {
      return resultData.request;
    }

    throw new Error(`Polling error: ${JSON.stringify(resultData)}`);
  }

  throw new Error("reCAPTCHA v2 solve timed out");
}

async function detectCallbackName(page) {
  return page.evaluate(() => {
    // Try data-callback attribute
    const el = document.querySelector("[data-callback]");
    if (el) return el.getAttribute("data-callback");

    // Try internal config
    if (typeof ___grecaptcha_cfg !== "undefined") {
      const clients = ___grecaptcha_cfg.clients;
      for (const key of Object.keys(clients)) {
        const json = JSON.stringify(clients[key]);
        const match = json.match(/"callback":"(\w+)"/);
        if (match) return match[1];
      }
    }

    return null;
  });
}

(async () => {
  const browser = await puppeteer.launch({ headless: false });
  const page = await browser.newPage();
  await page.goto(PAGE_URL, { waitUntil: "networkidle2" });

  // Detect callback
  const detected = await detectCallbackName(page);
  const callbackName = detected || CALLBACK_NAME;
  console.log(`Using callback: ${callbackName}`);

  // Solve the CAPTCHA
  const token = await solveRecaptchaV2(API_KEY, SITEKEY, PAGE_URL);
  console.log(`Solved token: ${token.slice(0, 80)}...`);

  // Invoke the callback
  await page.evaluate(
    (name, tkn) => {
      window[name](tkn);
    },
    callbackName,
    token
  );
  console.log("Callback invoked — site should process the token automatically");

  await sleep(3_000);
  await browser.close();
})();

PHP-Implementierung

Der API-Aufruf ist in PHP derselbe. Der Rückrufaufruf erfordert einen Browserkontext, daher deckt dieses Beispiel die serverseitige Lösung ab. Verwenden Sie für den Injektionsschritt ein Headless-Browser-Tool (z. B. PHP WebDriver).

<?php
$apiKey  = "YOUR_CAPTCHAAI_API_KEY";
$sitekey = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-";
$pageurl = "https://example.com/login";

// Step 1: Submit
$submit = file_get_contents("https://ocr.captchaai.com/in.php?" . http_build_query([
    "key"       => $apiKey,
    "method"    => "userrecaptcha",
    "googlekey" => $sitekey,
    "pageurl"   => $pageurl,
    "json"      => 1,
]));

$submitData = json_decode($submit, true);
if ($submitData["status"] !== 1) {
    die("Submit failed: " . $submit);
}

$captchaId = $submitData["request"];
echo "Task created — captcha ID: $captchaId\n";

// Step 2: Wait and poll
sleep(15);

for ($i = 0; $i < 60; $i++) {
    $result = file_get_contents("https://ocr.captchaai.com/res.php?" . http_build_query([
        "key"    => $apiKey,
        "action" => "get",
        "id"     => $captchaId,
        "json"   => 1,
    ]));

    $resultData = json_decode($result, true);

    if ($resultData["request"] === "CAPCHA_NOT_READY") {
        sleep(5);
        continue;
    }

    if ($resultData["status"] === 1) {
        $token = $resultData["request"];
        echo "Solved token: " . substr($token, 0, 80) . "...\n";
        // Pass $token to your browser automation to invoke the callback
        break;
    }

    die("Polling error: " . $result);
}

Nachdem Sie das Token in PHP erhalten haben, verwenden Sie ein Browser-Automatisierungstool (z. B. php-webdriver), um Folgendes auszuführen:

SubmitToken("TOKEN_FROM_CAPTCHAAI");

Häufige Fehler

Fehlerbehebung

Token gelöst, aber Seite reagiert nicht

Die häufigste Ursache: Sie setzen g-recaptcha-response, anstatt den Rückruf aufzurufen. Überprüfen Sie, ob das Widget data-callback oder callback in grecaptcha.render() hat. Wenn dies der Fall ist, müssen Sie diese Funktion aufrufen.

ReferenceError: SubmitToken is not defined

Die Callback-Funktion ist noch nicht geladen oder der Name ist falsch. Versuchen Sie:

1. Bestätigen Sie den Namen, indem Sie data-callback oder die interne Konfiguration überprüfen.
2. Warten Sie, bis die Seite vollständig geladen ist, bevor Sie sie aufrufen.
3. Auf minimierten Sites kann die Funktion einer Variablen zugewiesen werden – überprüfen Sie window.SubmitToken in der Konsole.

Token funktioniert auf Standard v2, schlägt auf dieser Seite jedoch fehl

Sie stehen wahrscheinlich vor einer Callback-Implementierung. Folgen Sie den Erkennungsschritten oben zur Bestätigung und wechseln Sie dann zum Callback-Aufruf.

ERROR_BAD_TOKEN_OR_PAGEURL

Das sitekey/pageurl-Paar ist ungültig. Dies ist ein API-Fehler, der nicht mit Callback vs. Standard zusammenhängt. Extrahieren Sie beide Werte erneut von der Seite.

Die Seite verfügt über mehrere reCAPTCHA-Widgets

Jedes Widget kann seinen eigenen Rückruf haben. Überprüfen Sie jedes g-recaptcha-Div oder überprüfen Sie ___grecaptcha_cfg.clients für alle registrierten Instanzen. Passen Sie das Widget an das Formular an, auf das Sie abzielen.

ERROR_CAPTCHA_UNSOLVABLE

Die Herausforderung konnte nicht gelöst werden. Versuchen Sie es erneut mit einer neuen Anfrage. Dies ist nicht rückrufspezifisch.

Die vollständige Fehlerreferenz finden Sie unterHäufige reCAPTCHA v2-Lösungsfehler.

Warum CaptchaAI dafür funktioniert

Das von CaptchaAI zurückgegebene Token ist dasselbe, unabhängig davon, wie die Site reCAPTCHA v2 implementiert. Der Unterschied liegt vollständig in Ihrem clientseitigen Code – wie Sie das Token an die Seite übermitteln.

Vollständig lauffähiges Beispiel

Benötigen Sie ein vollständig funktionierendes Projekt mit Umgebungseinrichtung, Abfragen, Wiederholungsversuchen und Fehlerbehandlung?

Das vollständige ausführbare Beispiel finden Sie auf GitHub →

FAQ

Was ist ein reCAPTCHA v2-Rückruf?

Ein Callback ist eine JavaScript-Funktion, die eine Website registriert, um das gelöste reCAPTCHA-Token zu erhalten. Anstatt das Token in das versteckte Feld g-recaptcha-response zu schreiben, ruft reCAPTCHA die Funktion direkt auf. Die Funktion löst normalerweise die Formularübermittlung, die Validierung oder eine Seitenumleitung aus.

Wie unterscheidet sich der Rückruf vom Standard-reCAPTCHA v2 für den API-Aufruf?

Es ist überhaupt nicht anders. Sie senden dieselbe method=userrecaptcha-Anfrage mit demselben Sitekey und derselben Seiten-URL. Der einzige Unterschied besteht darin, was Sie mit dem Token tun, nachdem Sie es erhalten haben – Sie rufen die Rückruffunktion auf, anstatt einen Feldwert festzulegen.

Wie finde ich den Namen der Callback-Funktion?

Drei zu überprüfende Stellen: (1) data-callback-Attribut im reCAPTCHA-Div, (2) callback-Eigenschaft in einem grecaptcha.render()-Aufruf im Seiten-JavaScript, (3) ___grecaptcha_cfg.clients[0]-Objekt in der Browserkonsole – navigieren Sie durch die Baumstruktur, um die callback-Eigenschaft zu finden.

Kann ich den Token mit beiden Methoden verwenden?

Der Token selbst funktioniert in beide Richtungen. Wenn die Site jedoch einen Rückruf erwartet, wird die Einstellung g-recaptcha-response ignoriert. Passen Sie die Injektionsmethode immer an die Erwartungen der Website an.

Benötige ich einen Browser, um den Rückruf aufzurufen?

Ja. Der Callback ist eine JavaScript-Funktion im Seitenkontext. Sie benötigen Selenium, Puppeteer, Playwright oder ein ähnliches Tool, das JavaScript auf der Zielseite ausführen kann.

Beginnen Sie mit der Lösung des reCAPTCHA v2-Rückrufs

1. Holen Sie sich Ihren API-Schlüssel —captchaai.com/api.php
2. Ermitteln Sie den Rückrufnamen – überprüfen Sie data-callback, grecaptcha.render() oder die interne Konfiguration
3. Kopieren Sie den obigen Python- oder Node.js-Code – ersetzen Sie Platzhalter durch Ihren Schlüssel, Sitekey, Pageurl und Callback-Namen
4. Führen Sie es aus – das Token kommt in weniger als 60 Sekunden an, der Rückruf wird ausgelöst und die Seite verarbeitet das Ergebnis
5. Steckplatz? Beginnen Sie mitHäufige reCAPTCHA v2-Lösungsfehleroder lesen Sie das GanzeCaptchaAI API-Dokumente

Verwandte Artikel

• Lösen Sie Recaptcha Invisible Python
• Recaptcha V2-Drehkreuz. Gleiche Handhabung vor Ort
• Recaptcha Enterprise Assessment Api Deep Dive