# reCAPTCHA mit einem Token abschließen

> Was Sie mit einem reCAPTCHA-Token (gRecaptchaResponse) tun: Funktionsweise, direktes Senden per Request (Feld g-recaptcha-response), Eintragen im Browser und Aufruf der Callback-Funktion, mit vollständigem Python-Beispiel auf der Google-Demoseite.

Source: https://docs.yescaptcha.com/de/guides/submit-recaptcha-token/ · Last verified: 2026-10-15

> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/guides/submit-recaptcha-token/

Der von YesCaptcha zurückgegebene `gRecaptchaResponse` ist derselbe Wert, den Google an die Seite übergibt, nachdem jemand das Captcha gelöst hat. Wenn Sie ihn haben, müssen Sie ihn wie ein Browser **an die Zielwebsite senden** (nicht an Google oder YesCaptcha). Die Website prüft ihn bei Google und lässt Sie anschließend durch. Es gibt zwei Möglichkeiten: den Request direkt senden oder den Token im Browser in die Seite eintragen und dann absenden.

## Funktionsweise

Im normalen Ablauf:

1.  Die Seite lädt reCAPTCHA und der Nutzer löst es;
2.  Google gibt der Seite einen Token, den die Seite in das Textfeld `g-recaptcha-response` einträgt (oder an eine Callback-Funktion übergibt);
3.  Der Nutzer sendet das Formular ab, der Token geht mit dem Formular an den Server der Website;
4.  Der Server der Website prüft den Token bei Google und lässt den Nutzer bei Erfolg durch.

Mit YesCaptcha übernehmen wir Schritt 1 und 2: Sie erstellen eine Aufgabe mit `websiteURL` und `websiteKey`, erhalten den Token und machen ab Schritt 3 weiter.

> **Achtung:** Ein Token ist nur einmal verwendbar und etwa 120 Sekunden gültig. Senden Sie ihn am besten innerhalb von 60 Sekunden ab. Abgelaufene Token akzeptiert die Website nicht.

## Methode 1: Request direkt senden (empfohlen)

1.  Führen Sie den Vorgang einmal manuell im Browser aus: Öffnen Sie mit F12 das Network-Panel, lösen Sie das Captcha, senden Sie ab und suchen Sie den Request, der das Formular übermittelt.
2.  Suchen Sie im Payload (oder in den Form Data) des Requests das Feld, das den Token enthält. Es heißt meist `g-recaptcha-response`, der Token beginnt mit `03A`. Manche Websites benennen es um, zum Beispiel `grecaptcharesponse` oder `captcha`.
3.  Senden Sie in Ihrem Programm denselben Request und ersetzen Sie den Wert des Felds durch den von YesCaptcha zurückgegebenen Token. Auch die übrigen Felder, Cookies und Header müssen mit denen des Browsers übereinstimmen, da Websites oft auch diese prüfen.

Ein vollständiges Beispiel auf der Google-Demoseite: zuerst lösen, dann den Token im Feld `g-recaptcha-response` an die Demoseite zurücksenden:

recaptcha_requests.py

```python
"""Solve reCAPTCHA v2 on Google's demo page and submit the token with plain HTTP (no browser).

Run:  pip install requests
      export YESCAPTCHA_CLIENT_KEY=your_client_key
      python recaptcha_requests.py
Each run creates one NoCaptchaTaskProxyless task (charged per the price list).
"""
import os
import time

import requests

CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
API = "https://api.yescaptcha.com"
WEBSITE_URL = "https://www.google.com/recaptcha/api2/demo"
WEBSITE_KEY = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"

def call(method, payload):
    data = requests.post(f"{API}/{method}", json={"clientKey": CLIENT_KEY, **payload}, timeout=30).json()
    if data.get("errorId"):
        raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
    return data

def get_token():
    task = {"type": "NoCaptchaTaskProxyless", "websiteURL": WEBSITE_URL, "websiteKey": WEBSITE_KEY}
    task_id = call("createTask", {"task": task})["taskId"]
    for _ in range(36):  # poll every 5 seconds, for up to about 3 minutes
        time.sleep(5)
        result = call("getTaskResult", {"taskId": task_id})
        if result.get("status") == "ready":
            return result["solution"]["gRecaptchaResponse"]
    raise TimeoutError(task_id)

token = get_token()
print("token:", token[:40], "...")

# Submit the token the same way the browser does: the demo form posts the field
# "g-recaptcha-response" back to the page. Check your own site's request in DevTools > Network.
page = requests.post(WEBSITE_URL, data={"g-recaptcha-response": token}, timeout=30)
print("passed" if "Verification Success" in page.text else "not passed", page.status_code)
```

## Methode 2: Im Browser eintragen (Selenium u. a.)

Wenn Sie mit Selenium, Playwright o. Ä. einen echten Browser steuern:

1.  Lesen Sie `data-sitekey` aus der Seite und erstellen Sie damit eine Aufgabe, um einen Token zu erhalten.
2.  Schreiben Sie den Token in das Textfeld `g-recaptcha-response` der Seite.
3.  Hat die Seite eine Callback-Funktion (`data-callback="..."`), rufen Sie sie mit dem Token auf. Bei manchen Websites wird der Absenden-Button erst klickbar, wenn der Callback aufgerufen wurde.
4.  Senden Sie das Formular ab.

```js
// Step 2: write the token (run in the page)
document.getElementById('g-recaptcha-response').value = 'TOKEN';
// Step 3: call the callback if there is one, e.g. data-callback="onSuccess"
onSuccess('TOKEN');
```

Bei mehreren reCAPTCHAs auf einer Seite kann die ID des Textfelds z. B. `g-recaptcha-response-1` lauten. Finden Sie das Textfeld nicht, lösen Sie das Captcha einmal manuell und suchen Sie in den Elements nach `03A`, um zu sehen, wo das Ergebnis abgelegt wird. Wie Sie die Callback-Funktion finden, steht unter [reCAPTCHA-Parameter finden](https://docs.yescaptcha.com/de/guides/find-recaptcha-parameters.md).

Vollständiges Beispiel (Selenium 4):

recaptcha_selenium.py

```python
"""Solve reCAPTCHA v2 on Google's demo page in a real browser with Selenium 4:
get a token from YesCaptcha, put it into the page, then submit the form.

Run:  pip install requests selenium
      export YESCAPTCHA_CLIENT_KEY=your_client_key
      python recaptcha_selenium.py
Each run creates one NoCaptchaTaskProxyless task (charged per the price list).
"""
import os
import time

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

CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
API = "https://api.yescaptcha.com"
WEBSITE_URL = "https://www.google.com/recaptcha/api2/demo"

def call(method, payload):
    data = requests.post(f"{API}/{method}", json={"clientKey": CLIENT_KEY, **payload}, timeout=30).json()
    if data.get("errorId"):
        raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
    return data

def get_token(website_url, website_key):
    task = {"type": "NoCaptchaTaskProxyless", "websiteURL": website_url, "websiteKey": website_key}
    task_id = call("createTask", {"task": task})["taskId"]
    for _ in range(36):
        time.sleep(5)
        result = call("getTaskResult", {"taskId": task_id})
        if result.get("status") == "ready":
            return result["solution"]["gRecaptchaResponse"]
    raise TimeoutError(task_id)

driver = webdriver.Chrome()  # Selenium 4 downloads a matching chromedriver automatically
try:
    driver.get(WEBSITE_URL)
    site_key = driver.find_element(By.CSS_SELECTOR, "[data-sitekey]").get_attribute("data-sitekey")
    token = get_token(WEBSITE_URL, site_key)

    # Put the token where reCAPTCHA keeps it ...
    driver.execute_script(
        "document.getElementById('g-recaptcha-response').value = arguments[0];", token
    )
    # ... and, if the page uses a callback (data-callback="..."), call it:
    callback = driver.find_element(By.CSS_SELECTOR, "[data-sitekey]").get_attribute("data-callback")
    if callback:
        driver.execute_script(f"window[{callback!r}](arguments[0]);", token)

    driver.find_element(By.ID, "recaptcha-demo-submit").click()
    time.sleep(2)
    print("passed" if "Verification Success" in driver.page_source else "not passed")
finally:
    driver.quit()
```

## reCAPTCHA v3

v3 hat keine Checkbox. Die Seite ruft bei Bedarf `grecaptcha.execute(Website-Key, {action: '...'})` auf, um einen Token zu erhalten, und legt ihn in ihren eigenen Request (der Feldname hängt von der Website ab, üblich sind `g-recaptcha-response`, `token`, `recaptchaToken`). Das Vorgehen entspricht Methode 1: Suchen Sie im Network-Panel den Request mit dem Token und senden Sie ihn nach. Beim Erstellen der Aufgabe muss `pageAction` mit dem `action` der Seite übereinstimmen.

## Trotz Absenden nicht erfolgreich

-   Der Token ist abgelaufen: Senden Sie ihn möglichst schnell ab, spätestens nach 60 Sekunden.
-   Sie haben nicht das Feld gesendet, das die Website prüft, oder andere Felder bzw. Cookies fehlen: Vergleichen Sie Punkt für Punkt mit dem Request im Browser.
-   Die Website prüft zusätzlich IP, User-Agent usw.: Verwenden Sie einen Typ mit eigenem Proxy (z. B. `NoCaptchaTask`) und senden Sie über denselben Proxy ab.
-   Der Score von v3 reicht nicht: Prüfen Sie `pageAction` oder wechseln Sie zu einem Typ mit festem hohem Score, siehe [reCAPTCHA v3](https://docs.yescaptcha.com/de/tasks/recaptcha-v3.md).
-   Die Risikoprüfung der Website wertet weitere Verhaltenssignale aus. Ist die Erfolgsquote mit Token gering, nutzen Sie stattdessen [Bilderkennung](https://docs.yescaptcha.com/de/tasks/recaptcha-classification.md) mit echten Klicks im Browser oder die [Browser-Erweiterung](https://docs.yescaptcha.com/de/extension.md).