# YesCaptcha Docs (full text)
> YesCaptcha ist eine Captcha-Erkennungs-API. Über eine JSON-Schnittstelle lösen Sie reCAPTCHA, hCaptcha, Cloudflare Turnstile, FunCaptcha, AWS WAF und Bild-Captchas. Abgerechnet wird per Punkteabzug pro Aufgabe, bei Fehlschlägen und Zeitüberschreitungen erfolgt automatisch eine Punkteerstattung.
---
# Captchas lösen mit einer JSON-Schnittstelle
> YesCaptcha ist eine Captcha-Erkennungs-API. Über eine JSON-Schnittstelle lösen Sie reCAPTCHA, hCaptcha, Cloudflare Turnstile, FunCaptcha, AWS WAF und Bild-Captchas. Abgerechnet wird per Punkteabzug pro Aufgabe, bei Fehlschlägen und Zeitüberschreitungen erfolgt automatisch eine Punkteerstattung.
Source: https://docs.yescaptcha.com/de/ · 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/
[Captcha-Erkennungs-APIStatus](https://status.yescaptcha.com/?lang=en)
Erkennt reCAPTCHA, hCaptcha, Cloudflare Turnstile, FunCaptcha, AWS WAF und alphanumerische Bild-Captchas. Abgerechnet wird per Punkteabzug pro Aufgabe, 1,000 Punkte = ¥1; bei Fehlschlägen und Zeitüberschreitungen erfolgt automatisch eine Punkteerstattung.
[Schnellstart](https://docs.yescaptcha.com/de/getting-started/quickstart.md)[API-Referenz](https://docs.yescaptcha.com/de/api/overview.md)
Version für KI und Programme:[llms.txt](https://docs.yescaptcha.com/de/llms.txt)[llms-full.txt](https://docs.yescaptcha.com/de/llms-full.txt)[OpenAPI](https://docs.yescaptcha.com/openapi.json)[Markdown](https://docs.yescaptcha.com/de/index.md)
YesCaptcha darf nur für rechtmäßige Zwecke verwendet werden. Jede rechtswidrige Nutzung ist untersagt.
POSTapi.yescaptcha.com/createTask
```
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
}
}
```
1. /createTasktaskId 61138bb6-19fb-11ec-a9c8-0242ac110006
2. /getTaskResultprocessing
3. /getTaskResultprocessing
4. /getTaskResultready
5. gRecaptchaResponse03AGdBq25SxXT-pmSeBXjzScW-EiocHwwpwqtk1QXlJnGnU...
1. 1Aufgabe erstellen
2. 2Ergebnis abrufen
3. 3Senden
Beispiel: reCAPTCHA v2, das Ergebnis wird alle 5 Sekunden abgefragt
Ab $0.30 / 1k
Niedrigster Preis pro Aufgabe
1,000 Punkte = ¥1
Fehlgeschlagene Aufgaben und Zeitüberschreitungen werden erstattet
2 Endpoints
Globaler Endpoint und China-Endpoint
9:00–21:00
Support durch Menschen (UTC+8)
[SchnellstartRegistrieren, ClientKey abrufen und in 5 Minuten die erste Anfrage senden](https://docs.yescaptcha.com/de/getting-started/quickstart.md)[API-ReferenzcreateTask, getTaskResult, Fehlercodes und Limit gleichzeitiger Aufgaben](https://docs.yescaptcha.com/de/api/overview.md)[Aufgabentypen und PreisePreise, Rückgabeweise und Parameter aller öffentlichen Typen](https://docs.yescaptcha.com/de/tasks.md)[Browser-ErweiterungVerifizierungen auf Webseiten ohne Code automatisch lösen](https://docs.yescaptcha.com/de/extension.md)
## Unterstützte Captchas
[01reCAPTCHAv2, v3, Enterprise sowie Bilderkennung für v2ab $0.90 / 1k](https://docs.yescaptcha.com/de/tasks/recaptcha-v2.md)[02hCaptchaToken zurückgeben oder Bilder erkennen und selbst anklickenab $1.20 / 1k](https://docs.yescaptcha.com/de/tasks/hcaptcha.md)[03Cloudflare TurnstileVerifizierungs-Token für Turnstileab $3.75 / 1k](https://docs.yescaptcha.com/de/tasks/turnstile.md)[04FunCaptchaBilderkennung für Bildaufgaben von Arkose Labs, alle Aufgabenarten werden unterstütztab $0.45 / 1k](https://docs.yescaptcha.com/de/tasks/funcaptcha-classification.md)[05AWS WAF / bCaptchaBilderkennung im 3×3-Rasterab $1.20 / 1k](https://docs.yescaptcha.com/de/tasks/aws-bcaptcha-classification.md)[06Alphanumerische BilderEinfache Zeichen-Captchas, synchrone Rückgabeab $0.30 / 1k](https://docs.yescaptcha.com/de/tasks/image-to-text.md)
## In drei Schritten integrieren
1. 01
**Aufgabe erstellen**
Senden Sie mit `createTask` den Aufgabentyp und die Website-Parameter und erhalten Sie eine `taskId`. Synchrone Typen wie Bilderkennung und alphanumerische Bild-Captchas liefern das Ergebnis direkt.
2. 02
**Ergebnis abrufen**
Rufen Sie alle 5 Sekunden `getTaskResult` auf. Sobald `status` den Wert `ready` hat, steht das Ergebnis in `solution`.
3. 03
**An die Zielwebsite senden**
Tragen Sie das erhaltene Token in das Formular oder die Anfrage der Seite ein. Ein Token ist nur einmal verwendbar; verwenden Sie es am besten innerhalb von 60 Sekunden.
POST /createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
}
}
```
POST /getTaskResult
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"gRecaptchaResponse": "03AGdBq25SxXT-pmSeBXjzScW-EiocHwwpwqtk1QXlJnGnU..."
}
}
```
## Häufig genutzte Seiten
- [**Fehlercodes**Bedeutung jedes Fehlercodes und wie Sie damit umgehen](https://docs.yescaptcha.com/de/api/errors.md)
- [**Limit gleichzeitiger Aufgaben und automatische Pausierung**Was bei Überschreitung und zu vielen Fehlern passiert](https://docs.yescaptcha.com/de/api/rate-limits.md)
- [**Abrechnung und Punkteerstattung**Punkte, Vorabbuchung, Punkteerstattung und Erstattung nach Meldung](https://docs.yescaptcha.com/de/getting-started/billing.md)
- [**Kontakt**WeChat, QQ, Telegram, E-Mail, Servicezeit 9:00–21:00 (UTC+8)](https://docs.yescaptcha.com/de/help/contact.md)
- [**Dashboard**Registrieren, ClientKey abrufen, aufladen](https://yescaptcha.com/)
---
# Einführung
> Was YesCaptcha ist: reCAPTCHA, hCaptcha, Turnstile, FunCaptcha und Bild-Captchas per API oder Browser-Erweiterung lösen, Abrechnung pro Aufgabe, bei Fehlschlag automatische Punkteerstattung.
Source: https://docs.yescaptcha.com/de/getting-started/introduction/ · 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/getting-started/introduction/
YesCaptcha ist ein Dienst zur Captcha-Erkennung. Sie senden die Daten eines Captchas an die YesCaptcha-API und erhalten entweder ein Token, das Sie direkt auf der Zielwebsite einreichen können, oder das Erkennungsergebnis eines Bildes. Unterstützt werden reCAPTCHA (v2, v3, Enterprise), hCaptcha, Cloudflare Turnstile, die Cloudflare-Prüfseite, FunCaptcha, AWS WAF, bCaptcha und alphanumerische Bild-Captchas. Die Abrechnung erfolgt pro Aufgabe über Punkte, 1,000 Punkte = ¥1; bei fehlgeschlagenen Aufgaben und Zeitüberschreitungen erfolgt automatisch eine Punkteerstattung.
YesCaptcha darf nur für rechtmäßige Zwecke verwendet werden. Jede rechtswidrige Nutzung ist untersagt.
## Zwei Nutzungsarten
| | API | Browser-Erweiterung (YesCaptcha Assistant) |
| --- | --- | --- |
| Geeignet für | Entwickler, die Code schreiben und Captchas in ihrem Programm im Batch verarbeiten | Nutzer ohne Programmierung, die im Browser arbeiten |
| Verwendung | `createTask` und `getTaskResult` mit Ihrem `clientKey` aufrufen | Erweiterung installieren und `clientKey` eintragen; Captchas werden automatisch erkannt und angeklickt |
| Unterstützt | Alle auf dieser Website aufgeführten Aufgabentypen | Bildaufgaben von reCAPTCHA v2, hCaptcha, FunCaptcha, AWS WAF und bCaptcha sowie Zeichen-Captchas |
| Kosten | Punkteabzug je nach Aufgabentyp | Die Erweiterung ist kostenlos; berechnet werden die dabei genutzten API-Aufrufe |
Beide Nutzungsarten verwenden dasselbe Konto, denselben `clientKey` und dasselbe Guthaben.
## Drei Arten von Ergebnissen
- **Token**: die meisten Aufgabentypen für reCAPTCHA, hCaptcha, Turnstile und FunCaptcha. Zurückgegeben wird eine Zeichenfolge, die Sie in das Formular oder die Anfrage der Seite einsetzen, um die Prüfung zu bestehen. Bilder müssen Sie nicht anklicken. Alle sind asynchron: Erstellen Sie zuerst die Aufgabe und fragen Sie dann alle 5 Sekunden das Ergebnis ab.
- **Ergebnisse der Bilderkennung**: Aufgabentypen, deren Name auf `Classification` endet. Sie senden die Bilder des Captchas und erhalten zurück, welche Bilder oder welche Position angeklickt werden sollen; das Anklicken im Browser übernimmt Ihr Programm. Die Antwort ist synchron: Eine Anfrage liefert das Ergebnis.
- **Text oder Cookies**: Die Erkennung alphanumerischer Bild-Captchas liefert den Text im Bild; die Cloudflare-Prüfseite liefert die Cookies nach bestandener Prüfung.
Alle Typen und Preise finden Sie unter [Aufgabentypen und Preise](https://docs.yescaptcha.com/de/tasks.md).
## Hier starten
[Schnellstart](https://docs.yescaptcha.com/de/getting-started/quickstart.md)Registrieren, ClientKey abrufen, erste Anfrage senden
[Endpoints](https://docs.yescaptcha.com/de/getting-started/endpoints.md)Globaler Endpoint und China-Endpoint
[Abrechnung und Punkteerstattung](https://docs.yescaptcha.com/de/getting-started/billing.md)Punkte, Vorabbuchung, Punkteerstattung, Erstattung nach Meldung
[Browser-Erweiterung](https://docs.yescaptcha.com/de/extension.md)Ohne Code im Browser automatisch erkennen
## Community-SDKs
SDKs von Nutzern, inoffiziell; bitte prüfen Sie diese vor der Verwendung selbst: siehe [Codebeispiele und SDKs](https://docs.yescaptcha.com/de/samples.md).
---
# Schnellstart
> Senden Sie in 5 Minuten Ihre erste YesCaptcha-Anfrage: registrieren, ClientKey kopieren, Guthaben aufladen und dann mit curl, Python oder Node.js ein Bild-Captcha erkennen (ImageToTextTaskOcrBase, synchrone Antwort, 2 Punkte pro Aufgabe).
Source: https://docs.yescaptcha.com/de/getting-started/quickstart/ · 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/getting-started/quickstart/
Diese Seite sendet die erste Anfrage mit dem einfachsten Aufgabentyp `ImageToTextTaskOcrBase` (erkennt Buchstaben und Ziffern in einem Bild). Er arbeitet synchron: Eine einzige `createTask`\-Anfrage liefert das Ergebnis. Eine Aufgabe kostet 2 Punkte (≈ $0.30 / 1k), es wird keine Seite eines Drittanbieters benötigt. So prüfen Sie am einfachsten, ob Ihr Konto und Ihr Code funktionieren.
1. **Konto registrieren**
Öffnen Sie [yescaptcha.com](https://yescaptcha.com/), registrieren Sie sich und melden Sie sich an.
2. **ClientKey kopieren**
Suchen Sie nach der Anmeldung im Dashboard ([yescaptcha.com/dashboard.html](https://yescaptcha.com/dashboard.html)) den Eintrag „Ihr ClientKey” und klicken Sie auf Kopieren. Kopieren Sie den vollständigen Wert.
> **Achtung:** Alle API-Anfragen werden mit dem ClientKey authentifiziert. Wer ihn kennt, kann Ihr Guthaben verbrauchen. Geben Sie ihn nicht weiter und schreiben Sie ihn nicht in öffentlichen Code. Ist er bekannt geworden, können Sie ihn an derselben Stelle zurücksetzen.
3. **Guthaben aufladen**
Das Guthaben muss über 10 Punkten liegen, damit Sie Aufgaben erstellen können. Zahlungsmethoden und VIP-Bonus finden Sie unter [Aufladung und VIP](https://docs.yescaptcha.com/de/account/recharge.md).
4. **Prüfen, ob der ClientKey funktioniert**
`getBalance` fragt das Guthaben ab und zieht keine Punkte ab:
```bash
curl -s https://api.yescaptcha.com/getBalance \
-H 'Content-Type: application/json' \
-d '{"clientKey": "YOUR_CLIENT_KEY"}'
```
Erhalten Sie `{"errorId": 0, "balance": 12345, ...}`, ist alles bereit; `balance` sind die verbleibenden Punkte. Bei `ERROR_KEY_DOES_NOT_EXIST` wurde der ClientKey falsch kopiert.
5. **Ein Bild erkennen**
Laden Sie das Beispielbild [captcha.jpg](https://docs.yescaptcha.com/samples/captcha.jpg) herunter (Sie können auch Ihr eigenes Captcha-Bild verwenden), legen Sie Ihren ClientKey in eine Umgebungsvariable und führen Sie das Skript aus:
```bash
export YESCAPTCHA_CLIENT_KEY=your_client_key
```
**curl**
quickstart.sh
```bash
#!/usr/bin/env bash
# First request: read an alphanumeric image captcha with ImageToTextTaskOcrBase (synchronous, 2 points per image)
# Usage: YESCAPTCHA_CLIENT_KEY=your_client_key bash quickstart.sh captcha.png
set -euo pipefail
IMAGE="${1:-captcha.png}"
BODY=$(base64 < "$IMAGE" | tr -d '\n') # no "data:" prefix, no line breaks
curl -s https://api.yescaptcha.com/createTask \
-H 'Content-Type: application/json' \
-d "{\"clientKey\": \"${YESCAPTCHA_CLIENT_KEY}\", \"task\": {\"type\": \"ImageToTextTaskOcrBase\", \"body\": \"${BODY}\"}}"
echo
```
**Python**
quickstart.py
```python
"""First request: read an alphanumeric image captcha with ImageToTextTaskOcrBase
(synchronous, 2 points per image).
Usage:
export YESCAPTCHA_CLIENT_KEY=your_client_key
python quickstart.py captcha.png
"""
import base64
import os
import sys
import requests
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
image_path = sys.argv[1] if len(sys.argv) > 1 else "captcha.png"
with open(image_path, "rb") as f:
body = base64.b64encode(f.read()).decode() # no "data:" prefix
r = requests.post(
"https://api.yescaptcha.com/createTask",
json={
"clientKey": CLIENT_KEY,
"task": {"type": "ImageToTextTaskOcrBase", "body": body},
},
timeout=30,
)
data = r.json()
if data.get("errorId"):
raise SystemExit(f"{data.get('errorCode')}: {data.get('errorDescription')}")
print("text:", data["solution"]["text"])
```
**Node.js**
quickstart.mjs
```js
// First request: read an alphanumeric image captcha with ImageToTextTaskOcrBase (synchronous, 2 points per image).
// Usage: YESCAPTCHA_CLIENT_KEY=your_client_key node quickstart.mjs captcha.png
import { readFileSync } from 'node:fs';
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY;
const body = readFileSync(process.argv[2] ?? 'captcha.png').toString('base64'); // no "data:" prefix
const res = await fetch('https://api.yescaptcha.com/createTask', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY, task: { type: 'ImageToTextTaskOcrBase', body } }),
});
const data = await res.json();
if (data.errorId) throw new Error(`${data.errorCode}: ${data.errorDescription}`);
console.log('text:', data.solution.text);
```
Führen Sie `bash quickstart.sh captcha.jpg`, `python quickstart.py captcha.jpg` oder `node quickstart.mjs captcha.jpg` aus. Für Python benötigen Sie zuvor `pip install requests`, für Node.js Version 18 oder höher.
6. **Ergebnis prüfen**
Bei Erfolg erhalten Sie:
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"text": "LMResm"
},
"taskId": "2376919c-1863-11ec-a012-94e6f7355a0b"
}
```
`errorId` 0 bedeutet Erfolg; der erkannte Text steht in `solution.text`. Bei `errorId` 1 schlagen Sie `errorCode` unter [Fehlercodes](https://docs.yescaptcha.com/de/api/errors.md) nach.
## Nächste Schritte
- Typen, die ein Token zurückgeben, etwa reCAPTCHA und hCaptcha, arbeiten **asynchron**: `createTask` liefert zuerst eine `taskId`, danach rufen Sie alle 5 Sekunden `getTaskResult` auf. Den vollständigen Ablauf finden Sie unter [Anfragen und Antworten](https://docs.yescaptcha.com/de/api/overview.md), ein Beispiel unter [reCAPTCHA v2](https://docs.yescaptcha.com/de/tasks/recaptcha-v2.md).
- Aufgabentyp auswählen: [Aufgabentypen und Preise](https://docs.yescaptcha.com/de/tasks.md).
- Ein Client, den Sie direkt in Ihr Projekt kopieren können: [Python](https://docs.yescaptcha.com/de/samples/python.md), [Node.js](https://docs.yescaptcha.com/de/samples/nodejs.md).
- Ohne Code: [Browser-Erweiterung](https://docs.yescaptcha.com/de/extension.md).
---
# Endpoints
> Die zwei Endpoints der YesCaptcha API, der globale api.yescaptcha.com und der China-Endpoint cn.yescaptcha.com. Nur HTTPS POST mit JSON; Aufgaben werden auf demselben Endpoint erstellt und abgefragt.
Source: https://docs.yescaptcha.com/de/getting-started/endpoints/ · 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/getting-started/endpoints/
Die YesCaptcha API hat zwei Endpoints mit identischen Methoden und Parametern. Wählen Sie den Endpoint, der zum Standort Ihrer Server passt:
| Endpoint | Adresse | Geeignet für |
| --- | --- | --- |
| Globaler Endpoint | `https://api.yescaptcha.com` | Server außerhalb des chinesischen Festlands |
| China-Endpoint | `https://cn.yescaptcha.com` | Server auf dem chinesischen Festland |
Die URL einer Methode besteht aus der Endpoint-Adresse und dem Methodennamen, zum Beispiel beim Erstellen einer Aufgabe:
- POST `https://api.yescaptcha.com/createTask` (Globaler Endpoint)
- POST `https://cn.yescaptcha.com/createTask` (China-Endpoint)
## Regeln
- Verwenden Sie nur HTTPS.
- Alle Methoden außer [/useragent](https://docs.yescaptcha.com/de/api/useragent.md) verwenden `POST` mit einem JSON-Body und dem Header `Content-Type: application/json`. Der Body darf höchstens 6 MB groß sein.
- Die Authentifizierung erfolgt über den `clientKey` im Body; weitere Header sind nicht nötig.
> **Hinweis:** Fragen Sie eine Aufgabe mit `getTaskResult` auf demselben Endpoint ab, auf dem Sie sie erstellt haben. Verwenden Sie die beiden Endpoints nicht gemischt.
## Alle Methoden
| Methode | Zweck | Hinweise |
| --- | --- | --- |
| [createTask](https://docs.yescaptcha.com/de/api/create-task.md) | Aufgabe erstellen | Synchrone Typen geben das Ergebnis direkt zurück |
| [getTaskResult](https://docs.yescaptcha.com/de/api/get-task-result.md) | Aufgabenergebnis abfragen | Bei asynchronen Typen alle 5 Sekunden abfragen |
| [getBalance](https://docs.yescaptcha.com/de/api/get-balance.md) | Guthaben abfragen | Kein Punkteabzug |
| [getSoftID](https://docs.yescaptcha.com/de/api/get-soft-id.md) | Entwickler-ID abfragen | Für die Entwicklerbeteiligung |
| [report](https://docs.yescaptcha.com/de/api/report.md) | Ergebnisse melden | Bei Typen der Bilderkennung kann eine Erstattung nach Meldung beantragt werden |
| [useragent](https://docs.yescaptcha.com/de/api/useragent.md) | Empfohlenen User-Agent abrufen | `GET`, für hCaptcha |
Wenn Sie keine Verbindung herstellen können, lesen Sie [Verbindungs- und Netzwerkprobleme](https://docs.yescaptcha.com/de/help/troubleshooting.md).
---
# Abrechnung und Punkteerstattung
> So rechnet YesCaptcha ab. 1,000 Punkte = ¥1, pro Aufgabentyp wird ein fester Preis abgezogen; bei fehlgeschlagener Erkennung und Timeout erfolgt automatisch eine Punkteerstattung, Anfragen mit Fehlerantwort kosten nichts; das Guthaben muss über 10 Punkten liegen; bei gemeldeten Fehlern der Bilderkennung erfolgt die Erstattung nach etwa 24 Stunden.
Source: https://docs.yescaptcha.com/de/getting-started/billing/ · 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/getting-started/billing/
YesCaptcha rechnet pro Aufgabe ab: Jeder Aufgabentyp hat einen festen Preis, 1,000 Punkte = ¥1. `NoCaptchaTaskProxyless` kostet zum Beispiel 15 Punkte (≈ $2.25 / 1k) pro Aufgabe. Die Preise aller Typen finden Sie unter [Aufgabentypen und Preise](https://docs.yescaptcha.com/de/tasks.md).
> **Tipp:** Sie zahlen nur für erfolgreiche Aufgaben: Bei fehlgeschlagener Erkennung oder Timeout erfolgt automatisch eine Punkteerstattung, und Anfragen, die einen Fehler zurückgeben, kosten nichts.
## Wann Punkte abgezogen werden
- **Asynchrone Typen** (die meisten Typen, die ein Token zurückgeben): Der Punkteabzug erfolgt, sobald die Aufgabe erfolgreich erstellt wurde. Schlägt die Erkennung danach fehl (`ERROR_CAPTCHA_UNSOLVABLE` usw.) oder tritt ein Timeout auf (`ERROR_TASK_TIMEOUT`, in der Regel nach 110 Sekunden), werden die Punkte automatisch zurückerstattet.
- **Synchrone Typen** (Bilderkennung, `ImageToTextTaskOcrBase`, `ImageToTextTaskMuggle`): Der Punkteabzug erfolgt, wenn das Ergebnis erfolgreich zurückgegeben wird.
- Wird beim Erstellen der Aufgabe bereits ein Fehler zurückgegeben (falsche Parameter, zu geringes Guthaben, Limit gleichzeitiger Aufgaben überschritten usw.), erfolgt kein Punkteabzug.
## Guthaben
- Das Guthaben muss **über 10 Punkten** liegen, damit Sie Aufgaben erstellen können. Andernfalls erhalten Sie `ERROR_ZERO_BALANCE`.
- Das Guthaben fragen Sie mit [getBalance](https://docs.yescaptcha.com/de/api/get-balance.md) ab; das kostet nichts.
- Zu Aufladung und VIP-Bonus siehe [Aufladung und VIP](https://docs.yescaptcha.com/de/account/recharge.md): Sobald Ihre gesamte Aufladung eine VIP-Stufe erreicht, erhalten Sie bei jeder weiteren Aufladung anteilig Bonuspunkte.
## Typen mit fallabhängigem Preis
- **reCAPTCHA v2 Bilderkennung** (`ReCaptchaV2Classification`): Ein 1x1-Bild und 3x3- bzw. 4x4-Bilder haben unterschiedliche Preise, siehe [reCAPTCHA v2 Bilderkennung](https://docs.yescaptcha.com/de/tasks/recaptcha-classification.md).
- **hCaptcha Bilderkennung** (`HCaptchaClassification`): Wird kein Ziel erkannt (leeres Ergebnis), erfolgt kein Punkteabzug.
## Erstattung nach Meldung eines Erkennungsfehlers
Wenn ein Ergebnis der Bilderkennung falsch war, können Sie es mit [report](https://docs.yescaptcha.com/de/api/report.md) melden. Bei erfüllten Bedingungen werden Punkte erstattet:
- Nur 5 Typen der Bilderkennung sind berechtigt: `FunCaptchaClassification`, `HCaptchaClassification`, `ReCaptchaV2Classification`, `AwsClassification` und `bCaptchaClassification`.
- Die Meldung muss **innerhalb von 1 Stunde** nach Erstellung der Aufgabe erfolgen; jede Aufgabe wird nur einmal gezählt.
- Die Erstattung erfolgt nicht sofort, sondern wird **nach etwa 24 Stunden** gesammelt abgerechnet.
- Bei der Abrechnung wird Ihre gemeldete Fehlerquote mit der anderer Nutzer zur selben Frage im selben Zeitraum verglichen: Liegt Ihre Fehlerquote deutlich über dem Niveau des Zeitraums, wird entsprechend der Fehlerquote des Zeitraums erstattet.
- Bitte melden Sie Erfolge und Fehler wahrheitsgemäß. Meldungen, die nur Fehler enthalten, dienen nicht als Referenz für den Zeitraum; Ihre Fehlerquote wird dann über alle von Ihnen erstellten Aufgaben berechnet.
- Bei Fragen zur Abrechnung können Sie sich an den [Support](https://docs.yescaptcha.com/de/help/contact.md) wenden und Einspruch einlegen.
Bei Typen, die ein Token zurückgeben (reCAPTCHA, hCaptcha, Turnstile usw.), entscheidet die Zielwebsite, ob das Token akzeptiert wird. Für solche Meldungen gibt es keine Erstattung.
## Wann kein Punkteabzug erfolgt
| Situation | Antwort |
| --- | --- |
| Falsche Parameter, nicht vorhandener Aufgabentyp, falscher `clientKey` | Der jeweilige Fehlercode |
| Guthaben nicht über 10 Punkten | `ERROR_ZERO_BALANCE` |
| Limit gleichzeitiger Aufgaben überschritten | `ERROR_THREADS_MAXIMUM`, siehe [Limit gleichzeitiger Aufgaben und automatische Pausierung](https://docs.yescaptcha.com/de/api/rate-limits.md) |
| Während einer automatischen Pausierung | `ERROR_IP_BLOCKED_5MIN` |
| Als ungültig erkannter sitekey oder Domain (während der Cache-Dauer) | Der ursprüngliche Fehlercode mit `cached: true` |
| Erkennung fehlgeschlagen, Timeout | Bereits abgezogene Punkte werden automatisch zurückerstattet |
## Beteiligung und Prämien
- Wenn Sie die Software oder Erweiterung eines anderen verwenden, können Ihre Aufgaben eine Entwickler-ID tragen. Der Entwickler erhält eine Beteiligung; Ihr Punkteabzug ändert sich dadurch nicht. Wenn Sie selbst Software entwickeln, siehe [Entwicklerbeteiligung](https://docs.yescaptcha.com/de/account/developer.md).
- Zum Einladen anderer Nutzer siehe [Empfehlungsprämie](https://docs.yescaptcha.com/de/account/referral.md).
---
# Anfragen und Antworten
> Allgemeine Konventionen der YesCaptcha API: POST mit JSON, Authentifizierung per clientKey, Antwortformat mit errorId, synchrone und asynchrone Aufgaben, Abfrage alle 5 Sekunden, Timeout nach 110 Sekunden, Ergebnisse etwa 10 Minuten gespeichert, Sprache der Hinweise nach Accept-Language.
Source: https://docs.yescaptcha.com/de/api/overview/ · 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/api/overview/
Alle Methoden werden per HTTPS `POST` mit JSON aufgerufen (nur `/useragent` ist ein `GET`), authentifizieren sich mit dem `clientKey` im Request-Body und antworten mit JSON: `errorId` 0 bedeutet Erfolg, 1 bedeutet Fehler mit einem `errorCode`. Ein Captcha zu lösen erfordert zwei Schritte: `createTask` erstellt die Aufgabe, `getTaskResult` wird alle 5 Sekunden nach dem Ergebnis abgefragt. Synchrone Typen liefern das Ergebnis direkt in `createTask`.
## Anfrage
```bash
curl -s https://api.yescaptcha.com/createTask \
-H 'Content-Type: application/json' \
-d '{"clientKey": "YOUR_CLIENT_KEY", "task": {"type": "ImageToTextTaskOcrBase", "body": "BASE64_IMAGE"}}'
```
- Endpoint: `https://api.yescaptcha.com` (global) oder `https://cn.yescaptcha.com` (China), siehe [Zugangsadressen](https://docs.yescaptcha.com/de/getting-started/endpoints.md).
- Der Body ist JSON, wird mit dem Header `Content-Type: application/json` gesendet und darf höchstens 6 MB groß sein. JSON darf keine Kommentare enthalten.
- Jede Anfrage muss `clientKey` enthalten. Kopieren Sie den im Dashboard angezeigten Wert vollständig.
> **Achtung:** Verwenden Sie bei Python requests `json=data`, nicht `data=data`. Letzteres sendet ein Formular und liefert `ERROR_TASK_ABSENT` oder `ERROR_REQUIRED_FIELDS`.
## Antwort
Erfolg:
```json
{
"errorId": 0,
"taskId": "61138bb6-19fb-11ec-a9c8-0242ac110006"
}
```
Fehler:
```json
{
"errorId": 1,
"errorCode": "ERROR_ZERO_BALANCE",
"errorDescription": "帐户余额不足"
}
```
| Feld | Beschreibung |
| --- | --- |
| `errorId` | 0 Erfolg, 1 Fehler |
| `errorCode` | Fehlercode im Fehlerfall; Bedeutung und Lösung siehe [Fehlercodes](https://docs.yescaptcha.com/de/api/errors.md) |
| `errorDescription` | Textbeschreibung der Fehlerursache |
| `taskId` | Aufgaben-ID |
| `status` | `processing` (in Bearbeitung) oder `ready` (fertig) |
| `solution` | Erkennungsergebnis; die Felder hängen vom Aufgabentyp ab, siehe die Seiten der einzelnen Aufgabentypen |
Werten Sie `errorId` und `errorCode` aus, nicht den Text von `errorDescription`; er kann sich ändern.
## Synchron und asynchron
| | Asynchron | Synchron |
| --- | --- | --- |
| Welche Typen | Typen, die ein Token zurückgeben (reCAPTCHA, hCaptcha, Turnstile, FunCaptcha), Cloudflare-Prüfseite, `ImageToTextTask`, `ImageToTextTaskM1` | Bilderkennung (Namen enden auf `Classification`), `ImageToTextTaskOcrBase`, `ImageToTextTaskMuggle` |
| `createTask` liefert | `taskId` | `status: "ready"` und `solution` |
| Ergebnis abrufen | `getTaskResult` alle 5 Sekunden aufrufen | Keine weitere Abfrage nötig |
Welcher Modus für welchen Typ gilt, steht in der Spalte „Rückgabeart“ unter [Aufgabentypen und Preise](https://docs.yescaptcha.com/de/tasks.md).
## Regelmäßige Abfrage (Polling)
1. Warten Sie nach der `taskId` aus `createTask` 5 Sekunden und rufen Sie dann `getTaskResult` auf.
2. Bei `status: "processing"` warten Sie weitere 5 Sekunden und versuchen es erneut; bei `status: "ready"` steht das Ergebnis in `solution`.
3. Bei `errorId: 1` beenden Sie die Abfrage dieser Aufgabe und behandeln den `errorCode`.
- Wiederholte Abfragen derselben `taskId` innerhalb von 5 Sekunden liefern sofort `processing`; häufigeres Abfragen liefert das Ergebnis nicht schneller.
- Eine Aufgabe wird in der Regel höchstens 110 Sekunden bearbeitet (bei wenigen Typen 180 bis 220 Sekunden); danach wird `ERROR_TASK_TIMEOUT` zurückgegeben und die Punkte werden automatisch erstattet (Punkteerstattung).
- Ergebnisse werden auf dem Server etwa 10 Minuten gespeichert; danach ist die `taskId` ungültig und Abfragen liefern `ERROR_TASKID_INVALID`.
- Abfragen von Ergebnissen kosten keine Punkte; nur das Erstellen einer Aufgabe führt zu einem Punkteabzug.
## Sprache der Hinweise
Bei Hinweisen zu automatischer Pausierung, zwischengespeicherten ungültigen Parametern und Abbruch der Abfrage richtet sich `errorDescription` nach dem Request-Header `Accept-Language`: Beginnt er mit `zh`, wird Chinesisch zurückgegeben, bei jeder anderen Sprache Englisch, ohne diesen Header beides. Die Beschreibungen anderer Fehlercodes sind nicht betroffen.
## Nächste Schritte
- [createTask: Aufgabe erstellen](https://docs.yescaptcha.com/de/api/create-task.md)
- [getTaskResult: Ergebnis abrufen](https://docs.yescaptcha.com/de/api/get-task-result.md)
- [Limit gleichzeitiger Aufgaben und automatische Pausierung](https://docs.yescaptcha.com/de/api/rate-limits.md): Bei zu vielen Fehlern wird Ihr Zugang für einige Minuten pausiert
---
# createTask – Aufgabe erstellen
> POST /createTask erstellt eine Captcha-Aufgabe: Anfragefelder (clientKey, task, softID), Reihenfolge der Prüfungen, asynchrone Typen liefern eine taskId, synchrone Typen direkt die solution; das Guthaben muss über 10 Punkten liegen.
Source: https://docs.yescaptcha.com/de/api/create-task/ · 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/api/create-task/
`createTask` erstellt eine Erkennungsaufgabe; mit `task.type` legen Sie fest, welches Captcha gelöst werden soll. Asynchrone Typen liefern eine `taskId`, mit der Sie anschließend das Ergebnis über [getTaskResult](https://docs.yescaptcha.com/de/api/get-task-result.md) abrufen; synchrone Typen liefern das Ergebnis direkt.
> **Hinweis:** Der Punkteabzug erfolgt, sobald die Aufgabe erfolgreich erstellt wurde. Ihr Guthaben muss über 10 Punkten liegen, um eine Aufgabe zu erstellen. Bei fehlgeschlagenen oder abgelaufenen Aufgaben erfolgt automatisch eine Punkteerstattung.
- POST `https://api.yescaptcha.com/createTask` (Globaler Endpoint)
- POST `https://cn.yescaptcha.com/createTask` (China-Endpoint)
## Anfragefelder
| Feld | Typ | Pflicht | Beschreibung |
| --- | --- | --- | --- |
| `clientKey` | string | Ja | Ihr ClientKey, zu kopieren im Dashboard auf [yescaptcha.com](https://yescaptcha.com/) |
| `task` | object | Ja | Das Aufgabenobjekt. Es muss `type` enthalten; die übrigen Felder richten sich nach dem Aufgabentyp (siehe die Seiten der einzelnen Aufgabentypen) |
| `softID` | integer | Nein | Entwickler-ID. Geben Sie sie an, wenn andere Ihre Software verwenden, um eine Entwicklerbeteiligung zu erhalten, siehe [Entwicklerbeteiligung](https://docs.yescaptcha.com/de/account/developer.md) |
## Anfragebeispiele
Ein Bild-Captcha erkennen (synchron):
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "ImageToTextTaskOcrBase",
"body": "BASE64_IMAGE"
}
}
```
Ein reCAPTCHA-v2-Token abrufen (asynchron):
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
}
}
```
Die `task`\-Felder der einzelnen Aufgabentypen finden Sie auf den Seiten unter [Aufgabentypen und Preise](https://docs.yescaptcha.com/de/tasks.md).
## Antwort
Asynchrone Typen:
```json
{
"errorId": 0,
"taskId": "61138bb6-19fb-11ec-a9c8-0242ac110006"
}
```
Merken Sie sich die `taskId` und fragen Sie nach 5 Sekunden mit `getTaskResult` ab.
Synchrone Typen:
```json
{
"errorId": 0,
"status": "ready",
"taskId": "2376919c-1863-11ec-a012-94e6f7355a0b",
"solution": {
"text": "LMResm"
}
}
```
Fehler:
```json
{
"errorId": 1,
"errorCode": "ERROR_TASK_NOT_SUPPORTED",
"errorDescription": "任务类型不正确或不受支持"
}
```
## Reihenfolge der Prüfungen
Der Server prüft eine Anfrage in dieser Reihenfolge und gibt beim ersten gefundenen Problem den entsprechenden Fehlercode zurück. Es erfolgt kein Punkteabzug:
1. Der Request-Body ist gültiges JSON: `ERROR_REQUEST_FORMATS`
2. `clientKey` ist angegeben: `ERROR_REQUIRED_FIELDS`
3. `clientKey` existiert: `ERROR_KEY_DOES_NOT_EXIST`
4. Der Schlüssel ist nicht automatisch pausiert: `ERROR_IP_BLOCKED_5MIN` (siehe [Limit gleichzeitiger Aufgaben und automatische Pausierung](https://docs.yescaptcha.com/de/api/rate-limits.md))
5. Das Guthaben liegt über 10 Punkten: `ERROR_ZERO_BALANCE`
6. `task` ist angegeben: `ERROR_TASK_ABSENT`
7. `task.type` existiert: `ERROR_TASK_NOT_SUPPORTED`
8. Alle Pflichtfelder sind vorhanden: `ERROR_REQUIRED_FIELDS` (`errorDescription` nennt das fehlende Feld)
9. Bei Bildaufgaben ist das Bild gültig: `ERROR_ZERO_CAPTCHA_FILESIZE`, `ERROR_IMAGE_TYPE_NOT_SUPPORTED` und weitere
## Vollständiges Beispiel
Eine Aufgabe erstellen und das Ergebnis regelmäßig abfragen (asynchroner Typ):
**curl**
```bash
curl -s https://api.yescaptcha.com/createTask \
-H 'Content-Type: application/json' \
-d '{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
}
}'
# Returns {"errorId":0,"taskId":"..."}; then poll every 5 seconds:
curl -s https://api.yescaptcha.com/getTaskResult \
-H 'Content-Type: application/json' \
-d '{"clientKey": "YOUR_CLIENT_KEY", "taskId": "TASK_ID"}'
```
**Python**
solve.py
```python
import os
import time
import requests
API = "https://api.yescaptcha.com"
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"] # Read the clientKey from an environment variable
def call(method, payload):
r = requests.post(f"{API}/{method}", json={"clientKey": CLIENT_KEY, **payload}, timeout=30)
data = r.json()
if data.get("errorId"):
raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
return data
def solve(task):
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"]
raise TimeoutError(task_id)
solution = solve({
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
})
print(solution["gRecaptchaResponse"])
```
**Node.js**
solve.mjs
```js
const API = 'https://api.yescaptcha.com';
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY; // Read the clientKey from an environment variable
async function call(method, payload) {
const res = await fetch(`${API}/${method}`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY, ...payload }),
});
const data = await res.json();
if (data.errorId) throw new Error(`${data.errorCode}: ${data.errorDescription}`);
return data;
}
async function solve(task) {
const { taskId } = await call('createTask', { task });
for (let i = 0; i < 36; i++) { // Poll every 5 seconds, for up to about 3 minutes
await new Promise((r) => setTimeout(r, 5000));
const result = await call('getTaskResult', { taskId });
if (result.status === 'ready') return result.solution;
}
throw new Error(`timeout: ${taskId}`);
}
const solution = await solve({
type: "NoCaptchaTaskProxyless",
websiteURL: "https://www.google.com/recaptcha/api2/demo",
websiteKey: "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
});
console.log(solution.gRecaptchaResponse);
```
---
# getTaskResult – Ergebnis abrufen
> POST /getTaskResult liefert das Ergebnis einer asynchronen Aufgabe. Fragen Sie alle 5 Sekunden ab, warten Sie bei processing weiter, lesen Sie bei ready die solution und beenden Sie die Abfrage bei Fehlern; Aufgaben laufen bis zu etwa 110 Sekunden, Ergebnisse bleiben etwa 10 Minuten erhalten, Abfragen kosten keine Punkte.
Source: https://docs.yescaptcha.com/de/api/get-task-result/ · 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/api/get-task-result/
`getTaskResult` liefert das Ergebnis einer asynchronen Aufgabe. Rufen Sie die Methode nach dem Erstellen der Aufgabe alle 5 Sekunden auf: Bei `processing` warten Sie weiter, bei `ready` steht das Ergebnis in `solution`, bei einem Fehler beenden Sie die Abfrage. Abfragen verursachen keinen Punkteabzug, egal wie oft Sie abfragen.
- POST `https://api.yescaptcha.com/getTaskResult` (Globaler Endpoint)
- POST `https://cn.yescaptcha.com/getTaskResult` (China-Endpoint)
## Anfrageparameter
| Feld | Typ | Pflicht | Beschreibung |
| --- | --- | --- | --- |
| `clientKey` | string | Ja | Ihr ClientKey, derselbe wie beim Erstellen der Aufgabe |
| `taskId` | string | Ja | Die von [createTask](https://docs.yescaptcha.com/de/api/create-task.md) zurückgegebene Aufgaben-ID |
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"taskId": "61138bb6-19fb-11ec-a9c8-0242ac110006"
}
```
## Rückgabe
| Situation | Rückgabe | Was zu tun ist |
| --- | --- | --- |
| In Bearbeitung | `errorId` ist 0, `status` ist `processing` | In 5 Sekunden erneut abfragen |
| Fertig | `errorId` ist 0, `status` ist `ready`, das Ergebnis steht in `solution` | `solution` auslesen; die Felder stehen auf den Seiten der einzelnen Aufgabentypen |
| Nicht gelöst | `errorId` ist 1, `errorCode` ist `ERROR_CAPTCHA_UNSOLVABLE` | Die Punkte wurden automatisch erstattet, Sie können die Aufgabe neu erstellen |
| Zeitüberschreitung | `errorId` ist 1, `errorCode` ist `ERROR_TASK_TIMEOUT` | Die Punkte wurden automatisch erstattet, Sie können die Aufgabe neu erstellen |
| Aufgabe nicht vorhanden oder abgelaufen | `errorId` ist 1, `errorCode` ist `ERROR_TASKID_INVALID` | Diese `taskId` nicht mehr abfragen |
Beispiel für eine fertige Aufgabe (reCAPTCHA v2):
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"gRecaptchaResponse": "03AGdBq25SxXT-pmSeBXjzScW-EiocHwwpwqtk1QXlJnGnU..."
}
}
```
## Regeln
- **Alle 5 Sekunden abfragen.** Wiederholte Abfragen derselben `taskId` innerhalb von 5 Sekunden liefern sofort `processing`; häufigeres Abfragen macht nichts schneller.
- **Eine Aufgabe wird höchstens etwa 110 Sekunden bearbeitet** (bei wenigen Typen 180 bis 220 Sekunden). Danach wird `ERROR_TASK_TIMEOUT` zurückgegeben und die Punkte werden automatisch erstattet. Als Obergrenze für das Warten im Programm empfehlen sich etwa 3 Minuten.
- **Ergebnisse bleiben etwa 10 Minuten erhalten**, danach wird die `taskId` ungültig und liefert `ERROR_TASKID_INVALID`. Verwenden Sie das Ergebnis möglichst sofort: Das Token selbst ist kürzer gültig (reCAPTCHA etwa 120 Sekunden).
- **Bei Fehlern beenden.** Nach `errorId: 1` ändert sich das Ergebnis nicht, wenn Sie dieselbe `taskId` weiter abfragen; ab der 3. Abfrage einer bereits beendeten Aufgabe weist `errorDescription` am Ende darauf hin, die Abfrage zu beenden. `ERROR_TASKID_INVALID` zählt für die Fehleranzahl der [automatischen Pausierung](https://docs.yescaptcha.com/de/api/rate-limits.md) mit (dieselbe ID wird nur beim ersten Mal gezählt).
- Fragen Sie auf demselben Endpoint ab, auf dem Sie die Aufgabe erstellt haben.
- `getTaskResult` ist von der automatischen Pausierung nicht betroffen: Aufgaben, die vor der Pausierung erstellt wurden, können weiterhin abgefragt werden.
---
# getBalance – Guthaben abfragen
> POST /getBalance liefert das Guthaben des Kontos in Punkten (1,000 Punkte = ¥1) sowie das Guthaben aus Entwicklerbeteiligung und Empfehlungsprämien. Kein Punkteabzug; geeignet, um den ClientKey zu prüfen.
Source: https://docs.yescaptcha.com/de/api/get-balance/ · 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/api/get-balance/
`getBalance` liefert die verbleibenden Punkte des Kontos (1,000 Punkte = ¥1) sowie das Guthaben aus Entwicklerbeteiligung und Empfehlungsprämien (in ¥). Es erfolgt kein Punkteabzug, daher eignet sich die Abfrage gut, um zu prüfen, ob der `clientKey` korrekt ist.
- POST `https://api.yescaptcha.com/getBalance` (Globaler Endpoint)
- POST `https://cn.yescaptcha.com/getBalance` (China-Endpoint)
## Anfrageparameter
| Feld | Typ | Pflicht | Beschreibung |
| --- | --- | --- | --- |
| `clientKey` | string | Ja | Kontoschlüssel (ClientKey) |
```json
{
"clientKey": "YOUR_CLIENT_KEY"
}
```
## Rückgabe
```json
{
"errorId": 0,
"balance": 1071810,
"softBalance": 36.0098,
"inviteBalance": 0,
"inviteBy": 0
}
```
| Feld | Typ | Beschreibung |
| --- | --- | --- |
| `balance` | integer | Kontoguthaben in Punkten (1,000 Punkte = ¥1). Zum Erstellen von Aufgaben muss es über 10 Punkten liegen |
| `softBalance` | number | Guthaben aus der Entwicklerbeteiligung in ¥, siehe [Entwicklerbeteiligung](https://docs.yescaptcha.com/de/account/developer.md) |
| `inviteBalance` | number | Guthaben aus Empfehlungsprämien in ¥, siehe [Empfehlungsprämie](https://docs.yescaptcha.com/de/account/referral.md) |
| `inviteBy` | integer | Benutzer-ID der Person, die Sie eingeladen hat; 0, wenn es keine gibt |
| `keyQuotaRemaining` | integer | Verbleibendes Ausgabenlimit dieses `clientKey` im aktuellen Zeitraum, in Punkten. Dieses Feld gibt es nur bei einem `clientKey` mit Limit; `balance` ist dann der kleinere Wert aus Kontoguthaben und verbleibendem Limit. Ohne Limit fehlt das Feld |
Bei einem falschen `clientKey` wird `ERROR_KEY_DOES_NOT_EXIST` zurückgegeben. Ist für den `clientKey` eine IP-Whitelist gesetzt und die anfragende IP nicht darin enthalten, wird `ERROR_KEY_IP_NOT_ALLOWED` zurückgegeben. `getBalance` unterliegt der [automatischen Pausierung](https://docs.yescaptcha.com/de/api/rate-limits.md): Während der Pausierung wird `ERROR_IP_BLOCKED_5MIN` zurückgegeben.
## Beispiele
**curl**
get-balance.sh
```bash
#!/usr/bin/env bash
# Check the balance. getBalance is free and is a quick way to verify your clientKey
set -euo pipefail
curl -s https://api.yescaptcha.com/getBalance \
-H 'Content-Type: application/json' \
-d "{\"clientKey\": \"${YESCAPTCHA_CLIENT_KEY}\"}"
echo
```
**Python**
get_balance.py
```python
"""Check the balance. getBalance is free and is a quick way to verify your clientKey."""
import os
import requests
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
r = requests.post(
"https://api.yescaptcha.com/getBalance",
json={"clientKey": CLIENT_KEY},
timeout=30,
)
data = r.json()
if data.get("errorId"):
# e.g. ERROR_KEY_DOES_NOT_EXIST when the clientKey is wrong
print("error:", data.get("errorCode"), data.get("errorDescription"))
else:
print("balance (points):", data["balance"])
```
**Node.js**
get-balance.mjs
```js
// Check the balance. getBalance is free and is a quick way to verify your clientKey. Node.js 18+
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY;
const res = await fetch('https://api.yescaptcha.com/getBalance', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY }),
});
const data = await res.json();
if (data.errorId) {
// e.g. ERROR_KEY_DOES_NOT_EXIST when the clientKey is wrong
console.log('error:', data.errorCode, data.errorDescription);
} else {
console.log('balance (points):', data.balance);
}
```
---
# getSoftID – Entwickler-ID abfragen
> POST /getSoftID gibt Ihre Entwickler-ID (softID) und die aufgelaufene Entwicklerbeteiligung zurück. Tragen Sie die softID in die createTask-Anfragen ein, die Ihre Software für andere Nutzer sendet, um eine Beteiligung zu erhalten.
Source: https://docs.yescaptcha.com/de/api/get-soft-id/ · 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/api/get-soft-id/
`getSoftID` gibt Ihre Entwickler-ID (`softID`) und den aufgelaufenen Betrag Ihrer Entwicklerbeteiligung (in Yuan) zurück. Wenn andere Ihre Software oder Erweiterung verwenden, tragen Sie diese ID in deren `createTask`\-Anfragen ein, um an deren Ausgaben beteiligt zu werden. Regeln und Auszahlung: [Entwicklerbeteiligung](https://docs.yescaptcha.com/de/account/developer.md).
- POST `https://api.yescaptcha.com/getSoftID` (Globaler Endpoint)
- POST `https://cn.yescaptcha.com/getSoftID` (China-Endpoint)
## Anfrageparameter
| Feld | Typ | Pflicht | Beschreibung |
| --- | --- | --- | --- |
| `clientKey` | string | Ja | Ihr eigener ClientKey (als Entwickler) |
```json
{
"clientKey": "YOUR_CLIENT_KEY"
}
```
## Rückgabe
```json
{
"errorId": 0,
"softID": 3,
"balance": 0.004
}
```
| Feld | Typ | Beschreibung |
| --- | --- | --- |
| `softID` | integer | Ihre Entwickler-ID |
| `balance` | number | Aufgelaufene Entwicklerbeteiligung in Yuan |
## Verwendung
Fügen Sie in den `createTask`\-Anfragen der Nutzer Ihrer Software das Feld `softID` auf oberster Ebene hinzu:
```json
{
"clientKey": "THE_USERS_CLIENT_KEY",
"task": {
"type": "ImageToTextTaskOcrBase",
"body": "BASE64_IMAGE"
},
"softID": 3
}
```
> **Achtung:** Setzen Sie `softID` auf die oberste Ebene des Request-Bodys, auf derselben Ebene wie `clientKey` und `task`, und achten Sie auf exakt dieselbe Groß- und Kleinschreibung. Innerhalb von `task` hat das Feld keine Wirkung.
`clientKey` ist der ClientKey des Nutzers, die Punkte werden dem Nutzer abgezogen; `softID` ist Ihre Entwickler-ID.
---
# report – Ergebnisse melden
> POST /report meldet, ob die Ergebnisse von Aufgaben korrekt waren; bitte melden Sie Erfolge und Fehler wahrheitsgemäß. Bei Bilderkennungstypen müssen Fehler innerhalb von 1 Stunde nach Erstellung der Aufgabe gemeldet werden, die Erstattung wird nach etwa 24 Stunden abgerechnet.
Source: https://docs.yescaptcha.com/de/api/report/ · 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/api/report/
Mit `report` teilen Sie uns mit, ob die Ergebnisse einer Gruppe von Aufgaben korrekt waren. **Bitte melden Sie Erfolge und Fehler.** Wenn Sie bei Bilderkennungstypen ein Ergebnis als „falsch“ melden, werden Punkte nach etwa 24 Stunden erstattet, sofern die Bedingungen erfüllt sind. Die Meldungen dienen außerdem dazu, die Erkennung zu bewerten und zu verbessern.
- POST `https://api.yescaptcha.com/report` (Globaler Endpoint)
- POST `https://cn.yescaptcha.com/report` (China-Endpoint)
## Anfrageparameter
| Feld | Typ | Pflicht | Beschreibung |
| --- | --- | --- | --- |
| `id` | array of string | Ja | Liste von Aufgaben-IDs; Sie können mehrere auf einmal melden |
| `isSuccess` | boolean | Ja | `true`: Ergebnis korrekt, `false`: Ergebnis falsch |
`clientKey` ist nicht erforderlich, die Aufgaben-ID ordnet die Aufgabe bereits zu.
```json
{
"id": ["610ff5e0-68eb-11ef-95a6-22e70a0b794d", "65b88c06-68eb-11ef-8e9a-52540023ccb3"],
"isSuccess": false
}
```
## Rückgabe
```json
{
"errorId": 0,
"status": "success"
}
```
## Bitte wahrheitsgemäß melden
Die Meldungen dienen sowohl der Abrechnung der Erstattung als auch der Bewertung und Verbesserung der Erkennung. Bitte melden Sie das tatsächliche Ergebnis:
- Melden Sie korrekt erkannte Aufgaben mit `isSuccess: true` und falsche mit `false`. Meldungen, die nur Fehler enthalten oder unabhängig vom Ergebnis alles als Fehler melden, werden in Statistik und Abrechnung nicht berücksichtigt.
- Die Fehlerrate wird über alle Aufgaben berechnet, die Sie in diesem Zeitraum erstellt haben, nicht nur über die gemeldeten. Mehr Fehlermeldungen führen nicht zu mehr Erstattung: Liegt Ihre Fehlerrate deutlich über der des gleichen Zeitraums, erstatten wir nur nach der Fehlerrate des Zeitraums.
- Wenn für eine Prüfung mehrere Bilder verwendet wurden (z. B. fünf Runden bei FunCaptcha) und Sie nicht wissen, welches falsch war, können Sie die ganze Gruppe von Aufgaben gemeinsam als Fehler melden. Besteht die Prüfung, melden Sie die ganze Gruppe ebenso gemeinsam als Erfolg.
## Erstattung nach einer Fehlermeldung
- Nur 5 Bilderkennungstypen werden erstattet: `FunCaptchaClassification`, `HCaptchaClassification`, `ReCaptchaV2Classification`, `AwsClassification`, `bCaptchaClassification`.
- Es zählen nur Meldungen **innerhalb von 1 Stunde** nach Erstellung der Aufgabe; jede Aufgabe wird höchstens einmal erstattet.
- Die Erstattung erfolgt nicht sofort, sondern wird **nach etwa 24 Stunden** gesammelt abgerechnet.
- Bei der Abrechnung wird Ihre gemeldete Fehlerrate mit der anderer Nutzer verglichen, die im gleichen Zeitraum dieselben Fragen hatten. Liegt Ihre Rate deutlich über dem Niveau des Zeitraums, erstatten wir nach der Fehlerrate des Zeitraums.
- Bei Fragen zur Abrechnung können Sie den [Support kontaktieren](https://docs.yescaptcha.com/de/help/contact.md) und Einspruch einlegen.
Bei Typen, die ein Token zurückgeben (reCAPTCHA, hCaptcha, Turnstile, FunCaptcha usw.), entscheidet die Zielwebsite, ob das Token akzeptiert wird; Meldungen führen hier nicht zu einer Erstattung. Alle Abrechnungsregeln finden Sie unter [Abrechnung und Punkteerstattung](https://docs.yescaptcha.com/de/getting-started/billing.md).
---
# useragent – User-Agent abrufen
> GET https://api.yescaptcha.com/useragent gibt den aktuell empfohlenen Browser-User-Agent zurück (reiner Text). Das Feld userAgent bei hCaptcha-Aufgaben akzeptiert nur diesen Wert.
Source: https://docs.yescaptcha.com/de/api/useragent/ · 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/api/useragent/
`/useragent` gibt den aktuell empfohlenen Browser-User-Agent als reinen Text zurück. Es ist weder ein `clientKey` nötig noch fällt ein Punkteabzug an. Das Feld `userAgent` bei [hCaptcha](https://docs.yescaptcha.com/de/tasks/hcaptcha.md)\-Aufgaben akzeptiert nur diesen Wert. Verwenden Sie ihn auch beim Besuch der Zielseite, damit Tokens leichter akzeptiert werden.
- GET `https://api.yescaptcha.com/useragent` (Globaler Endpoint)
- GET `https://cn.yescaptcha.com/useragent` (China-Endpoint)
## Beispiel
```bash
curl -s https://api.yescaptcha.com/useragent
```
Antwort (Wert vom 2026-10-15; er ändert sich mit neuen Browserversionen):
```text
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36
```
> **Hinweis:** Der Wert wird laufend aktualisiert. Schreiben Sie ihn nicht fest in den Code, sondern rufen Sie ihn bei jedem Start einmal ab.
- Enthält ein Ergebnis ein `userAgent`, verwenden Sie beim Senden des Tokens den Wert aus dem Ergebnis.
---
# Fehlercodes
> Alle Fehlercodes der YesCaptcha API mit Bedeutung und Vorgehen: Anfrageformat, Konto und Guthaben, gleichzeitige Aufgaben und Pausierung, Aufgabenergebnis, Website-Parameter, Bilder, Proxy, Server. Anfragen, die einen Fehler zurückgeben, werden nicht berechnet.
Source: https://docs.yescaptcha.com/de/api/errors/ · 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/api/errors/
Bei einem Fehler gibt die API `errorId: 1` zurück. `errorCode` enthält den Fehlercode, `errorDescription` die Beschreibung als Text. Anfragen, die einen Fehler zurückgeben, verursachen keinen Punkteabzug: Tritt der Fehler schon beim Erstellen der Aufgabe auf, wird nichts abgezogen. Schlägt die Erkennung nach dem Erstellen fehl oder läuft sie in ein Timeout, erfolgt automatisch eine Punkteerstattung.
> **Tipp:** Werten Sie im Programm `errorCode` aus, nicht den Text von `errorDescription`. Die Textbeschreibung kann sich ändern.
```json
{
"errorId": 1,
"errorCode": "ERROR_ZERO_BALANCE",
"errorDescription": "帐户余额不足"
}
```
## Vorgehen bei Fehlern
1. **Parameterfehler** (Anfrageformat, ClientKey, Aufgabentyp, Website-Parameter, Bilder) ändern sich durch erneutes Senden nicht. Korrigieren Sie zuerst die Anfrage.
2. **Fehlgeschlagene Erkennung und Timeouts** (`ERROR_CAPTCHA_UNSOLVABLE`, `ERROR_TASK_TIMEOUT`): Sie können die Aufgabe neu erstellen.
3. Beenden Sie nach einem Fehler die **regelmäßige Abfrage (Polling)** für diese `taskId`. Senden Sie dieselbe Anfrage nicht unverändert in hoher Frequenz erneut.
4. Fehler mit der Kennzeichnung „zählt zur automatischen Pausierung“: Treten für denselben `clientKey` innerhalb einer Minute 100 davon auf, wird das Erstellen von Aufgaben für 5 Minuten pausiert. Fehler mit der Kennzeichnung „Cache“ zählen nicht mit, aber solange sie im Cache sind, geben gleiche Anfragen direkt den ursprünglichen Fehler zurück. Details: [Limit gleichzeitiger Aufgaben und automatische Pausierung](https://docs.yescaptcha.com/de/api/rate-limits.md).
## Alle Fehlercodes
### Anfrageformat
| Fehlercode | Bedeutung | Was zu tun ist |
| --- | --- | --- |
| `ERROR_REQUIRED_FIELDS` | Ein Pflichtfeld fehlt (etwa `clientKey` oder `websiteURL` / `websiteKey` für den Aufgabentyp), oder der Request-Body ist kein JSON | Ergänzen Sie die fehlenden Felder gemäß der Seite des Aufgabentyps und senden Sie JSON per `POST` mit `Content-Type: application/json` |
| `ERROR_REQUEST_FORMATS` (Zählt zur Pausierung) | Der Request-Body ist kein gültiges JSON | Erzeugen Sie den Body mit einer JSON-Bibliothek statt durch Zusammensetzen von Strings; JSON darf keine `//`\-Kommentare enthalten |
| `ERROR_TASK_ABSENT` (Zählt zur Pausierung) | Das Feld `task` fehlt in einem `createTask`\-Aufruf | Legen Sie die Aufgabenparameter in einem `task`\-Objekt ab. Verwenden Sie bei Python requests `json=data`, nicht `data=data` |
| `ERROR_TASK_NOT_SUPPORTED` (Zählt zur Pausierung) | `task.type` ist falsch geschrieben, oder der Typ wurde eingestellt | Kopieren Sie den Typnamen aus "Aufgabentypen und Preise"; bei Namen wird zwischen Groß- und Kleinschreibung unterschieden |
| `ERROR_PAGE_NOT_FOUND` | Der angeforderte Pfad existiert nicht | Prüfen Sie die Endpoint-URL, z. B. `https://api.yescaptcha.com/createTask`; bei Methodennamen wird zwischen Groß- und Kleinschreibung unterschieden |
| `ERROR_BAD_REQUEST` | Die Anfrage kann nicht verarbeitet werden, meist wegen einer falschen HTTP-Methode (GET statt POST) oder ungültiger Parameterwerte | Senden Sie JSON per `POST` und prüfen Sie die Typen und Werte der Parameter |
| `ERROR_ILLEGAL_PARAMETERS` | Ein Parameterwert ist ungültig. Typisch für die Cloudflare-Prüfseite: `websiteURL` ist keine öffentliche URL mit `http://` / `https://`, `postData` ist kein Objekt oder `requiredCookies` ist kein Array von Strings (von createTask zurückgegeben, kein Punkteabzug); oder die Zieldomain konnte über den Proxy nicht aufgelöst werden (von getTaskResult zurückgegeben, automatische Punkteerstattung) | Korrigieren Sie den Wert gemäß der Parametertabelle auf der Seite des Aufgabentyps. Wenn die Domain nicht aufgelöst werden konnte, prüfen Sie die Schreibweise der URL und ob der Proxy die Website erreichen kann |
### Konto und Guthaben
| Fehlercode | Bedeutung | Was zu tun ist |
| --- | --- | --- |
| `ERROR_KEY_DOES_NOT_EXIST` (Zählt zur Pausierung) | Der `clientKey` existiert nicht: Beim Kopieren wurden Zeichen hinzugefügt oder gingen verloren, oder der Schlüssel wurde im Dashboard zurückgesetzt | Kopieren Sie den Schlüssel erneut aus dem Dashboard auf yescaptcha.com, ohne Leerzeichen oder Zeilenumbrüche |
| `ERROR_KEY_EXPIRED` (Zählt zur Pausierung) | Der `clientKey` ist abgelaufen (wird von createTask und getBalance zurückgegeben, kein Punkteabzug). Entweder wurde er lange nicht verwendet und das System hat zum Schutz des Kontos ein Ablaufdatum gesetzt (vor dem Ablauf wird eine Erinnerung per E-Mail gesendet), oder das für diesen `clientKey` festgelegte Ablaufdatum ist überschritten | Melden Sie sich im Dashboard auf yescaptcha.com an. Wenn er nach langer Nichtverwendung abgelaufen ist, erzeugen Sie einen neuen `clientKey`; das Guthaben wird automatisch auf den neuen übertragen. Wenn ein Ablaufdatum festgelegt wurde, ändern Sie es oder verwenden Sie einen anderen `clientKey`. Aktualisieren Sie anschließend Ihr Programm mit dem neuen `clientKey` |
| `ERROR_KEY_IP_NOT_ALLOWED` | Für diesen `clientKey` ist eine IP-Zulassungsliste festgelegt, und die IP, von der die Anfrage stammt, steht nicht darauf (wird von createTask und getBalance zurückgegeben, ohne Punkteabzug, zählt nicht für die automatische Pausierung) | Melden Sie sich im Dashboard auf yescaptcha.com an und fügen Sie die öffentliche IP des Rechners, der die Anfragen sendet, zur Zulassungsliste dieses `clientKey` hinzu, oder verwenden Sie einen anderen `clientKey`. Wenn mehrere Rechner die API aufrufen, fügen Sie die öffentliche IP jedes einzelnen hinzu (gemeint ist die IP, die die YesCaptcha-API aufruft, nicht der Proxy in den Aufgabenparametern) |
| `ERROR_KEY_QUOTA_EXCEEDED` | Für diesen `clientKey` ist ein Ausgabenlimit festgelegt, und das verbleibende Limit des aktuellen Zeitraums reicht für den Punkteabzug dieser Aufgabe nicht aus (wird von createTask zurückgegeben, ohne Punkteabzug, zählt nicht für die automatische Pausierung). Das Limit rechnet mit den tatsächlich abgezogenen Punkten; Punkte, die bei fehlgeschlagenen Aufgaben oder Zeitüberschreitung erstattet werden, werden dem Limit wieder gutgeschrieben | Melden Sie sich im Dashboard auf yescaptcha.com an und erhöhen Sie das Limit dieses `clientKey`, warten Sie auf den nächsten Zeitraum (das Limit wird täglich, jeden Montag oder am 1. jedes Monats zurückgesetzt, jeweils nach Pekinger Zeit; ein einmaliges Limit wird nicht zurückgesetzt), oder verwenden Sie einen anderen `clientKey`. Mit `getBalance` erhalten Sie das verbleibende Limit dieses `clientKey` (`keyQuotaRemaining`) |
| `ERROR_ZERO_BALANCE` | Unzureichendes Guthaben. Das Guthaben muss über 10 Punkten liegen, um eine Aufgabe zu erstellen | Laden Sie Ihr Guthaben auf und versuchen Sie es erneut. Mit `getBalance` können Sie das Guthaben abfragen |
### Gleichzeitige Aufgaben und Pausierung
| Fehlercode | Bedeutung | Was zu tun ist |
| --- | --- | --- |
| `ERROR_THREADS_MAXIMUM` (Zählt teilweise zur Pausierung) | Für das Konto sind zu viele Aufgaben dieses Typs gleichzeitig in Bearbeitung. `limit` in der Antwort ist das aktuelle Limit. Die Anfrage wurde nicht verarbeitet und es erfolgte kein Punkteabzug | Warten Sie, bis laufende Anfragen zurückkehren, oder warten Sie 1–2 Sekunden und versuchen Sie es erneut; begrenzen Sie die Anzahl gleichzeitig wartender Anfragen |
| `ERROR_IP_BLOCKED_5MIN` | Dieser `clientKey` hat in kurzer Zeit zu viele Fehler verursacht und wurde automatisch pausiert. `retryAfter` ist die verbleibende Zeit in Sekunden und `blockReason` ist der Fehler, der dies ausgelöst hat | Korrigieren Sie die Anfrage gemäß `blockReason` und warten Sie `retryAfter` Sekunden; Senden während der Pausierung verlängert diese nicht |
| `ERROR_NO_SLOT_AVAILABLE` | Der Erkennungsdienst ist vorübergehend überlastet. Wenn `createTask` diesen Fehler zurückgibt, wird kein Punkteabzug vorgenommen; eine Aufgabe, die zu lange in der Warteschlange war, liefert ihn auch bei `getTaskResult` zurück und wird automatisch mit einer Punkteerstattung ausgeglichen | Warten Sie einige Sekunden und erstellen Sie die Aufgabe erneut |
### Aufgaben und Ergebnisse
| Fehlercode | Bedeutung | Was zu tun ist |
| --- | --- | --- |
| `ERROR_TASKID_INVALID` (Zählt zur Pausierung) | Die `taskId` existiert nicht, ist abgelaufen (Ergebnisse werden etwa 10 Minuten aufbewahrt), gehört zu einem anderen `clientKey` oder wurde auf dem anderen Endpoint erstellt | Beenden Sie die regelmäßige Abfrage (Polling) dieser Aufgabe. Fragen Sie mit demselben Endpoint und demselben `clientKey` ab, mit denen sie erstellt wurde |
| `ERROR_TASK_TIMEOUT` | Die Aufgabe wurde nicht rechtzeitig abgeschlossen (in der Regel 110 Sekunden); die Punkte wurden automatisch erstattet (Punkteerstattung) | Erstellen Sie eine neue Aufgabe; wenn weiterhin Zeitüberschreitungen auftreten, probieren Sie einen anderen Aufgabentyp für dasselbe Captcha |
| `ERROR_CAPTCHA_UNSOLVABLE` | Das Captcha konnte diesmal nicht gelöst werden; die Punkte wurden erstattet (Punkteerstattung). Dies zählt nicht zur automatischen Pausierung | Erstellen Sie eine neue Aufgabe. Wenn der Fehler weiterhin auftritt, prüfen Sie `websiteURL`, `websiteKey` und weitere Parameter oder probieren Sie einen anderen Aufgabentyp für dasselbe Captcha |
| `ERROR_SETTLEMENT_FAILED` (Zählt zur Pausierung) | Das Guthaben reichte bei der Abrechnung nicht aus, daher wurde kein Ergebnis zurückgegeben | Laden Sie Ihr Guthaben auf und erstellen Sie eine neue Aufgabe |
| `ERROR_NO_SUCH_CAPCHA_ID` | Die Aufgabe ist nicht mehr gültig | Beenden Sie die regelmäßige Abfrage (Polling) dieser Aufgabe und erstellen Sie eine neue |
| `ERROR_RECAPTCHA_TIMEOUT` | Die Lösung des Captchas hat das Zeitlimit überschritten; die Punkte wurden erstattet (Punkteerstattung) | Erstellen Sie eine neue Aufgabe |
### Parameter der Zielwebsite
| Fehlercode | Bedeutung | Was zu tun ist |
| --- | --- | --- |
| `ERROR_RECAPTCHA_INVALID_SITEKEY` (Zwischengespeichert, keine Pausierung) | Der `websiteKey` ist ungültig | Suchen Sie den Sitekey erneut auf der Seite (siehe die Anleitungen zum Finden von Parametern). Identische Anfragen geben diesen Fehler während der Cache-Dauer direkt zurück, mit `cached: true` |
| `ERROR_RECAPTCHA_INVALID_DOMAIN` (Zwischengespeichert, keine Pausierung) | Die Domain von `websiteURL` passt nicht zum `websiteKey` | Setzen Sie `websiteURL` auf die Seite, auf der das Captcha angezeigt wird |
| `ERROR_INVALID_KEY_TYPE` (Zwischengespeichert, keine Pausierung) | Der Sitekey gehört zu einem anderen Captcha, z. B. ein v3-Key, der mit einem v2-Aufgabentyp verwendet wird | Bestimmen Sie zuerst den Captcha-Typ (siehe "Captcha-Typ bestimmen") und wählen Sie den passenden Aufgabentyp; für unsichtbares v2 setzen Sie `isInvisible` |
| `ERROR_DOMAIN_NOT_ALLOWED` (Zwischengespeichert, keine Pausierung) | Diese Website wird nicht unterstützt | Probieren Sie einen anderen Aufgabentyp für dasselbe Captcha oder wenden Sie sich an den Support |
| `ERROR_HIGH_DEMAND_DOMAIN` (Zählt zur Pausierung) | Diese Website wird nicht unterstützt | Senden Sie keine Aufgaben mehr für diese Website und wenden Sie sich an den Support |
| `ERROR_FAILED_LOADING_WIDGET` | Das Captcha konnte mit den angegebenen Parametern nicht geladen werden | Prüfen Sie `websiteURL` und `websiteKey`; bei Aufgabentypen mit eigenem Proxy prüfen Sie, ob der Proxy die Website erreichen kann |
### Bilder
| Fehlercode | Bedeutung | Was zu tun ist |
| --- | --- | --- |
| `ERROR_ZERO_CAPTCHA_FILESIZE` (Zählt zur Pausierung) | Das Bild ist leer oder zu klein | Prüfen Sie, ob die Base64-Daten vollständig sind und kein Präfix `data:image/...;base64,` enthalten |
| `ERROR_TOO_BIG_CAPTCHA_FILESIZE` (Zählt zur Pausierung) | Das Bild ist zu groß | Komprimieren oder verkleinern Sie das Bild; der gesamte Request-Body darf 6 MB nicht überschreiten |
| `ERROR_IMAGE_TYPE_NOT_SUPPORTED` (Zählt zur Pausierung) | Das Bildformat wird nicht unterstützt, oder das Bild kann von diesem Aufgabentyp nicht verarbeitet werden. Ein einmaliges Auftreten pausiert den Schlüssel für 30 Minuten | Verwenden Sie JPG oder PNG und stellen Sie sicher, dass das Bild zum Aufgabentyp passt, z. B. benötigt die reCAPTCHA-Bilderkennung 100x100, 300x300 oder 450x450 |
| `ERROR_ILLEGAL_IMAGE` (Zählt zur Pausierung) | Die Bildgröße entspricht nicht den Anforderungen dieses Aufgabentyps | Passen Sie die Bildgröße wie auf der Seite des Aufgabentyps beschrieben an |
| `ERROR_PARSE_IMAGE_FAIL` | Das Bild konnte nicht dekodiert werden, häufig weil das Base64 unvollständig ist oder ein Präfix enthält | Prüfen Sie die Base64-Kodierung und entfernen Sie das Präfix `data:` sowie Zeilenumbrüche |
| `ERROR_UNKNOWN_QUESTION` | Die `question` ist falsch, oder diese Frage wird noch nicht unterstützt | Vergleichen Sie sie mit der Fragenliste auf der Seite des Aufgabentyps. Bei nicht unterstützten Fragen wenden Sie sich an den Support; neue Fragen werden in der Regel innerhalb von 3 Werktagen unterstützt |
| `ERROR_UNKNOW_450x450_QUESTION` | Diese Frage wird für 4x4-Bilder (450x450) noch nicht unterstützt | Laden Sie die Aufgabe auf der Seite neu, um eine andere Frage zu erhalten |
### Proxys
| Fehlercode | Bedeutung | Was zu tun ist |
| --- | --- | --- |
| `ERROR_PROXY_CONNECT_REFUSED` | Der Proxy hat die Verbindung abgelehnt | Prüfen Sie Adresse, Port und Protokoll des Proxys und stellen Sie sicher, dass er externe Verbindungen akzeptiert (keine lokale Adresse wie 127.0.0.1) |
| `ERROR_PROXY_CONNECT_TIMEOUT` | Die Verbindung zum Proxy hat das Zeitlimit überschritten | Verwenden Sie einen zuverlässigeren Proxy |
| `ERROR_PROXY_READ_TIMEOUT` | Das Lesen über den Proxy hat das Zeitlimit überschritten | Verwenden Sie einen schnelleren Proxy |
| `ERROR_PROXY_BANNED` | Der Proxy ist nicht verfügbar, oder seine IP wird von der Zielwebsite blockiert | Verwenden Sie einen anderen Proxy |
| `ERROR_PROXY_INCORRECT` | Die Proxy-Parameter sind fehlerhaft formatiert | Prüfen Sie das Format von `proxyType`, `proxyAddress`, `proxyPort` (oder des `proxy`\-Strings) |
| `ERROR_PROXY_TRANSPARENT` | Der Proxy ist transparent und legt die echte IP offen | Verwenden Sie einen anonymen (Elite-)Proxy |
| `ERROR_PROXY_NOT_AUTHORISED` | Benutzername oder Passwort des Proxys sind falsch | Prüfen Sie `proxyLogin` und `proxyPassword` (oder die Zugangsdaten im `proxy`\-String) |
| `ERROR_PROXY_TLS_ERROR` | Der TLS-Handshake mit dem Proxy ist fehlgeschlagen, häufig weil `proxyType` falsch ist (z. B. https bei einem http-Proxy) | Prüfen Sie das Proxy-Protokoll |
| `ERROR_PROXY_CONNECTION_FAILED` | Verbindung zum Proxy-Server nicht möglich | Prüfen Sie Adresse und Port des Proxys und stellen Sie sicher, dass er funktioniert |
### Server
| Fehlercode | Bedeutung | Was zu tun ist |
| --- | --- | --- |
| `ERROR_SERVICE_UNAVALIABLE` | Der Dienst ist vorübergehend nicht verfügbar (der Code wird `UNAVALIABLE` geschrieben) | Versuchen Sie es später erneut; wenden Sie sich an den Support, falls der Fehler weiterhin auftritt |
| `ERROR_INTERNAL_SERVER_ERROR` | Ein interner Serverfehler ist aufgetreten | Versuchen Sie es später erneut; wenn der Fehler weiterhin auftritt, wenden Sie sich mit der `taskId` an den Support |
| `ERROR_UNKNOWN` | Ein nicht klassifizierter Fehler | Versuchen Sie es später erneut; wenn der Fehler weiterhin auftritt, wenden Sie sich mit der `taskId` an den Support |
## Zusätzliche Felder
Manche Fehlerantworten enthalten zusätzliche Felder:
| Feld | Auftreten bei | Beschreibung |
| --- | --- | --- |
| `retryAfter` | `ERROR_IP_BLOCKED_5MIN`, gecachte Fehler | Wie viele Sekunden noch zu warten sind |
| `blockReason` | `ERROR_IP_BLOCKED_5MIN` | Der Fehlercode, der die Pausierung ausgelöst hat |
| `blockDetail` | `ERROR_IP_BLOCKED_5MIN` | Typ, URL und sitekey der Anfragen, die die Pausierung ausgelöst haben, zur leichteren Eingrenzung |
| `cached` | gecachte Fehler | `true` bedeutet, dass es sich um ein gecachtes Ergebnis handelt und nichts erkannt wurde |
| `badRequest` | gecachte Fehler | Die Parameter, die den Cache getroffen haben |
| `limit` | `ERROR_THREADS_MAXIMUM` | Ihr aktuelles Limit gleichzeitiger Aufgaben |
Die Sprachregeln für `errorDescription` finden Sie unter [Anfrage und Antwort](https://docs.yescaptcha.com/de/api/overview.md).
---
# Limit gleichzeitiger Aufgaben und automatische Pausierung
> Das Limit gleichzeitiger Aufgaben bei YesCaptcha (ERROR_THREADS_MAXIMUM, kein Punkteabzug, keine Pausierung), die automatische Pausierung bei zu vielen Fehlern (100 pro Minute führen zu 5 Minuten Pause, ERROR_IP_BLOCKED_5MIN) und der Cache für ungültige Parameter (cached).
Source: https://docs.yescaptcha.com/de/api/rate-limits/ · 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/api/rate-limits/
Damit die Erkennung für alle Nutzer schnell bleibt, gibt es bei YesCaptcha drei Schutzregeln: ein Limit für die **Anzahl der Aufgaben, die ein Konto gleichzeitig in Bearbeitung hat** (Limit gleichzeitiger Aufgaben), eine **kurze Pausierung** eines `clientKey`, der in kurzer Zeit **zu viele Fehler** erzeugt (automatische Pausierung), und einen **Cache für bereits als ungültig erkannte Parameter**, der für einige Zeit direkt den ursprünglichen Fehler zurückgibt. In allen drei Fällen erfolgt kein Punkteabzug.
## Limit gleichzeitiger Aufgaben
Wir begrenzen pro Konto und pro Aufgabentyp die Anzahl der Aufgaben, die gleichzeitig in Bearbeitung sind. Begrenzt wird die Gleichzeitigkeit, nicht die Anzahl der Anfragen pro Minute.
- Eine Aufgabe gilt ab dem Aufruf von `createTask` bis zur Rückkehr dieses Aufrufs als „in Bearbeitung“. Typen der Bilderkennung liefern das Ergebnis direkt in `createTask`, daher gilt: **Gleichzeitigkeit ≈ pro Sekunde gesendete Aufgaben × Dauer pro Aufgabe**. Beispiel: Bei 0.5 Sekunden pro Aufgabe und 40 Aufgaben pro Sekunde liegt die Gleichzeitigkeit bei etwa 20.
- Anfragen desselben Kontos werden zusammengerechnet; jeder Aufgabentyp wird getrennt gezählt.
- Anfragen über dem Limit liefern sofort `ERROR_THREADS_MAXIMUM`. Das Feld `limit` in der Antwort enthält Ihr aktuelles Limit. **Es erfolgt kein Punkteabzug, und die Anfragen zählen nicht für die automatische Pausierung.**
- Wenn die Erkennungsserver überlastet sind, wird das Limit für diesen Aufgabentyp bei dem Konto, das die meiste Erkennungszeit beansprucht, **vorübergehend halbiert und nach 10 Minuten automatisch wiederhergestellt**. Das bremst nur, das Konto wird nicht pausiert.
- Wenn Sie ein höheres Limit benötigen, wenden Sie sich an den [Support](https://docs.yescaptcha.com/de/help/contact.md). Sobald die Standardlimits der einzelnen Typen feststehen, werden sie auf dieser Seite und im [Änderungsprotokoll des Dienstes](https://docs.yescaptcha.com/de/changelog.md) veröffentlicht.
```json
{
"errorId": 1,
"errorCode": "ERROR_THREADS_MAXIMUM",
"errorDescription": "This account already has 30 tasks of this type in progress, which is the limit. Lower the concurrency and wait for pending requests to return before sending more; rejected requests are not charged and do not lead to a block.",
"limit": 30
}
```
(Die Zahlen im Beispiel dienen nur der Veranschaulichung.)
### Empfohlene Vorgehensweise
1. Begrenzen Sie im Programm die Anzahl der Anfragen, die gleichzeitig auf ein Ergebnis warten, zum Beispiel mit einem Semaphor (Semaphore) oder einem Thread-Pool fester Größe, statt nur die Anzahl pro Sekunde zu steuern.
2. Warten Sie nach `ERROR_THREADS_MAXIMUM`, bis bereits gesendete Anfragen zurückgekehrt sind, bevor Sie neue senden, oder versuchen Sie es nach 1 bis 2 Sekunden erneut. Wiederholen Sie nicht sofort in einer Schleife.
3. Senden Sie Stapelaufgaben gleichmäßig verteilt und nicht Tausende oder Zehntausende auf einmal.
Beispiel in Python (asyncio):
```python
import asyncio
import os
import aiohttp
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
LIMIT = 15 # below your concurrency limit
sem = asyncio.Semaphore(LIMIT)
async def solve(session, task):
async with sem: # at most LIMIT requests in progress at a time
result = {}
for attempt in range(5):
async with session.post(
"https://api.yescaptcha.com/createTask",
json={"clientKey": CLIENT_KEY, "task": task},
) as resp:
result = await resp.json()
if result.get("errorCode") != "ERROR_THREADS_MAXIMUM":
return result
await asyncio.sleep(1 + attempt) # over the limit: wait and retry
return result
```
## Automatische Pausierung
Erzeugt derselbe `clientKey` in kurzer Zeit viele fehlerhafte Anfragen, wird das Erstellen von Aufgaben automatisch pausiert:
| Auslöser | Dauer der Pausierung |
| --- | --- |
| Innerhalb derselben Kalenderminute 100 der unten aufgeführten Fehler | 5 Minuten |
| `ERROR_IMAGE_TYPE_NOT_SUPPORTED` tritt 1 Mal auf | 30 Minuten |
| Innerhalb derselben Kalenderminute 1000 Treffer im „Cache für ungültige Parameter“ | 5 Minuten |
Fehler, die zur Pausierung zählen:
- [`ERROR_REQUEST_FORMATS`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_REQUEST_FORMATS)
- [`ERROR_TASK_ABSENT`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_TASK_ABSENT)
- [`ERROR_TASK_NOT_SUPPORTED`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_TASK_NOT_SUPPORTED)
- [`ERROR_KEY_DOES_NOT_EXIST`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_KEY_DOES_NOT_EXIST)
- [`ERROR_KEY_EXPIRED`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_KEY_EXPIRED)
- [`ERROR_TASKID_INVALID`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_TASKID_INVALID)
- [`ERROR_SETTLEMENT_FAILED`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_SETTLEMENT_FAILED)
- [`ERROR_HIGH_DEMAND_DOMAIN`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_HIGH_DEMAND_DOMAIN)
- [`ERROR_ZERO_CAPTCHA_FILESIZE`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_ZERO_CAPTCHA_FILESIZE)
- [`ERROR_TOO_BIG_CAPTCHA_FILESIZE`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_TOO_BIG_CAPTCHA_FILESIZE)
- [`ERROR_IMAGE_TYPE_NOT_SUPPORTED`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_IMAGE_TYPE_NOT_SUPPORTED)
- [`ERROR_ILLEGAL_IMAGE`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_ILLEGAL_IMAGE)
`ERROR_THREADS_MAXIMUM`, das durch das Limit gleichzeitiger Aufgaben des Kontos zurückgegeben wird (mit dem Feld `limit`), zählt nicht mit; der gleichnamige Fehler bei überlasteter Erkennung (ohne `limit`) zählt mit. Nicht mit zählen unter anderem fehlgeschlagene Erkennungen (`ERROR_CAPTCHA_UNSOLVABLE`), unzureichendes Guthaben (`ERROR_ZERO_BALANCE`), fehlende Felder (`ERROR_REQUIRED_FIELDS`) und nicht unterstützte Fragen (`ERROR_UNKNOWN_QUESTION`).
Während der Pausierung gilt:
- Betroffen sind nur `createTask` und `getBalance`; sie liefern `ERROR_IP_BLOCKED_5MIN`. `getTaskResult` ist nicht betroffen: Vor der Pausierung erstellte Aufgaben können weiterhin abgefragt werden.
- Die Antwort enthält `retryAfter` (verbleibende Sekunden), `blockReason` (der Fehlercode, der die Pausierung ausgelöst hat) und `blockDetail` (Typ, URL und sitekey dieser Anfragen). Korrigieren Sie Ihr Programm anhand dieser Angaben.
- Weitere Anfragen verlängern die Pausierung nicht. Sie endet automatisch, Sie müssen den Support nicht kontaktieren.
- Im Dashboard auf [yescaptcha.com](https://yescaptcha.com/) sehen Sie die Pausierungen der letzten 24 Stunden.
```json
{
"errorId": 1,
"errorCode": "ERROR_IP_BLOCKED_5MIN",
"errorDescription": "...",
"retryAfter": 182,
"blockReason": "ERROR_TASK_NOT_SUPPORTED"
}
```
## Cache für ungültige Parameter
Manche Fehler hängen von den Anfrageparametern ab; ein erneutes Senden mit denselben Parametern ändert das Ergebnis nicht:
- [`ERROR_RECAPTCHA_INVALID_SITEKEY`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_RECAPTCHA_INVALID_SITEKEY)
- [`ERROR_RECAPTCHA_INVALID_DOMAIN`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_RECAPTCHA_INVALID_DOMAIN)
- [`ERROR_INVALID_KEY_TYPE`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_INVALID_KEY_TYPE)
- [`ERROR_DOMAIN_NOT_ALLOWED`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_DOMAIN_NOT_ALLOWED)
Diese Fehler zählen nicht für die automatische Pausierung, sondern werden seitenweit zwischengespeichert: nach der ersten Feststellung für 2 Minuten, bei erneuter Bestätigung innerhalb von 1 Stunde für 10 Minuten. Während der Cache-Dauer liefern gleiche Anfragen (gleicher Aufgabentyp und gleicher `websiteKey` oder gleiche Website-Domain) direkt den ursprünglichen Fehler, ohne Punkteabzug; die Antwort enthält `"cached": true`, `retryAfter` (verbleibende Sekunden im Cache) und `badRequest` (der betroffene Parameter). Nach Korrektur des `websiteKey` oder einem Wechsel des Aufgabentyps wirkt sich das sofort aus.
## Unterschied zwischen Limit gleichzeitiger Aufgaben und automatischer Pausierung
| | Limit gleichzeitiger Aufgaben | Automatische Pausierung |
| --- | --- | --- |
| Ursache | Zu viele Aufgaben gleichzeitig in Bearbeitung | Zu viele fehlerhafte Anfragen in kurzer Zeit |
| Verhalten | Nur die überzähligen Anfragen werden abgelehnt, `ERROR_THREADS_MAXIMUM` | Dieser `clientKey` kann keine Aufgaben mehr erstellen, `ERROR_IP_BLOCKED_5MIN` |
| Wiederherstellung | Sobald Anfragen abgeschlossen sind, können neue gesendet werden; ein halbiertes Limit kehrt nach 10 Minuten zurück | Endet automatisch |
| Punkteabzug | Nein | Nein |
---
# Aufgabentypen und Preise
> Preise (Punkte, 1,000 Punkte = ¥1) und Rückgabeart aller öffentlichen YesCaptcha-Aufgabentypen: Token für reCAPTCHA, hCaptcha und Turnstile, Cookies für die Cloudflare-Prüfseite sowie Erkennungsergebnisse für Bild-zu-Text und Bilderkennung.
Source: https://docs.yescaptcha.com/de/tasks/ · Last verified: 2026-10-19
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/tasks/
Für jede Aufgabe wird je nach Typ eine feste Anzahl Punkte abgezogen (1,000 Punkte = ¥1). Bei fehlgeschlagener Erkennung oder Timeout werden die Punkte automatisch erstattet. Die Tabelle listet alle öffentlichen Aufgabentypen und lässt sich nach Namen durchsuchen. Maschinenlesbare Version: [/data/task-types.json](https://docs.yescaptcha.com/data/task-types.json).
| Captcha | Aufgabentyp | Preis | Modus |
| --- | --- | --- | --- |
| [reCAPTCHA v2](https://docs.yescaptcha.com/de/tasks/recaptcha-v2.md) | `NoCaptchaTaskProxyless` | $2.25 / 1k; 15 Punkte/Aufgabe · ¥15 / 1k | Asynchron |
| [reCAPTCHA v2](https://docs.yescaptcha.com/de/tasks/recaptcha-v2.md) | `RecaptchaV2TaskProxyless` | $3.00 / 1k; 20 Punkte/Aufgabe · ¥20 / 1k | Asynchron |
| [reCAPTCHA v2](https://docs.yescaptcha.com/de/tasks/recaptcha-v2.md) | `NoCaptchaTask` Eigener Proxy | $2.25 / 1k; 15 Punkte/Aufgabe · ¥15 / 1k | Asynchron |
| [reCAPTCHA v2](https://docs.yescaptcha.com/de/tasks/recaptcha-v2.md) | `RecaptchaV2EnterpriseTaskProxyless` | $3.00 / 1k; 20 Punkte/Aufgabe · ¥20 / 1k | Asynchron |
| [reCAPTCHA v2](https://docs.yescaptcha.com/de/tasks/recaptcha-v2.md) | `RecaptchaV2EnterpriseTask` Eigener Proxy | $3.00 / 1k; 20 Punkte/Aufgabe · ¥20 / 1k | Asynchron |
| [reCAPTCHA v3](https://docs.yescaptcha.com/de/tasks/recaptcha-v3.md) | `RecaptchaV3TaskProxyless` | $3.00 / 1k; 20 Punkte/Aufgabe · ¥20 / 1k | Asynchron |
| [reCAPTCHA v3](https://docs.yescaptcha.com/de/tasks/recaptcha-v3.md) | `RecaptchaV3TaskProxylessM1` | $3.75 / 1k; 25 Punkte/Aufgabe · ¥25 / 1k | Asynchron |
| [reCAPTCHA v3](https://docs.yescaptcha.com/de/tasks/recaptcha-v3.md) | `RecaptchaV3TaskProxylessM1S7` | $4.50 / 1k; 30 Punkte/Aufgabe · ¥30 / 1k | Asynchron |
| [reCAPTCHA v3](https://docs.yescaptcha.com/de/tasks/recaptcha-v3.md) | `RecaptchaV3TaskProxylessM1S9` | $5.25 / 1k; 35 Punkte/Aufgabe · ¥35 / 1k | Asynchron |
| [reCAPTCHA v3](https://docs.yescaptcha.com/de/tasks/recaptcha-v3.md) | `RecaptchaV3EnterpriseTask` | $3.00 / 1k; 20 Punkte/Aufgabe · ¥20 / 1k | Asynchron |
| [reCAPTCHA v3](https://docs.yescaptcha.com/de/tasks/recaptcha-v3.md) | `RecaptchaV3EnterpriseTaskM1` | $3.75 / 1k; 25 Punkte/Aufgabe · ¥25 / 1k | Asynchron |
| [hCaptcha](https://docs.yescaptcha.com/de/tasks/hcaptcha.md) | `HCaptchaTaskProxyless` | $4.50 / 1k; 30 Punkte/Aufgabe · ¥30 / 1k | Asynchron |
| [hCaptcha](https://docs.yescaptcha.com/de/tasks/hcaptcha.md) | `HCaptchaTaskProxylessM1` | $4.50 / 1k; 30 Punkte/Aufgabe · ¥30 / 1k | Asynchron |
| [hCaptcha](https://docs.yescaptcha.com/de/tasks/hcaptcha.md) | `HCaptchaTask` Eigener Proxy | $2.25 / 1k; 15 Punkte/Aufgabe · ¥15 / 1k | Asynchron |
| [Cloudflare Turnstile](https://docs.yescaptcha.com/de/tasks/turnstile.md) | `TurnstileTaskProxyless` | $3.75 / 1k; 25 Punkte/Aufgabe · ¥25 / 1k | Asynchron |
| [Cloudflare Turnstile](https://docs.yescaptcha.com/de/tasks/turnstile.md) | `TurnstileTaskProxylessM1` | $4.50 / 1k; 30 Punkte/Aufgabe · ¥30 / 1k | Asynchron |
| [Cloudflare Turnstile](https://docs.yescaptcha.com/de/tasks/turnstile.md) | `TurnstileTask` Eigener Proxy | $3.75 / 1k; 25 Punkte/Aufgabe · ¥25 / 1k | Asynchron |
| [Cloudflare-Prüfseite](https://docs.yescaptcha.com/de/tasks/cloudflare-challenge.md) | `CloudFlareTaskS2` Eigener Proxy | $3.75 / 1k; 25 Punkte/Aufgabe · ¥25 / 1k | Asynchron |
| [Cloudflare-Prüfseite](https://docs.yescaptcha.com/de/tasks/cloudflare-challenge.md) | `CloudFlareTaskS3` Eigener Proxy | $3.00 / 1k; 20 Punkte/Aufgabe · ¥20 / 1k | Asynchron |
| [Bild zu Text](https://docs.yescaptcha.com/de/tasks/image-to-text.md) | `ImageToTextTaskOcrBase` | $0.30 / 1k; 2 Punkte/Aufgabe · ¥2 / 1k | Synchron |
| [Bild zu Text](https://docs.yescaptcha.com/de/tasks/image-to-text.md) | `ImageToTextTaskMuggle` | $0.30 / 1k; 2 Punkte/Aufgabe · ¥2 / 1k | Synchron |
| [Bild zu Text](https://docs.yescaptcha.com/de/tasks/image-to-text.md) | `ImageToTextTask` | $0.60 / 1k; 4 Punkte/Aufgabe · ¥4 / 1k | Asynchron |
| [Bild zu Text](https://docs.yescaptcha.com/de/tasks/image-to-text.md) | `ImageToTextTaskM1` | $2.25 / 1k; 15 Punkte/Aufgabe · ¥15 / 1k | Asynchron |
| [reCAPTCHA v2 Bilderkennung](https://docs.yescaptcha.com/de/tasks/recaptcha-classification.md) | `ReCaptchaV2Classification` | $0.90 / 1k; 6 Punkte/Aufgabe · ¥6 / 1k | Synchron |
| [hCaptcha Bilderkennung](https://docs.yescaptcha.com/de/tasks/hcaptcha-classification.md) | `HCaptchaClassification` | $1.20 / 1k; 8 Punkte/Aufgabe · ¥8 / 1k | Synchron |
| [FunCaptcha Bilderkennung](https://docs.yescaptcha.com/de/tasks/funcaptcha-classification.md) | `FunCaptchaClassification` | $0.45 / 1k; 3 Punkte/Aufgabe · ¥3 / 1k | Synchron |
| [AWS WAF / bCaptcha Bilderkennung](https://docs.yescaptcha.com/de/tasks/aws-bcaptcha-classification.md) | `AwsClassification` | $1.20 / 1k; 8 Punkte/Aufgabe · ¥8 / 1k | Synchron |
| [AWS WAF / bCaptcha Bilderkennung](https://docs.yescaptcha.com/de/tasks/aws-bcaptcha-classification.md) | `bCaptchaClassification` | $1.20 / 1k; 8 Punkte/Aufgabe · ¥8 / 1k | Synchron |
Die Preise in US-Dollar sind Schätzwerte bei 1 US$ ≈ ¥6.67 (2026-10-27). Aufgaben werden in Punkten berechnet: 1,000 Punkte = ¥1 bei Aufladung in CNY; Aufladungen in US-Dollar (PayPal, Kryptowährung) werden zum Wechselkurs zum Zahlungszeitpunkt in CNY und dann in Punkte umgerechnet.
## Welchen Typ brauche ich?
| Sie möchten | Verwenden Sie | Rückgabe |
| --- | --- | --- |
| Ein Token erhalten und direkt senden, ohne Bilder anzuklicken | [reCAPTCHA v2](https://docs.yescaptcha.com/de/tasks/recaptcha-v2.md), [reCAPTCHA v3](https://docs.yescaptcha.com/de/tasks/recaptcha-v3.md), [hCaptcha](https://docs.yescaptcha.com/de/tasks/hcaptcha.md), [Turnstile](https://docs.yescaptcha.com/de/tasks/turnstile.md) | Token, asynchron |
| Die Cloudflare-Seite „Einen Moment bitte …“ passieren | [Cloudflare-Prüfseite](https://docs.yescaptcha.com/de/tasks/cloudflare-challenge.md) | Cookies, User-Agent und Seiteninhalt, asynchron |
| Bilder selbst im Browser anklicken | [reCAPTCHA v2 Bilderkennung](https://docs.yescaptcha.com/de/tasks/recaptcha-classification.md), [hCaptcha Bilderkennung](https://docs.yescaptcha.com/de/tasks/hcaptcha-classification.md), [FunCaptcha Bilderkennung](https://docs.yescaptcha.com/de/tasks/funcaptcha-classification.md), [AWS WAF / bCaptcha Bilderkennung](https://docs.yescaptcha.com/de/tasks/aws-bcaptcha-classification.md) | Welche Bilder oder welche Position anzuklicken sind, synchron |
| Zeichen in einem Bild erkennen | [Bild-zu-Text](https://docs.yescaptcha.com/de/tasks/image-to-text.md) | Text, meist synchron |
Sie wissen nicht, um welches Captcha es sich handelt? Siehe [Captcha-Typ bestimmen](https://docs.yescaptcha.com/de/guides/identify-captcha.md).
## Namensmuster
- **`Proxyless`**: Das Captcha wird über unser Netzwerk geladen, ein Proxy ist nicht nötig. Typen ohne `Proxyless` im Namen (z. B. `NoCaptchaTask`, `HCaptchaTask`) verwenden Ihren eigenen Proxy und erfordern die Proxy-Felder. Sie eignen sich, wenn die Zielwebsite die IP-Adresse des Besuchers prüft.
- **Suffixe wie `M1`**: Eine weitere Route für dasselbe Captcha, mit gleichen Parametern und anderem Preis. Besteht eine Route nicht oft genug, können Sie die andere probieren; beide dienen auch als Ersatz füreinander.
- **`Classification`**: Bilderkennung. Gibt zurück, wo geklickt werden muss, kein Token.
- **`Enterprise`**: reCAPTCHA Enterprise.
## Hinweise
- Bei reCAPTCHA v2 Bilderkennung richtet sich der Preis nach der Bildgröße. Bei hCaptcha Bilderkennung wird kein Punkteabzug vorgenommen, wenn kein Ziel erkannt wird. Details stehen auf den jeweiligen Seiten.
- Maßgeblich sind die Preise auf dieser Seite. Abgezogen werden Punkte nur beim Erstellen von Aufgaben; Abfragen von Ergebnissen kosten nichts. Die Abrechnungsregeln finden Sie unter [Abrechnung und Punkteerstattung](https://docs.yescaptcha.com/de/getting-started/billing.md).
---
# reCAPTCHA v2
> Mit YesCaptcha ein reCAPTCHA-v2-Token (Standard, unsichtbar, Enterprise) erhalten: Aufgabentypen und Preise, Anfrageparameter, Beispiele in curl/Python/Node.js und Ergebnisformat.
Source: https://docs.yescaptcha.com/de/tasks/recaptcha-v2/ · 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/tasks/recaptcha-v2/
Eine reCAPTCHA-v2-Aufgabe gibt ein Token (`gRecaptchaResponse`) zurück. Wenn Sie es an die Zielwebsite senden, bestehen Sie die Prüfung, ohne Bilder anzuklicken. Der am häufigsten genutzte Typ `NoCaptchaTaskProxyless` kostet 15 Punkte (≈ $2.25 / 1k) pro Aufgabe und arbeitet asynchron: Erstellen Sie die Aufgabe mit `createTask` und rufen Sie dann alle 5 Sekunden `getTaskResult` auf, um das Ergebnis abzuholen. Bei fehlgeschlagenen Aufgaben und Zeitüberschreitungen erfolgt automatisch eine Punkteerstattung.
- POST `https://api.yescaptcha.com/createTask` (Globaler Endpoint)
- POST `https://cn.yescaptcha.com/createTask` (China-Endpoint)
Der Anfragekörper ist JSON und wird mit Ihrem `clientKey` authentifiziert (kopieren Sie ihn im Dashboard auf [yescaptcha.com](https://yescaptcha.com/)). Fragen Sie das Ergebnis an dem Endpoint ab, an dem Sie die Aufgabe erstellt haben.
## Einsatzszenarien
- Auf der Seite gibt es ein Kontrollkästchen „Ich bin kein Roboter“ (I’m not a robot): Standardversion.
- Es gibt kein Kontrollkästchen, und die Bildaufgabe erscheint erst nach dem Klick auf den Senden-Button: unsichtbare Version. Fügen Sie `"isInvisible": true` hinzu.
- Die Seite lädt `recaptcha/enterprise.js`, oder die Anfrageadressen enthalten `enterprise`: Enterprise-Version. Verwenden Sie einen Typ, dessen Name `Enterprise` enthält.
Wenn Sie nicht sicher sind, um welche Variante es sich handelt, lesen Sie [Captcha-Typ bestimmen](https://docs.yescaptcha.com/de/guides/identify-captcha.md). Wenn die Erfolgsquote per Token nicht ausreicht, können Sie stattdessen [reCAPTCHA-v2-Bilderkennung](https://docs.yescaptcha.com/de/tasks/recaptcha-classification.md) verwenden: Die API teilt Ihnen mit, welche Bilder anzuklicken sind, und Sie klicken im Browser selbst.
## Typen und Preise
| Aufgabentyp | Preis | Modus | Hinweise |
| --- | --- | --- | --- |
| `NoCaptchaTaskProxyless` | $2.25 / 1k; 15 Punkte/Aufgabe · ¥15 / 1k | Asynchron | |
| `RecaptchaV2TaskProxyless` | $3.00 / 1k; 20 Punkte/Aufgabe · ¥20 / 1k | Asynchron | Gleiche Parameter wie NoCaptchaTaskProxyless, aber über eine andere Route; beide können als Fallback füreinander verwendet werden |
| `NoCaptchaTask` | $2.25 / 1k; 15 Punkte/Aufgabe · ¥15 / 1k | Asynchron | Eigener Proxy |
| `RecaptchaV2EnterpriseTaskProxyless` | $3.00 / 1k; 20 Punkte/Aufgabe · ¥20 / 1k | Asynchron | |
| `RecaptchaV2EnterpriseTask` | $3.00 / 1k; 20 Punkte/Aufgabe · ¥20 / 1k | Asynchron | Eigener Proxy |
Die Preise in US-Dollar sind Schätzwerte bei 1 US$ ≈ ¥6.67; Aufgaben werden in Punkten berechnet.
- `NoCaptchaTaskProxyless` und `RecaptchaV2TaskProxyless` haben dieselben Parameter, laufen aber über verschiedene Routen. Wenn einer davon eine unzureichende Erfolgsquote hat, versuchen Sie den anderen.
- Typen ohne `Proxyless` im Namen (`NoCaptchaTask`, `RecaptchaV2EnterpriseTask`) laden das Captcha über Ihren eigenen Proxy. Dafür müssen Sie `proxyType`, `proxyAddress`, `proxyPort` und weitere Felder übergeben. Verwenden Sie sie, wenn die Zielwebsite Anforderungen an die IP-Adresse des Besuchers stellt.
## Anfrageparameter
Das `task`\-Objekt von `createTask`:
| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `type` | string | Ja | Aufgabentyp; siehe „Aufgabentypen und Preise“ auf dieser Seite |
| `websiteURL` | string | Ja | Vollständige URL der Seite, auf der das Captcha angezeigt wird. Verwenden Sie die Website, auf der Sie das Captcha sehen, nicht die Domain des Captcha-Anbieters |
| `websiteKey` | string | Ja | Der Website-Schlüssel (sitekey), zu finden im Quelltext der Seite oder in den Netzwerkanfragen; ändert sich in der Regel nicht |
| `isInvisible` | boolean | Nein | Auf true setzen für die unsichtbare Variante; sonst weglassen |
| `proxyType` | string | Einige Typen | Proxy-Protokoll: `http`, `https`, `socks4` oder `socks5` (Erforderlich für NoCaptchaTask, RecaptchaV2EnterpriseTask) |
| `proxyAddress` | string | Einige Typen | IP-Adresse oder Hostname des Proxys. Lokale oder private Adressen wie 127.0.0.1 oder 192.168.x.x funktionieren nicht, da unsere Server sie nicht erreichen können (Erforderlich für NoCaptchaTask, RecaptchaV2EnterpriseTask) |
| `proxyPort` | integer | Einige Typen | Proxy-Port (Erforderlich für NoCaptchaTask, RecaptchaV2EnterpriseTask) |
| `proxyLogin` | string | Nein | Proxy-Benutzername, falls der Proxy eine Authentifizierung erfordert (nur NoCaptchaTask, RecaptchaV2EnterpriseTask) |
| `proxyPassword` | string | Nein | Proxy-Passwort, falls der Proxy eine Authentifizierung erfordert (nur NoCaptchaTask, RecaptchaV2EnterpriseTask) |
| `userAgent` | string | Nein | User-Agent des Browsers. Enthält das Ergebnis einen `userAgent`, verwenden Sie diesen Wert, wenn Sie das Token senden (nur NoCaptchaTask, RecaptchaV2EnterpriseTask) |
| `enterprisePayload` | object | Nein | Zusätzliche Enterprise-Parameter, z. B. der `s`\-Wert von reCAPTCHA Enterprise: `{"s": "..."}`. Weglassen, wenn die Seite ihn nicht verwendet (nur RecaptchaV2EnterpriseTaskProxyless, RecaptchaV2EnterpriseTask) |
Wie Sie `websiteURL` und `websiteKey` finden, lesen Sie unter [reCAPTCHA-Parameter finden](https://docs.yescaptcha.com/de/guides/find-recaptcha-parameters.md).
## Anfragebeispiel
Am Beispiel der offiziellen Demoseite von Google:
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
}
}
```
Vollständiger Code (Aufgabe erstellen, alle 5 Sekunden abfragen, Token ausgeben). Legen Sie vor dem Ausführen Ihren ClientKey in der Umgebungsvariable `YESCAPTCHA_CLIENT_KEY` ab:
**curl**
```bash
curl -s https://api.yescaptcha.com/createTask \
-H 'Content-Type: application/json' \
-d '{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
}
}'
# Returns {"errorId":0,"taskId":"..."}; then poll every 5 seconds:
curl -s https://api.yescaptcha.com/getTaskResult \
-H 'Content-Type: application/json' \
-d '{"clientKey": "YOUR_CLIENT_KEY", "taskId": "TASK_ID"}'
```
**Python**
solve.py
```python
import os
import time
import requests
API = "https://api.yescaptcha.com"
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"] # Read the clientKey from an environment variable
def call(method, payload):
r = requests.post(f"{API}/{method}", json={"clientKey": CLIENT_KEY, **payload}, timeout=30)
data = r.json()
if data.get("errorId"):
raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
return data
def solve(task):
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"]
raise TimeoutError(task_id)
solution = solve({
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
})
print(solution["gRecaptchaResponse"])
```
**Node.js**
solve.mjs
```js
const API = 'https://api.yescaptcha.com';
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY; // Read the clientKey from an environment variable
async function call(method, payload) {
const res = await fetch(`${API}/${method}`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY, ...payload }),
});
const data = await res.json();
if (data.errorId) throw new Error(`${data.errorCode}: ${data.errorDescription}`);
return data;
}
async function solve(task) {
const { taskId } = await call('createTask', { task });
for (let i = 0; i < 36; i++) { // Poll every 5 seconds, for up to about 3 minutes
await new Promise((r) => setTimeout(r, 5000));
const result = await call('getTaskResult', { taskId });
if (result.status === 'ready') return result.solution;
}
throw new Error(`timeout: ${taskId}`);
}
const solution = await solve({
type: "NoCaptchaTaskProxyless",
websiteURL: "https://www.google.com/recaptcha/api2/demo",
websiteKey: "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
});
console.log(solution.gRecaptchaResponse);
```
Bei der Enterprise-Version: Wenn die Seite einen `s`\-Wert an reCAPTCHA übergibt, tragen Sie ihn in `enterprisePayload` ein:
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "RecaptchaV2EnterpriseTaskProxyless",
"websiteURL": "https://example.com/login",
"websiteKey": "SITE_KEY_OF_THE_PAGE",
"enterprisePayload": {
"s": "S_VALUE_FROM_THE_PAGE"
}
}
}
```
Mit eigenem Proxy:
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "NoCaptchaTask",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
"proxyType": "http",
"proxyAddress": "proxy.example.com",
"proxyPort": 8080,
"proxyLogin": "user",
"proxyPassword": "pass"
}
}
```
## Ergebnis
`createTask` gibt die Aufgaben-ID zurück:
```json
{
"errorId": 0,
"taskId": "61138bb6-19fb-11ec-a9c8-0242ac110006"
}
```
Rufen Sie damit `getTaskResult` auf. Solange die Aufgabe noch bearbeitet wird, lautet die Antwort `{"errorId": 0, "status": "processing"}`; fragen Sie nach 5 Sekunden erneut ab. Ist die Aufgabe abgeschlossen, lautet die Antwort:
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"gRecaptchaResponse": "03AGdBq25SxXT-pmSeBXjzScW-EiocHwwpwqtk1QXlJnGnU..."
}
}
```
| Feld | Typ | Beschreibung |
| --- | --- | --- |
| `gRecaptchaResponse` | string | Das Token, das an die Zielwebsite gesendet wird. Einmalig verwendbar, ca. 120 Sekunden gültig; verwenden Sie es innerhalb von 60 Sekunden |
Eine Aufgabe wird höchstens etwa 110 Sekunden bearbeitet. Danach wird `ERROR_TASK_TIMEOUT` zurückgegeben und die Punkte werden erstattet. Bei Fehlern ist `errorId` gleich 1; behandeln Sie sie anhand von `errorCode`, siehe [Fehlercodes](https://docs.yescaptcha.com/de/api/errors.md). Wie Sie das Token nach dem Erhalt senden, lesen Sie unter [reCAPTCHA mit einem Token abschließen](https://docs.yescaptcha.com/de/guides/submit-recaptcha-token.md).
> **Tipp:** Ein Token ist nur einmal verwendbar und etwa 120 Sekunden gültig. Senden Sie es am besten innerhalb von 60 Sekunden nach Erhalt.
## Häufige Fragen
### Warum besteht das Token für dieselbe Website manchmal die Prüfung und manchmal nicht?
Ob ein Token besteht, entscheidet die Zielwebsite. Sie bewertet jede Verifizierung mit einem Score und legt einen Schwellenwert fest, der sich jederzeit ändern kann. Deshalb unterscheidet sich die Erfolgsquote von Website zu Website, und nicht jedes Token besteht. Sie können einen ähnlichen Aufgabentyp zum Vergleich der Erfolgsquote ausprobieren oder stattdessen die [Bilderkennung](https://docs.yescaptcha.com/de/tasks/recaptcha-classification.md) verwenden.
### Wie lange ist ein Token gültig?
Es ist nur einmal verwendbar und etwa 120 Sekunden gültig. Senden Sie es am besten innerhalb von 60 Sekunden nach Erhalt. Die Gültigkeitsdauer legt Google fest.
### Wird bei fehlgeschlagener Lösung ein Punkteabzug berechnet?
Nein. Aufgaben, die `ERROR_CAPTCHA_UNSOLVABLE` zurückgeben oder in eine Zeitüberschreitung laufen, werden automatisch mit einer Punkteerstattung abgeschlossen, siehe [Abrechnung und Punkteerstattung](https://docs.yescaptcha.com/de/getting-started/billing.md).
## Verwandte Anleitungen
- [Captcha-Typ bestimmen](https://docs.yescaptcha.com/de/guides/identify-captcha.md)
- [reCAPTCHA-Parameter finden](https://docs.yescaptcha.com/de/guides/find-recaptcha-parameters.md)
- [reCAPTCHA mit einem Token abschließen](https://docs.yescaptcha.com/de/guides/submit-recaptcha-token.md)
- [reCAPTCHA-v2-Bilderkennung mit simulierten Klicks (Selenium)](https://docs.yescaptcha.com/de/guides/recaptcha-click-selenium.md)
---
# reCAPTCHA v3
> Mit YesCaptcha reCAPTCHA-v3-Tokens (auch Enterprise) abrufen: wie Sie pageAction ausfüllen, die Typen mit festem Score 0.7 und 0.9, Aufgabentypen und Preise, Parameter, Beispiele und Ergebnisformat.
Source: https://docs.yescaptcha.com/de/tasks/recaptcha-v3/ · 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/tasks/recaptcha-v3/
reCAPTCHA v3 hat weder ein Kontrollkästchen noch Bilder; die Seite bewertet Besucher im Hintergrund. YesCaptcha liefert ein Token (`gRecaptchaResponse`), das Sie an die Zielwebsite übermitteln. `RecaptchaV3TaskProxyless` kostet 20 Punkte (≈ $3.00 / 1k) pro Aufgabe und arbeitet asynchron: erst `createTask`, dann alle 5 Sekunden `getTaskResult`. Fehlgeschlagene Aufgaben und Zeitüberschreitungen führen automatisch zur Punkteerstattung.
- POST `https://api.yescaptcha.com/createTask` (Globaler Endpoint)
- POST `https://cn.yescaptcha.com/createTask` (China-Endpoint)
Der Request-Body ist JSON, die Authentifizierung erfolgt mit `clientKey`. Fragen Sie das Ergebnis an demselben Endpoint ab, an dem Sie die Aufgabe erstellt haben.
## Anwendungsfälle
- Im Quelltext der Seite steht `grecaptcha.execute(...)`, oder die Seite lädt `recaptcha/api.js?render=WEBSITE_KEY`: reCAPTCHA v3 (Standardversion).
- Die Seite ruft `grecaptcha.enterprise.execute(...)` auf oder lädt `recaptcha/enterprise.js`: reCAPTCHA v3 Enterprise. Verwenden Sie `RecaptchaV3EnterpriseTask` oder `RecaptchaV3EnterpriseTaskM1`.
So erkennen Sie den Typ: [Captcha-Typ erkennen](https://docs.yescaptcha.com/de/guides/identify-captcha.md).
## Aufgabentypen und Preise
| Aufgabentyp | Preis | Modus | Hinweise |
| --- | --- | --- | --- |
| `RecaptchaV3TaskProxyless` | $3.00 / 1k; 20 Punkte/Aufgabe · ¥20 / 1k | Asynchron | |
| `RecaptchaV3TaskProxylessM1` | $3.75 / 1k; 25 Punkte/Aufgabe · ¥25 / 1k | Asynchron | |
| `RecaptchaV3TaskProxylessM1S7` | $4.50 / 1k; 30 Punkte/Aufgabe · ¥30 / 1k | Asynchron | Fordert einen Score von 0.7 an; kein zusätzlicher Parameter erforderlich |
| `RecaptchaV3TaskProxylessM1S9` | $5.25 / 1k; 35 Punkte/Aufgabe · ¥35 / 1k | Asynchron | Fordert einen Score von 0.9 an; kein zusätzlicher Parameter erforderlich |
| `RecaptchaV3EnterpriseTask` | $3.00 / 1k; 20 Punkte/Aufgabe · ¥20 / 1k | Asynchron | |
| `RecaptchaV3EnterpriseTaskM1` | $3.75 / 1k; 25 Punkte/Aufgabe · ¥25 / 1k | Asynchron | |
Die Preise in US-Dollar sind Schätzwerte bei 1 US$ ≈ ¥6.67; Aufgaben werden in Punkten berechnet.
- `RecaptchaV3TaskProxyless` und `RecaptchaV3TaskProxylessM1` haben dieselben Parameter, laufen aber über unterschiedliche Routen; Sie können sie gegenseitig als Fallback nutzen.
- Verlangt die Zielwebsite einen hohen Score, verwenden Sie `RecaptchaV3TaskProxylessM1S7` (0.7) oder `RecaptchaV3TaskProxylessM1S9` (0.9). Zusätzliche Parameter sind nicht nötig.
## Request-Parameter
| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `type` | string | Ja | Aufgabentyp; siehe „Aufgabentypen und Preise“ auf dieser Seite |
| `websiteURL` | string | Ja | Vollständige URL der Seite, auf der das Captcha angezeigt wird. Verwenden Sie die Website, auf der Sie das Captcha sehen, nicht die Domain des Captcha-Anbieters |
| `websiteKey` | string | Ja | Der Website-Schlüssel (sitekey), zu finden im Quelltext der Seite oder in den Netzwerkanfragen; ändert sich in der Regel nicht |
| `pageAction` | string | Nein | Die reCAPTCHA-v3-Action; sie muss mit dem Wert übereinstimmen, den die Seite an `grecaptcha.execute` übergibt, sonst wird das Token möglicherweise abgelehnt |
`pageAction` muss mit der `action` übereinstimmen, die die Seite in `grecaptcha.execute(WEBSITE_KEY, {action: '...'})` übergibt. Bei falschem Wert kann die Website das Token ablehnen. So finden Sie den Wert: [reCAPTCHA-Parameter finden](https://docs.yescaptcha.com/de/guides/find-recaptcha-parameters.md).
## Request-Beispiel
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "RecaptchaV3TaskProxyless",
"websiteURL": "https://example.com/login",
"websiteKey": "SITE_KEY_OF_THE_PAGE",
"pageAction": "login"
}
}
```
**curl**
```bash
curl -s https://api.yescaptcha.com/createTask \
-H 'Content-Type: application/json' \
-d '{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "RecaptchaV3TaskProxyless",
"websiteURL": "https://example.com/login",
"websiteKey": "SITE_KEY_OF_THE_PAGE",
"pageAction": "login"
}
}'
# Returns {"errorId":0,"taskId":"..."}; then poll every 5 seconds:
curl -s https://api.yescaptcha.com/getTaskResult \
-H 'Content-Type: application/json' \
-d '{"clientKey": "YOUR_CLIENT_KEY", "taskId": "TASK_ID"}'
```
**Python**
solve.py
```python
import os
import time
import requests
API = "https://api.yescaptcha.com"
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"] # Read the clientKey from an environment variable
def call(method, payload):
r = requests.post(f"{API}/{method}", json={"clientKey": CLIENT_KEY, **payload}, timeout=30)
data = r.json()
if data.get("errorId"):
raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
return data
def solve(task):
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"]
raise TimeoutError(task_id)
solution = solve({
"type": "RecaptchaV3TaskProxyless",
"websiteURL": "https://example.com/login",
"websiteKey": "SITE_KEY_OF_THE_PAGE",
"pageAction": "login",
})
print(solution["gRecaptchaResponse"])
```
**Node.js**
solve.mjs
```js
const API = 'https://api.yescaptcha.com';
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY; // Read the clientKey from an environment variable
async function call(method, payload) {
const res = await fetch(`${API}/${method}`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY, ...payload }),
});
const data = await res.json();
if (data.errorId) throw new Error(`${data.errorCode}: ${data.errorDescription}`);
return data;
}
async function solve(task) {
const { taskId } = await call('createTask', { task });
for (let i = 0; i < 36; i++) { // Poll every 5 seconds, for up to about 3 minutes
await new Promise((r) => setTimeout(r, 5000));
const result = await call('getTaskResult', { taskId });
if (result.status === 'ready') return result.solution;
}
throw new Error(`timeout: ${taskId}`);
}
const solution = await solve({
type: "RecaptchaV3TaskProxyless",
websiteURL: "https://example.com/login",
websiteKey: "SITE_KEY_OF_THE_PAGE",
pageAction: "login",
});
console.log(solution.gRecaptchaResponse);
```
Ersetzen Sie `websiteURL`, `websiteKey` und `pageAction` durch die Werte der Zielwebsite.
## Ergebnis
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"gRecaptchaResponse": "03AGdBq25SxXT-pmSeBXjzScW-EiocHwwpwqtk1QXlJnGnU..."
}
}
```
| Feld | Typ | Beschreibung |
| --- | --- | --- |
| `gRecaptchaResponse` | string | Das Token, das an die Zielwebsite gesendet wird. Einmalig verwendbar, ca. 120 Sekunden gültig; verwenden Sie es innerhalb von 60 Sekunden |
Solange die Aufgabe läuft, erhalten Sie `{"errorId": 0, "status": "processing"}`; fragen Sie nach 5 Sekunden erneut ab. Bei Fehlern gehen Sie anhand von `errorCode` vor, siehe [Fehlercodes](https://docs.yescaptcha.com/de/api/errors.md). Wie Sie das Token übermitteln, steht in [reCAPTCHA mit einem Token abschließen](https://docs.yescaptcha.com/de/guides/submit-recaptcha-token.md).
## FAQ
### Warum lehnt die Website manche Tokens ab?
Bei v3 entscheidet die Zielwebsite anhand des Scores, und sie kann ihren Schwellenwert jederzeit ändern. Nicht jedes Token wird daher akzeptiert. Prüfen Sie, ob `pageAction` korrekt ist; verlangt die Website einen hohen Score, versuchen Sie `M1S7` oder `M1S9`; Sie können auch andere Typen derselben Familie vergleichen.
### Wie fülle ich v3 Enterprise aus?
Wie bei der Standardversion: `websiteURL`, `websiteKey`, `pageAction`, mit dem Typ `RecaptchaV3EnterpriseTask` oder `RecaptchaV3EnterpriseTaskM1`.
### Wie lange ist ein Token gültig?
Es ist nur einmal verwendbar und etwa 120 Sekunden gültig. Übermitteln Sie es innerhalb von 60 Sekunden.
## Weiterführende Anleitungen
- [Captcha-Typ erkennen](https://docs.yescaptcha.com/de/guides/identify-captcha.md)
- [reCAPTCHA-Parameter finden](https://docs.yescaptcha.com/de/guides/find-recaptcha-parameters.md) (einschließlich `pageAction`)
- [reCAPTCHA mit einem Token abschließen](https://docs.yescaptcha.com/de/guides/submit-recaptcha-token.md)
---
# hCaptcha
> hCaptcha-Token mit YesCaptcha abrufen: HCaptchaTaskProxyless, HCaptchaTaskProxylessM1 und HCaptchaTask mit eigenem Proxy, wie Sie userAgent und rqdata füllen und wie Sie den zurückgegebenen respKey verwenden.
Source: https://docs.yescaptcha.com/de/tasks/hcaptcha/ · 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/tasks/hcaptcha/
Eine hCaptcha-Aufgabe liefert ein Token (`gRecaptchaResponse`). Senden Sie es zusammen mit dem zurückgegebenen `userAgent` (manchmal auch `respKey`) an die Zielwebsite, um die Prüfung zu bestehen. `HCaptchaTaskProxyless` kostet 30 Punkte (≈ $4.50 / 1k) pro Aufgabe, `HCaptchaTask` (eigener Proxy) kostet 15 Punkte (≈ $2.25 / 1k) pro Aufgabe. Beide sind asynchron: zuerst `createTask`, dann alle 5 Sekunden `getTaskResult`. Bei fehlgeschlagener Erkennung oder Timeout erfolgt automatisch eine Punkteerstattung.
- POST `https://api.yescaptcha.com/createTask` (Globaler Endpoint)
- POST `https://cn.yescaptcha.com/createTask` (China-Endpoint)
Der Request-Body ist JSON; die Authentifizierung erfolgt mit `clientKey`. Fragen Sie das Ergebnis auf demselben Endpoint ab, auf dem Sie die Aufgabe erstellt haben.
## Anwendungsfälle
Auf der Seite gibt es das hCaptcha-Kontrollkästchen „Ich bin ein Mensch” oder es erscheint eine hCaptcha-Bildaufgabe. Wenn Sie ein Token direkt absenden möchten, nutzen Sie die Typen auf dieser Seite. Wenn Sie die Bilder selbst im Browser anklicken möchten, nutzen Sie [hCaptcha-Bilderkennung](https://docs.yescaptcha.com/de/tasks/hcaptcha-classification.md).
> **Hinweis:** Die Erfolgsquote von hCaptcha schwankt je nach Website stark. Testen Sie zuerst mit einer kleinen Menge.
## Typen und Preise
| Aufgabentyp | Preis | Modus | Hinweise |
| --- | --- | --- | --- |
| `HCaptchaTaskProxyless` | $4.50 / 1k; 30 Punkte/Aufgabe · ¥30 / 1k | Asynchron | |
| `HCaptchaTaskProxylessM1` | $4.50 / 1k; 30 Punkte/Aufgabe · ¥30 / 1k | Asynchron | Gleiche Parameter wie HCaptchaTaskProxyless, aber über eine andere Route; beide können als Fallback füreinander verwendet werden |
| `HCaptchaTask` | $2.25 / 1k; 15 Punkte/Aufgabe · ¥15 / 1k | Asynchron | Eigener Proxy |
Die Preise in US-Dollar sind Schätzwerte bei 1 US$ ≈ ¥6.67; Aufgaben werden in Punkten berechnet.
- `HCaptchaTaskProxyless` und `HCaptchaTaskProxylessM1` haben dieselben Parameter, aber unterschiedliche Routen und können sich gegenseitig als Ausweichlösung dienen.
- `HCaptchaTask` lädt das Captcha über Ihren eigenen Proxy; die Proxy-Felder müssen angegeben werden. Verwenden Sie diesen Typ, wenn die Zielwebsite die IP des Besuchers prüft.
## Request-Parameter
| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `type` | string | Ja | Aufgabentyp; siehe „Aufgabentypen und Preise“ auf dieser Seite |
| `websiteURL` | string | Ja | Vollständige URL der Seite, auf der das Captcha angezeigt wird. Verwenden Sie die Website, auf der Sie das Captcha sehen, nicht die Domain des Captcha-Anbieters |
| `websiteKey` | string | Ja | Der hCaptcha-Website-Schlüssel (sitekey), in der Regel eine UUID |
| `userAgent` | string | Nein | User-Agent des Browsers. Empfohlen, aber es wird nur der Wert akzeptiert, den `GET https://api.yescaptcha.com/useragent` zurückgibt; senden Sie das Token mit dem `userAgent` aus dem Ergebnis |
| `isInvisible` | boolean | Nein | Auf true setzen für die unsichtbare Variante; sonst weglassen |
| `rqdata` | string | Nein | rqdata für hCaptcha Enterprise; wird von manchen Websites verlangt und findet sich in der Regel in der Anfrage, die das Captcha lädt |
| `proxyType` | string | Einige Typen | Proxy-Protokoll: `http`, `https`, `socks4` oder `socks5` (Erforderlich für HCaptchaTask) |
| `proxyAddress` | string | Einige Typen | IP-Adresse oder Hostname des Proxys. Lokale oder private Adressen wie 127.0.0.1 oder 192.168.x.x funktionieren nicht, da unsere Server sie nicht erreichen können (Erforderlich für HCaptchaTask) |
| `proxyPort` | integer | Einige Typen | Proxy-Port (Erforderlich für HCaptchaTask) |
| `proxyLogin` | string | Nein | Proxy-Benutzername, falls der Proxy eine Authentifizierung erfordert (nur HCaptchaTask) |
| `proxyPassword` | string | Nein | Proxy-Passwort, falls der Proxy eine Authentifizierung erfordert (nur HCaptchaTask) |
- `websiteURL` ist die Seite, auf der das Captcha erscheint, **nicht** hcaptcha.com.
- `userAgent` wird empfohlen; erlaubt ist nur ein Wert, den [/useragent](https://docs.yescaptcha.com/de/api/useragent.md) zurückgibt.
- `rqdata`: Wird von hCaptcha Enterprise verlangt (z. B. bei einigen Social- und Chat-Websites) und lässt sich meist in der Anfrage finden, die das Captcha lädt. Bei normalen Websites nicht angeben.
Wie Sie die Parameter finden, steht unter [hCaptcha-Parameter finden](https://docs.yescaptcha.com/de/guides/find-hcaptcha-parameters.md).
## Request-Beispiel
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "HCaptchaTaskProxyless",
"websiteURL": "https://accounts.hcaptcha.com/demo",
"websiteKey": "a5f74b19-9e45-40e0-b45d-47ff91b7a6c2"
}
}
```
**curl**
```bash
curl -s https://api.yescaptcha.com/createTask \
-H 'Content-Type: application/json' \
-d '{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "HCaptchaTaskProxyless",
"websiteURL": "https://accounts.hcaptcha.com/demo",
"websiteKey": "a5f74b19-9e45-40e0-b45d-47ff91b7a6c2"
}
}'
# Returns {"errorId":0,"taskId":"..."}; then poll every 5 seconds:
curl -s https://api.yescaptcha.com/getTaskResult \
-H 'Content-Type: application/json' \
-d '{"clientKey": "YOUR_CLIENT_KEY", "taskId": "TASK_ID"}'
```
**Python**
solve.py
```python
import os
import time
import requests
API = "https://api.yescaptcha.com"
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"] # Read the clientKey from an environment variable
def call(method, payload):
r = requests.post(f"{API}/{method}", json={"clientKey": CLIENT_KEY, **payload}, timeout=30)
data = r.json()
if data.get("errorId"):
raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
return data
def solve(task):
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"]
raise TimeoutError(task_id)
solution = solve({
"type": "HCaptchaTaskProxyless",
"websiteURL": "https://accounts.hcaptcha.com/demo",
"websiteKey": "a5f74b19-9e45-40e0-b45d-47ff91b7a6c2",
})
print(solution["gRecaptchaResponse"])
```
**Node.js**
solve.mjs
```js
const API = 'https://api.yescaptcha.com';
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY; // Read the clientKey from an environment variable
async function call(method, payload) {
const res = await fetch(`${API}/${method}`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY, ...payload }),
});
const data = await res.json();
if (data.errorId) throw new Error(`${data.errorCode}: ${data.errorDescription}`);
return data;
}
async function solve(task) {
const { taskId } = await call('createTask', { task });
for (let i = 0; i < 36; i++) { // Poll every 5 seconds, for up to about 3 minutes
await new Promise((r) => setTimeout(r, 5000));
const result = await call('getTaskResult', { taskId });
if (result.status === 'ready') return result.solution;
}
throw new Error(`timeout: ${taskId}`);
}
const solution = await solve({
type: "HCaptchaTaskProxyless",
websiteURL: "https://accounts.hcaptcha.com/demo",
websiteKey: "a5f74b19-9e45-40e0-b45d-47ff91b7a6c2",
});
console.log(solution.gRecaptchaResponse);
```
Mit eigenem Proxy:
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "HCaptchaTask",
"websiteURL": "https://accounts.hcaptcha.com/demo",
"websiteKey": "a5f74b19-9e45-40e0-b45d-47ff91b7a6c2",
"proxyType": "http",
"proxyAddress": "proxy.example.com",
"proxyPort": 8080,
"proxyLogin": "user",
"proxyPassword": "pass"
}
}
```
## Ergebnis
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"gRecaptchaResponse": "P1_eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9...",
"userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36",
"respKey": "E0_eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9..."
}
}
```
| Feld | Typ | Beschreibung |
| --- | --- | --- |
| `gRecaptchaResponse` | string | Das Token, das an die Zielwebsite gesendet wird. Einmalig verwendbar, ca. 120 Sekunden gültig; verwenden Sie es innerhalb von 60 Sekunden |
| `userAgent` | string | Der User-Agent, mit dem das Token erzeugt wurde. Verwenden Sie diesen Wert beim Senden des Tokens, auch wenn er von dem abweicht, den Sie übergeben haben |
| `respKey` | string | Ein Wert, den manche Websites zusammen mit dem Token verlangen; senden Sie ihn mit, falls vorhanden |
So senden Sie das Ergebnis ab:
1. Tragen Sie das Token in das Feld `h-captcha-response` der Seite ein (und in `g-recaptcha-response`, falls vorhanden) oder in das Feld, das die Schnittstelle der Zielwebsite verlangt.
2. Verwenden Sie beim Absenden der Anfrage den zurückgegebenen `userAgent` als User-Agent.
3. Wurde ein `respKey` zurückgegeben, senden Sie ihn wie von der Website verlangt mit.
Solange die Aufgabe bearbeitet wird, lautet die Antwort `{"errorId": 0, "status": "processing"}`; fragen Sie nach 5 Sekunden erneut ab. Fehler behandeln Sie anhand von `errorCode`, siehe [Fehlercodes](https://docs.yescaptcha.com/de/api/errors.md).
## Häufige Fragen
### Warum ist die Erfolgsquote nicht stabil?
hCaptcha entscheidet anhand der Einstellungen der Website, der IP des Besuchers und der Browserumgebung, daher unterscheidet sich die Erfolgsquote je nach Website. Prüfen Sie, dass Sie den zurückgegebenen `userAgent` verwenden. Nutzen Sie bei IP-sensiblen Websites `HCaptchaTask` mit eigenem Proxy und senden Sie auch die Anfrage über denselben Proxy ab. Sie können außerdem zum Vergleich `HCaptchaTaskProxylessM1` ausprobieren.
### Wie lange ist ein Token gültig?
Es ist nur einmal verwendbar und etwa 120 Sekunden gültig. Senden Sie es nach Erhalt möglichst schnell ab.
## Verwandte Anleitungen
- [hCaptcha-Parameter finden](https://docs.yescaptcha.com/de/guides/find-hcaptcha-parameters.md)
- [hCaptcha-Bilderkennung: Klicks simulieren (Selenium)](https://docs.yescaptcha.com/de/guides/hcaptcha-click-selenium.md)
---
# Cloudflare Turnstile
> Cloudflare-Turnstile-Tokens mit YesCaptcha abrufen: TurnstileTaskProxyless, TurnstileTaskProxylessM1 und TurnstileTask mit eigenem Proxy, Parameter, Beispiele und Ergebnisformat sowie der Unterschied zur Cloudflare-Prüfseite.
Source: https://docs.yescaptcha.com/de/tasks/turnstile/ · Last verified: 2026-10-21
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/tasks/turnstile/
Eine Cloudflare-Turnstile-Aufgabe gibt ein Token (`token`) zurück, das Sie an die Zielwebsite senden, um die Prüfung zu bestehen. `TurnstileTaskProxyless` kostet 25 Punkte (≈ $3.75 / 1k) pro Aufgabe und arbeitet asynchron: zuerst `createTask`, dann alle 5 Sekunden `getTaskResult`. Bei fehlgeschlagenen Aufgaben und Zeitüberschreitung erfolgt automatisch eine Punkteerstattung.
- POST `https://api.yescaptcha.com/createTask` (Globaler Endpoint)
- POST `https://cn.yescaptcha.com/createTask` (China-Endpoint)
Der Request-Body ist JSON und wird mit `clientKey` authentifiziert. Fragen Sie das Ergebnis an demselben Endpoint ab, an dem Sie die Aufgabe erstellt haben.
## Einsatzszenarien
In einem Formular der Seite ist ein Cloudflare-Prüffeld (“Bestätigen Sie, dass Sie ein Mensch sind”) eingebettet, und die Seite lädt ein Skript von `challenges.cloudflare.com/turnstile`.
Wenn Cloudflare die gesamte Seite abfängt und “Einen Moment bitte…” bzw. “Ihr Browser wird überprüft” anzeigt, handelt es sich um die Cloudflare-Prüfseite und nicht um Turnstile. Verwenden Sie dafür [Cloudflare-Prüfseite](https://docs.yescaptcha.com/de/tasks/cloudflare-challenge.md). Den Unterschied erklärt [Captcha-Typ bestimmen](https://docs.yescaptcha.com/de/guides/identify-captcha.md).
## Aufgabentypen und Preise
| Aufgabentyp | Preis | Modus | Hinweise |
| --- | --- | --- | --- |
| `TurnstileTaskProxyless` | $3.75 / 1k; 25 Punkte/Aufgabe · ¥25 / 1k | Asynchron | |
| `TurnstileTaskProxylessM1` | $4.50 / 1k; 30 Punkte/Aufgabe · ¥30 / 1k | Asynchron | |
| `TurnstileTask` | $3.75 / 1k; 25 Punkte/Aufgabe · ¥25 / 1k | Asynchron | Eigener Proxy |
Die Preise in US-Dollar sind Schätzwerte bei 1 US$ ≈ ¥6.67; Aufgaben werden in Punkten berechnet.
- `TurnstileTaskProxyless` und `TurnstileTaskProxylessM1` haben dieselben Parameter, nutzen aber unterschiedliche Routen und können sich gegenseitig als Ersatz dienen.
- `TurnstileTask` lädt das Captcha über Ihren eigenen Proxy; die Proxy-Felder müssen angegeben werden.
## Request-Parameter
| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `type` | string | Ja | Aufgabentyp; siehe „Aufgabentypen und Preise“ auf dieser Seite |
| `websiteURL` | string | Ja | Vollständige URL der Seite, auf der das Captcha angezeigt wird. Verwenden Sie die Website, auf der Sie das Captcha sehen, nicht die Domain des Captcha-Anbieters |
| `websiteKey` | string | Ja | Der Turnstile-Website-Schlüssel (sitekey), beginnt in der Regel mit 0x |
| `pageAction` | string | Nein | Die `action`, die die Seite an Turnstile übergibt (eine Option von `turnstile.render` oder `data-action` am Widget-Element), z. B. `login`. In den meisten Fällen nicht nötig; fügen Sie sie nur hinzu, wenn Aufgaben weiterhin fehlschlagen |
| `data` | string | Nein | Die `cData`, die die Seite an Turnstile übergibt (eine Option von `turnstile.render` oder `data-cdata` am Widget-Element), z. B. `c0bd4b36-7419-4e18-83c6-378699f2a9a2`. In den meisten Fällen nicht nötig; fügen Sie sie nur hinzu, wenn Aufgaben weiterhin fehlschlagen |
| `proxyType` | string | Einige Typen | Proxy-Protokoll: `http`, `https`, `socks4` oder `socks5` (Erforderlich für TurnstileTask) |
| `proxyAddress` | string | Einige Typen | IP-Adresse oder Hostname des Proxys. Lokale oder private Adressen wie 127.0.0.1 oder 192.168.x.x funktionieren nicht, da unsere Server sie nicht erreichen können (Erforderlich für TurnstileTask) |
| `proxyPort` | integer | Einige Typen | Proxy-Port (Erforderlich für TurnstileTask) |
| `proxyLogin` | string | Nein | Proxy-Benutzername, falls der Proxy eine Authentifizierung erfordert (nur TurnstileTask) |
| `proxyPassword` | string | Nein | Proxy-Passwort, falls der Proxy eine Authentifizierung erfordert (nur TurnstileTask) |
| `userAgent` | string | Nein | User-Agent des Browsers. Enthält das Ergebnis einen `userAgent`, verwenden Sie diesen Wert, wenn Sie das Token senden (nur TurnstileTask) |
`websiteKey` beginnt in der Regel mit `0x`. Wie Sie ihn finden, steht unter [Turnstile-Parameter finden](https://docs.yescaptcha.com/de/guides/find-turnstile-parameters.md).
### Wenn Aufgaben nicht bestanden werden: pageAction und data
In den meisten Fällen genügen `websiteURL` und `websiteKey`; diese beiden Parameter sind nicht nötig. Wenn Sie sicher sind, dass `websiteURL` und `websiteKey` stimmen, die Aufgabe aber trotzdem nicht bestanden wird, prüfen Sie, ob die Seite beim Aufruf von Turnstile `action` und `cData` übergibt (Parameter von `turnstile.render` oder `data-action` und `data-cdata` am Element des Prüffelds). Falls ja, übernehmen Sie die Werte unverändert:
- `pageAction`: der `action`\-Wert der Seite, z. B. `login`
- `data`: der `cData`\-Wert der Seite, z. B. `c0bd4b36-7419-4e18-83c6-378699f2a9a2`
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "TurnstileTaskProxyless",
"websiteURL": "https://example.com/login",
"websiteKey": "0x4AAAAAAA_SITE_KEY",
"pageAction": "login",
"data": "c0bd4b36-7419-4e18-83c6-378699f2a9a2"
}
}
```
## Request-Beispiel
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "TurnstileTaskProxyless",
"websiteURL": "https://example.com/login",
"websiteKey": "0x4AAAAAAA_SITE_KEY"
}
}
```
**curl**
```bash
curl -s https://api.yescaptcha.com/createTask \
-H 'Content-Type: application/json' \
-d '{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "TurnstileTaskProxyless",
"websiteURL": "https://example.com/login",
"websiteKey": "0x4AAAAAAA_SITE_KEY"
}
}'
# Returns {"errorId":0,"taskId":"..."}; then poll every 5 seconds:
curl -s https://api.yescaptcha.com/getTaskResult \
-H 'Content-Type: application/json' \
-d '{"clientKey": "YOUR_CLIENT_KEY", "taskId": "TASK_ID"}'
```
**Python**
solve.py
```python
import os
import time
import requests
API = "https://api.yescaptcha.com"
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"] # Read the clientKey from an environment variable
def call(method, payload):
r = requests.post(f"{API}/{method}", json={"clientKey": CLIENT_KEY, **payload}, timeout=30)
data = r.json()
if data.get("errorId"):
raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
return data
def solve(task):
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"]
raise TimeoutError(task_id)
solution = solve({
"type": "TurnstileTaskProxyless",
"websiteURL": "https://example.com/login",
"websiteKey": "0x4AAAAAAA_SITE_KEY",
})
print(solution["token"])
```
**Node.js**
solve.mjs
```js
const API = 'https://api.yescaptcha.com';
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY; // Read the clientKey from an environment variable
async function call(method, payload) {
const res = await fetch(`${API}/${method}`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY, ...payload }),
});
const data = await res.json();
if (data.errorId) throw new Error(`${data.errorCode}: ${data.errorDescription}`);
return data;
}
async function solve(task) {
const { taskId } = await call('createTask', { task });
for (let i = 0; i < 36; i++) { // Poll every 5 seconds, for up to about 3 minutes
await new Promise((r) => setTimeout(r, 5000));
const result = await call('getTaskResult', { taskId });
if (result.status === 'ready') return result.solution;
}
throw new Error(`timeout: ${taskId}`);
}
const solution = await solve({
type: "TurnstileTaskProxyless",
websiteURL: "https://example.com/login",
websiteKey: "0x4AAAAAAA_SITE_KEY",
});
console.log(solution.token);
```
Ersetzen Sie `websiteURL` und `websiteKey` durch die Werte der Zielwebsite.
## Ergebnis
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"token": "0.ufq5RgSVZd11DPSX1brdrxnEs28KcVlKj2ORchqxSy2q9yAW6ciq3hriXDF4x...",
"userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36"
}
}
```
| Feld | Typ | Beschreibung |
| --- | --- | --- |
| `token` | string | Das Token, das an die Zielwebsite gesendet wird. Einmalig verwendbar; senden Sie es so schnell wie möglich |
| `userAgent` | string | Der User-Agent, mit dem das Token erzeugt wurde. Verwenden Sie diesen Wert beim Senden des Tokens, auch wenn er von dem abweicht, den Sie übergeben haben |
Tragen Sie das `token` in das Feld `cf-turnstile-response` der Seite (oder in das Feld, das die Schnittstelle der Zielwebsite verlangt) ein und senden Sie es ab. Verwenden Sie dabei als User-Agent der Anfrage den zurückgegebenen `userAgent`.
Solange die Aufgabe läuft, lautet die Antwort `{"errorId": 0, "status": "processing"}`; fragen Sie nach 5 Sekunden erneut ab. Bei Fehlern gehen Sie nach `errorCode` vor, siehe [Fehlercodes](https://docs.yescaptcha.com/de/api/errors.md).
## Häufige Fragen
### Wie lange ist ein Token gültig?
Es ist nur einmal verwendbar. Senden Sie es nach Erhalt möglichst schnell ab (Turnstile-Tokens laufen in der Regel innerhalb weniger Minuten ab; das legt Cloudflare fest).
### Die Website lehnt die Übermittlung trotzdem ab
Prüfen Sie, ob `websiteURL` die Seite mit dem Prüffeld ist und `websiteKey` stimmt, und verwenden Sie beim Absenden den zurückgegebenen `userAgent`. Wenn die Seite `action` und `cData` übergibt, geben Sie diese als `pageAction` und `data` mit an, siehe oben [Wenn Aufgaben nicht bestanden werden](#if-tasks-keep-failing-pageaction-and-data). Prüft die Website zusätzlich die IP, verwenden Sie `TurnstileTask` und senden Sie über denselben Proxy ab.
## Verwandte Anleitungen
- [Captcha-Typ bestimmen](https://docs.yescaptcha.com/de/guides/identify-captcha.md)
- [Turnstile-Parameter finden](https://docs.yescaptcha.com/de/guides/find-turnstile-parameters.md)
---
# Cloudflare-Prüfseite
> Mit YesCaptcha die "Just a moment..."-Prüfseite von Cloudflare passieren und cf_clearance sowie weitere Cookies, den User-Agent und den Seiteninhalt erhalten: Parameter von CloudFlareTaskS2 und CloudFlareTaskS3, Proxy-Anforderungen, Ergebnis, Verwendung des Ergebnisses und häufige Fehler.
Source: https://docs.yescaptcha.com/de/tasks/cloudflare-challenge/ · Last verified: 2026-10-19
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/tasks/cloudflare-challenge/
Die Cloudflare-Prüfseite ist eine Seite, die den gesamten Zugriff auf eine Website blockiert und “Just a moment…” bzw. “Ihr Browser wird überprüft” anzeigt. YesCaptcha öffnet die Seite über den von Ihnen angegebenen Proxy, besteht die Prüfung und gibt Cookies wie `cf_clearance`, den verwendeten User-Agent, die Request- und Response-Header sowie das HTML der Seite nach der Prüfung zurück. `CloudFlareTaskS2` kostet 25 Punkte (≈ $3.75 / 1k) pro Aufgabe, `CloudFlareTaskS3` kostet 20 Punkte (≈ $3.00 / 1k) pro Aufgabe. Beide Typen haben dieselben Parameter, dasselbe Ergebnis und dieselbe Wirkung und unterscheiden sich nur im Preis. Die Antwort erfolgt asynchron; eine Aufgabe dauert in der Regel 6 bis 35 Sekunden, je nach Website mit großen Unterschieden. Bei fehlgeschlagener Erkennung oder Timeout erfolgt automatisch eine Punkteerstattung.
- POST `https://api.yescaptcha.com/createTask` (Globaler Endpoint)
- POST `https://cn.yescaptcha.com/createTask` (China-Endpoint)
## Anwendungsfälle
- Der Seitenquelltext enthält `__cf_chl_rt_tk` oder `cdn-cgi/challenge-platform`, und der Titel lautet `Just a moment...`: Das ist die Cloudflare-Prüfseite. Auch Prüfseiten, auf denen Sie das Kontrollkästchen “Bestätigen Sie, dass Sie ein Mensch sind” anklicken müssen, werden mit dieser Seite behandelt.
- Wenn nur ein Cloudflare-Widget in einem Formular eingebettet ist, handelt es sich um [Turnstile](https://docs.yescaptcha.com/de/tasks/turnstile.md) und nicht um diese Seite.
- Wenn Sie mit einer Bibliothek wie requests den Status 403 und “Just a moment…” erhalten, der Browser die Seite aber direkt öffnen kann: Meist wird nur der TLS-Fingerprint blockiert. Verwenden Sie eine Bibliothek, die den TLS-Fingerprint eines Browsers nachahmt (z. B. curl\_cffi); dann ist keine Lösung der Prüfung nötig.
## Typen und Preise
| Aufgabentyp | Preis | Modus | Hinweise |
| --- | --- | --- | --- |
| `CloudFlareTaskS2` | $3.75 / 1k; 25 Punkte/Aufgabe · ¥25 / 1k | Asynchron | Eigener Proxy |
| `CloudFlareTaskS3` | $3.00 / 1k; 20 Punkte/Aufgabe · ¥20 / 1k | Asynchron | Eigener Proxy |
Die Preise in US-Dollar sind Schätzwerte bei 1 US$ ≈ ¥6.67; Aufgaben werden in Punkten berechnet.
## Anfrageparameter
| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `type` | string | Ja | Aufgabentyp; siehe „Aufgabentypen und Preise“ auf dieser Seite |
| `websiteURL` | string | Ja | Vollständige URL der Seite hinter der Prüfseite. Muss eine öffentliche URL mit `http://` oder `https://` sein; private IP-Adressen sowie lokale oder interne Hostnamen wie `localhost` werden abgelehnt |
| `proxy` | string | Ja | Proxy als ein String: `http://user:pass@proxy.example.com:8080` (HTTP-Proxy, Zugangsdaten optional) oder `socks5://proxy.example.com:1080` (ohne Zugangsdaten). `https://`\-Proxys und SOCKS5 mit Zugangsdaten werden nicht unterstützt, und lokale oder private Adressen werden abgelehnt. Alle Anfragen für die Zielseite laufen über diesen Proxy |
| `userAgent` | string | Nein | In der Regel weglassen. Nur ein User-Agent von Desktop-Chrome unter Linux wird verwendet; alles andere (Windows, macOS, Mobilgeräte, andere Browser) wird ignoriert. Verwenden Sie für spätere Anfragen immer `user_agent` aus dem Ergebnis |
| `waitLoad` | boolean | Nein | Standardmäßig false. Bei true wartet die Aufgabe nach bestandener Prüfung, bis die Netzwerkaktivität der Seite zur Ruhe kommt, bevor sie das Ergebnis zurückgibt; `content` enthält dann mehr dynamisch nachgeladene Inhalte, und es dauert einige Sekunden länger |
| `requiredCookies` | array | Nein | Namen der Cookies, die zwingend erhalten werden müssen, als Array von Strings, z. B. `["cf_clearance"]`. Wenn angegeben, ist die Aufgabe nur erfolgreich, wenn alle erhalten wurden; andernfalls gibt sie `ERROR_CAPTCHA_UNSOLVABLE` zurück und es erfolgt eine Punkteerstattung. Wenn weggelassen, versucht die Aufgabe trotzdem, `cf_clearance` zu erhalten, gilt aber auch mit anderen erhaltenen Cookies als erfolgreich (mit Punkteabzug); geben Sie es daher ausdrücklich an, wenn Sie `cf_clearance` benötigen |
| `blockImage` | boolean | Nein | Bei true werden Bilder der Zielseite nicht geladen (außer denen, die die Cloudflare-Prüfung selbst benötigt), was Proxy-Traffic spart |
| `postData` | object | Nein | Wenn gesetzt, wird es wie ein normales HTML-Formular per POST an `websiteURL` gesendet (`application/x-www-form-urlencoded`): Jeder Schlüssel ist ein Formularfeld, und die Werte werden als Strings gesendet, z. B. `{"name": "hi"}`. Muss ein Objekt sein |
### Proxy-Anforderungen
`proxy` ist ein Pflichtfeld; alle Anfragen zum Öffnen der Zielseite laufen über diesen Proxy. `cf_clearance` ist an die Exit-IP gebunden, daher müssen Sie auch bei späteren Zugriffen auf die Zielwebsite denselben Proxy verwenden.
| Schreibweise | Unterstützt |
| --- | --- |
| `http://user:pass@proxy.example.com:8080` | Ja: HTTP-Proxy mit Benutzername und Passwort |
| `http://proxy.example.com:8080` | Ja: HTTP-Proxy ohne Benutzername und Passwort |
| `socks5://proxy.example.com:1080` | Ja: SOCKS5-Proxy ohne Benutzername und Passwort; `socks5h://` wird wie `socks5://` behandelt |
| `socks5://user:pass@proxy.example.com:1080` | Nein, gibt `ERROR_PROXY_INCORRECT` zurück; wenn Sie Zugangsdaten benötigen, verwenden Sie stattdessen einen HTTP-Proxy |
| `https://proxy.example.com:443` oder andere Protokolle, oder fehlender Port | Nein, gibt `ERROR_PROXY_INCORRECT` zurück |
| Lokale, interne oder reservierte Adressen wie `127.0.0.1`, `192.168.x.x`, `10.x.x.x` oder Domains, die auf solche Adressen auflösen | Abgelehnt, gibt `ERROR_PROXY_BANNED` zurück |
> **Prüfung beim Erstellen der Aufgabe:** Bei ungültiger URL oder ungültigem Proxy gibt `createTask` sofort einen Fehler zurück, es erfolgt kein Punkteabzug. Wenn die Verbindung zu einem Proxy in kurzer Zeit mehrfach fehlschlägt, gibt auch das Erstellen von Aufgaben mit diesem Proxy für einige Zeit direkt `ERROR_PROXY_BANNED` zurück. Verwenden Sie einen anderen Proxy oder versuchen Sie es später erneut.
### User-Agent
Übergeben Sie in der Regel kein `userAgent`. Die Prüfung wird mit Chrome für Linux-Desktop bestanden, daher wird nur ein User-Agent von Chrome für Linux-Desktop übernommen; alle anderen (Windows, macOS, Mobilgeräte oder andere Browser) werden ignoriert: In Tests besteht die Cloudflare-Prüfung nicht, wenn die tatsächliche Browserumgebung nicht zum User-Agent passt. Verwenden Sie für alle weiteren Anfragen den `user_agent` aus dem Ergebnis.
## Anfragebeispiel
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "CloudFlareTaskS3",
"websiteURL": "https://example.com/",
"proxy": "http://user:pass@proxy.example.com:8080",
"requiredCookies": ["cf_clearance"]
}
}
```
- Für `CloudFlareTaskS2` ändern Sie nur `type`, alles andere bleibt gleich.
- Wenn `requiredCookies` auf `["cf_clearance"]` gesetzt ist, schlägt die Aufgabe fehl und die Punkte werden erstattet, falls `cf_clearance` nicht erhalten wird. Ohne diese Angabe gilt die Aufgabe auch dann als erfolgreich und es erfolgt ein Punkteabzug, wenn nur andere Cookies, aber kein `cf_clearance` erhalten wurden.
- Um ein Formular zu senden, fügen Sie `postData` hinzu, zum Beispiel `{"name": "hi"}`; es wird als POST-Formular an `websiteURL` gesendet.
Rufen Sie nach dem Erstellen alle 5 Sekunden `getTaskResult` ab. Der Ablauf ist derselbe wie bei anderen asynchronen Aufgaben, siehe [getTaskResult](https://docs.yescaptcha.com/de/api/get-task-result.md).
## Ergebnis
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"user_agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36",
"cookies": {
"cf_clearance": "Wq3vXk9...-1760860800-1.2.1.1-..."
},
"request_headers": {
"accept-language": "en-US,en;q=0.9",
"user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36"
},
"headers": {
"content-type": "text/html; charset=UTF-8",
"server": "cloudflare"
},
"content": "..."
}
}
```
Die Cookie-Werte und Header oben sind nur Beispiele; maßgeblich ist die tatsächliche Antwort.
| Feld | Typ | Beschreibung |
| --- | --- | --- |
| `cookies` | object | Alle Cookies im Browser nach bestandener Prüfung (Objekt mit Name-zu-Wert-Zuordnung), enthält in der Regel `cf_clearance`; wenn Sie `requiredCookies` gesetzt haben, ist jedes davon enthalten. Verwenden Sie sie zusammen mit dem zurückgegebenen `user_agent` und dem Proxy, den Sie angegeben haben |
| `user_agent` | string | Der User-Agent, den der Browser tatsächlich zum Bestehen der Prüfung verwendet hat (Desktop-Chrome unter Linux). `cf_clearance` ist daran gebunden, verwenden Sie ihn daher für alle Folgeanfragen |
| `request_headers` | object | Request-Header, die der Browser bei seiner letzten Anfrage an die Zielseite gesendet hat; verwenden Sie sie in Folgeanfragen erneut |
| `headers` | object | Response-Header der Zielseite nach bestandener Prüfung |
| `content` | string | HTML-Quelltext der Zielseite nach bestandener Prüfung |
## Ergebnis verwenden
1. Verwenden Sie für weitere Anfragen **gleichzeitig** die zurückgegebenen `cookies`, den zurückgegebenen `user_agent` und denselben Proxy wie beim Erstellen der Aufgabe. `cf_clearance` ist an User-Agent und Exit-IP gebunden; weicht eines der drei ab, erscheint die Prüfseite erneut.
2. Senden Sie nach Möglichkeit auch die `request_headers` mit und verwenden Sie einen browserähnlichen TLS-Fingerprint (z. B. die Option `impersonate` von curl\_cffi).
3. `cf_clearance` hat eine Gültigkeitsdauer (von der Zielwebsite festgelegt, teils bis zu 1 Stunde). Innerhalb dieser Zeit müssen Sie die Prüfung nicht erneut lösen; bei zu hoher Anfragefrequenz kann Cloudflare die IP sperren.
4. Wenn Sie nur den Seiteninhalt benötigen, können Sie direkt `content` verwenden und müssen die Seite nicht erneut abrufen.
## Häufige Fehler
Fehler, die beim Erstellen der Aufgabe zurückgegeben werden, führen zu keinem Punkteabzug; bei Aufgaben, die nach dem Erstellen fehlschlagen oder in ein Timeout laufen, erfolgt automatisch eine Punkteerstattung. Die API gibt nur den Fehlercode und eine allgemeine Beschreibung zurück; die konkrete Ursache entnehmen Sie der folgenden Tabelle.
| Fehlercode | Wann er zurückgegeben wird | Was zu tun ist |
| --- | --- | --- |
| `ERROR_REQUIRED_FIELDS` | Beim Erstellen der Aufgabe: `websiteURL` oder `proxy` fehlt | Beide Pflichtfelder ergänzen |
| `ERROR_ILLEGAL_PARAMETERS` | Beim Erstellen der Aufgabe: `websiteURL` ist keine öffentliche URL mit `http://` / `https://`, `postData` ist kein Objekt oder `requiredCookies` ist kein Array von Strings. Bei der Ergebnisabfrage: Die Domain der Ziel-URL kann über den Proxy nicht aufgelöst werden | Parameter korrigieren; Schreibweise der URL prüfen und prüfen, ob der Proxy die Website erreichen kann |
| `ERROR_PROXY_INCORRECT` | Beim Erstellen der Aufgabe: Das Proxy-Format ist falsch oder der Port fehlt, oder es wurde ein `https://`\-Proxy bzw. ein SOCKS5-Proxy mit Zugangsdaten verwendet | Schreibweise gemäß “Proxy-Anforderungen” oben anpassen; wenn Zugangsdaten nötig sind, einen HTTP-Proxy verwenden |
| `ERROR_PROXY_BANNED` | Beim Erstellen der Aufgabe: Der Proxy ist eine lokale, interne oder reservierte Adresse, oder die Verbindung zu diesem Proxy ist in kurzer Zeit mehrfach fehlgeschlagen. Bei der Ergebnisabfrage: Cloudflare der Zielwebsite hat die IP dieses Proxys direkt blockiert (Seite “Sorry, you have been blocked” bzw. “Access denied”) | Anderen Proxy verwenden; je besser die IP-Qualität, desto leichter die Prüfung |
| `ERROR_PROXY_CONNECT_REFUSED` | Verbindung zum Proxy nicht möglich (Verbindung abgelehnt, Domain des Proxys nicht auflösbar), oder beim Öffnen der Seite über den Proxy wurde die Verbindung abgelehnt oder zurückgesetzt | Proxy-Adresse und Port prüfen, sicherstellen, dass der Proxy online ist und externe Zugriffe erlaubt; bei weiterem Fehlschlagen anderen Proxy verwenden |
| `ERROR_PROXY_CONNECT_TIMEOUT` | Zeitüberschreitung beim Verbinden mit dem Proxy oder beim Öffnen der Seite über den Proxy | Einen schnelleren, stabileren Proxy verwenden |
| `ERROR_PROXY_NOT_AUTHORISED` | Benutzername oder Passwort des Proxys sind falsch | Zugangsdaten in `proxy` prüfen; Sonderzeichen URL-kodieren |
| `ERROR_PROXY_TLS_ERROR` | Beim Öffnen der Seite über den Proxy ist der TLS-Handshake fehlgeschlagen | Proxy-Adresse, Port und Protokoll prüfen; bei weiterem Fehlschlagen anderen Proxy verwenden |
| `ERROR_CAPTCHA_UNSOLVABLE` | Die Prüfung wurde in der vorgegebenen Zeit nicht bestanden, die Seite zeigte nach dem Bestehen weiterhin die Prüfseite, oder ein in `requiredCookies` angefordertes Cookie wurde nicht erhalten | Zuerst mit einem anderen Proxy erneut versuchen; bei einzelnen Websites können Sie den Support kontaktieren |
| `ERROR_NO_SLOT_AVAILABLE` | Beim Erstellen der Aufgabe: Die Warteschlange ist voll. Bei der Ergebnisabfrage: Die Aufgabe hat zu lange in der Warteschlange gewartet und nicht begonnen, die Punkte wurden erstattet | Einige Sekunden warten und die Aufgabe erneut erstellen |
| `ERROR_TASK_TIMEOUT` | Die Aufgabe wurde nicht in der vorgegebenen Zeit abgeschlossen | Aufgabe erneut erstellen; anhaltende Timeouts deuten meist auf einen zu langsamen Proxy hin |
Alle Fehlercodes finden Sie unter [Fehlercodes](https://docs.yescaptcha.com/de/api/errors.md).
## Verwandte Themen
- [Captcha-Typ bestimmen](https://docs.yescaptcha.com/de/guides/identify-captcha.md): Unterschied zwischen Cloudflare-Prüfseite und Turnstile
- [Cloudflare Turnstile](https://docs.yescaptcha.com/de/tasks/turnstile.md)
---
# Bilder mit Buchstaben und Ziffern erkennen
> Erkennen Sie Buchstaben und Ziffern in Bildern mit YesCaptcha. ImageToTextTaskOcrBase und ImageToTextTaskMuggle liefern synchron; ImageToTextTask und ImageToTextTaskM1 arbeiten asynchron und unterstützen Groß-/Kleinschreibung, reine Ziffern, Rechenaufgaben und Längenvorgaben. Eigene Modelle sind möglich.
Source: https://docs.yescaptcha.com/de/tasks/image-to-text/ · 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/tasks/image-to-text/
Senden Sie ein Captcha-Bild mit Buchstaben und Ziffern als Base64, und Sie erhalten den darin enthaltenen Text zurück (`solution.text`). `ImageToTextTaskOcrBase` kostet 2 Punkte (≈ $0.30 / 1k) pro Bild und arbeitet synchron: Ein einziger `createTask`\-Request liefert das Ergebnis. Wenn Sie Vorgaben wie Groß-/Kleinschreibung, reine Ziffern oder Rechenaufgaben angeben müssen, verwenden Sie das asynchrone `ImageToTextTask`.
- POST `https://api.yescaptcha.com/createTask` (Globaler Endpoint)
- POST `https://cn.yescaptcha.com/createTask` (China-Endpoint)
Der Request-Body ist JSON und wird mit `clientKey` authentifiziert.
## Typen und Preise
| Aufgabentyp | Preis | Modus | Hinweise |
| --- | --- | --- | --- |
| `ImageToTextTaskOcrBase` | $0.30 / 1k; 2 Punkte/Aufgabe · ¥2 / 1k | Synchron | |
| `ImageToTextTaskMuggle` | $0.30 / 1k; 2 Punkte/Aufgabe · ¥2 / 1k | Synchron | Unterstützt keine case-/numeric-Optionen; mit project\_name wählen Sie ein individuelles Modell aus |
| `ImageToTextTask` | $0.60 / 1k; 4 Punkte/Aufgabe · ¥4 / 1k | Asynchron | |
| `ImageToTextTaskM1` | $2.25 / 1k; 15 Punkte/Aufgabe · ¥15 / 1k | Asynchron | |
Die Preise in US-Dollar sind Schätzwerte bei 1 US$ ≈ ¥6.67; Aufgaben werden in Punkten berechnet.
| Sie benötigen | Verwenden Sie |
| --- | --- |
| Gewöhnliche Captchas mit Buchstaben und Ziffern, am günstigsten und schnellsten | `ImageToTextTaskOcrBase`, `ImageToTextTaskMuggle` (synchron) |
| Erkennung mit einem für Sie angepassten Modell | `ImageToTextTaskMuggle` mit `project_name` |
| Unterscheidung von Groß-/Kleinschreibung, nur Ziffern, Rechenaufgaben, begrenzte Länge | `ImageToTextTask`, `ImageToTextTaskM1` (asynchron) |
Die Typen verwenden unterschiedliche Modelle und Routen, daher kann das Ergebnis bei gleichen Bildern abweichen. Testen Sie mehrere Typen und wählen Sie den besten.
## Request-Parameter
| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `type` | string | Ja | Aufgabentyp; siehe „Aufgabentypen und Preise“ auf dieser Seite |
| `body` | string | Ja | Base64-kodiertes Bild ohne das Präfix `data:image/...;base64,` und ohne Zeilenumbrüche |
| `project_name` | string | Nein | Name eines individuellen Modells, nur von `ImageToTextTaskMuggle` unterstützt. Weglassen, um das allgemeine Modell für Buchstaben und Ziffern zu verwenden. Für ein individuelles Modell wenden Sie sich an den Support (nur ImageToTextTaskMuggle) |
| `phrase` | boolean | Nein | true bedeutet, dass die Antwort mindestens ein Leerzeichen enthält (nur ImageToTextTask, ImageToTextTaskM1) |
| `case` | boolean | Nein | true bedeutet, dass die Antwort zwischen Groß- und Kleinschreibung unterscheidet (nur ImageToTextTask, ImageToTextTaskM1) |
| `numeric` | integer | Nein | 0 keine Vorgabe; 1 nur Ziffern; 2 keine Ziffern (nur ImageToTextTask, ImageToTextTaskM1) |
| `math` | boolean | Nein | true bedeutet, dass das Bild eine Rechenaufgabe ist und die Antwort deren Ergebnis ist (nur ImageToTextTask, ImageToTextTaskM1) |
| `minLength` | integer | Nein | Minimale Länge der Antwort; 0 bedeutet kein Limit (nur ImageToTextTask, ImageToTextTaskM1) |
| `maxLength` | integer | Nein | Maximale Länge der Antwort; 0 bedeutet kein Limit (nur ImageToTextTask, ImageToTextTaskM1) |
`body` ist die Base64-Kodierung der Bilddatei. WebP-Bilder werden automatisch konvertiert.
> **Achtung:** Verwenden Sie im Base64-String weder das Präfix `data:image/...;base64,` noch Zeilenumbrüche.
## Request-Beispiel
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "ImageToTextTaskOcrBase",
"body": "BASE64_IMAGE"
}
}
```
Vollständiger Code (liest `captcha.png` aus dem aktuellen Verzeichnis):
**curl**
```bash
# Replace BASE64_IMAGE with the Base64-encoded image
curl -s https://api.yescaptcha.com/createTask \
-H 'Content-Type: application/json' \
-d '{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "ImageToTextTaskOcrBase",
"body": "BASE64_IMAGE"
}
}'
```
**Python**
solve.py
```python
import os
import base64
import requests
API = "https://api.yescaptcha.com"
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"] # Read the clientKey from an environment variable
def call(method, payload):
r = requests.post(f"{API}/{method}", json={"clientKey": CLIENT_KEY, **payload}, timeout=30)
data = r.json()
if data.get("errorId"):
raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
return data
def solve(task):
return call("createTask", {"task": task})["solution"]
# Base64-encode the image (no data: prefix)
with open("captcha.png", "rb") as f:
image_b64 = base64.b64encode(f.read()).decode()
solution = solve({
"type": "ImageToTextTaskOcrBase",
"body": image_b64,
})
print(solution["text"])
```
**Node.js**
solve.mjs
```js
import { readFileSync } from 'node:fs';
const API = 'https://api.yescaptcha.com';
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY; // Read the clientKey from an environment variable
async function call(method, payload) {
const res = await fetch(`${API}/${method}`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY, ...payload }),
});
const data = await res.json();
if (data.errorId) throw new Error(`${data.errorCode}: ${data.errorDescription}`);
return data;
}
async function solve(task) {
const { solution } = await call('createTask', { task });
return solution;
}
// Base64-encode the image (no data: prefix)
const imageB64 = readFileSync('captcha.png').toString('base64');
const solution = await solve({
type: "ImageToTextTaskOcrBase",
body: imageB64,
});
console.log(solution.text);
```
Asynchrone Aufgabe mit Vorgaben:
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "ImageToTextTask",
"body": "BASE64_IMAGE",
"case": true,
"numeric": 0,
"minLength": 4,
"maxLength": 6
}
}
```
## Ergebnis
Synchrone Typen liefern das Ergebnis direkt in `createTask`:
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"text": "LMResm"
},
"taskId": "2376919c-1863-11ec-a012-94e6f7355a0b"
}
```
Asynchrone Typen (`ImageToTextTask`, `ImageToTextTaskM1`) liefern zunächst eine `taskId`. Fragen Sie danach alle 5 Sekunden mit `getTaskResult` ab (Polling); bei Abschluss hat `solution` dasselbe Format.
| Feld | Typ | Beschreibung |
| --- | --- | --- |
| `text` | string | Der erkannte Text |
## Eigene Modelle
Das allgemeine Modell funktioniert bei allen Captchas mit Buchstaben und Ziffern, ist aber etwas weniger genau als ein speziell trainiertes Modell. Wenn die Bilder, die Sie erkennen möchten, immer im gleichen Stil gehalten sind, können Sie den [Support kontaktieren](https://docs.yescaptcha.com/de/help/contact.md), um ein eigenes Modell zu erhalten, und es anschließend mit `ImageToTextTaskMuggle` und `project_name` auswählen.
## FAQ
### Wird bei falscher Erkennung ein Punkteabzug berechnet?
Bei synchronen Typen werden Punkte abgezogen, sobald ein Ergebnis zurückgegeben wird, auch wenn es falsch ist. Vergleichen Sie andere Typen oder lassen Sie ein eigenes Modell erstellen.
### Ich erhalte `ERROR_ZERO_CAPTCHA_FILESIZE` oder `ERROR_PARSE_IMAGE_FAIL`
Das Base64 des Bildes ist unvollständig oder enthält das Präfix `data:` bzw. Zeilenumbrüche. Prüfen Sie die Kodierung, siehe [Fehlercodes](https://docs.yescaptcha.com/de/api/errors.md).
## Verwandte Beispiele
- [Schnellstart](https://docs.yescaptcha.com/de/getting-started/quickstart.md): erster Request mit `ImageToTextTaskOcrBase`
- [Python-Beispiele](https://docs.yescaptcha.com/de/samples/python.md)
---
# reCAPTCHA v2 Bilderkennung
> Erkennen Sie reCAPTCHA-v2-Bildaufgaben mit YesCaptcha (ReCaptchaV2Classification): Laden Sie ein 3x3-, 4x4- oder 1x1-Bild mit der Fragen-ID hoch und erhalten Sie die anzuklickenden Felder synchron zurück; Abrechnung nach Bildgröße, Tabelle der Fragen-IDs.
Source: https://docs.yescaptcha.com/de/tasks/recaptcha-classification/ · 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/tasks/recaptcha-classification/
`ReCaptchaV2Classification` erkennt die Bildaufgaben von reCAPTCHA v2: Sie senden das Bild und die Fragen-ID und erhalten zurück, welche Felder anzuklicken sind; das Klicken im Browser übernimmt Ihr Programm. Es gibt **kein Token** zurück. Die Antwort kommt synchron, eine einzige `createTask`\-Anfrage liefert das Ergebnis. Ein 3x3- oder 4x4-Bild kostet 6 Punkte (≈ $0.90 / 1k), ein 1x1-Bild ist günstiger (siehe Tabelle).
> **Tipp:** Wenn Sie keine eigene Klicklogik schreiben möchten, nutzen Sie die [Browser-Erweiterung](https://docs.yescaptcha.com/de/extension.md). Sie klickt auf Basis dieser Schnittstelle automatisch.
- POST `https://api.yescaptcha.com/createTask` (Globaler Endpoint)
- POST `https://cn.yescaptcha.com/createTask` (China-Endpoint)
## Typen und Preise
| Aufgabentyp | Preis | Modus | Hinweise |
| --- | --- | --- | --- |
| `ReCaptchaV2Classification` | $0.90 / 1k; 6 Punkte/Aufgabe · ¥6 / 1k | Synchron | 2 Punkte für ein 1x1-Feld (100x100); 6 Punkte für 3x3 (300x300) und 4x4 (450x450) |
Die Preise in US-Dollar sind Schätzwerte bei 1 US$ ≈ ¥6.67; Aufgaben werden in Punkten berechnet.
## Anfrageparameter
| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `type` | string | Ja | Aufgabentyp; siehe „Aufgabentypen und Preise“ auf dieser Seite |
| `image` | string | Ja | Base64-kodiertes Aufgabenbild ohne das Präfix `data:` |
| `question` | string | Ja | Frage-ID, z. B. `/m/0k4j`; siehe „Frage-IDs“ auf dieser Seite |
| `confidence` | number | Nein | Konfidenzschwelle von 0 bis 1, nur für 3x3-Bilder relevant. Wenn gesetzt (0.5 ist ein guter Startwert), werden alle Felder oberhalb dieses Werts zurückgegeben; wenn nicht gesetzt, werden die 3 wahrscheinlichsten Felder zurückgegeben |
> **Achtung:** Das Bild muss auf eine der Standardgrößen in der folgenden Tabelle skaliert werden; der Server erkennt den Aufgabentyp anhand der Größe.
| Aufgabenart | Bildgröße | Rückgabe |
| --- | --- | --- |
| 3x3-Raster („Alle Bilder auswählen“) | 300 × 300 | `objects`: anzuklickende Felder |
| 4x4-Raster („Alle Felder auswählen“) | 450 × 450 | `objects`: anzuklickende Felder |
| 1x1-Bild (einzelnes Bild, das nach dem Klicken im 3x3-Raster nachgeladen wird) | 100 × 100 | `hasObject`: ob dieses Bild anzuklicken ist |
Bei Screenshots entscheidet die Fragestellung: Beim 3x3-Raster lautet sie „Alle Bilder auswählen“ (Select all images with …), beim 4x4-Raster „Alle Felder auswählen“ (Select all squares with …).
## Anfragebeispiel
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "ReCaptchaV2Classification",
"image": "BASE64_IMAGE",
"question": "/m/0k4j"
}
}
```
## Ergebnis
3x3, 4x4:
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"objects": [1, 5, 8],
"type": "multi"
},
"taskId": "3a9e8cb8-3871-11ec-9794-94e6f7355a0b"
}
```
1x1-Bild:
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"hasObject": true,
"type": "single"
}
}
```
| Feld | Typ | Beschreibung |
| --- | --- | --- |
| `objects` | array | Indizes der anzuklickenden Felder, beginnend bei 0, von links nach rechts und von oben nach unten |
| `hasObject` | boolean | Wird bei einem 1x1-Einzelbild zurückgegeben; gibt an, ob das Bild das Ziel enthält |
| `type` | string | Aufgabenart: `multi` (3x3- oder 4x4-Bild, siehe `objects`), `single` (1x1-Einzelbild, siehe `hasObject`); `drag` bei hCaptcha-Ziehaufgaben |
Die Felder werden ab 0 nummeriert, von links nach rechts und von oben nach unten:
## confidence: alle passenden Felder auf einmal erhalten
Nach dem Klicken im 3x3-Raster erscheinen in der Regel 1x1-Bilder, die ebenfalls geprüft werden müssen. Wenn diese Bilder schwer zu erfassen sind (z. B. bei der Entwicklung für Mobilgeräte), können Sie `confidence` übergeben:
- Ohne `confidence` liefert ein 3x3-Bild die 3 Felder mit dem höchsten Score (reCAPTCHA verlangt mindestens 3 Klicks).
- Mit `confidence` (empfohlen: `0.5`) werden alle Felder zurückgegeben, deren Score über diesem Wert liegt; das können mehr oder weniger als 3 sein. Gibt es keine passenden Felder, ist das Array leer. So müssen Sie keine 1x1-Bilder mehr aufnehmen.
- Bei 4x4- und 1x1-Bildern hat der Parameter keine Wirkung.
## Fragen-IDs
`question` erwartet die ID der Frage (beginnt mit `/m/`), nicht den Fragetext. Die ID steht zusammen mit dem Bild in der Antwort der Anfrage, mit der reCAPTCHA die Aufgabe lädt (`reload` oder `userverify`). Die folgende Tabelle zeigt gängige Fragen; die chinesischen Texte dienen nur als Orientierung:
Insgesamt 16
| Fragen-ID | Frage (Englisch) |
| --- | --- |
| `/m/0pg52` | `taxis` |
| `/m/01bjv` | `bus` |
| `/m/04_sv` | `motorcycles` |
| `/m/013xlm` | `tractors` |
| `/m/01jk_4` | `chimneys` |
| `/m/014xcs` | `crosswalks` |
| `/m/015qff` | `traffic lights` |
| `/m/0199g` | `bicycles` |
| `/m/015qbp` | `parking meters` |
| `/m/0k4j` | `cars` |
| `/m/015kr` | `bridges` |
| `/m/019jd` | `boats` |
| `/m/0cdl1` | `palm trees` |
| `/m/09d_r` | `mountains or hills` |
| `/m/01pns0` | `fire hydrant` |
| `/m/01lynh` | `stairs` |
Keine passenden Fragen
`ERROR_UNKNOWN_QUESTION` bedeutet, dass die ID falsch ist oder die Frage noch nicht unterstützt wird. `ERROR_UNKNOW_450x450_QUESTION` bedeutet, dass die Frage mit 4x4-Bildern noch nicht unterstützt wird; laden Sie die Aufgabe auf der Seite neu, um eine andere zu erhalten.
## Meldung und Erstattung
Wenn die Prüfung nach dem Klicken fehlschlägt, können Sie die Aufgaben innerhalb von 1 Stunde mit [report](https://docs.yescaptcha.com/de/api/report.md) melden. Die Erstattung wird nach etwa 24 Stunden abgerechnet; die Regeln finden Sie unter [Abrechnung und Punkteerstattung](https://docs.yescaptcha.com/de/getting-started/billing.md). Melden Sie auch bestandene Prüfungen mit `isSuccess: true`.
## Weiterführende Anleitungen
- [reCAPTCHA v2 Bilderkennung: Klicks simulieren (Selenium)](https://docs.yescaptcha.com/de/guides/recaptcha-click-selenium.md)
- [reCAPTCHA v2 (gibt Token zurück)](https://docs.yescaptcha.com/de/tasks/recaptcha-v2.md)
---
# hCaptcha-Bilderkennung
> hCaptcha-Bildaufgaben mit YesCaptcha erkennen (HCaptchaClassification): Auswahl im 3×3-Raster, Klick auf eine bestimmte Position, Ziehen an eine bestimmte Position, animierte Fragen; synchrone Antwort, kein Punkteabzug, wenn kein Ziel erkannt wird.
Source: https://docs.yescaptcha.com/de/tasks/hcaptcha-classification/ · 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/tasks/hcaptcha-classification/
`HCaptchaClassification` erkennt die Bildaufgaben von hCaptcha: Sie senden die Frage und die Bilder und erhalten zurück, welche Bilder auszuwählen sind, welche Position anzuklicken ist oder wohin gezogen werden soll. Die Aktion führt Ihr Programm im Browser aus. Der Typ gibt **kein Token** zurück. Die Antwort kommt synchron, jede Anfrage kostet 8 Punkte (≈ $1.20 / 1k), und wenn kein Ziel erkannt wird (leeres Ergebnis), erfolgt kein Punkteabzug.
> **Tipp:** Wenn Sie keine eigene Klick-Logik schreiben möchten, nutzen Sie die [Browser-Erweiterung](https://docs.yescaptcha.com/de/extension.md); sie unterstützt alle diese Aufgabenarten. Wenn Sie ein Token statt Klickpositionen benötigen, verwenden Sie [hCaptcha](https://docs.yescaptcha.com/de/tasks/hcaptcha.md).
- POST `https://api.yescaptcha.com/createTask` (Globaler Endpoint)
- POST `https://cn.yescaptcha.com/createTask` (China-Endpoint)
## Typen und Preise
| Aufgabentyp | Preis | Modus | Hinweise |
| --- | --- | --- | --- |
| `HCaptchaClassification` | $1.20 / 1k; 8 Punkte/Aufgabe · ¥8 / 1k | Synchron | Kein Punkteabzug, wenn kein Ziel gefunden wird |
Die Preise in US-Dollar sind Schätzwerte bei 1 US$ ≈ ¥6.67; Aufgaben werden in Punkten berechnet.
## Anfrageparameter
| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `type` | string | Ja | Aufgabentyp; siehe „Aufgabentypen und Preise“ auf dieser Seite |
| `queries` | array | Ja | Liste der Base64-codierten Aufgabenbilder in der Reihenfolge auf der Seite (9 Einzelbilder bei einem 3×3-Raster) |
| `question` | string | Nein | Die vollständige Frage, wie sie auf der Seite angezeigt wird (empfohlen: Vereinfachtes Chinesisch oder Englisch), z. B. `Please click each image containing a bicycle`. Senden Sie mindestens eines von `question` und `anchors`; empfohlen ist, beide zu senden |
| `anchors` | array | Nein | Base64-codierte Beispielbilder, die neben der Frage angezeigt werden; erforderlich bei Fragen, die Beispielbilder haben |
- Übergeben Sie `question` unverändert so, wie die Frage auf der Seite angezeigt wird. Eine Übersetzung ist nicht nötig; es wird empfohlen, hCaptcha auf Vereinfachtes Chinesisch oder Englisch umzustellen. Neue Formulierungen werden in der Regel schnell unterstützt, ganz neue Kategorien innerhalb von 3 Werktagen.
> **Achtung:** Wenn oben rechts neben der Frage ein kleines Beispielbild angezeigt wird, übergeben Sie es in `anchors`. Fragen, die sich nur mit dem Beispielbild beantworten lassen, werden ohne `anchors` nicht erkannt.
## Auswahl im 3×3-Raster
Die Frage lautet „Klicken Sie auf jedes Bild mit …“, darunter stehen 9 kleine Bilder. Legen Sie in `queries` die 9 Bilder als Base64 ab, in der Reihenfolge auf der Seite:
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "HCaptchaClassification",
"question": "Please click each image containing a bicycle",
"queries": ["BASE64_IMAGE_1", "BASE64_IMAGE_2"]
}
}
```
Antwort:
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"objects": [true, false, false, true, true, false, true, true, false],
"top_k": [0, 3, 4, 6, 7],
"confidences": [1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0]
}
}
```
`objects` und `top_k` bedeuten dasselbe: `objects` gibt für jedes Bild an, ob es ein Ziel ist, `top_k` listet die Indizes der Zielbilder auf (ab 0). Klicken Sie diese Bilder an.
## Klick auf eine bestimmte Position
Die Frage lautet „Klicken Sie auf …“, darunter steht ein großes Bild, auf dem eine oder mehrere Positionen anzuklicken sind.
1. Übernehmen Sie `question` von der Seite. Wenn Beispielbilder vorhanden sind, legen Sie sie in `anchors` ab.
2. Legen Sie ein Bild in `queries` ab: am besten das direkt aus dem Canvas exportierte Original (am besten als JPG). Wenn nur ein Screenshot möglich ist, erfassen Sie genau den Bereich des großen Bildes (im Bild unten rot umrandet), nicht mehr und nicht weniger.
3. `box` in der Antwort enthält die anzuklickenden Koordinaten der Reihe nach als x1, y1, x2, y2, …, mit der oberen linken Ecke des hochgeladenen Bildes als Ursprung.
4. Weicht die Größe des hochgeladenen Bildes von der Anzeigegröße auf der Seite ab, müssen Sie umrechnen: x auf der Seite = zurückgegebenes x × Anzeigebreite ÷ Breite des hochgeladenen Bildes (y entsprechend). Beispiel: Bei zurückgegebenem x = 769, einer Canvas-Anzeigebreite von 350 und einer Breite des hochgeladenen Bildes von 1000 klicken Sie auf der Seite bei 769 × 350 ÷ 1000 ≈ 269.
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "HCaptchaClassification",
"question": "Please click on the entity present in the sample image.",
"anchors": ["BASE64_ANCHOR_1", "BASE64_ANCHOR_2", "BASE64_ANCHOR_3"],
"queries": ["BASE64_OF_THE_BIG_IMAGE"]
}
}
```
Antwort:
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"box": ["221", "213"]
}
}
```
Müssen mehrere Ziele angeklickt werden, enthält `box` nacheinander mehrere Koordinatenpaare: `["221", "213", "340", "118", ...]`.
## Ziehen an eine bestimmte Position
Die Frage lautet „Ziehen Sie … nach …“; das Teil rechts muss an die passende Stelle im Bild gezogen werden.
1. Übernehmen Sie `question` von der Seite.
2. Legen Sie einen Screenshot in `queries` ab. Das Bild muss **sowohl** das zu ziehende Teil **als auch** die Zielposition zeigen; jede Seite des Bildes sollte mindestens 260 Pixel lang sein.
3. Jeder Eintrag in `box` in der Antwort ist ein Ziehvorgang: `start` ist die Position des Teils, `end` die Position, an die es gezogen werden soll. Bei mehreren Teilen ziehen Sie sie nacheinander.
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"type": "drag",
"box": [
{
"start": [644, 218],
"end": [239, 315]
}
]
}
}
```
Wenn Sie statt eines Screenshots Protokolldaten erhalten (Bilder der Teile, Koordinaten der Teile und das große Hintergrundbild), setzen Sie die Teile zunächst anhand der Koordinaten auf das große Bild. Erzeugen Sie so ein Bild im selben Stil wie der Screenshot der Seite und senden Sie dieses.
## Animierte Fragen
Ist das Aufgabenbild eine Animation, legen Sie die Animation (GIF o. Ä.) als Base64 in `queries` ab. Empfohlen wird eine Animationsdauer von mindestens 3 Sekunden, am besten 5 bis 6 Sekunden, bei etwa 12 FPS.
## Meldung und Erstattung nach Meldung
Schlägt die Prüfung nach dem Klicken fehl, können Sie die Aufgabe innerhalb von 1 Stunde mit [report](https://docs.yescaptcha.com/de/api/report.md) melden. Die Erstattung wird nach etwa 24 Stunden abgerechnet. Die Regeln finden Sie unter [Abrechnung und Punkteerstattung](https://docs.yescaptcha.com/de/getting-started/billing.md).
## Verwandte Anleitungen
- [hCaptcha-Bilderkennung mit simulierten Klicks (Selenium)](https://docs.yescaptcha.com/de/guides/hcaptcha-click-selenium.md)
---
# FunCaptcha-Bilderkennung
> FunCaptcha-Bildaufgaben (Arkose Labs) mit YesCaptcha lösen (FunCaptchaClassification): Laden Sie das Aufgabenbild (3×2-Raster mit 6 Feldern oder ein links und rechts zusammengesetztes Pfeil-Rätsel) und die englische Frage hoch und erhalten Sie synchron, welches Bild zu wählen ist; alle Aufgabenarten werden unterstützt.
Source: https://docs.yescaptcha.com/de/tasks/funcaptcha-classification/ · Last verified: 2026-10-16
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/tasks/funcaptcha-classification/
`FunCaptchaClassification` erkennt FunCaptcha-Bildaufgaben (Arkose Labs): Senden Sie das Aufgabenbild und die englische Frage, und Sie erhalten zurück, welches Bild zu wählen ist; Ihr Programm klickt es anschließend im Browser an. Es gibt **kein Token** zurück. Die Abfrage ist synchron, jede Anfrage kostet 3 Punkte (≈ $0.45 / 1k).
> **Tipp:** Ohne Code nutzen Sie die [Browser-Erweiterung](https://docs.yescaptcha.com/de/extension.md), die die Aufgabe direkt auf der Webseite automatisch löst.
- POST `https://api.yescaptcha.com/createTask` (Globaler Endpoint)
- POST `https://cn.yescaptcha.com/createTask` (China-Endpoint)
## Typen und Preise
| Aufgabentyp | Preis | Modus | Hinweise |
| --- | --- | --- | --- |
| `FunCaptchaClassification` | $0.45 / 1k; 3 Punkte/Aufgabe · ¥3 / 1k | Synchron | |
Die Preise in US-Dollar sind Schätzwerte bei 1 US$ ≈ ¥6.67; Aufgaben werden in Punkten berechnet.
## Anfrageparameter
| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `type` | string | Ja | Aufgabentyp; siehe „Aufgabentypen und Preise“ auf dieser Seite |
| `image` | string | Ja | Base64-kodiertes Aufgabenbild ohne das Präfix `data:` |
| `question` | string | Ja | Der Fragetext auf Englisch (z. B. `Pick the image that is the correct way up`); die unterstützten Fragen sind auf dieser Seite aufgeführt |
- `image` enthält nur den Bildteil der Aufgabe (6er-Raster oder das links und rechts zusammengesetzte Bild der Pfeil-Aufgabe). Der Titel und die Schaltflächen darüber gehören nicht ins Bild. Der Screenshot muss vollständig sein, denn fehlt ein Teil, leidet die Erkennung. Ein vertikal angeordnetes 6er-Raster können Sie unverändert als Originalbild hochladen.
- `question` ist der vollständige englische Fragetext genau so, wie er auf der Webseite steht, mit korrekter Groß- und Kleinschreibung. Übersetzen Sie ihn nicht selbst. Ist die Webseite in einer anderen Sprache, stellen Sie das Captcha zuerst auf Englisch um. Der Server bestimmt die Aufgabenart anhand der Frage, daher muss sie stimmen.
## Anfragebeispiel
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "FunCaptchaClassification",
"image": "BASE64_IMAGE",
"question": "Pick the bread"
}
}
```
## Ergebnis
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"objects": [4],
"labels": ["parrot", "panda", "octopus", "owl", "bread", "dog"]
},
"taskId": "04a3fa76-11a0-11ed-a58c-0ef20f419382"
}
```
| Feld | Typ | Beschreibung |
| --- | --- | --- |
| `objects` | array | Index des auszuwählenden Bilds, beginnend bei 0, von links nach rechts und von oben nach unten |
| `labels` | array | Erkannte Labels |
`objects: [4]` bedeutet: Wählen Sie das 5. Bild (Zählung ab 0, von links nach rechts und von oben nach unten). Eine Aufgabe besteht oft aus mehreren Runden nacheinander; machen Sie in jeder Runde einen neuen Screenshot und senden Sie eine neue Anfrage.
## Unterstützte Fragen
**Alle Aufgabenarten werden unterstützt**, Sie müssen vorher keine Fragenliste prüfen: Senden Sie einfach die englische Frage und das Aufgabenbild von der Webseite. Erhalten Sie `ERROR_UNKNOWN_QUESTION`, wenden Sie sich an den [Support](https://docs.yescaptcha.com/de/help/contact.md).
Aktuell am häufigsten ist das links und rechts zusammengesetzte Pfeil-Rätsel: Links steht das Beispiel zum Abgleichen, rechts das aktuelle Bild. Mit den Pfeilen auf der Webseite wechseln Sie das rechte Bild, bis Sie das passende gefunden haben. Laden Sie das ganze Bild (beide Hälften) so hoch, wie es auf der Webseite erscheint, zum Beispiel:
`Use the arrows to change the number of objects until it matches the left image`Anzahl stimmt mit dem linken Bild überein
`use the arrows to choose the image where all the darts add up to the number in the left image`Die Summe der Zahlen auf den Dartpfeilen entspricht der Zahl im linken Bild
`use the arrows to find the jigsaw puzzle that is missing the puzzle piece shown on the left`Es fehlt genau das links gezeigte Puzzleteil
`find the image that has the prize on the left held by the claw in the machine on the right`Die Klaue hält den Preis von links
Die andere Art ist die Bildauswahl im 6er-Raster (z. B. `Pick the bread`): Laden Sie den Teil mit dem 6er-Raster hoch, siehe das Anfragebeispiel oben.
## Meldung und Erstattung
Schlägt die Übermittlung einer Aufgabenreihe am Ende fehl und Sie wissen nicht, welche Runde falsch war, können Sie die Aufgaben-IDs der ganzen Reihe gemeinsam mit [report](https://docs.yescaptcha.com/de/api/report.md) melden (innerhalb von 1 Stunde). Die Erstattung nach Meldung wird nach etwa 24 Stunden abgerechnet. Die Regeln finden Sie unter [Abrechnung und Punkteerstattung](https://docs.yescaptcha.com/de/getting-started/billing.md).
---
# AWS WAF / bCaptcha Bilderkennung
> AWS WAF CAPTCHA und bCaptcha 3×3-Raster-Bildaufgaben mit YesCaptcha erkennen (AwsClassification, bCaptchaClassification): Laden Sie das ganze Bild und die Frage hoch und erhalten Sie synchron die Felder, die angeklickt werden müssen.
Source: https://docs.yescaptcha.com/de/tasks/aws-bcaptcha-classification/ · 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/tasks/aws-bcaptcha-classification/
`AwsClassification` erkennt 3×3-Raster-Bildaufgaben von AWS WAF CAPTCHA, `bCaptchaClassification` erkennt 3×3-Raster-Bildaufgaben von bCaptcha: Senden Sie das ganze Bild und die Frage, und Sie erhalten zurück, welche Felder angeklickt werden müssen; das Anklicken übernimmt Ihr Programm im Browser. Diese Typen geben **kein Token** zurück. Die Antwort kommt synchron, jede Anfrage kostet 8 Punkte (≈ $1.20 / 1k).
Ohne Code können Sie die [Browser-Erweiterung](https://docs.yescaptcha.com/de/extension.md) verwenden.
- POST `https://api.yescaptcha.com/createTask` (Globaler Endpoint)
- POST `https://cn.yescaptcha.com/createTask` (China-Endpoint)
## Typen und Preise
| Aufgabentyp | Preis | Modus | Hinweise |
| --- | --- | --- | --- |
| `AwsClassification` | $1.20 / 1k; 8 Punkte/Aufgabe · ¥8 / 1k | Synchron | |
| `bCaptchaClassification` | $1.20 / 1k; 8 Punkte/Aufgabe · ¥8 / 1k | Synchron | |
Die Preise in US-Dollar sind Schätzwerte bei 1 US$ ≈ ¥6.67; Aufgaben werden in Punkten berechnet.
Beide Typen haben dieselben Parameter und dasselbe Rückgabeformat. Wählen Sie nach der Herkunft des Captchas: `AwsClassification` für AWS WAF, `bCaptchaClassification` für bCaptcha.
## Anfrageparameter
| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `type` | string | Ja | Aufgabentyp; siehe „Aufgabentypen und Preise“ auf dieser Seite |
| `queries` | string | Ja | Base64 des gesamten 3×3-Raster-Bilds (ein einzelnes Bild) |
| `question` | string | Nein | Die vollständige Frage, wie sie auf der Seite angezeigt wird, z. B. `Select all hats`; andere Sprachen werden automatisch übersetzt |
`queries` enthält das **ganze** 3×3-Raster-Bild (ein Bild, nicht 9 Einzelbilder). Übernehmen Sie `question` unverändert als vollständigen Satz von der Webseite; Chinesisch und Englisch funktionieren, andere Sprachen werden automatisch übersetzt.
## Anfragebeispiel
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "AwsClassification",
"queries": "BASE64_IMAGE",
"question": "Select all hats"
}
}
```
## Ergebnis
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"label": "Select All Hats",
"objects": [false, true, false, false, true, true, true, true, false],
"top_k": [1, 4, 5, 6, 7],
"confidences": [0.0, 1.0, 0.0, 0.255, 1.0, 1.0, 0.9637, 0.9999, 0.0]
},
"taskId": "2053f690-3c3b-11f0-8ffb-d2c180657082"
}
```
| Feld | Typ | Beschreibung |
| --- | --- | --- |
| `label` | string | Das erkannte Ziel der Frage |
| `objects` | array | Ob jedes der 9 Felder ein Ziel ist (true / false), von links nach rechts und von oben nach unten |
| `top_k` | array | Indizes (ab 0) der Bilder, die Ziele sind; gleiche Bedeutung wie `objects`, verwenden Sie eines von beiden |
| `confidences` | array | Konfidenz jedes Ergebnisses |
Die 9 Felder sind im 3×3-Raster von links nach rechts und von oben nach unten von 0 bis 8 nummeriert. `objects` und `top_k` bedeuten dasselbe, verwenden Sie eines von beiden: Klicken Sie die Felder an, bei denen `objects` den Wert `true` hat, oder die Nummern in `top_k`.
## Meldung und Erstattung
Wenn die Prüfung nach dem Klicken fehlschlägt, können Sie die Aufgabe innerhalb von 1 Stunde mit [report](https://docs.yescaptcha.com/de/api/report.md) melden. Die Erstattung nach Meldung wird nach etwa 24 Stunden abgerechnet. Die Regeln finden Sie unter [Abrechnung und Punkteerstattung](https://docs.yescaptcha.com/de/getting-started/billing.md).
---
# YesCaptcha Assistant
> YesCaptcha Assistant (Browser-Erweiterung) erkennt und klickt reCAPTCHA, hCaptcha, FunCaptcha, AWS WAF und weitere Captchas in Chrome und Firefox automatisch. Die Erweiterung ist kostenlos; abgerechnet werden die dabei genutzten API-Aufrufe per Punkteabzug. Store-Links, Installationspakete und Installationsvideos für Chrome, BitBrowser und Kiwi Browser.
Source: https://docs.yescaptcha.com/de/extension/ · Last verified: 2026-10-24
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/extension/
YesCaptcha Assistant ist eine Browser-Erweiterung für Chrome und Firefox: Wenn eine Seite ein Captcha anzeigt, sendet die Erweiterung die Aufgabe zur Erkennung an YesCaptcha und klickt automatisch, ganz ohne Code. Die Erweiterung selbst ist kostenlos; bei der Erkennung werden Punkte für die genutzten API-Typen abgezogen. Dabei gelten dasselbe Konto und dasselbe Guthaben wie für die API.
## Was sie kann
- Bildaufgaben von reCAPTCHA v2, hCaptcha, FunCaptcha, AWS WAF und bCaptcha automatisch erkennen und anklicken.
- Einfache Text-Captchas: Klicken Sie mit der rechten Maustaste auf das Bild und wählen Sie „Mark as captcha source“, dann mit der rechten Maustaste auf das Eingabefeld und „Put captcha answer here“. Die Erweiterung erkennt den Text und trägt ihn ein.
- In den Einstellungen lässt sich jeder Captcha-Typ einzeln ein- oder ausschalten; Klickgeschwindigkeit und Wiederholungen bei Fehlern sind einstellbar.
> **Hinweis:** Nicht jede Website lässt sich damit überwinden; testen Sie zuerst.
## Installation
**Über den Store installieren (empfohlen, wird automatisch aktualisiert):**
- Chrome (und Chromium-basierte Browser wie Edge): [Chrome Web Store](https://chromewebstore.google.com/detail/yescaptcha-assistant/jiofmdifioeejeilfkpegipdjiopiekl)
- Firefox: [Firefox-Add-ons](https://addons.mozilla.org/firefox/addon/yescaptcha-assistant/)
Öffnen Sie die Seite der Erweiterung im Chrome Web Store, klicken Sie auf „Zu Chrome hinzufügen“, klicken Sie dann in der Symbolleiste auf das Erweiterungssymbol und tragen Sie Ihren `clientKey` ein:
Ihr Browser kann dieses Video nicht abspielen. Laden Sie es stattdessen herunter: [Video: Installation über den Chrome Web Store (34 s)](https://docs.yescaptcha.com/videos/extension-chrome-store.mp4)
Video: Installation über den Chrome Web Store (34 s)
**Wenn sich der Store nicht öffnen lässt, laden Sie das Installationspaket herunter:**
Chrome-Version
Version
1.4.12
Größe
1.1 MB
Aktualisiert
2026-11-10
[Herunterladen](https://api.yescaptcha.com/extension/chrome/latest)[Chrome Web Store](https://chromewebstore.google.com/detail/yescaptcha-assistant/jiofmdifioeejeilfkpegipdjiopiekl)
Firefox-Version
Version
0.4.6
Größe
0.9 MB
Aktualisiert
2026-10-31
[Herunterladen](https://api.yescaptcha.com/extension/firefox/latest)[Firefox-Add-ons](https://addons.mozilla.org/firefox/addon/yescaptcha-assistant/)
Die Version im Firefox-Store kann älter sein als das Paket hier. Für die neueste Version verwenden Sie das Installationspaket.
### Chrome: Installation per Paket
1. Laden Sie die ZIP-Datei herunter und entpacken Sie sie in einen dauerhaften Ordner.
2. Öffnen Sie in der Adressleiste `chrome://extensions` und aktivieren Sie oben rechts den „Entwicklermodus“.
3. Klicken Sie auf „Entpackte Erweiterung laden“ und wählen Sie den eben entpackten Ordner.
4. Klicken Sie in der Symbolleiste auf das Erweiterungssymbol und tragen Sie Ihren `clientKey` ein.
Sie können auch vor dem Laden die entpackte Datei `config.js` mit einem Texteditor öffnen, Ihren `clientKey` zwischen die Anführungszeichen von `clientKey: ''` schreiben und speichern. Nach der Installation müssen Sie ihn dann nicht mehr eingeben. Das spart Aufwand, wenn Sie die Erweiterung in vielen Browser-Umgebungen installieren.
Ihr Browser kann dieses Video nicht abspielen. Laden Sie es stattdessen herunter: [Video: Chrome-Installation per Paket, mit vorab in config.js eingetragenem clientKey (44 s; das Video zeigt eine ältere Version, die Schritte sind gleich)](https://docs.yescaptcha.com/videos/extension-chrome-zip.mp4)
Video: Chrome-Installation per Paket, mit vorab in config.js eingetragenem clientKey (44 s; das Video zeigt eine ältere Version, die Schritte sind gleich)
> **Achtung:** Löschen oder verschieben Sie den entpackten Ordner danach nicht, sonst kann der Browser die Erweiterung nicht mehr laden. Per Paket installierte Erweiterungen werden nicht automatisch aktualisiert; laden Sie bei einer neuen Version das Paket erneut herunter.
### Firefox: Installation per Paket
1. Laden Sie die `.xpi`\-Datei herunter.
2. Öffnen Sie in der Adressleiste `about:addons`, klicken Sie auf das Zahnradsymbol, wählen Sie „Add-on aus Datei installieren“ und dann die heruntergeladene Datei.
3. Klicken Sie in der Symbolleiste auf das Erweiterungssymbol und tragen Sie Ihren `clientKey` ein.
## Installation in BitBrowser
BitBrowser und andere Anti-Detect-Browser (anti-detect browser) basieren auf Chrome. Die Erweiterung wird im Extension Center hinzugefügt und kann dann für alle Fenster oder nur für ausgewählte Fenster aktiviert werden. Die folgenden Schritte und Videos wurden mit BitBrowser 6.0 und chinesischer Oberfläche aufgenommen; neuere Versionen können leicht abweichen.
### Aus dem Chrome Web Store hinzufügen
1. Klicken Sie in BitBrowser in der linken Seitenleiste auf das Extension Center, dann auf „Benutzerdefinierte Erweiterung hinzufügen“ und wählen Sie „Chrome-Store-Erweiterung hinzufügen“.
2. Fügen Sie im Feld für die URL der Erweiterungsdetails die Chrome-Web-Store-Adresse der Erweiterung `https://chromewebstore.google.com/detail/yescaptcha-assistant/jiofmdifioeejeilfkpegipdjiopiekl` ein und klicken Sie auf die Schaltfläche rechts neben dem Feld. Sobald YesCaptcha Assistant erkannt wird, klicken Sie auf „OK“.
3. Klicken Sie auf der Karte von YesCaptcha Assistant auf „Einstellungen“ und legen Sie fest, wo die Erweiterung aktiv ist: in allen Fenstern oder nur in ausgewählten Fenstern (dann die gewünschten Fenster anhaken). Klicken Sie auf „OK“.
4. Öffnen Sie ein Browserfenster, klicken Sie in der Symbolleiste auf das Erweiterungssymbol, öffnen Sie YesCaptcha Assistant und tragen Sie Ihren `clientKey` ein. Sobald das Guthaben angezeigt wird, ist alles eingerichtet.
Ihr Browser kann dieses Video nicht abspielen. Laden Sie es stattdessen herunter: [Video: Erweiterung in BitBrowser aus dem Chrome Web Store hinzufügen (30 s)](https://docs.yescaptcha.com/videos/extension-bit-store.mp4)
Video: Erweiterung in BitBrowser aus dem Chrome Web Store hinzufügen (30 s)
### Per Installationspaket hinzufügen
1. Laden Sie das Chrome-Paket von oben herunter und entpacken Sie es in einen dauerhaften Ordner.
2. (Optional) Öffnen Sie die Datei `config.js` im Ordner mit einem Texteditor, tragen Sie Ihren `clientKey` zwischen die Anführungszeichen von `clientKey: ''` ein und speichern Sie. So müssen Sie ihn nach der Installation in keinem Fenster mehr eingeben.
3. Klicken Sie im Extension Center auf „Benutzerdefinierte Erweiterung hinzufügen“ und wählen Sie „Lokale Erweiterung hinzufügen“. Wählen Sie beim Hochladen den entpackten Ordner (die Ebene, in der `manifest.json` liegt) und klicken Sie auf „OK“.
4. Klicken Sie nach dem erfolgreichen Hochladen auf der Karte von YesCaptcha Assistant auf „Einstellungen“, wählen Sie, wo die Erweiterung aktiv sein soll (alle Fenster oder ausgewählte Fenster), und klicken Sie auf „OK“.
5. Öffnen Sie ein Browserfenster und klicken Sie unter dem Erweiterungssymbol auf YesCaptcha Assistant. Sobald ClientKey und Guthaben angezeigt werden, ist alles eingerichtet.
Ihr Browser kann dieses Video nicht abspielen. Laden Sie es stattdessen herunter: [Video: Paket in BitBrowser hinzufügen (46 s; das Video zeigt eine ältere Version, die Schritte sind gleich)](https://docs.yescaptcha.com/videos/extension-bit-zip.mp4)
Video: Paket in BitBrowser hinzufügen (46 s; das Video zeigt eine ältere Version, die Schritte sind gleich)
## Auf Android-Smartphones (Kiwi Browser)
> **Achtung:** Kiwi Browser wird seit Januar 2025 nicht mehr gepflegt und wurde aus Google Play entfernt; es gibt keine Updates und keine Sicherheitspatches mehr. Die folgenden Schritte und das Video stammen aus der alten Dokumentation und dienen als Orientierung für Nutzer, die Kiwi Browser noch verwenden. Die aktuelle Version der Erweiterung wurde auf Kiwi Browser nicht erneut getestet.
1. Laden Sie das Chrome-Paket (`.zip`) auf das Smartphone herunter, ohne es zu entpacken. Wenn Ihr ClientKey vorab eingetragen sein soll, entpacken Sie das Paket zuerst auf einem Computer, ändern Sie `config.js` und packen Sie es wieder als ZIP (`manifest.json` muss auf der obersten Ebene des Archivs liegen).
2. Tippen Sie in Kiwi Browser oben rechts auf das Menü und wählen Sie „Extensions“.
3. Aktivieren Sie „Developer mode“, tippen Sie auf „+ (from .zip/.crx/.user.js)“ und wählen Sie das heruntergeladene Paket.
4. Öffnen Sie das Menü oben rechts erneut; ganz unten erscheint YesCaptcha Assistant. Öffnen Sie es und tragen Sie Ihren `clientKey` ein. Sobald das Guthaben angezeigt wird, ist alles eingerichtet.
Ihr Browser kann dieses Video nicht abspielen. Laden Sie es stattdessen herunter: [Video: Installation in Kiwi Browser (16 s; das Video zeigt eine ältere Version, die Schritte sind gleich)](https://docs.yescaptcha.com/videos/extension-kiwi.mp4)
Video: Installation in Kiwi Browser (16 s; das Video zeigt eine ältere Version, die Schritte sind gleich)
## Einrichtung
1. Registrieren Sie sich auf [yescaptcha.com](https://yescaptcha.com/), laden Sie Ihr Guthaben auf und kopieren Sie Ihren `clientKey` im Dashboard; siehe [Schnellstart](https://docs.yescaptcha.com/de/getting-started/quickstart.md).
2. Klicken Sie auf das Erweiterungssymbol und tragen Sie den Schlüssel im Einstellungsfenster ein. Sobald das Guthaben angezeigt wird, ist alles eingerichtet.
3. Öffnen Sie eine Seite mit einem Captcha; die Erkennung startet automatisch.
## Kosten
Die Erweiterung ist kostenlos. Bei der Erkennung werden Punkte nach den genutzten Aufgabentypen abgezogen: Bildaufgaben von reCAPTCHA nach dem Preis für [reCAPTCHA v2 Bilderkennung](https://docs.yescaptcha.com/de/tasks/recaptcha-classification.md), hCaptcha nach dem Preis für [hCaptcha Bilderkennung](https://docs.yescaptcha.com/de/tasks/hcaptcha-classification.md). Falsche Ergebnisse können Sie melden und erhalten eine Erstattung nach Meldung; siehe [Abrechnung und Punkteerstattung](https://docs.yescaptcha.com/de/getting-started/billing.md).
---
# Den Captcha-Typ bestimmen
> So erkennen Sie, welches Captcha eine Seite verwendet (reCAPTCHA v2, unsichtbares v2, v3, Enterprise, hCaptcha, Cloudflare Turnstile im Unterschied zur Cloudflare-Prüfseite) und welchen YesCaptcha-Aufgabentyp Sie dafür nutzen.
Source: https://docs.yescaptcha.com/de/guides/identify-captcha/ · 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/identify-captcha/
Der erste Schritt zur Wahl des richtigen Aufgabentyps ist, das Captcha zu erkennen. Am zuverlässigsten öffnen Sie die Entwicklertools des Browsers (F12) und prüfen im Network-Panel (Netzwerk), welches Captcha-Skript die Seite lädt. Sie können es auch am Aussehen erkennen.
## Am Aussehen erkennen
So sehen die einzelnen Captchas auf einer Webseite aus (animierte Darstellungen, keine Screenshots). Klicken Sie auf eine Karte, um die zugehörige Typseite zu öffnen. Wenn das Aussehen nicht eindeutig ist, bestätigen Sie es mit der Kurzübersicht und dem Network-Panel weiter unten.
- [reCAPTCHA v2: Kontrollkästchen · Unsichtbar](https://docs.yescaptcha.com/de/tasks/recaptcha-v2.md)
- [reCAPTCHA v3](https://docs.yescaptcha.com/de/tasks/recaptcha-v3.md)
- [reCAPTCHA v2 Bilderkennung: 3×3-Raster · 4×4-Raster · 1×1-Einzelbild](https://docs.yescaptcha.com/de/tasks/recaptcha-classification.md)
- [hCaptcha](https://docs.yescaptcha.com/de/tasks/hcaptcha.md)
- [hCaptcha-Bilderkennung: Bildraster · Punkt anklicken · Ziehen und Ablegen · Animiert](https://docs.yescaptcha.com/de/tasks/hcaptcha-classification.md)
- [Cloudflare Turnstile: Automatisch · Kontrollkästchen](https://docs.yescaptcha.com/de/tasks/turnstile.md)
- [Cloudflare-Prüfseite: Automatisch · Kontrollkästchen](https://docs.yescaptcha.com/de/tasks/cloudflare-challenge.md)
- [FunCaptcha-Bilderkennung: Pfeile · 6-Bilder-Raster](https://docs.yescaptcha.com/de/tasks/funcaptcha-classification.md)
- [AWS WAF / bCaptcha Bilderkennung: AWS WAF · bCaptcha](https://docs.yescaptcha.com/de/tasks/aws-bcaptcha-classification.md)
- [Bilder mit Buchstaben und Ziffern erkennen: Mit Rauschen · Störlinien · Rechenaufgabe](https://docs.yescaptcha.com/de/tasks/image-to-text.md)
## Kurzübersicht
| Was Sie sehen | Was es ist | Welcher Aufgabentyp |
| --- | --- | --- |
| Ein Kontrollkästchen „Ich bin kein Roboter“ / „I’m not a robot“ | reCAPTCHA v2 | [reCAPTCHA v2](https://docs.yescaptcha.com/de/tasks/recaptcha-v2.md) |
| Kein Kontrollkästchen; erst nach dem Klick auf „Senden“ erscheint eine Bildaufgabe; unten rechts ein kleines reCAPTCHA-Logo | reCAPTCHA v2 unsichtbar (oder v3) | Siehe „reCAPTCHA-Versionen“ weiter unten |
| Keinerlei Interaktion; unten rechts nur das reCAPTCHA-Logo | reCAPTCHA v3 | [reCAPTCHA v3](https://docs.yescaptcha.com/de/tasks/recaptcha-v3.md) |
| Ein Kontrollkästchen „Ich bin ein Mensch“; Bildaufgaben mit hCaptcha-Kennzeichnung | hCaptcha | [hCaptcha](https://docs.yescaptcha.com/de/tasks/hcaptcha.md) |
| Ein Cloudflare-Prüffeld im Formular; nach dem Häkchen bleibt die Seite stehen | Cloudflare Turnstile | [Turnstile](https://docs.yescaptcha.com/de/tasks/turnstile.md) |
| Die ganze Seite zeigt „Einen Moment bitte…“ / „Verbindung wird überprüft“ und leitet automatisch weiter | Cloudflare-Prüfseite | [Cloudflare-Prüfseite](https://docs.yescaptcha.com/de/tasks/cloudflare-challenge.md) |
| Puzzle- und Bildaufgaben von Arkose Labs (z. B. „Wählen Sie das richtig ausgerichtete Bild“) | FunCaptcha | [FunCaptcha-Bilderkennung](https://docs.yescaptcha.com/de/tasks/funcaptcha-classification.md) |
| Ein Bild mit verzerrten Buchstaben und Ziffern | Zeichen-Captcha | [Bild zu Text](https://docs.yescaptcha.com/de/tasks/image-to-text.md) |
## reCAPTCHA-Versionen
Suchen Sie im Network-Panel nach `api.js` oder `enterprise.js`:
| Geladenes Skript | Version |
| --- | --- |
| `recaptcha/api.js` ohne `render`\-Parameter oder mit `render=explicit` | v2 Standard |
| Wie oben, und die URL der `anchor`\-Anfrage enthält `size=invisible` | v2 unsichtbar: fügen Sie in der Aufgabe `"isInvisible": true` hinzu |
| `recaptcha/api.js?render=WEBSITE_SCHLÜSSEL` (`render` ist nicht `explicit`) | v3 Standard |
| `recaptcha/enterprise.js` ohne `render`\-Parameter oder mit `render=explicit` | v2 Enterprise |
| `recaptcha/enterprise.js?render=WEBSITE_SCHLÜSSEL` | v3 Enterprise |
Beispiele:
```text
https://www.google.com/recaptcha/api.js?onload=onloadcallback&render=explicit → v2
https://www.google.com/recaptcha/api.js?render=6LdyC2cUAAAAACGuDKpXeDorzUDWXmdqeg-xy696 → v3
https://www.google.com/recaptcha/enterprise.js?render=explicit → v2 Enterprise
```
Das unsichtbare v2 lässt sich manchmal nur mit einem v3-Typ lösen. Probieren Sie beide aus.
Sie können auch den folgenden Code in der Konsole (Console) ausführen. Er listet alle reCAPTCHAs auf der Seite mit Version, Website-Schlüssel, Seiten-URL und Callback-Funktion auf:
find-recaptcha-clients.js
```js
// Paste into the browser DevTools console on a page with reCAPTCHA, then run findRecaptchaClients().
// Lists every reCAPTCHA on the page: version (V2/V3), sitekey, page URL and the callback function.
function findRecaptchaClients() {
if (typeof ___grecaptcha_cfg === 'undefined') return [];
return Object.entries(___grecaptcha_cfg.clients).map(([cid, client]) => {
const data = { id: cid, version: cid >= 10000 ? 'V3' : 'V2' };
const objects = Object.entries(client).filter(([, value]) => value && typeof value === 'object');
objects.forEach(([toplevelKey, toplevel]) => {
const found = Object.entries(toplevel).find(
([, value]) => value && typeof value === 'object' && 'sitekey' in value && 'size' in value,
);
if (toplevel instanceof HTMLElement && toplevel.tagName === 'DIV') data.pageurl = toplevel.baseURI;
if (found) {
const [sublevelKey, sublevel] = found;
data.sitekey = sublevel.sitekey;
const callbackKey = data.version === 'V2' ? 'callback' : 'promise-callback';
const callback = sublevel[callbackKey];
if (!callback) {
data.callback = null;
data.function = null;
} else {
data.function = callback;
const keys = [cid, toplevelKey, sublevelKey, callbackKey].map((key) => `['${key}']`).join('');
data.callback = `___grecaptcha_cfg.clients${keys}`;
}
}
});
return data;
});
}
findRecaptchaClients();
```
Beispielausgabe:
```json
[
{
"id": "0",
"version": "V2",
"sitekey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
"function": "onSuccess",
"callback": "___grecaptcha_cfg.clients['0']['l']['l']['callback']",
"pageurl": "https://www.google.com/recaptcha/api2/demo"
}
]
```
Zum Vergleich eignen sich die offiziellen Demoseiten von Google: v2 Standard `https://www.google.com/recaptcha/api2/demo`, v2 unsichtbar `https://www.google.com/recaptcha/api2/demo?invisible=true`.
## Turnstile und Cloudflare-Prüfseite
Beide stammen von Cloudflare, sind aber nicht dasselbe:
- **Turnstile** ist ein Prüffeld, das in ein Formular der Seite eingebettet ist. Nach der Prüfung erscheint ein Häkchen, die Seite selbst wird nicht weitergeleitet. Die Seite lädt `challenges.cloudflare.com/turnstile/v0/api.js`. Verwenden Sie [Turnstile](https://docs.yescaptcha.com/de/tasks/turnstile.md).
- **Die Cloudflare-Prüfseite** ersetzt die gesamte Seite durch die Prüfseite von Cloudflare mit „Einen Moment bitte…“ bzw. „xx.com muss zuerst die Sicherheit Ihrer Verbindung überprüfen“. Sie kann ebenfalls ein Prüffeld enthalten; nach bestandener Prüfung werden Sie automatisch auf die eigentliche Seite weitergeleitet. Im Quelltext stehen `__cf_chl_rt_tk` oder `cdn-cgi/challenge-platform`. Verwenden Sie [Cloudflare-Prüfseite](https://docs.yescaptcha.com/de/tasks/cloudflare-challenge.md).
Wenn Ihr Programm bei der Anfrage 403 und „Just a moment…“ erhält, die Seite sich im Browser aber direkt öffnen lässt, wird meist nur der TLS-Fingerprint blockiert. Verwenden Sie dann eine Bibliothek, die den TLS-Fingerprint eines Browsers nachahmt (z. B. curl\_cffi). Dann gelingt die Anfrage, und die Prüfseite muss nicht gelöst werden.
---
# reCAPTCHA-Parameter finden
> So finden Sie websiteKey (sitekey), websiteURL, den pageAction von v3 und die Callback-Funktion von reCAPTCHA in den Bereichen Network, Sources und Console der Entwicklertools, mit einem Skript für die automatische Suche.
Source: https://docs.yescaptcha.com/de/guides/find-recaptcha-parameters/ · 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/find-recaptcha-parameters/
Für eine reCAPTCHA-Aufgabe benötigen Sie `websiteURL` (die Seite, auf der das Captcha erscheint) und `websiteKey` (den Website-Schlüssel); v3 braucht zusätzlich `pageAction`. Wenn Sie den Browser mit Selenium oder ähnlichen Tools steuern, brauchen Sie außerdem die Callback-Funktion. All das finden Sie in den Entwicklertools des Browsers (F12).
## Der schnellste Weg: Skript für die automatische Suche
Öffnen Sie die Seite mit dem Captcha, öffnen Sie mit F12 die Konsole (Console), fügen Sie das folgende Skript ein und führen Sie es aus:
find-recaptcha-clients.js
```js
// Paste into the browser DevTools console on a page with reCAPTCHA, then run findRecaptchaClients().
// Lists every reCAPTCHA on the page: version (V2/V3), sitekey, page URL and the callback function.
function findRecaptchaClients() {
if (typeof ___grecaptcha_cfg === 'undefined') return [];
return Object.entries(___grecaptcha_cfg.clients).map(([cid, client]) => {
const data = { id: cid, version: cid >= 10000 ? 'V3' : 'V2' };
const objects = Object.entries(client).filter(([, value]) => value && typeof value === 'object');
objects.forEach(([toplevelKey, toplevel]) => {
const found = Object.entries(toplevel).find(
([, value]) => value && typeof value === 'object' && 'sitekey' in value && 'size' in value,
);
if (toplevel instanceof HTMLElement && toplevel.tagName === 'DIV') data.pageurl = toplevel.baseURI;
if (found) {
const [sublevelKey, sublevel] = found;
data.sitekey = sublevel.sitekey;
const callbackKey = data.version === 'V2' ? 'callback' : 'promise-callback';
const callback = sublevel[callbackKey];
if (!callback) {
data.callback = null;
data.function = null;
} else {
data.function = callback;
const keys = [cid, toplevelKey, sublevelKey, callbackKey].map((key) => `['${key}']`).join('');
data.callback = `___grecaptcha_cfg.clients${keys}`;
}
}
});
return data;
});
}
findRecaptchaClients();
```
In der Ausgabe ist `sitekey` der `websiteKey`, `pageurl` die `websiteURL` und `version` zeigt, ob es v2 oder v3 ist. `function` und `callback` bezeichnen die Callback-Funktion:
```json
[
{
"id": "0",
"version": "V2",
"sitekey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
"function": "onSuccess",
"callback": "___grecaptcha_cfg.clients['0']['l']['l']['callback']",
"pageurl": "https://www.google.com/recaptcha/api2/demo"
}
]
```
Ein leeres Array bedeutet, dass reCAPTCHA auf der Seite noch nicht geladen ist. Führen Sie das Skript erneut aus, sobald das Captcha erscheint.
## websiteKey und websiteURL
Suchen Sie im Network-Bereich nach `anchor` und suchen Sie eine Anfrage wie diese:
```text
https://www.google.com/recaptcha/api2/anchor?ar=1&k=6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9&co=...&hl=en&size=normal
```
- Der Wert nach `k=` ist der `websiteKey`.
- Als `websiteURL` tragen Sie die vollständige Adresse der Seite ein, auf der das Captcha erscheint (in der Regel der `Referer` dieser Anfrage).
Sie können auch im Quelltext der Seite nach `data-sitekey` suchen.
## pageAction (v3)
`pageAction` ist die `action`, die die Seite bei `grecaptcha.execute(Website-Schlüssel, {action: '...'})` übergibt. Der Wert muss mit dem der Seite übereinstimmen.
**Methode 1: Quelltext durchsuchen.** Klicken Sie im Bereich Sources der Entwicklertools mit der rechten Maustaste und wählen Sie „Search in all files“. Suchen Sie bei normalem v3 nach `.execute(`, bei v3 Enterprise nach `.enterprise.execute`, und sehen Sie sich die darauf folgende `action` an:
```js
grecaptcha.ready(function () {
grecaptcha.execute('6LdpS-gUAAAAAL3Qr2yP7rkrQjkKBVvEY_48JS5l', { action: 'login' }).then(function (token) {
// ...
});
});
```
Hier ist `pageAction` also `login`.
**Methode 2: Haltepunkt.** Ist der Code verschleiert und die Suche findet nichts, führen Sie in der Konsole `debug(grecaptcha.execute)` aus (bei Enterprise `debug(grecaptcha.enterprise.execute)`) und lösen Sie dann auf der Seite eine Aktion aus, die die Prüfung startet (zum Beispiel Klick auf „Anmelden“). Wenn der Debugger am Haltepunkt stoppt, lesen Sie den Wert von `action` rechts im Bereich Scope ab.
Eine Website kann in verschiedenen Schritten unterschiedliche `action`\-Werte verwenden (zum Beispiel bei der Registrierung zuerst `signup/submit_email`, dann `signup/success`). Verwenden Sie den Wert des Schritts, den Sie bestehen müssen. Mit F8 setzen Sie die Ausführung fort und sehen die nächste `action`.
## Callback-Funktion
Wenn Sie den Token mit Selenium oder ähnlichen Tools im Browser eintragen, rufen Sie danach die Callback-Funktion der Seite auf, um ihr mitzuteilen, dass die Prüfung abgeschlossen ist:
- Suchen Sie im Bereich Elements nach `data-callback`. Der Wert ist der Name der Callback-Funktion, zum Beispiel `data-callback="onSuccess"`.
- Oder suchen Sie nach `grecaptcha.render` und sehen Sie sich den Parameter `callback` an.
- Oder prüfen Sie in der Konsole `___grecaptcha_cfg.clients` oder verwenden Sie das oben beschriebene Skript.
So rufen Sie sie auf:
```python
driver.execute_script("onSuccess(arguments[0])", g_recaptcha_response)
```
Manche Seiten haben keine Callback-Funktion. Tragen Sie dann den Token in das Textfeld `g-recaptcha-response` ein und senden Sie das Formular direkt ab. Den vollständigen Ablauf finden Sie unter [reCAPTCHA mit einem Token abschließen](https://docs.yescaptcha.com/de/guides/submit-recaptcha-token.md).
---
# hCaptcha-Parameter finden
> So finden Sie den websiteKey (sitekey), die websiteURL und bei der Enterprise-Variante den rqdata von hCaptcha: Suchen Sie im Seitenquelltext nach data-sitekey oder im Network-Tab nach den Requests checksiteconfig und getcaptcha.
Source: https://docs.yescaptcha.com/de/guides/find-hcaptcha-parameters/ · 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/find-hcaptcha-parameters/
Für eine [hCaptcha](https://docs.yescaptcha.com/de/tasks/hcaptcha.md)\-Aufgabe benötigen Sie `websiteURL` (die Adresse der Seite, auf der das Captcha erscheint) und `websiteKey` (der Website-Schlüssel im UUID-Format); bei der Enterprise-Variante wird manchmal zusätzlich `rqdata` benötigt. Alle Werte finden Sie in den Entwicklertools des Browsers (F12).
## websiteKey
**Methode 1: Seitenquelltext durchsuchen.** Drücken Sie im Elements-Panel Strg+F (auf dem Mac Cmd+F) und suchen Sie nach `data-sitekey`:
```html
```
Der Wert von `data-sitekey` ist der `websiteKey`.
**Methode 2: Netzwerk-Requests prüfen.** Suchen Sie im Network-Panel nach `hcaptcha` und öffnen Sie den Request `checksiteconfig`. Der Wert nach `sitekey=` in der Adresse ist der `websiteKey`:
```text
https://api.hcaptcha.com/checksiteconfig?v=...&host=example.com&sitekey=51829642-2cda-4b09-896c-594f89d700cc&sc=1&swa=1
```
## websiteURL
Tragen Sie die vollständige Adresse der Seite ein, auf der das Captcha erscheint, **nicht** `hcaptcha.com`. Das `host=` im obigen Request ist die Domain dieser Seite.
## rqdata (Enterprise-Variante)
Manche Websites nutzen hCaptcha Enterprise und liefern bei jedem Laden des Captchas einen `rqdata`\-Wert aus; ohne ihn wird das Captcha nicht bestanden. Er steht meist in der Antwort einer eigenen API der Website (zum Beispiel `captcha_rqdata` in der Antwort des Login-Requests) oder wird beim Aufruf von `hcaptcha.render` / `hcaptcha.setData` übergeben. Tragen Sie ihn in das Feld `rqdata` der Aufgabe ein. `rqdata` kann in der Regel nur einmal verwendet werden, holen Sie daher jedes Mal einen neuen Wert.
## userAgent
Für `userAgent` dürfen Sie nur den Wert verwenden, den [/useragent](https://docs.yescaptcha.com/de/api/useragent.md) zurückgibt. Beim Absenden des Tokens verwenden Sie den `userAgent` aus dem Erkennungsergebnis.
---
# Turnstile-Parameter finden
> So finden Sie den websiteKey (sitekey, beginnt mit 0x) und die websiteURL von Cloudflare Turnstile: Suchen Sie im Seitenquelltext nach data-sitekey oder turnstile.render, oder prüfen Sie im Network-Panel die Requests an challenges.cloudflare.com.
Source: https://docs.yescaptcha.com/de/guides/find-turnstile-parameters/ · Last verified: 2026-10-21
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/guides/find-turnstile-parameters/
Für eine [Turnstile](https://docs.yescaptcha.com/de/tasks/turnstile.md)\-Aufgabe benötigen Sie `websiteURL` (die Adresse der Seite, auf der das Captcha erscheint) und `websiteKey` (den Website-Schlüssel, meist mit `0x` am Anfang). Prüfen Sie zuerst, ob es sich um Turnstile und nicht um die Cloudflare-Prüfseite handelt, siehe [Captcha-Typ bestimmen](https://docs.yescaptcha.com/de/guides/identify-captcha.md).
## websiteKey
**Methode 1: Seitenquelltext durchsuchen.** Suchen Sie in den Entwicklertools (F12) im Elements-Panel nach `data-sitekey`:
```html
```
**Methode 2: Skripte durchsuchen.** Wird das Captcha per JavaScript gerendert, klicken Sie im Sources-Panel mit der rechten Maustaste auf „Search in all files“ und suchen nach `turnstile.render`. Den `sitekey` finden Sie in den Parametern:
```js
turnstile.render('#container', { sitekey: '0x4AAAAAAAxxxxxxxxxxxxxx', callback: onDone });
```
**Methode 3: Netzwerkanfragen prüfen.** Suchen Sie im Network-Panel nach `challenges.cloudflare.com`. Die Adresse des Captcha-iframes enthält den Website-Schlüssel, der mit `0x` beginnt.
## websiteURL
Tragen Sie die vollständige Adresse der Seite ein, auf der das Captcha erscheint, zum Beispiel `https://example.com/login`.
## action und cData (meist nicht nötig)
In den meisten Fällen sind sie nicht nötig. Suchen Sie sie nur, wenn `websiteKey` und `websiteURL` sicher stimmen und die Aufgabe trotzdem scheitert: Prüfen Sie ebenfalls in den Parametern von `turnstile.render` oder am Captcha-Element, ob `action` und `cData` vorhanden sind (am Element heißen sie `data-action` und `data-cdata`):
```js
turnstile.render('#container', { sitekey: '0x4AAAAAAAxxxxxxxxxxxxxx', action: 'login', cData: 'c0bd4b36-7419-4e18-83c6-378699f2a9a2' });
```
Sind sie vorhanden, übergeben Sie beim Erstellen der Aufgabe `action` als `pageAction` und `cData` als `data`, siehe [Turnstile](https://docs.yescaptcha.com/de/tasks/turnstile.md).
## Token übermitteln
Tragen Sie nach der Erkennung das `token` in das versteckte Formularfeld `cf-turnstile-response` ein (bei Seiten, die `turnstile.render` mit einem `callback` verwenden, rufen Sie diese Callback-Funktion mit dem Token auf) und senden Sie das Formular ab. Verwenden Sie für die Anfrage das `userAgent` aus dem Ergebnis als User-Agent.
---
# 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).
---
# reCAPTCHA-v2-Bilderkennung: Klicks simulieren mit Selenium
> Mit Python, Selenium 4 und ReCaptchaV2Classification reCAPTCHA-v2-Bildaufgaben im Browser automatisch anklicken: Captcha auslösen, Frage und Bild auslesen, Erkennungs-API aufrufen, Felder anklicken, absenden; vollständiger Beispielcode.
Source: https://docs.yescaptcha.com/de/guides/recaptcha-click-selenium/ · 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/recaptcha-click-selenium/
Diese Anleitung öffnet mit Selenium 4 die reCAPTCHA-Demoseite von Google und löst die Bildaufgabe in einem echten Browser: Sie liest Frage und Bild aus, lässt von der [reCAPTCHA-v2-Bilderkennung](https://docs.yescaptcha.com/de/tasks/recaptcha-classification.md) (`ReCaptchaV2Classification`) bestimmen, welche Felder anzuklicken sind, und klickt diese an. Anders als beim Abruf eines Tokens wird die Prüfung im Browser selbst abgeschlossen. Das eignet sich für Websites, auf denen Tokens selten akzeptiert werden.
Wenn Sie keinen Code schreiben möchten, nutzen Sie direkt die [Browser-Erweiterung](https://docs.yescaptcha.com/de/extension.md). Sie klickt automatisch über dieselbe API.
## Vorbereitung
```bash
pip install requests selenium pillow
export YESCAPTCHA_CLIENT_KEY=your_client_key
```
Chrome muss installiert sein. Selenium 4 lädt den passenden chromedriver automatisch herunter.
## Ablauf
1. **Kontrollkästchen anklicken.** Es befindet sich im iframe mit `title="reCAPTCHA"`. Wechseln Sie zuerst in dieses iframe und klicken Sie `#recaptcha-anchor` an.
2. **In das iframe der Aufgabe wechseln.** Die Aufgabe liegt in einem anderen iframe (title enthält “challenge”).
3. **Frage auslesen.** Der fett gesetzte Text in `.rc-imageselect-desc-wrapper strong` ist das gesuchte Ziel, zum Beispiel “traffic lights”. Die API erwartet die Fragen-ID. Wandeln Sie den Namen mithilfe der Zuordnungstabelle in eine ID um (`/m/015qff`), siehe [Fragen-IDs](https://docs.yescaptcha.com/de/tasks/recaptcha-classification.md). Für den Abgleich ist die englische Browseroberfläche am bequemsten.
4. **Bild abrufen.** Die Bilder in den Feldern sind in Wirklichkeit Ausschnitte eines einzigen großen Bildes. Laden Sie das `src` von `td.rc-imageselect-tile img` herunter. Skalieren Sie 9 Felder (3x3) auf 300×300 und 16 Felder (4x4) auf 450×450 und wandeln Sie das Bild in Base64 um.
5. **Erkennen.** Rufen Sie `createTask` mit dem Typ `ReCaptchaV2Classification` auf und übergeben Sie `image` und `question`. Mit `"confidence": 0.5` liefert die API bei 3x3-Bildern alle passenden Felder auf einmal zurück, sodass Sie die nach dem Klick neu eingeblendeten kleinen Bilder nicht mehr verarbeiten müssen.
6. **Klicken.** `objects` enthält die Feldnummern, beginnend bei 0, von links nach rechts und von oben nach unten. Klicken Sie die entsprechenden `td`\-Elemente nacheinander an.
7. **Prüfen.** Klicken Sie `#recaptcha-verify-button` an. Erscheint eine neue Runde, gehen Sie zurück zu Schritt 3. Schließt sich das Aufgabenfenster, ist die Prüfung bestanden.
8. **Formular absenden.** Kehren Sie zur Hauptseite zurück und klicken Sie auf die Schaltfläche zum Absenden.
## Vollständiger Code
recaptcha_click_selenium.py
```python
"""Click through a reCAPTCHA v2 image challenge with Selenium 4 and ReCaptchaV2Classification.
Flow: open the page -> click the checkbox -> read the target name and the grid image ->
ask YesCaptcha which tiles to click -> click them -> press Verify. Repeat if a new challenge appears.
Run: pip install requests selenium pillow
export YESCAPTCHA_CLIENT_KEY=your_client_key
python recaptcha_click_selenium.py
Each recognized image is charged (see the price list). reCAPTCHA's page structure can change;
adjust the selectors below if a step stops working.
"""
import base64
import io
import os
import time
import requests
from PIL import Image
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
PAGE_URL = "https://www.google.com/recaptcha/api2/demo"
# Target names shown in the challenge (English UI) -> question IDs.
# Full list: https://docs.yescaptcha.com/en/tasks/recaptcha-classification/
QUESTION_IDS = {
"taxis": "/m/0pg52", "bus": "/m/01bjv", "buses": "/m/01bjv", "motorcycles": "/m/04_sv",
"tractors": "/m/013xlm", "chimneys": "/m/01jk_4", "crosswalks": "/m/014xcs",
"traffic lights": "/m/015qff", "bicycles": "/m/0199g", "parking meters": "/m/015qbp",
"cars": "/m/0k4j", "bridges": "/m/015kr", "boats": "/m/019jd", "palm trees": "/m/0cdl1",
"mountains or hills": "/m/09d_r", "fire hydrants": "/m/01pns0", "a fire hydrant": "/m/01pns0",
"stairs": "/m/01lynh",
}
def classify(image_b64, question):
task = {"type": "ReCaptchaV2Classification", "image": image_b64, "question": question, "confidence": 0.5}
data = requests.post(
"https://api.yescaptcha.com/createTask",
json={"clientKey": CLIENT_KEY, "task": task},
timeout=30,
).json()
if data.get("errorId"):
raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
return data["solution"] # synchronous: the solution comes back right away
def grid_image_b64(url, size):
"""Download the challenge image and scale it to the standard size (300 for 3x3, 450 for 4x4)."""
img = Image.open(io.BytesIO(requests.get(url, timeout=30).content)).convert("RGB")
img = img.resize((size, size))
buf = io.BytesIO()
img.save(buf, format="JPEG")
return base64.b64encode(buf.getvalue()).decode()
driver = webdriver.Chrome()
wait = WebDriverWait(driver, 15)
try:
driver.get(PAGE_URL)
# 1. Click the checkbox (inside the "reCAPTCHA" iframe)
wait.until(EC.frame_to_be_available_and_switch_to_it((By.CSS_SELECTOR, 'iframe[title="reCAPTCHA"]')))
wait.until(EC.element_to_be_clickable((By.ID, "recaptcha-anchor"))).click()
driver.switch_to.default_content()
# 2. Switch to the challenge iframe and solve rounds until it closes
wait.until(EC.frame_to_be_available_and_switch_to_it(
(By.XPATH, '//iframe[contains(@title, "challenge")]')))
for _ in range(5):
target = wait.until(EC.presence_of_element_located(
(By.CSS_SELECTOR, ".rc-imageselect-desc-wrapper strong"))).text.strip().lower()
question = QUESTION_IDS.get(target)
if not question:
print("unsupported target, reloading:", target)
driver.find_element(By.ID, "recaptcha-reload-button").click()
time.sleep(2)
continue
tiles = driver.find_elements(By.CSS_SELECTOR, "td.rc-imageselect-tile")
size = 450 if len(tiles) == 16 else 300
url = driver.find_element(By.CSS_SELECTOR, "td.rc-imageselect-tile img").get_attribute("src")
solution = classify(grid_image_b64(url, size), question)
for index in solution.get("objects", []):
tiles[index].click()
time.sleep(0.3)
time.sleep(1)
driver.find_element(By.ID, "recaptcha-verify-button").click()
time.sleep(3)
driver.switch_to.default_content()
frame = driver.find_element(By.XPATH, '//iframe[contains(@title, "challenge")]')
if not frame.is_displayed(): # challenge closed: passed
break
driver.switch_to.frame(frame)
driver.switch_to.default_content()
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()
```
## Hinweise
- Die Seitenstruktur von reCAPTCHA ändert sich von Zeit zu Zeit. Wenn die Selektoren im Code nicht mehr funktionieren, passen Sie sie an die tatsächliche Seite an.
- Jede Erkennung eines Bildes verursacht einen Punkteabzug (Preise siehe [reCAPTCHA-v2-Bilderkennung](https://docs.yescaptcha.com/de/tasks/recaptcha-classification.md)). Aufgaben, deren Verifizierung nach dem Klicken fehlgeschlagen ist, können Sie innerhalb von 1 Stunde [melden](https://docs.yescaptcha.com/de/api/report.md), um eine Erstattung nach Meldung zu beantragen.
- Wenn eine Frage nicht in der Zuordnungstabelle enthalten ist, klicken Sie auf die Schaltfläche zum Neuladen, um eine andere Aufgabe zu erhalten, oder bitten Sie den Support, sie zu ergänzen.
---
# hCaptcha-Bilderkennung per Klick-Simulation (Selenium)
> Mit Python, Selenium 4 und HCaptchaClassification hCaptcha-Aufgaben mit 3×3-Raster im Browser automatisch lösen: Kontrollkästchen anklicken, Frage und 9 Bilder auslesen, die Erkennungs-API aufrufen, klicken und absenden – mit vollständigem Beispielcode.
Source: https://docs.yescaptcha.com/de/guides/hcaptcha-click-selenium/ · 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/hcaptcha-click-selenium/
Diese Anleitung öffnet die Demoseite von hCaptcha mit Selenium 4 und löst die Aufgabe mit dem 3×3-Raster in einem echten Browser: Sie liest die Frage und die 9 Bilder aus, lässt per [hCaptcha-Bilderkennung](https://docs.yescaptcha.com/de/tasks/hcaptcha-classification.md) (`HCaptchaClassification`) bestimmen, welche Felder Treffer sind, und klickt diese an.
hCaptcha kennt außerdem Aufgaben wie „Klicken Sie auf eine bestimmte Stelle“ oder „Ziehen“. Sie liefern Koordinaten statt Rasterfelder; die Vorgehensweise steht unter [hCaptcha-Bilderkennung](https://docs.yescaptcha.com/de/tasks/hcaptcha-classification.md). Wenn Sie keinen Code schreiben möchten, nutzen Sie direkt die [Browser-Erweiterung](https://docs.yescaptcha.com/de/extension.md); sie unterstützt alle diese Aufgabentypen.
## Vorbereitung
```bash
pip install requests selenium
export YESCAPTCHA_CLIENT_KEY=your_client_key
```
## Ablauf
1. **Kontrollkästchen anklicken.** Es befindet sich im hCaptcha-iframe, dessen Adresse `frame=checkbox` enthält. Wechseln Sie in das iframe und klicken Sie `#checkbox` an.
2. **Zum iframe der Aufgabe wechseln.** Die Aufgabe liegt in dem iframe, dessen Adresse `frame=challenge` enthält.
3. **Frage auslesen.** Der Text von `.prompt-text` ist die Frage; übergeben Sie ihn unverändert an die API (es empfiehlt sich, die Oberfläche von hCaptcha auf Englisch oder vereinfachtes Chinesisch umzustellen). Wenn neben der Frage ein kleines Beispielbild angezeigt wird, übergeben Sie es ebenfalls in `anchors`.
4. **Bilder abrufen.** Das Hintergrundbild von `.task-image .image` jedes Feldes ist ein Einzelbild. Laden Sie die Bilder der Reihe nach herunter, wandeln Sie sie in Base64 um und bilden Sie daraus die Liste `queries`.
5. **Erkennen.** Rufen Sie `createTask` mit dem Typ `HCaptchaClassification` auf. Die zurückgegebenen `objects` entsprechen den Feldern eins zu eins; `true` bedeutet Treffer.
6. **Klicken und absenden.** Klicken Sie die Treffer-Felder an und dann auf die Schaltfläche zum Absenden. Es können mehrere Runden nacheinander folgen; wiederholen Sie dann die Schritte 3 bis 6.
7. **Fertig.** Nach bestandener Prüfung steht das Token im Feld `h-captcha-response` auf der Seite; senden Sie es zusammen mit dem Formular ab.
## Vollständiger Code
hcaptcha_click_selenium.py
```python
"""Click through an hCaptcha 3x3 image challenge with Selenium 4 and HCaptchaClassification.
Flow: open the page -> click the checkbox -> read the question and the 9 images ->
ask YesCaptcha which images match -> click them -> submit. Repeat while new rounds appear.
Run: pip install requests selenium
export YESCAPTCHA_CLIENT_KEY=your_client_key
python hcaptcha_click_selenium.py
Each recognized round is charged (see the price list; rounds with no target found are free).
hCaptcha changes its page structure often; adjust the selectors below if a step stops working.
Click and drag questions return coordinates instead; see the HCaptchaClassification page.
"""
import base64
import os
import re
import time
import requests
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
PAGE_URL = "https://accounts.hcaptcha.com/demo"
def classify(question, images_b64):
task = {"type": "HCaptchaClassification", "question": question, "queries": images_b64}
data = requests.post(
"https://api.yescaptcha.com/createTask",
json={"clientKey": CLIENT_KEY, "task": task},
timeout=60,
).json()
if data.get("errorId"):
raise RuntimeError(f"{data.get('errorCode')}: {data.get('errorDescription')}")
return data["solution"] # synchronous
def background_image_b64(element):
"""The tiles are s with a CSS background image; download it and Base64-encode it."""
style = element.get_attribute("style") or ""
match = re.search(r'url\("?(.*?)"?\)', style)
if not match:
return None
return base64.b64encode(requests.get(match.group(1), timeout=30).content).decode()
driver = webdriver.Chrome()
wait = WebDriverWait(driver, 15)
try:
driver.get(PAGE_URL)
# 1. Click the checkbox (inside the first hCaptcha iframe)
wait.until(EC.frame_to_be_available_and_switch_to_it(
(By.CSS_SELECTOR, 'iframe[src*="hcaptcha"][src*="frame=checkbox"]')))
wait.until(EC.element_to_be_clickable((By.ID, "checkbox"))).click()
driver.switch_to.default_content()
# 2. Solve rounds in the challenge iframe
wait.until(EC.frame_to_be_available_and_switch_to_it(
(By.CSS_SELECTOR, 'iframe[src*="hcaptcha"][src*="frame=challenge"]')))
for _ in range(5):
question = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, ".prompt-text"))).text.strip()
tiles = driver.find_elements(By.CSS_SELECTOR, ".task-image")
images = [background_image_b64(t.find_element(By.CSS_SELECTOR, ".image")) for t in tiles]
if not tiles or None in images:
print("not a 3x3 image challenge; see the docs for click/drag questions")
break
solution = classify(question, images)
for tile, hit in zip(tiles, solution.get("objects", [])):
if hit:
tile.click()
time.sleep(0.3)
driver.find_element(By.CSS_SELECTOR, ".button-submit").click()
time.sleep(3)
if not driver.find_elements(By.CSS_SELECTOR, ".task-image"):
break
driver.switch_to.default_content()
token = driver.find_element(By.NAME, "h-captcha-response").get_attribute("value")
print("token received" if token else "not passed")
finally:
driver.quit()
```
## Hinweise
- Die Seitenstruktur von hCaptcha ändert sich häufig. Wenn die Selektoren im Code nicht mehr funktionieren, passen Sie sie an die tatsächliche Seite an.
- Jede Erkennungsrunde verursacht einen Punkteabzug; wird kein Treffer erkannt, werden keine Punkte abgezogen. Wurde die Prüfung nach dem Klicken abgelehnt, können Sie dies innerhalb von 1 Stunde [melden](https://docs.yescaptcha.com/de/api/report.md) und eine Erstattung nach Meldung beantragen.
- Wenn bei einer neuen Frage `ERROR_UNKNOWN_QUESTION` zurückgegeben wird, laden Sie die Seite neu, um eine andere Aufgabe zu erhalten, oder wenden Sie sich an den Support.
---
# Codebeispiele und SDKs
> Lauffähige YesCaptcha-Codebeispiele (Python, Node.js, curl, C#, Easy Language) und inoffizielle Community-SDKs (Python, Node.js, Go).
Source: https://docs.yescaptcha.com/de/samples/ · 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/samples/
Die Beispiele hier sind vollständige, direkt lauffähige Dateien. Sie lesen den ClientKey aus der Umgebungsvariable `YESCAPTCHA_CLIENT_KEY`. Auf den Seiten der einzelnen Aufgabentypen finden Sie außerdem curl-, Python- und Node.js-Beispiele, die für den jeweiligen Typ erzeugt wurden.
[Python](https://docs.yescaptcha.com/de/samples/python.md)Guthaben abfragen, erste Anfrage, wiederverwendbarer Client, Steuerung gleichzeitiger Aufgaben, Selenium
[Node.js](https://docs.yescaptcha.com/de/samples/nodejs.md)Node.js 18+, keine Drittanbieter-Bibliotheken nötig
[C#](https://docs.yescaptcha.com/de/samples/csharp.md).NET 6+
[Easy Language](https://docs.yescaptcha.com/de/samples/easy-language.md)Klick-Beispiele, die von Nutzern beigesteuert wurden
Zum Testen nur über die Kommandozeile: curl-Beispiele finden Sie in der [Schnellstart](https://docs.yescaptcha.com/de/getting-started/quickstart.md)\-Anleitung und unter [getBalance](https://docs.yescaptcha.com/de/api/get-balance.md).
## Community-SDKs
Die folgenden SDKs wurden von Nutzern beigesteuert und sind **inoffiziell**. Wir haben den Code nicht geprüft. Bewerten Sie sie bitte vor der Verwendung selbst und wenden Sie sich bei Problemen an die Autoren:
| Sprache | Projekt |
| --- | --- |
| Python | [github.com/yescaptcha/yescaptcha-python](https://github.com/yescaptcha/yescaptcha-python) |
| Node.js | [github.com/ScoLib/yescaptcha](https://github.com/ScoLib/yescaptcha) |
| Go | [github.com/FreedWu/yescaptcha](https://github.com/FreedWu/yescaptcha) |
| Go | [github.com/deanxv/yescaptcha-go](https://github.com/deanxv/yescaptcha-go) |
Prüfen Sie bei jedem SDK, ob es den Endpoint `api.yescaptcha.com` oder `cn.yescaptcha.com` verwendet und die Aufgabentypen genauso benennt wie diese Website.
---
# Python
> YesCaptcha Python-Beispiele: Guthaben abfragen, Bild-Captcha lösen, wiederverwendbare Client-Klasse (Aufgabe erstellen, alle 5 Sekunden abfragen), Steuerung gleichzeitiger Aufgaben mit asyncio sowie reCAPTCHA-Übermittlung mit requests und Selenium.
Source: https://docs.yescaptcha.com/de/samples/python/ · 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/samples/python/
Voraussetzungen: Python 3.8 oder höher und `pip install requests`. Setzen Sie vor dem Start die Umgebungsvariable:
```bash
export YESCAPTCHA_CLIENT_KEY=your_client_key
```
## Guthaben abfragen
Kostenlos; damit prüfen Sie, ob der ClientKey korrekt ist:
get_balance.py
```python
"""Check the balance. getBalance is free and is a quick way to verify your clientKey."""
import os
import requests
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
r = requests.post(
"https://api.yescaptcha.com/getBalance",
json={"clientKey": CLIENT_KEY},
timeout=30,
)
data = r.json()
if data.get("errorId"):
# e.g. ERROR_KEY_DOES_NOT_EXIST when the clientKey is wrong
print("error:", data.get("errorCode"), data.get("errorDescription"))
else:
print("balance (points):", data["balance"])
```
## Ein Bild-Captcha lösen
Der synchrone Aufgabentyp `ImageToTextTaskOcrBase` liefert das Ergebnis mit einer einzigen Anfrage. Beispielbild: [captcha.jpg](https://docs.yescaptcha.com/samples/captcha.jpg).
quickstart.py
```python
"""First request: read an alphanumeric image captcha with ImageToTextTaskOcrBase
(synchronous, 2 points per image).
Usage:
export YESCAPTCHA_CLIENT_KEY=your_client_key
python quickstart.py captcha.png
"""
import base64
import os
import sys
import requests
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
image_path = sys.argv[1] if len(sys.argv) > 1 else "captcha.png"
with open(image_path, "rb") as f:
body = base64.b64encode(f.read()).decode() # no "data:" prefix
r = requests.post(
"https://api.yescaptcha.com/createTask",
json={
"clientKey": CLIENT_KEY,
"task": {"type": "ImageToTextTaskOcrBase", "body": body},
},
timeout=30,
)
data = r.json()
if data.get("errorId"):
raise SystemExit(f"{data.get('errorCode')}: {data.get('errorDescription')}")
print("text:", data["solution"]["text"])
```
## Ein wiederverwendbarer Client
Kopieren Sie die folgende Datei in Ihr Projekt; sie funktioniert für synchrone und asynchrone Aufgabentypen:
yescaptcha.py
```python
"""A small client you can copy into your project: create tasks, poll results, check the balance.
from yescaptcha import YesCaptcha
client = YesCaptcha(os.environ["YESCAPTCHA_CLIENT_KEY"])
solution = client.solve({
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
})
print(solution["gRecaptchaResponse"])
"""
import os
import time
import requests
class YesCaptchaError(Exception):
def __init__(self, code, description):
super().__init__(f"{code}: {description}")
self.code = code
self.description = description
class YesCaptcha:
def __init__(self, client_key, endpoint="https://api.yescaptcha.com", poll_interval=5, timeout=180):
self.client_key = client_key
self.endpoint = endpoint.rstrip("/")
self.poll_interval = poll_interval # 5 s: polling the same taskId more often only returns "processing"
self.timeout = timeout
self.session = requests.Session()
def call(self, method, payload=None):
body = {"clientKey": self.client_key, **(payload or {})}
data = self.session.post(f"{self.endpoint}/{method}", json=body, timeout=30).json()
if data.get("errorId"):
raise YesCaptchaError(data.get("errorCode"), data.get("errorDescription"))
return data
def balance(self):
return self.call("getBalance")["balance"]
def solve(self, task):
created = self.call("createTask", {"task": task})
if created.get("status") == "ready": # synchronous types return the solution directly
return created["solution"]
task_id = created["taskId"]
deadline = time.time() + self.timeout
while time.time() < deadline:
time.sleep(self.poll_interval)
result = self.call("getTaskResult", {"taskId": task_id})
if result.get("status") == "ready":
return result["solution"]
raise TimeoutError(f"task {task_id} not ready after {self.timeout}s")
if __name__ == "__main__":
client = YesCaptcha(os.environ["YESCAPTCHA_CLIENT_KEY"])
print("balance:", client.balance())
```
```python
from yescaptcha import YesCaptcha
client = YesCaptcha(os.environ["YESCAPTCHA_CLIENT_KEY"])
solution = client.solve({
"type": "HCaptchaTaskProxyless",
"websiteURL": "https://accounts.hcaptcha.com/demo",
"websiteKey": "a5f74b19-9e45-40e0-b45d-47ff91b7a6c2",
})
print(solution["gRecaptchaResponse"])
```
Bei Fehlern wird `YesCaptchaError` ausgelöst; `e.code` ist der Fehlercode (Bedeutung siehe [Fehlercodes](https://docs.yescaptcha.com/de/api/errors.md)).
## Gleichzeitige Aufgaben steuern
Begrenzen Sie beim Senden von Aufgaben im Stapel die Anzahl der gleichzeitig in Bearbeitung befindlichen Anfragen und warten Sie bei `ERROR_THREADS_MAXIMUM` kurz, bevor Sie es erneut versuchen (erfordert `pip install aiohttp`). Erläuterungen finden Sie unter [Limit gleichzeitiger Aufgaben und automatische Pausierung](https://docs.yescaptcha.com/de/api/rate-limits.md):
concurrency.py
```python
"""Limit concurrency: keep the number of requests waiting for a result below your limit, and back off
on ERROR_THREADS_MAXIMUM (rejected requests are not charged). Requires: pip install aiohttp"""
import asyncio
import os
import aiohttp
CLIENT_KEY = os.environ["YESCAPTCHA_CLIENT_KEY"]
LIMIT = 15 # below your concurrency limit
sem = asyncio.Semaphore(LIMIT)
async def solve(session, task):
async with sem: # at most LIMIT requests in progress at a time
result = {}
for attempt in range(5):
async with session.post(
"https://api.yescaptcha.com/createTask",
json={"clientKey": CLIENT_KEY, "task": task},
) as resp:
result = await resp.json()
if result.get("errorCode") != "ERROR_THREADS_MAXIMUM":
return result
await asyncio.sleep(1 + attempt) # over the limit: wait and retry
return result
async def main(tasks):
async with aiohttp.ClientSession() as session:
return await asyncio.gather(*(solve(session, t) for t in tasks))
if __name__ == "__main__":
print(asyncio.run(main([])))
```
## reCAPTCHA-Token übermitteln
- Direkt mit requests übermitteln: siehe [reCAPTCHA mit einem Token abschließen](https://docs.yescaptcha.com/de/guides/submit-recaptcha-token.md)
- Im Browser mit Selenium eintragen: siehe [reCAPTCHA mit einem Token abschließen](https://docs.yescaptcha.com/de/guides/submit-recaptcha-token.md)
- Klicks auf Bildaufgaben mit Selenium simulieren: siehe [Klicksimulation für reCAPTCHA-v2-Bilderkennung](https://docs.yescaptcha.com/de/guides/recaptcha-click-selenium.md), [Klicksimulation für hCaptcha-Bilderkennung](https://docs.yescaptcha.com/de/guides/hcaptcha-click-selenium.md)
---
# Node.js
> YesCaptcha-Beispiele für Node.js (Node.js 18+ mit dem integrierten fetch, ohne Abhängigkeiten): Guthaben abfragen, ein Bild-Captcha erkennen und eine wiederverwendbare Client-Klasse (Aufgabe erstellen, alle 5 Sekunden abfragen).
Source: https://docs.yescaptcha.com/de/samples/nodejs/ · 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/samples/nodejs/
Voraussetzungen: Node.js 18 oder neuer (integriertes `fetch`). Die Beispiele sind ES-Module (`.mjs`) und benötigen keine Abhängigkeiten. Setzen Sie vor dem Start die Umgebungsvariable:
```bash
export YESCAPTCHA_CLIENT_KEY=your_client_key
```
## Guthaben abfragen
Kein Punkteabzug; damit prüfen Sie, ob der ClientKey korrekt ist:
get-balance.mjs
```js
// Check the balance. getBalance is free and is a quick way to verify your clientKey. Node.js 18+
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY;
const res = await fetch('https://api.yescaptcha.com/getBalance', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY }),
});
const data = await res.json();
if (data.errorId) {
// e.g. ERROR_KEY_DOES_NOT_EXIST when the clientKey is wrong
console.log('error:', data.errorCode, data.errorDescription);
} else {
console.log('balance (points):', data.balance);
}
```
## Ein Bild-Captcha erkennen
Der synchrone Typ `ImageToTextTaskOcrBase` liefert das Ergebnis in einer einzigen Anfrage. Beispielbild: [captcha.jpg](https://docs.yescaptcha.com/samples/captcha.jpg). Führen Sie `node quickstart.mjs captcha.jpg` aus.
quickstart.mjs
```js
// First request: read an alphanumeric image captcha with ImageToTextTaskOcrBase (synchronous, 2 points per image).
// Usage: YESCAPTCHA_CLIENT_KEY=your_client_key node quickstart.mjs captcha.png
import { readFileSync } from 'node:fs';
const CLIENT_KEY = process.env.YESCAPTCHA_CLIENT_KEY;
const body = readFileSync(process.argv[2] ?? 'captcha.png').toString('base64'); // no "data:" prefix
const res = await fetch('https://api.yescaptcha.com/createTask', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: CLIENT_KEY, task: { type: 'ImageToTextTaskOcrBase', body } }),
});
const data = await res.json();
if (data.errorId) throw new Error(`${data.errorCode}: ${data.errorDescription}`);
console.log('text:', data.solution.text);
```
## Ein wiederverwendbarer Client
yescaptcha.mjs
```js
// A small client you can copy into your project: create tasks, poll results, check the balance. Node.js 18+
//
// import { YesCaptcha } from './yescaptcha.mjs';
// const client = new YesCaptcha(process.env.YESCAPTCHA_CLIENT_KEY);
// const solution = await client.solve({ type: 'NoCaptchaTaskProxyless', websiteURL: '...', websiteKey: '...' });
export class YesCaptchaError extends Error {
constructor(code, description) {
super(`${code}: ${description}`);
this.code = code;
}
}
export class YesCaptcha {
constructor(clientKey, { endpoint = 'https://api.yescaptcha.com', pollInterval = 5000, timeout = 180000 } = {}) {
this.clientKey = clientKey;
this.endpoint = endpoint.replace(/\/$/, '');
this.pollInterval = pollInterval; // 5 s: polling the same taskId more often only returns "processing"
this.timeout = timeout;
}
async call(method, payload = {}) {
const res = await fetch(`${this.endpoint}/${method}`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ clientKey: this.clientKey, ...payload }),
});
const data = await res.json();
if (data.errorId) throw new YesCaptchaError(data.errorCode, data.errorDescription);
return data;
}
async balance() {
return (await this.call('getBalance')).balance;
}
async solve(task) {
const created = await this.call('createTask', { task });
if (created.status === 'ready') return created.solution; // synchronous types return the solution directly
const deadline = Date.now() + this.timeout;
while (Date.now() < deadline) {
await new Promise((r) => setTimeout(r, this.pollInterval));
const result = await this.call('getTaskResult', { taskId: created.taskId });
if (result.status === 'ready') return result.solution;
}
throw new Error(`task ${created.taskId} not ready after ${this.timeout} ms`);
}
}
if (import.meta.url === `file://${process.argv[1]}`) {
const client = new YesCaptcha(process.env.YESCAPTCHA_CLIENT_KEY);
console.log('balance:', await client.balance());
}
```
```js
import { YesCaptcha } from './yescaptcha.mjs';
const client = new YesCaptcha(process.env.YESCAPTCHA_CLIENT_KEY);
const solution = await client.solve({
type: 'TurnstileTaskProxyless',
websiteURL: 'https://example.com/login',
websiteKey: '0x4AAAAAAA_SITE_KEY',
});
console.log(solution.token);
```
Bei Fehlern wird `YesCaptchaError` ausgelöst; `err.code` ist der Fehlercode, seine Bedeutung finden Sie unter [Fehlercodes](https://docs.yescaptcha.com/de/api/errors.md).
---
# C#
> YesCaptcha C#-Beispiel (.NET 6+, HttpClient und System.Text.Json). Fragt das Guthaben ab, erstellt eine reCAPTCHA-v2-Aufgabe und fragt das Ergebnis alle 5 Sekunden ab.
Source: https://docs.yescaptcha.com/de/samples/csharp/ · 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/samples/csharp/
Voraussetzungen: .NET 6 oder höher, nur die Standardbibliothek (`HttpClient`, `System.Text.Json`).
```bash
dotnet new console -o YesCaptchaDemo
cd YesCaptchaDemo
# replace Program.cs with the code below
export YESCAPTCHA_CLIENT_KEY=your_client_key
dotnet run
```
Program.cs
```csharp
// YesCaptcha C# sample (.NET 6+): check the balance, then solve a reCAPTCHA v2.
// Run: dotnet new console -o YesCaptchaDemo, replace Program.cs with this file, set YESCAPTCHA_CLIENT_KEY, then dotnet run
using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Threading.Tasks;
class Program
{
const string Api = "https://api.yescaptcha.com";
static readonly HttpClient Http = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
static readonly string ClientKey = Environment.GetEnvironmentVariable("YESCAPTCHA_CLIENT_KEY") ?? "";
static async Task Call(string method, JsonObject payload)
{
payload["clientKey"] = ClientKey;
var res = await Http.PostAsJsonAsync($"{Api}/{method}", payload);
var data = JsonNode.Parse(await res.Content.ReadAsStringAsync())!;
if ((int?)data["errorId"] != 0)
throw new Exception($"{data["errorCode"]}: {data["errorDescription"]}");
return data;
}
static async Task Solve(JsonObject task)
{
var created = await Call("createTask", new JsonObject { ["task"] = task });
if ((string?)created["status"] == "ready") return created["solution"]!; // synchronous types
var taskId = (string)created["taskId"]!;
for (var i = 0; i < 36; i++) // poll every 5 seconds, for up to about 3 minutes
{
await Task.Delay(5000);
var result = await Call("getTaskResult", new JsonObject { ["taskId"] = taskId });
if ((string?)result["status"] == "ready") return result["solution"]!;
}
throw new TimeoutException(taskId);
}
static async Task Main()
{
var balance = await Call("getBalance", new JsonObject());
Console.WriteLine($"balance (points): {balance["balance"]}");
var solution = await Solve(new JsonObject
{
["type"] = "NoCaptchaTaskProxyless",
["websiteURL"] = "https://www.google.com/recaptcha/api2/demo",
["websiteKey"] = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
});
Console.WriteLine(solution["gRecaptchaResponse"]);
}
}
```
Für andere Aufgabentypen ändern Sie nur das Aufgabenobjekt in `Solve`; die Felder finden Sie auf den jeweiligen Seiten unter [Aufgabentypen](https://docs.yescaptcha.com/de/tasks.md). Synchrone Typen (bilderkennung, `ImageToTextTaskOcrBase`) liefern das Ergebnis direkt in `createTask` zurück; `Solve` behandelt das bereits.
---
# Easy Language (易语言)
> Von Nutzern bereitgestellte YesCaptcha-Beispiele in Easy Language (易语言): Klicksimulation für reCAPTCHA und hCaptcha, Bilderkennung für FunCaptcha, Übermittlung von reCAPTCHA-Tokens; Downloads und wichtige Hinweise zum Aufruf der API.
Source: https://docs.yescaptcha.com/de/samples/easy-language/ · 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/samples/easy-language/
Easy Language (易语言) ist eine chinesischsprachige Programmiersprache, die in China verbreitet ist. Die Beispiele stammen von Nutzern (南方填表, 松 u. a.) und dienen nur als Orientierung; wir haben sie nicht Zeile für Zeile geprüft. Sie enthalten:
- Klicksimulation für reCAPTCHA und hCaptcha (nach dem Start des Browsers wird automatisch erkannt und geklickt)
- Bilderkennung für FunCaptcha
- Übermittlung von reCAPTCHA-Tokens
> **Downloads:** Die Beispielpakete (das größte ist etwa 87 MB groß und enthält einen Browser) ziehen an eine neue Download-Adresse um. Bitte wenden Sie sich bis dahin an den [Support](https://docs.yescaptcha.com/de/help/contact.md), um sie zu erhalten.
## Wichtige Hinweise zum Aufruf der API mit Easy Language
Sie brauchen die Beispielpakete nicht: Mit dem Befehl für Webzugriffe (POST) in Easy Language können Sie die API direkt aufrufen:
1. URL `https://api.yescaptcha.com/createTask`, Methode `POST`, Header `Content-Type: application/json`.
2. Der Inhalt ist JSON-Text, zum Beispiel `{"clientKey":"YOUR_CLIENT_KEY","task":{"type":"ImageToTextTaskOcrBase","body":"BASE64_IMAGE"}}`.
3. Ist `errorId` in der JSON-Antwort 0, war die Anfrage erfolgreich. Bei asynchronen Typen entnehmen Sie `taskId` und senden alle 5 Sekunden `{"clientKey":"…","taskId":"…"}` an `https://api.yescaptcha.com/getTaskResult`, bis `status` den Wert `ready` hat.
4. Das Base64 des Bildes darf weder das Präfix `data:image/...;base64,` noch Zeilenumbrüche enthalten.
Format von Anfrage und Antwort: [Anfragen und Antworten](https://docs.yescaptcha.com/de/api/overview.md).
## Wenn ein Beispiel nicht läuft
- Meldung, dass der Browser nicht erstellt werden kann: Verwenden Sie den im Beispielpaket mitgelieferten Browser, deinstallieren Sie Browser, die möglicherweise in Konflikt stehen, oder kompilieren Sie das Programm und führen Sie es danach aus.
- Ein Fehlercode wird zurückgegeben: Prüfen Sie die Parameter anhand der [Fehlercodes](https://docs.yescaptcha.com/de/api/errors.md).
---
# Mehrere ClientKeys: Limit, IP-Whitelist und Ablaufdatum
> Ein YesCaptcha-Konto kann bis zu 20 ClientKeys haben, die alle vom selben Konto-Guthaben abbuchen. Jeder kann ein eigenes Ausgabenlimit (pro Tag, Woche oder Monat oder einmalig, Zurücksetzung nach Pekinger Zeit), eine IP-Whitelist und ein Ablaufdatum haben, wirksam innerhalb weniger Sekunden.
Source: https://docs.yescaptcha.com/de/account/client-keys/ · Last verified: 2026-10-29
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/account/client-keys/
Ein YesCaptcha-Konto kann bis zu 20 `clientKey` haben (einschließlich des ursprünglichen). Sie verwalten sie im [yescaptcha.com](https://yescaptcha.com/security)\-Dashboard auf der Seite „Schlüssel & Sicherheit“. Jeder `clientKey` kann Aufgaben erstellen und das Guthaben abfragen, und alle buchen vom selben Konto-Guthaben ab. Jeder kann ein eigenes Limit, eine eigene IP-Whitelist und ein eigenes Ablaufdatum haben; Änderungen wirken innerhalb weniger Sekunden.
Typische Einsatzfälle: getrennte Keys für Test- und Produktivumgebung oder für verschiedene Projekte; Keys an eigene Kunden oder Partner weitergeben, jeweils mit eigenem Limit; und wenn ein `clientKey` offengelegt wird, löschen Sie nur diesen, ohne andere Programme zu beeinträchtigen.
## Haupt-Key und Sub-Keys
| | Haupt-Key | Sub-Key |
| --- | --- | --- |
| Was es ist | Der ursprüngliche `clientKey`, einer pro Konto | Zusätzlich zum Haupt-Key angelegt, bis zu 19 |
| Limit, IP-Whitelist, Ablaufdatum | Können gesetzt werden | Können gesetzt werden |
| Zurücksetzen | Ja: der alte wird sofort ungültig, das Guthaben wechselt zum neuen | Nein; löschen und einen neuen anlegen |
| Löschen | Nein | Ja: wird innerhalb weniger Sekunden ungültig und lässt sich nicht wiederherstellen |
- Alle haben dasselbe Format: Die ersten 40 Zeichen sind der geheime Schlüssel, danach folgt Ihre Benutzer-ID.
- Das Zurücksetzen des Haupt-Keys betrifft die Sub-Keys nicht.
- Mit welchem `clientKey` Sie Aufgaben erstellen oder das Guthaben abfragen, die API und die Antworten sind gleich; es kommen nur die Prüfungen von Limit, IP-Whitelist und Ablaufdatum hinzu.
## ClientKey anlegen
1. Melden Sie sich bei [yescaptcha.com](https://yescaptcha.com/) an und öffnen Sie die Seite „Schlüssel & Sicherheit“ ([yescaptcha.com/security](https://yescaptcha.com/security)).
2. Klicken Sie unter „Alle Keys“ auf „Neuer Sub-Key“. Name (bis zu 40 Zeichen), Limit, IP-Whitelist und Ablaufdatum sind optional und können später geändert werden.
3. Bestätigen Sie Ihre Identität erneut, wenn Sie dazu aufgefordert werden. Anlegen, Ändern und Löschen erfordern dies jeweils.
4. Kopieren Sie den vollständigen `clientKey` und tragen Sie ihn in Ihr Programm ein. Sie können ihn später über das Augen-Symbol in der Liste erneut anzeigen.
> **Hinweis:** Anlegen, Ändern und Löschen wirken innerhalb weniger Sekunden. Ein Aufruf direkt nach dem Anlegen kann `ERROR_KEY_DOES_NOT_EXIST` zurückgeben; warten Sie einige Sekunden und versuchen Sie es erneut. In den ersten Sekunden nach dem Löschen oder Verschärfen von Einstellungen können bereits gesendete Anfragen noch mit den alten Einstellungen verarbeitet werden.
## Limit
Ein Limit begrenzt, wie viele Punkte ein `clientKey` pro Zeitraum höchstens ausgeben darf (1,000 Punkte = ¥1). Es kann zwischen 1 und 10,000,000,000 Punkten liegen. Es gibt vier Zeiträume, die nach Pekinger Zeit (UTC+8) zurückgesetzt werden:
| Zeitraum | Zurücksetzung |
| --- | --- |
| Pro Tag | Jeden Tag um 00:00 Uhr |
| Pro Woche | Jeden Montag um 00:00 Uhr |
| Pro Monat | Am 1. jedes Monats um 00:00 Uhr |
| Einmaliger Gesamtbetrag | Nie. Ist er aufgebraucht, kann dieser `clientKey` keine Aufgaben mehr erstellen; erhöhen Sie das Limit, um ihn weiter zu nutzen |
- Gezählt werden die tatsächlich abgezogenen Punkte: Punkte, die bei fehlgeschlagenen Aufgaben oder Zeitüberschreitung erstattet werden, werden auch dem Limit wieder gutgeschrieben.
- Reicht der Rest des Limits im aktuellen Zeitraum für den Punkteabzug einer Aufgabe nicht aus, gibt `createTask` [`ERROR_KEY_QUOTA_EXCEEDED`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_KEY_QUOTA_EXCEEDED) zurück. Es werden keine Punkte abgezogen, und es zählt nicht für die [automatische Pausierung](https://docs.yescaptcha.com/de/api/rate-limits.md).
- In der Liste im Dashboard sehen Sie, wie viel jeder `clientKey` im aktuellen Zeitraum verbraucht hat und wann er das nächste Mal zurückgesetzt wird.
- Ein Limit ist kein eigenes Guthaben: Alle `clientKey` buchen vom selben Konto-Guthaben ab, und ist das Konto-Guthaben aufgebraucht, erhalten Sie wie gewohnt `ERROR_ZERO_BALANCE`.
Wenn Sie [`getBalance`](https://docs.yescaptcha.com/de/api/get-balance.md) mit einem `clientKey` aufrufen, für den ein Limit gesetzt ist, ist `balance` der kleinere Wert aus Konto-Guthaben und Rest-Limit des aktuellen Zeitraums, und es gibt zusätzlich das Feld `keyQuotaRemaining` (verbleibendes Limit, in Punkten). Ein `clientKey` ohne Limit enthält dieses Feld nicht, die Antwort bleibt wie bisher.
```json
{
"errorId": 0,
"balance": 20000,
"softBalance": 0,
"inviteBalance": 0,
"inviteBy": 0,
"keyQuotaRemaining": 20000
}
```
## IP-Whitelist
Ein `clientKey` mit IP-Whitelist funktioniert nur für Anfragen, die von den IPs in der Liste gesendet werden. Leer bedeutet keine Einschränkung.
- Tragen Sie die **öffentliche IP des Rechners ein, der die YesCaptcha-API aufruft** (die ausgehende IP), nicht den Proxy aus den Aufgabenparametern. Wenn mehrere Rechner die API aufrufen, tragen Sie die öffentliche IP jedes einzelnen ein.
- Eine IPv4- oder IPv6-Adresse oder ein CIDR-Bereich pro Zeile, bis zu 50 Einträge. Eine einzelne Adresse erlaubt nur diese eine IP.
- Schreiben Sie Bereiche als Netzwerkadresse: `203.0.113.0/24` ist zulässig, `203.0.113.5/24` nicht (die Host-Bits sind nicht 0).
```text
203.0.113.10
198.51.100.0/24
2001:db8::/32
```
- Liegt die IP der Anfrage nicht in der Liste, geben `createTask` und `getBalance` [`ERROR_KEY_IP_NOT_ALLOWED`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_KEY_IP_NOT_ALLOWED) zurück. Es werden keine Punkte abgezogen, und es zählt nicht für die automatische Pausierung.
- Wenn sich Ihre ausgehende IP ändert (Heim-Breitband, Cloud-Funktionen, rotierende Ausgangs-IPs), setzen Sie keine Whitelist oder tragen Sie den gesamten Bereich ein.
## Ablaufdatum
- Jeder `clientKey` (auch der Haupt-Key) kann ein Ablaufdatum haben, das innerhalb der nächsten zehn Jahre liegen muss. Sie können es jederzeit ändern oder entfernen.
- Nach dem Ablauf geben `createTask` und `getBalance` mit diesem Key [`ERROR_KEY_EXPIRED`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_KEY_EXPIRED) zurück; es werden keine Punkte abgezogen. Bereits erstellte Aufgaben können weiterhin mit `getTaskResult` abgeholt werden.
- Wird ein `clientKey` lange nicht verwendet, setzt das System zum Schutz Ihres Kontos ein Ablaufdatum und erinnert Sie vor Ablauf per E-Mail. Dieses Ablaufdatum lässt sich nicht ändern: Erzeugen Sie einen neuen Haupt-Key (das Guthaben wechselt automatisch zum neuen) oder legen Sie einen neuen `clientKey` an und aktualisieren Sie dann Ihr Programm.
## Guthaben, Limit gleichzeitiger Aufgaben und automatische Pausierung
- **Guthaben**: Alle `clientKey` buchen vom selben Konto-Guthaben ab. Aufladungen, VIP-Bonus, Empfehlungsprämien und Entwicklerbeteiligung gehören zum Konto, unabhängig davon, welchen `clientKey` Sie verwenden.
- **Limit gleichzeitiger Aufgaben**: gilt pro Konto; alle `clientKey` teilen sich dasselbe Limit. Siehe [Limit gleichzeitiger Aufgaben und automatische Pausierung](https://docs.yescaptcha.com/de/api/rate-limits.md).
- **Automatische Pausierung**: gilt pro `clientKey`. Wird ein `clientKey` wegen zu vieler Fehler pausiert, sind die anderen nicht betroffen.
## Zugehörige Fehlercodes
| Fehlercode | Wann er zurückgegeben wird |
| --- | --- |
| [`ERROR_KEY_QUOTA_EXCEEDED`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_KEY_QUOTA_EXCEEDED) | Der Rest des Limits im aktuellen Zeitraum reicht für diese Aufgabe nicht aus (`createTask`) |
| [`ERROR_KEY_IP_NOT_ALLOWED`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_KEY_IP_NOT_ALLOWED) | Die IP der Anfrage steht nicht in der IP-Whitelist dieses `clientKey` (`createTask`, `getBalance`) |
| [`ERROR_KEY_EXPIRED`](https://docs.yescaptcha.com/de/api/errors.md#ERROR_KEY_EXPIRED) | Der `clientKey` ist abgelaufen (`createTask`, `getBalance`) |
Bei keinem von diesen werden Punkte abgezogen. Was zu tun ist, steht unter [Fehlercodes](https://docs.yescaptcha.com/de/api/errors.md).
---
# Aufladung und VIP
> So laden Sie Ihr YesCaptcha-Guthaben auf (WeChat Pay, Alipay, PayPal, Kryptowährung); 1,000 Punkte = ¥1. Mit Ihrer kumulierten Aufladung steigen Sie automatisch von VIP 1 bis VIP 10 auf, danach erhält jede Aufladung anteilig Bonuspunkte.
Source: https://docs.yescaptcha.com/de/account/recharge/ · 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/account/recharge/
Laden Sie Ihr Guthaben auf der Aufladeseite im Dashboard von [yescaptcha.com](https://yescaptcha.com/) auf ([yescaptcha.com/payment.html](https://yescaptcha.com/payment.html)). 1,000 Punkte = ¥1, sofort nach Gutschrift verfügbar. Sobald Ihre kumulierte Aufladung bestimmte Beträge erreicht, werden Sie automatisch in eine VIP-Stufe hochgestuft. Danach erhält jede Aufladung zusätzliche Punkte entsprechend dem Bonussatz Ihrer VIP-Stufe.
## Zahlungsmethoden
| Methode | Hinweise |
| --- | --- |
| WeChat Pay | Zahlung per QR-Code |
| Alipay | Zahlung per QR-Code oder Weiterleitung |
| PayPal | Für Nutzer außerhalb Chinas |
| Kryptowährung | Über Cryptomus; unterstützt BTC, ETH, USDT und mehr |
| Banküberweisung | Wenden Sie sich an den Support; die Gutschrift erfolgt manuell, nachdem die Finanzabteilung die Zahlung bestätigt hat |
Ihren Aufladeverlauf sehen Sie auf der Aufladeseite. Bei Problemen mit der Zahlung [wenden Sie sich an den Support](https://docs.yescaptcha.com/de/help/contact.md) und geben Sie die Bestelldaten an.
## VIP-Stufen
Sobald Ihre kumulierte Aufladung eine der Schwellen in der folgenden Tabelle erreicht, werden Sie automatisch in die entsprechende Stufe hochgestuft. Ab dann erhält jede Aufladung den Bonussatz als zusätzliche Punkte.
| Stufe | Aufladungen insgesamt | Bonus bei jeder Aufladung |
| --- | --- | --- |
| VIP 1 | ¥10 | 2% |
| VIP 2 | ¥100 | 5% |
| VIP 3 | ¥500 | 8% |
| VIP 4 | ¥1.000 | 10% |
| VIP 5 | ¥2.000 | 15% |
| VIP 6 | ¥3.000 | 20% |
| VIP 7 | ¥6.000 | 25% |
| VIP 8 | ¥12.000 | 30% |
| VIP 9 | ¥24.000 | 35% |
| VIP 10 | ¥48.000 | 40% |
- **Kumuliert**: Es spielt keine Rolle, auf wie viele Aufladungen sich der Betrag verteilt; entscheidend ist die Summe.
- **Berechnung nach der Aufladung**: Laden Sie zum Beispiel gleich beim ersten Mal ¥1,000 auf und erreichen damit die Schwelle für VIP 4, erhält diese Aufladung bereits den Bonussatz von VIP 4.
- Wenn Sie sich über den Empfehlungslink eines Freundes registrieren, erhalten Sie sofort eine VIP-Stufe; siehe [Empfehlungsprämie](https://docs.yescaptcha.com/de/account/referral.md).
- Ihre aktuelle Stufe und Ihren Bonussatz sehen Sie auf der Aufladeseite im Dashboard.
---
# Empfehlungsprämie
> YesCaptcha-Empfehlungsprämie: Eingeladene Nutzer erhalten bei der Registrierung eine VIP-Stufe (Ihre Stufe minus 1, von VIP 1 bis VIP 6), und Sie erhalten 20 % der Ausgaben der eingeladenen Person (bei gleichzeitiger Entwicklerbeteiligung je 10 %). Die Prämie können Sie in Guthaben umwandeln oder ab ¥100 im Dashboard auszahlen lassen.
Source: https://docs.yescaptcha.com/de/account/referral/ · 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/account/referral/
Laden Sie Freunde zu YesCaptcha ein: Sie erhalten bei der Registrierung sofort eine VIP-Stufe, und Sie bekommen 20 % ihrer Ausgaben als Prämie. Die Prämie können Sie in Guthaben auf Ihrem Konto umwandeln oder ab ¥100 im Dashboard auszahlen lassen.
## So laden Sie ein
Melden Sie sich im Dashboard auf [yescaptcha.com](https://yescaptcha.com/) an. Im Panel „Empfehlungsprogramm“ der Übersicht sehen Sie Ihren Empfehlungslink, die Zahl der eingeladenen Personen und Ihre bisher angesammelten Prämien. Senden Sie den Empfehlungslink an Freunde; sie registrieren sich über diesen Link.
## Regeln
1. **VIP-Stufe Ihres Freundes**: Nach der Registrierung erhält Ihr Freund direkt eine VIP-Stufe, nämlich Ihre Stufe minus 1, mindestens VIP 1 und höchstens VIP 6. Beispiel: Sind Sie VIP 6, ist Ihr Freund nach der Registrierung VIP 5. Die Bonus-Sätze der einzelnen Stufen finden Sie unter [Aufladung und VIP](https://docs.yescaptcha.com/de/account/recharge.md).
2. **Ihre Prämie**: Bei jeder Ausgabe Ihres Freundes (Punkteabzug für Erkennungen) erhalten Sie **20 %** des Ausgabenbetrags.
3. **Zusammen mit Entwicklerbeteiligung**: Enthalten die Aufgaben Ihres Freundes zusätzlich die ID eines Entwicklers (siehe [Entwicklerbeteiligung](https://docs.yescaptcha.com/de/account/developer.md)), erhalten der Einladende und der Entwickler **je 10 %**.
4. Meldet Ihr Freund ein falsches Erkennungsergebnis und erhält dafür eine Erstattung nach Meldung, wird die zugehörige Prämie wieder abgezogen.
5. Das Prämien-Guthaben können Sie mit `inviteBalance` aus [getBalance](https://docs.yescaptcha.com/de/api/get-balance.md) abfragen (Einheit: CNY).
## Prämien verwenden
- **In Guthaben umwandeln**: Übertragen Sie die Prämien im Dashboard auf Ihr Konto-Guthaben, bei 1,000 Punkte = ¥1, und nutzen Sie sie für Erkennungen.
- **Auszahlen**: Ab einer Prämie von **¥100** können Sie im Dashboard eine Auszahlung beantragen; sie wird nach Prüfung überwiesen.
- Die Einkommensteuer auf ausgezahlte Beträge melden Sie selbst.
## Über uns schreiben
Wenn Sie in Foren, Blogs oder sozialen Medien Empfehlungen, Tutorials, Erfahrungsberichte, Erweiterungen oder Bibliotheken zu YesCaptcha veröffentlichen, senden Sie den Link an den Support. Wir prüfen ihn und vergeben je nach Qualität gegebenenfalls Punkte oder eine VIP-Stufe als Prämie.
Änderungen an diesen Regeln werden auf dieser Seite und im [Änderungsprotokoll](https://docs.yescaptcha.com/de/changelog.md) veröffentlicht.
---
# Entwicklerbeteiligung
> YesCaptcha Entwicklerbeteiligung: Senden Sie in den Anfragen Ihrer Software oder Erweiterung Ihre softID mit und erhalten Sie 20 % der Ausgaben der Nutzer (10 % für Sie und 10 % für den Einladenden, falls es einen gibt). Sie können den Betrag in Guthaben umwandeln oder ab ¥100 im Dashboard auszahlen lassen.
Source: https://docs.yescaptcha.com/de/account/developer/ · 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/account/developer/
Wenn Ihre Software, Ihr Skript oder Ihre Erweiterung YesCaptcha nutzt, können Sie in den Anfragen, die sie für andere Nutzer sendet, Ihre Entwickler-ID (`softID`) mitsenden und erhalten eine Beteiligung an deren Ausgaben. Die Nutzer verwenden weiterhin ihren eigenen `clientKey` und ihre eigenen Punkte; die Beteiligung verursacht ihnen keine zusätzlichen Kosten.
## Einbindung
1. Rufen Sie [getSoftID](https://docs.yescaptcha.com/de/api/get-soft-id.md) mit Ihrem eigenen `clientKey` auf, um Ihre Entwickler-ID zu erhalten:
```json
{
"errorId": 0,
"softID": 3,
"balance": 0.004
}
```
2. Fügen Sie in jeder `createTask`\-Anfrage Ihrer Software das Feld `softID` auf oberster Ebene hinzu (auf derselben Ebene wie `clientKey` und `task`; Groß- und Kleinschreibung beachten):
```json
{
"clientKey": "THE_USERS_CLIENT_KEY",
"task": {
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
},
"softID": 3
}
```
`clientKey` ist der eigene Schlüssel des Nutzers.
## Beteiligungsregeln
- Für Aufgaben mit Ihrer `softID` werden **20 %** der tatsächlichen Ausgaben des Nutzers Ihrer Entwicklerbeteiligung gutgeschrieben.
- Wurde der Nutzer zusätzlich von jemandem eingeladen (siehe [Empfehlungsprämie](https://docs.yescaptcha.com/de/account/referral.md)), erhalten Entwickler und Einladender **jeweils 10 %**.
- Nur Aufgaben mit erfolgreichem Punkteabzug werden berücksichtigt; fehlgeschlagene Aufgaben und Aufgaben mit Zeitüberschreitung, für die eine Punkteerstattung erfolgt, zählen nicht. Meldet der Nutzer ein falsches Ergebnis und erhält eine Erstattung nach Meldung, wird die Beteiligung für diese Aufgabe wieder abgezogen.
- Ihr Beteiligungsguthaben (in CNY) sehen Sie über `balance` aus [getSoftID](https://docs.yescaptcha.com/de/api/get-soft-id.md) oder `softBalance` aus [getBalance](https://docs.yescaptcha.com/de/api/get-balance.md).
## Beteiligung verwenden
- **In Guthaben umwandeln**: Übertragen Sie den Betrag im Dashboard auf Ihr Kontoguthaben, bei 1,000 Punkte = ¥1.
- **Auszahlen**: Sobald der Betrag **¥100** erreicht, stellen Sie im Dashboard eine Auszahlungsanfrage; die Auszahlung erfolgt nach Prüfung.
- Die Einkommensteuer auf ausgezahlte Beträge melden Sie selbst.
---
# Häufige Fragen
> Häufige Fragen zu YesCaptcha: Kosten bei fehlgeschlagener Erkennung, Gültigkeit von Tokens, Erfolgsquote, menschliche oder maschinelle Erkennung, Kontosperrung, ein ClientKey an mehreren Stellen, Wahl des Endpoints, Erweiterung und API im Vergleich.
Source: https://docs.yescaptcha.com/de/help/faq/ · 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/help/faq/
## Werden bei fehlgeschlagener Erkennung Punkte abgezogen?
Nein. Aufgaben, die nicht gelöst werden konnten (`ERROR_CAPTCHA_UNSOLVABLE`) oder in ein Timeout laufen (`ERROR_TASK_TIMEOUT`), werden automatisch mit einer Punkteerstattung abgeschlossen. Anfragen, die einen Fehlercode zurückgeben, etwa wegen falscher Parameter, kosten nichts. Wenn Sie ein Token erhalten, die Zielwebsite es aber ablehnt, wird die Aufgabe als erfolgreich abgerechnet, da wir die Entscheidung der Website nicht kennen. Bei Bilderkennung können Sie falsche Klickpositionen melden und eine Erstattung nach Meldung beantragen. Details finden Sie unter [Abrechnung und Punkteerstattung](https://docs.yescaptcha.com/de/getting-started/billing.md).
## Was kostet eine Erkennung?
Pro Aufgabentyp wird eine feste Anzahl Punkte abgezogen (1,000 Punkte = ¥1); die Preise unterscheiden sich je nach Typ. Alle Preise finden Sie unter [Aufgabentypen und Preise](https://docs.yescaptcha.com/de/tasks.md). Eine maschinenlesbare Version gibt es unter [/data/task-types.json](https://docs.yescaptcha.com/data/task-types.json).
## Wie lange ist ein Token gültig?
Tokens von reCAPTCHA, hCaptcha und Turnstile sind nur einmal verwendbar. Ein reCAPTCHA-Token ist etwa 120 Sekunden gültig; wir empfehlen, es innerhalb von 60 Sekunden nach Erhalt zu senden. Die Gültigkeitsdauer legt der Captcha-Anbieter fest.
## Warum wird ein Token manchmal nicht akzeptiert?
Ob ein Token akzeptiert wird, entscheidet die Zielwebsite. Sie berücksichtigt unter anderem Score, IP und Browserumgebung, und ihre Schwellenwerte können sich jederzeit ändern, daher unterscheidet sich die Erfolgsquote je nach Website. Sie können andere Aufgabentypen für dasselbe Captcha vergleichen, einen Typ mit eigenem Proxy verwenden und das Token über denselben Proxy senden oder auf Bilderkennung wechseln und im Browser real klicken.
## Wie lange dauert die Erkennung?
Asynchrone Aufgaben dauern in der Regel einige Sekunden bis einige zehn Sekunden, höchstens etwa 110 Sekunden (bei wenigen Typen 180 bis 220 Sekunden). Danach läuft die Aufgabe in ein Timeout und die Punkte werden automatisch erstattet. Bilderkennung und Bild-zu-Text (Buchstaben und Ziffern) sind synchron und liefern das Ergebnis in einer einzigen Anfrage.
## Erkennen Menschen oder Maschinen?
Maschinen, auf Basis von Machine-Learning-Modellen.
## Kann mein Konto durch die Nutzung von YesCaptcha gesperrt werden?
Wir liefern nur das Erkennungsergebnis und greifen nicht auf Ihr Konto bei der Zielwebsite zu. Wie die Zielwebsite Aktivitäten bewertet und ob sie Konten sperrt, entscheidet allein die Website; bitte halten Sie deren Regeln ein. YesCaptcha darf nur für rechtmäßige Zwecke verwendet werden, die Nutzung für rechtswidrige Zwecke ist untersagt.
## Kann ich einen ClientKey in mehreren Programmen und Browsern gleichzeitig verwenden?
Ja. Anfragen desselben Kontos werden für das [Limit gleichzeitiger Aufgaben](https://docs.yescaptcha.com/de/api/rate-limits.md) zusammengerechnet und teilen sich dasselbe Guthaben.
## Globalen oder China-Endpoint verwenden?
Für Server in Festlandchina verwenden Sie `cn.yescaptcha.com`, für alle anderen Regionen `api.yescaptcha.com`. Fragen Sie das Ergebnis an dem Endpoint ab, an dem Sie die Aufgabe erstellt haben. Siehe [Endpoints](https://docs.yescaptcha.com/de/getting-started/endpoints.md).
## Was ist der Unterschied zwischen Browser-Erweiterung und API?
Die Erweiterung ruft für die Erkennung dieselbe API auf. Sie ist kostenlos installierbar, zieht Punkte für die genutzten API-Aufrufe ab und eignet sich für die Nutzung im Browser ohne Code. Die API eignet sich für die Stapelverarbeitung in Programmen. Siehe [Browser-Erweiterung](https://docs.yescaptcha.com/de/extension.md).
## Warum wurde ich pausiert und erhalte ERROR\_IP\_BLOCKED\_5MIN?
Mit demselben ClientKey sind innerhalb einer Minute zu viele fehlerhafte Anfragen entstanden, daher wurde er automatisch für einige Minuten pausiert und wird danach automatisch wieder freigegeben. `blockReason` in der Antwort nennt den Fehlercode, der die Pausierung ausgelöst hat; korrigieren Sie Ihr Programm entsprechend. Siehe [Limit gleichzeitiger Aufgaben und automatische Pausierung](https://docs.yescaptcha.com/de/api/rate-limits.md).
## Welche Websites werden unterstützt?
Wir erkennen Captcha-Typen, nicht bestimmte Websites. Ob die Prüfung bestanden wird, hängt von den Einstellungen der Zielwebsite ab; testen Sie daher zuerst mit einer kleinen Menge. Wird eine Website nicht unterstützt, wird `ERROR_DOMAIN_NOT_ALLOWED` zurückgegeben.
---
# Verbindungsprobleme
> Was tun, wenn die YesCaptcha API nicht erreichbar ist: Schritte zur Fehlersuche bei Failed to establish a new connection, DNS-Fehlern, Störungen durch Proxy-Software und SSL-Zertifikatsfehlern (Certificate has expired, SSLEOFError).
Source: https://docs.yescaptcha.com/de/help/troubleshooting/ · 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/help/troubleshooting/
Verbindungsfehler beim Aufruf der API (zum Beispiel `Failed to establish a new connection`, `getaddrinfo failed`, Timeouts oder SSL-Fehler) liegen meist am lokalen Netzwerk, am DNS oder an Proxy-Software. Gehen Sie die folgenden Schritte der Reihe nach durch.
## 1\. Zuerst den anderen Endpoint testen
YesCaptcha hat zwei Endpoints: `https://api.yescaptcha.com` (global) und `https://cn.yescaptcha.com` (China). Verwenden Sie auf Servern in Festlandchina den China-Endpoint, überall sonst den globalen Endpoint. Wenn Sie den Endpoint wechseln, fragen Sie auch die Ergebnisse über denselben Endpoint ab.
```bash
curl -s https://api.yescaptcha.com/getBalance -H 'Content-Type: application/json' -d '{"clientKey": "YOUR_CLIENT_KEY"}'
curl -s https://cn.yescaptcha.com/getBalance -H 'Content-Type: application/json' -d '{"clientKey": "YOUR_CLIENT_KEY"}'
```
Liefert einer der beiden Aufrufe JSON zurück, funktioniert Ihr Netzwerk, und das Problem liegt in der Route zum anderen Endpoint.
## 2\. Proxy-Software prüfen
Für den Zugriff auf YesCaptcha ist kein Proxy nötig. Wenn auf dem Rechner Proxy- oder VPN-Software läuft:
- Schalten Sie sie aus und versuchen Sie es erneut.
- Wenn sie eingeschaltet bleiben muss, wechseln Sie vom globalen Modus in einen regelbasierten Modus (PAC) oder tragen Sie `api.yescaptcha.com` und `cn.yescaptcha.com` in die Liste der direkten Verbindungen ein.
- Tritt in Python bei laufendem Proxy `SSLEOFError(8, 'EOF occurred in violation of protocol')` auf, liegt es meist ebenfalls am Proxy. Schalten Sie den Proxy aus oder lassen Sie diese beiden Domains direkt verbinden.
## 3\. Netzwerk und DNS prüfen
```bash
ping api.yescaptcha.com
```
- Meldung, dass der Host nicht gefunden wird: Die DNS-Auflösung ist fehlgeschlagen. Leeren Sie den DNS-Cache (Windows: `ipconfig /flushdns`; macOS: `sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder`) oder stellen Sie den DNS des Rechners auf einen öffentlichen DNS um (zum Beispiel `223.5.5.5`, `119.29.29.29`, `8.8.8.8`) und versuchen Sie es erneut.
- Ping schlägt fehl, die Adresse wird aber aufgelöst: Möglicherweise blockiert das Netzwerk ICMP. Das bedeutet nicht, dass die API nicht erreichbar ist. Maßgeblich ist das Ergebnis des curl-Aufrufs aus Schritt 1.
## 4\. SSL-Zertifikatsfehler
- Bei `Certificate has expired` oder `certificate verify failed`: Prüfen Sie zuerst, ob die **Systemzeit** des Rechners korrekt ist. Aktualisieren Sie dann das Betriebssystem, das Python-Paket `certifi`, Postman und andere Tools auf die neueste Version, damit sie die aktuellen Root-Zertifikate enthalten.
- Verwenden Sie immer `https://`. Wechseln Sie nicht zu `http://` und schalten Sie die Zertifikatsprüfung nicht aus, um den Fehler zu umgehen.
## 5\. Es funktioniert immer noch nicht
[Kontaktieren Sie den Support](https://docs.yescaptcha.com/de/help/contact.md) und senden Sie dabei Folgendes mit: die vollständige Fehlermeldung, den verwendeten Endpoint, den Standort Ihres Servers und die Ausgabe des curl-Aufrufs aus Schritt 1.
---
# Kontakt
> Kontaktieren Sie den YesCaptcha-Support per WeChat, QQ, WhatsApp, LINE, Telegram @yescaptcha_official oder E-Mail yescaptcha@gmail.com, erreichbar 9:00–21:00 Uhr UTC+8.
Source: https://docs.yescaptcha.com/de/help/contact/ · 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/help/contact/
Der YesCaptcha-Support ist **9:00–21:00 Uhr UTC+8** (Pekinger Zeit) erreichbar. Wenn wir verzögert antworten, hinterlassen Sie eine Nachricht; wir kümmern uns so schnell wie möglich darum.
- E-Mail: [yescaptcha@gmail.com](mailto:yescaptcha@gmail.com)
- Telegram: [@yescaptcha\_official](https://t.me/yescaptcha_official)
Per QR-Code hinzufügen:
**WeChat**In WeChat scannen und uns hinzufügen; wir können Sie zur Nutzergruppe hinzufügen
**QQ**In QQ scannen und uns hinzufügen
**WhatsApp**Mit der WhatsApp-Kamera scannen
**LINE**In LINE unter „Freunde hinzufügen“ scannen
**[Telegram](https://t.me/yescaptcha_official)**@yescaptcha\_official
Bitte geben Sie bei Ihrer Anfrage Folgendes an:
- Ihre Konto-E-Mail oder Nutzer-ID (senden Sie **niemals** Ihren `clientKey`);
- die zugehörige `taskId`, den Fehlercode und den Zeitpunkt;
- welchen Aufgabentyp und welchen Endpoint (`api.yescaptcha.com` oder `cn.yescaptcha.com`) Sie verwendet haben.
Viele Fragen werden bereits in den [FAQ](https://docs.yescaptcha.com/de/help/faq.md), den [Fehlercodes](https://docs.yescaptcha.com/de/api/errors.md) und unter [Verbindungs- und Netzwerkprobleme](https://docs.yescaptcha.com/de/help/troubleshooting.md) beantwortet.
---
# Service-Änderungsprotokoll
> Änderungen, die YesCaptcha-Nutzer betreffen, nach Datum: neue und eingestellte Aufgabentypen, Abrechnungs- und Erstattungsregeln, Limit gleichzeitiger Aufgaben, Umzug der Dokumentation. Erfasst ab Oktober 2026.
Source: https://docs.yescaptcha.com/de/changelog/ · Last verified: 2026-10-19
> This page was machine-translated from the Chinese version. If anything differs, the Chinese version prevails: https://docs.yescaptcha.com/zh/changelog/
Hier werden Änderungen nach Datum erfasst, die Nutzer betreffen: neue und eingestellte Aufgabentypen, Abrechnungsregeln, Regeln für Limits und Ähnliches. Die neuesten Einträge stehen oben.
## 2026-10-19
- **Die Cloudflare-Prüfseite ist nicht mehr als „nicht empfohlen“ markiert**: Der Dienst hinter `CloudFlareTaskS2` und `CloudFlareTaskS3` wurde neu aufgebaut; eine Aufgabe dauert in der Regel 6 bis 35 Sekunden. Beide Typen haben dieselben Parameter, Ergebnisse und dieselbe Wirksamkeit; die Preise bleiben unverändert (25 und 20 Punkte). Proxys müssen `http://` (optional mit Zugangsdaten) oder `socks5://` ohne Zugangsdaten sein; `https://`\-Proxys sowie lokale und interne Adressen werden schon beim Erstellen der Aufgabe abgelehnt (kein Punkteabzug). `userAgent` wird nur übernommen, wenn es sich um Chrome für den Linux-Desktop handelt; verwenden Sie für spätere Anfragen `user_agent` aus dem Ergebnis. Wenn Sie `requiredCookies` angeben, gilt die Aufgabe nur als erfolgreich, wenn alle Cookies geliefert werden. Siehe [Cloudflare-Prüfseite](https://docs.yescaptcha.com/de/tasks/cloudflare-challenge.md).
## 2026-10-16
- **Die Token-Typen für FunCaptcha werden vorerst nicht empfohlen**: Sie sind teuer und es gibt keine stabile Lösung. `FunCaptchaTask` kostet jetzt 30 Punkte pro Aufgabe (vorher 15). `FunCaptchaTaskProxyless` liefert weiterhin keine erfolgreichen Ergebnisse; fehlgeschlagene Aufgaben werden automatisch per Punkteerstattung zurückerstattet. Um FunCaptcha zu lösen, verwenden Sie [FunCaptcha-Bilderkennung](https://docs.yescaptcha.com/de/tasks/funcaptcha-classification.md) oder die Browser-Erweiterung.
## 2026-10-15
- **Umzug der Dokumentation**: Die Dokumentation ist von Confluence auf diese Website (docs.yescaptcha.com) umgezogen, auf Chinesisch und Englisch; maßgeblich ist die chinesische Fassung. [llms.txt](https://docs.yescaptcha.com/llms.txt), [OpenAPI](https://docs.yescaptcha.com/openapi.json) und eine Markdown-Version jeder Seite stehen für KI-Werkzeuge und Programme bereit.
- **Erstattung nach Meldung wird nach etwa 24 Stunden abgerechnet**: Bei Aufgaben der Bilderkennung, die als falsch gemeldet werden, erfolgt die Erstattung nicht mehr sofort, sondern wird nach etwa 24 Stunden gesammelt abgerechnet. Liegt die Fehlerquote deutlich über der im selben Zeitraum üblichen, wird nach der Fehlerquote des Zeitraums erstattet. Siehe [Abrechnung und Punkteerstattung](https://docs.yescaptcha.com/de/getting-started/billing.md).
- **Limit gleichzeitiger Aufgaben**: Aufgaben in Bearbeitung werden jetzt pro Konto und Aufgabentyp gezählt. Bei Überschreitung wird `ERROR_THREADS_MAXIMUM` zurückgegeben; es erfolgt kein Punkteabzug und die Anfrage zählt nicht für die automatische Pausierung. Sobald die Limits der einzelnen Typen feststehen, werden sie unter [Limit gleichzeitiger Aufgaben und automatische Pausierung](https://docs.yescaptcha.com/de/api/rate-limits.md) veröffentlicht.
- **Weitere öffentliche Aufgabentypen**: `HCaptchaTask`, `NoCaptchaTask`, `TurnstileTask` und `RecaptchaV2EnterpriseTask` (mit eigenem Proxy) sowie `FunCaptchaTaskProxylessM1`, `FunCaptchaTask` und `HCaptchaTaskProxylessM1` sind jetzt dokumentiert.
- **Token-Typen für FunCaptcha**: `FunCaptchaTaskProxylessM1` und `FunCaptchaTask` sind verfügbar. Die Leitung von `FunCaptchaTaskProxyless` liefert seit etwa 2026-09-10 keine erfolgreichen Ergebnisse mehr; fehlgeschlagene Aufgaben werden automatisch per Punkteerstattung zurückerstattet.
- **Eingestellt**: Die Serie reCAPTCHA K1 mit angepasstem Fingerprint, `FunCaptchaTaskS1`, `CloudFlareTaskS1`, `TurnstileTaskS2`, `TurnstileTaskProxylessS2`, `bCaptcha2Classification` und `GeneralClassification` wurden eingestellt.
## Vor 2026-10-15
- Die **Selbstbedienungs-Vermietung dedizierter Server** wurde eingestellt.