# YesCaptcha Docs (full text)
> YesCaptcha est une API de reconnaissance de captchas : résolvez reCAPTCHA, hCaptcha, Cloudflare Turnstile, FunCaptcha, AWS WAF et les captchas image via une seule API JSON, avec un paiement par tâche et un remboursement automatique des tâches échouées ou expirées.
---
# Résolvez les captchas avec une seule API JSON
> YesCaptcha est une API de reconnaissance de captchas : résolvez reCAPTCHA, hCaptcha, Cloudflare Turnstile, FunCaptcha, AWS WAF et les captchas image via une seule API JSON, avec un paiement par tâche et un remboursement automatique des tâches échouées ou expirées.
Source: https://docs.yescaptcha.com/fr/ · 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 de reconnaissance de captchaÉtat](https://status.yescaptcha.com/?lang=en)
YesCaptcha résout reCAPTCHA, hCaptcha, Cloudflare Turnstile, FunCaptcha, AWS WAF et les captchas image alphanumériques. Le débit de points se fait par tâche (1,000 points = ¥1) ; les tâches échouées ou expirées sont remboursées automatiquement.
[Démarrage rapide](https://docs.yescaptcha.com/fr/getting-started/quickstart.md)[Référence de l'API](https://docs.yescaptcha.com/fr/api/overview.md)
Versions lisibles par machine :[llms.txt](https://docs.yescaptcha.com/fr/llms.txt)[llms-full.txt](https://docs.yescaptcha.com/fr/llms-full.txt)[OpenAPI](https://docs.yescaptcha.com/openapi.json)[Markdown](https://docs.yescaptcha.com/fr/index.md)
YesCaptcha est réservé à un usage légal. Tout usage illégal est interdit.
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. 1Créer une tâche
2. 2Obtenir le résultat
3. 3Envoyer
Exemple : reCAPTCHA v2, interrogation du résultat toutes les 5 secondes
À partir de $0.30 / 1k
Prix le plus bas par tâche
1,000 points = ¥1
Les tâches échouées ou expirées donnent lieu à un remboursement de points
2 endpoints
Endpoint mondial et endpoint Chine
9:00–21:00
Support humain (UTC+8)
[Démarrage rapideCréez un compte, récupérez votre ClientKey et envoyez votre première requête en 5 minutes](https://docs.yescaptcha.com/fr/getting-started/quickstart.md)[Référence de l'APIcreateTask, getTaskResult, codes d'erreur et limite de tâches simultanées](https://docs.yescaptcha.com/fr/api/overview.md)[Types de tâches et prixPrix, mode de retour et paramètres de tous les types publics](https://docs.yescaptcha.com/fr/tasks.md)[Extension de navigateurRésolvez les captchas sur les pages web sans écrire de code](https://docs.yescaptcha.com/fr/extension.md)
## Captchas pris en charge
[01reCAPTCHAv2, v3, Enterprise, et reconnaissance d'images pour la v2À partir de $0.90 / 1k](https://docs.yescaptcha.com/fr/tasks/recaptcha-v2.md)[02hCaptchaObtenez un token, ou reconnaissez les images et cliquez vous-mêmeÀ partir de $1.20 / 1k](https://docs.yescaptcha.com/fr/tasks/hcaptcha.md)[03Cloudflare TurnstileTokens de vérification TurnstileÀ partir de $3.75 / 1k](https://docs.yescaptcha.com/fr/tasks/turnstile.md)[04FunCaptchaReconnaissance des énigmes image d'Arkose Labs, tous les types d'énigmes sont pris en chargeÀ partir de $0.45 / 1k](https://docs.yescaptcha.com/fr/tasks/funcaptcha-classification.md)[05AWS WAF / bCaptchaReconnaissance d'images en grille 3×3À partir de $1.20 / 1k](https://docs.yescaptcha.com/fr/tasks/aws-bcaptcha-classification.md)[06Image en texteCaptchas image alphanumériques, résultat renvoyé en mode synchroneÀ partir de $0.30 / 1k](https://docs.yescaptcha.com/fr/tasks/image-to-text.md)
## Trois étapes
1. 01
**Créer une tâche**
Envoyez le type de tâche et les paramètres du site à `createTask` pour obtenir un `taskId`. Les types synchrones, comme la reconnaissance d'images et l'image en texte, renvoient le résultat immédiatement.
2. 02
**Récupérer le résultat**
Appelez `getTaskResult` toutes les 5 secondes. Quand `status` vaut `ready`, le résultat se trouve dans `solution`.
3. 03
**Le soumettre au site cible**
Placez le token dans le formulaire ou la requête de la page. Un token est à usage unique ; utilisez-le dans les 60 secondes.
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..."
}
}
```
## Accès fréquents
- [**Codes d'erreur**La signification de chaque code d'erreur et comment le traiter](https://docs.yescaptcha.com/fr/api/errors.md)
- [**Limite de tâches simultanées et suspension automatique**Ce qui se passe en cas de dépassement ou de trop nombreuses erreurs](https://docs.yescaptcha.com/fr/api/rate-limits.md)
- [**Facturation et remboursement de points**Points, prédébit, remboursement de points et remboursement après signalement](https://docs.yescaptcha.com/fr/getting-started/billing.md)
- [**Nous contacter**WeChat, QQ, Telegram, e-mail, de 9:00 à 21:00 (UTC+8)](https://docs.yescaptcha.com/fr/help/contact.md)
- [**Tableau de bord**Créer un compte, récupérer votre ClientKey, recharger](https://yescaptcha.com/)
---
# Introduction
> Qu'est-ce que YesCaptcha : résolvez reCAPTCHA, hCaptcha, Turnstile, FunCaptcha et les captchas d'images via une API ou une extension de navigateur. Facturation par tâche, remboursement automatique des tâches échouées.
Source: https://docs.yescaptcha.com/fr/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 est un service de reconnaissance de captchas. Vous envoyez les informations du captcha à l’API YesCaptcha et vous recevez soit un token à soumettre au site cible, soit le résultat de reconnaissance d’une image. Le service prend en charge reCAPTCHA (v2, v3 et Enterprise), hCaptcha, Cloudflare Turnstile, la page de vérification Cloudflare, FunCaptcha, AWS WAF, bCaptcha et les captchas d’images alphanumériques. Chaque tâche est facturée en points (1,000 points = ¥1) ; les tâches échouées ou expirées font l’objet d’un remboursement de points automatique.
YesCaptcha est réservé à un usage légal. Tout usage illégal est interdit.
## Deux façons de l’utiliser
| | API | Extension de navigateur (YesCaptcha Assistant) |
| --- | --- | --- |
| Pour qui | Les développeurs qui traitent les captchas dans leur propre code | Ceux qui n’écrivent pas de code et travaillent dans un navigateur |
| Comment | Appelez `createTask` et `getTaskResult` avec votre `clientKey` | Installez l’extension et saisissez votre `clientKey` ; les captchas sont reconnus et cliqués automatiquement |
| Prise en charge | Tous les types de tâche listés sur ce site | Les épreuves d’images de reCAPTCHA v2, hCaptcha, FunCaptcha, AWS WAF et bCaptcha, ainsi que les captchas de caractères |
| Coût | Débit de points selon le type de tâche | L’extension est gratuite ; vous payez les appels à l’API qu’elle effectue |
Les deux utilisent le même compte, le même `clientKey` et le même solde.
## Trois types de résultats
- **Token** : la plupart des types de tâche reCAPTCHA, hCaptcha, Turnstile et FunCaptcha. Vous obtenez une chaîne à placer dans le formulaire ou la requête de la page pour passer la vérification, sans cliquer sur des images. Ces tâches sont asynchrones : créez la tâche, puis interrogez le résultat toutes les 5 secondes.
- **Résultats de reconnaissance d’images** : les types dont le nom se termine par `Classification`. Vous envoyez les images du captcha et vous obtenez les images ou les positions à cliquer ; votre propre code effectue les clics dans le navigateur. Ces tâches sont synchrones : une seule requête renvoie le résultat.
- **Texte ou cookies** : la reconnaissance d’images alphanumériques renvoie le texte contenu dans l’image ; la tâche pour la page de vérification Cloudflare renvoie les cookies obtenus après la validation.
Tous les types de tâche et leurs prix : [Types de tâche et prix](https://docs.yescaptcha.com/fr/tasks.md).
## Pour commencer
[Démarrage rapide](https://docs.yescaptcha.com/fr/getting-started/quickstart.md)Créez un compte, récupérez votre ClientKey, envoyez votre première requête
[Endpoints](https://docs.yescaptcha.com/fr/getting-started/endpoints.md)Endpoint mondial et endpoint Chine
[Facturation et remboursements](https://docs.yescaptcha.com/fr/getting-started/billing.md)Points, préautorisation, remboursement de points, remboursement après signalement
[Extension de navigateur](https://docs.yescaptcha.com/fr/extension.md)Reconnaissance automatique dans le navigateur, sans code
## SDK communautaires
SDK fournis par des utilisateurs, non officiels ; évaluez-les avant de les utiliser : voir [Exemples de code et SDK](https://docs.yescaptcha.com/fr/samples.md).
---
# Démarrage rapide
> Envoyez votre première requête YesCaptcha en 5 minutes : créez un compte, copiez votre ClientKey, rechargez votre solde, puis lisez un captcha image avec curl, Python ou Node.js (ImageToTextTaskOcrBase, synchrone, 2 points par image).
Source: https://docs.yescaptcha.com/fr/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/
Cette page envoie une première requête avec le type de tâche le plus simple, `ImageToTextTaskOcrBase`, qui lit les lettres et les chiffres d’une image. Il est synchrone (une seule requête `createTask` renvoie le résultat), coûte 2 points (≈ $0.30 / 1k) par image et ne dépend d’aucun site tiers : c’est un bon moyen de vérifier que votre compte et votre code fonctionnent.
1. **Créer un compte**
Créez un compte et connectez-vous sur [yescaptcha.com](https://yescaptcha.com/).
2. **Copier votre ClientKey**
Dans le tableau de bord ([yescaptcha.com/dashboard.html](https://yescaptcha.com/dashboard.html)), repérez « Votre ClientKey » et cliquez sur copier. Copiez la valeur en entier.
> **Attention:** Toutes les requêtes API sont authentifiées avec la ClientKey : quiconque la possède peut dépenser votre solde. Ne la partagez pas et ne l’intégrez pas à du code public ; si elle fuite, réinitialisez-la au même endroit.
3. **Recharger votre solde**
Votre solde doit dépasser 10 points pour créer des tâches. Moyens de paiement et bonus VIP : [Recharge et VIP](https://docs.yescaptcha.com/fr/account/recharge.md).
4. **Vérifier que la ClientKey fonctionne**
`getBalance` renvoie votre solde et n’entraîne aucun débit de points :
```bash
curl -s https://api.yescaptcha.com/getBalance \
-H 'Content-Type: application/json' \
-d '{"clientKey": "YOUR_CLIENT_KEY"}'
```
Si vous obtenez `{"errorId": 0, "balance": 12345, ...}`, tout est prêt ; `balance` correspond à vos points restants. `ERROR_KEY_DOES_NOT_EXIST` signifie que la clé a été mal copiée.
5. **Lire une image**
Téléchargez l’image d’exemple [captcha.jpg](https://docs.yescaptcha.com/samples/captcha.jpg) (ou utilisez votre propre image de captcha), placez votre ClientKey dans une variable d’environnement, puis lancez l’un des scripts :
```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);
```
Lancez `bash quickstart.sh captcha.jpg`, `python quickstart.py captcha.jpg` ou `node quickstart.mjs captcha.jpg`. Python nécessite `pip install requests` ; Node.js nécessite la version 18 ou supérieure.
6. **Lire le résultat**
En cas de succès, vous obtenez :
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"text": "LMResm"
},
"taskId": "2376919c-1863-11ec-a012-94e6f7355a0b"
}
```
`errorId` à 0 signifie que la requête a réussi ; le texte lu se trouve dans `solution.text`. Si `errorId` vaut 1, consultez `errorCode` dans [Codes d’erreur](https://docs.yescaptcha.com/fr/api/errors.md).
## Étapes suivantes
- Les tâches qui renvoient un token, comme reCAPTCHA et hCaptcha, sont **asynchrones** : `createTask` renvoie un `taskId`, puis vous appelez `getTaskResult` toutes les 5 secondes. Le déroulement complet est décrit dans [Requêtes et réponses](https://docs.yescaptcha.com/fr/api/overview.md) ; un exemple est donné avec [reCAPTCHA v2](https://docs.yescaptcha.com/fr/tasks/recaptcha-v2.md).
- Choisir un type de tâche : [Types de tâches et tarifs](https://docs.yescaptcha.com/fr/tasks.md).
- Un client à copier directement dans votre projet : [Python](https://docs.yescaptcha.com/fr/samples/python.md), [Node.js](https://docs.yescaptcha.com/fr/samples/nodejs.md).
- Sans écrire de code : [Extension de navigateur](https://docs.yescaptcha.com/fr/extension.md).
---
# Endpoints
> Les deux endpoints de l'API YesCaptcha, l'endpoint mondial api.yescaptcha.com et l'endpoint Chine cn.yescaptcha.com. HTTPS POST avec JSON uniquement ; créez et interrogez une tâche sur le même endpoint.
Source: https://docs.yescaptcha.com/fr/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/
L’API YesCaptcha propose deux endpoints dont les méthodes et les paramètres sont identiques. Choisissez celui qui correspond à l’emplacement de vos serveurs :
| Endpoint | Adresse | À utiliser pour |
| --- | --- | --- |
| Endpoint mondial | `https://api.yescaptcha.com` | Serveurs hors de Chine continentale |
| Endpoint Chine | `https://cn.yescaptcha.com` | Serveurs en Chine continentale |
L’URL d’une méthode est l’adresse de l’endpoint suivie du nom de la méthode, par exemple pour créer une tâche :
- POST `https://api.yescaptcha.com/createTask` (Endpoint mondial)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint Chine)
## Règles
- HTTPS uniquement.
- Toutes les méthodes, sauf [/useragent](https://docs.yescaptcha.com/fr/api/useragent.md), utilisent `POST` avec un corps JSON et l’en-tête `Content-Type: application/json`. Le corps de la requête ne doit pas dépasser 6 MB.
- L’authentification se fait avec le `clientKey` dans le corps de la requête ; aucun autre en-tête n’est nécessaire.
> **Note:** Interrogez une tâche avec `getTaskResult` sur le même endpoint que celui où vous l’avez créée. Ne mélangez pas les deux endpoints.
## Toutes les méthodes
| Méthode | Rôle | Remarques |
| --- | --- | --- |
| [createTask](https://docs.yescaptcha.com/fr/api/create-task.md) | Créer une tâche | Les types synchrones renvoient directement le résultat |
| [getTaskResult](https://docs.yescaptcha.com/fr/api/get-task-result.md) | Obtenir le résultat d’une tâche | Pour les types asynchrones, interrogez toutes les 5 secondes |
| [getBalance](https://docs.yescaptcha.com/fr/api/get-balance.md) | Consulter le solde | Sans débit de points |
| [getSoftID](https://docs.yescaptcha.com/fr/api/get-soft-id.md) | Obtenir votre ID développeur | Pour la part développeur |
| [report](https://docs.yescaptcha.com/fr/api/report.md) | Signaler un résultat | Les types de reconnaissance d’images peuvent donner lieu à un remboursement après signalement |
| [useragent](https://docs.yescaptcha.com/fr/api/useragent.md) | Obtenir le User-Agent recommandé | `GET`, utilisé avec hCaptcha |
Si vous n’arrivez pas à vous connecter, consultez [Problèmes de connexion et de réseau](https://docs.yescaptcha.com/fr/help/troubleshooting.md).
---
# Facturation et remboursements
> Comment YesCaptcha débite les points : 1,000 points = ¥1, selon le type de tâche ; les tâches échouées ou expirées sont remboursées automatiquement, les requêtes qui renvoient une erreur ne sont pas débitées ; le solde doit être supérieur à 10 points ; les signalements d'échec en reconnaissance d'images sont remboursés environ 24 heures plus tard.
Source: https://docs.yescaptcha.com/fr/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 débite les points par tâche : chaque type de tâche a un prix fixe, 1,000 points = ¥1. Par exemple, `NoCaptchaTaskProxyless` coûte 15 points (≈ $2.25 / 1k) par tâche. Les prix de chaque type sont indiqués dans [Types de tâches et tarifs](https://docs.yescaptcha.com/fr/tasks.md).
> **Astuce:** Vous ne payez que les tâches réussies : les tâches échouées ou expirées sont remboursées automatiquement, et les requêtes qui renvoient une erreur ne sont pas débitées.
## Quand les points sont débités
- **Types asynchrones** (la plupart des types qui renvoient un token) : le débit a lieu à la création de la tâche. Si la tâche échoue ensuite (`ERROR_CAPTCHA_UNSOLVABLE`, etc.) ou expire (`ERROR_TASK_TIMEOUT`, généralement après 110 secondes), les points sont remboursés automatiquement.
- **Types synchrones** (reconnaissance d’images, `ImageToTextTaskOcrBase`, `ImageToTextTaskMuggle`) : le débit a lieu au moment où le résultat est renvoyé.
- Les requêtes rejetées dès la création de la tâche (paramètres incorrects, solde insuffisant, limite de tâches simultanées dépassée, etc.) ne sont pas débitées.
## Solde
- Votre solde doit être **supérieur à 10 points** pour créer une tâche ; sinon, vous obtenez `ERROR_ZERO_BALANCE`.
- Consultez-le avec [getBalance](https://docs.yescaptcha.com/fr/api/get-balance.md), sans débit de points.
- Pour la recharge et le bonus VIP, consultez [Recharge et VIP](https://docs.yescaptcha.com/fr/account/recharge.md) : une fois que votre recharge cumulée atteint un niveau VIP, chaque recharge suivante donne droit à des points de bonus proportionnels.
## Types à prix variable
- **Reconnaissance d’images reCAPTCHA v2** (`ReCaptchaV2Classification`) : une petite image 1x1 et une grande image 3x3 ou 4x4 n’ont pas le même prix ; voir [Reconnaissance d’images reCAPTCHA v2](https://docs.yescaptcha.com/fr/tasks/recaptcha-classification.md).
- **Reconnaissance d’images hCaptcha** (`HCaptchaClassification`) : aucun débit si aucune cible n’est reconnue (résultat vide).
## Remboursement après signalement d’une erreur de reconnaissance
Si un résultat de reconnaissance d’images est erroné, vous pouvez le signaler avec [report](https://docs.yescaptcha.com/fr/api/report.md). Les tâches éligibles donnent lieu à un remboursement de points :
- Seuls 5 types de reconnaissance d’images sont concernés : `FunCaptchaClassification`, `HCaptchaClassification`, `ReCaptchaV2Classification`, `AwsClassification` et `bCaptchaClassification`.
- Signalez **dans l’heure** qui suit la création de la tâche ; chaque tâche n’est comptée qu’une fois.
- Le remboursement n’est pas immédiat : il est réglé **environ 24 heures plus tard**.
- Lors du règlement, votre taux d’échec signalé est comparé à celui des autres utilisateurs sur les mêmes questions pendant la même période. S’il est nettement supérieur au niveau de la période, le remboursement est calculé au taux d’échec de la période.
- Signalez honnêtement les réussites comme les échecs. Les signalements qui ne contiennent que des échecs ne sont pas utilisés comme référence pour la période, et votre taux d’échec est calculé sur l’ensemble des tâches que vous avez créées.
- Si vous contestez le résultat d’un règlement, [contactez le support](https://docs.yescaptcha.com/fr/help/contact.md) pour faire appel.
Pour les types qui renvoient un token (reCAPTCHA, hCaptcha, Turnstile, etc.), c’est le site cible qui décide si le token est accepté ; le signalement ne donne donc lieu à aucun remboursement.
## Cas sans débit de points
| Situation | Réponse |
| --- | --- |
| Paramètres incorrects, type inexistant, `clientKey` incorrect | Le code d’erreur correspondant |
| Solde non supérieur à 10 points | `ERROR_ZERO_BALANCE` |
| Limite de tâches simultanées dépassée | `ERROR_THREADS_MAXIMUM` ; voir [Limite de tâches simultanées et suspension automatique](https://docs.yescaptcha.com/fr/api/rate-limits.md) |
| Pendant une suspension automatique | `ERROR_IP_BLOCKED_5MIN` |
| sitekey ou domaine déjà jugé invalide (pendant la durée du cache) | Le code d’erreur d’origine, avec `cached: true` |
| Échec de la reconnaissance ou expiration | Les points déjà débités sont remboursés automatiquement |
## Part développeur et récompenses
- Si vous utilisez le logiciel ou l’extension d’un tiers, vos tâches peuvent porter un ID développeur : le développeur reçoit une part, sans effet sur votre débit. Si vous développez votre propre logiciel, consultez [Part développeur](https://docs.yescaptcha.com/fr/account/developer.md).
- Pour inviter d’autres personnes à s’inscrire, consultez [Récompense de parrainage](https://docs.yescaptcha.com/fr/account/referral.md).
---
# Requêtes et réponses
> Conventions communes de l'API YesCaptcha : POST JSON, authentification par clientKey, format de réponse avec errorId, tâches synchrones et asynchrones, interrogation toutes les 5 secondes, délai maximal de 110 secondes, résultats conservés environ 10 minutes, langue des messages selon Accept-Language.
Source: https://docs.yescaptcha.com/fr/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/
Toutes les méthodes reçoivent un `POST` HTTPS avec un corps JSON (seul `/useragent` est en `GET`), s’authentifient avec le `clientKey` du corps de la requête et renvoient du JSON : `errorId` à 0 signifie un succès, à 1 un échec accompagné d’un `errorCode`. Résoudre un captcha se fait en deux étapes : `createTask` crée la tâche, puis `getTaskResult` est interrogé toutes les 5 secondes pour obtenir le résultat. Les types synchrones renvoient directement le résultat dans `createTask`.
## Requête
```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` (mondial) ou `https://cn.yescaptcha.com` (Chine). Voir [Adresses d’accès](https://docs.yescaptcha.com/fr/getting-started/endpoints.md).
- Le corps est au format JSON, envoyé avec l’en-tête `Content-Type: application/json`, et ne dépasse pas 6 MB. Le JSON ne peut pas contenir de commentaires.
- Chaque requête doit inclure `clientKey`, copié en entier depuis le tableau de bord.
> **Attention:** Avec requests en Python, utilisez `json=data` et non `data=data`. Ce dernier envoie un formulaire et renvoie `ERROR_TASK_ABSENT` ou `ERROR_REQUIRED_FIELDS`.
## Réponse
Succès :
```json
{
"errorId": 0,
"taskId": "61138bb6-19fb-11ec-a9c8-0242ac110006"
}
```
Échec :
```json
{
"errorId": 1,
"errorCode": "ERROR_ZERO_BALANCE",
"errorDescription": "帐户余额不足"
}
```
| Champ | Description |
| --- | --- |
| `errorId` | 0 : succès, 1 : échec |
| `errorCode` | Code d’erreur en cas d’échec ; signification et solutions dans [Codes d’erreur](https://docs.yescaptcha.com/fr/api/errors.md) |
| `errorDescription` | Description textuelle de la cause de l’échec |
| `taskId` | ID de tâche |
| `status` | `processing` (en cours) ou `ready` (terminé) |
| `solution` | Résultat de la résolution ; les champs dépendent du type de tâche (voir la page de chaque type de tâche) |
Dans votre code, appuyez-vous sur `errorId` et `errorCode`, pas sur le texte de `errorDescription`, qui peut changer.
## Synchrone et asynchrone
| | Asynchrone | Synchrone |
| --- | --- | --- |
| Types concernés | Types qui renvoient un token (reCAPTCHA, hCaptcha, Turnstile, FunCaptcha), page de vérification Cloudflare, `ImageToTextTask`, `ImageToTextTaskM1` | Reconnaissance d’images (noms se terminant par `Classification`), `ImageToTextTaskOcrBase`, `ImageToTextTaskMuggle` |
| `createTask` renvoie | `taskId` | `status: "ready"` et `solution` |
| Obtenir le résultat | Appelez `getTaskResult` toutes les 5 secondes | Rien de plus à faire |
La colonne « Mode de retour » de [Types de tâches et prix](https://docs.yescaptcha.com/fr/tasks.md) indique le mode de chaque type.
## Interrogation périodique (polling)
1. Une fois le `taskId` renvoyé par `createTask`, attendez 5 secondes avant d’appeler `getTaskResult`.
2. Si la réponse est `status: "processing"`, attendez encore 5 secondes puis réessayez ; si elle est `status: "ready"`, le résultat se trouve dans `solution`.
3. Si la réponse est `errorId: 1`, arrêtez d’interroger cette tâche et traitez l’`errorCode`.
- Les requêtes répétées pour le même `taskId` dans un délai de 5 secondes renvoient immédiatement `processing` ; interroger plus souvent ne donne pas le résultat plus vite.
- Une tâche est traitée au maximum pendant environ 110 secondes (180 à 220 secondes pour quelques types) ; passé ce délai, elle renvoie `ERROR_TASK_TIMEOUT` et les points sont remboursés automatiquement.
- Les résultats sont conservés côté serveur environ 10 minutes ; ensuite le `taskId` expire et la requête renvoie `ERROR_TASKID_INVALID`.
- La consultation du résultat n’entraîne aucun débit de points ; seule la création de la tâche est débitée.
## Langue des messages
Pour les messages de suspension automatique, de paramètres invalides mis en cache et d’arrêt de l’interrogation, `errorDescription` suit l’en-tête de requête `Accept-Language` : chinois si la valeur commence par `zh`, anglais pour toute autre langue, et les deux langues si l’en-tête est absent. Les descriptions des autres codes d’erreur ne sont pas concernées.
## Étape suivante
- [createTask : créer une tâche](https://docs.yescaptcha.com/fr/api/create-task.md)
- [getTaskResult : obtenir le résultat](https://docs.yescaptcha.com/fr/api/get-task-result.md)
- [Limite de tâches simultanées et suspension automatique](https://docs.yescaptcha.com/fr/api/rate-limits.md) : trop d’erreurs entraînent une suspension de quelques minutes
---
# createTask — créer une tâche
> POST /createTask crée une tâche de reconnaissance de captcha : paramètres de la requête (clientKey, task, softID), ordre des vérifications, taskId renvoyé en asynchrone, solution renvoyée directement en synchrone. Le solde doit être supérieur à 10 points.
Source: https://docs.yescaptcha.com/fr/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` crée une tâche de reconnaissance ; `task.type` indique quel captcha résoudre. Les types asynchrones renvoient un `taskId`, que vous passez ensuite à [getTaskResult](https://docs.yescaptcha.com/fr/api/get-task-result.md) pour récupérer le résultat ; les types synchrones renvoient directement le résultat.
> **Note:** Les points sont débités à la création réussie de la tâche, et votre solde doit être supérieur à 10 points pour en créer une. Les tâches en échec ou expirées donnent lieu à un remboursement de points automatique.
- POST `https://api.yescaptcha.com/createTask` (Endpoint mondial)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint Chine)
## Paramètres de la requête
| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `clientKey` | string | Oui | Votre ClientKey, à copier depuis le tableau de bord de [yescaptcha.com](https://yescaptcha.com/) |
| `task` | object | Oui | L’objet de la tâche. Il doit contenir `type` ; les autres champs dépendent du type de tâche (voir la page de chaque type de tâche) |
| `softID` | integer | Non | ID développeur. Ajoutez le vôtre lorsque d’autres personnes utilisent votre logiciel pour recevoir une part développeur ; voir [Part développeur](https://docs.yescaptcha.com/fr/account/developer.md) |
## Exemples de requête
Lire un captcha image (synchrone) :
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "ImageToTextTaskOcrBase",
"body": "BASE64_IMAGE"
}
}
```
Obtenir un token reCAPTCHA v2 (asynchrone) :
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
}
}
```
Les champs de `task` de chaque type figurent dans les pages de [Types de tâches et tarifs](https://docs.yescaptcha.com/fr/tasks.md).
## Réponse
Types asynchrones :
```json
{
"errorId": 0,
"taskId": "61138bb6-19fb-11ec-a9c8-0242ac110006"
}
```
Conservez le `taskId` et commencez à appeler `getTaskResult` 5 secondes plus tard.
Types synchrones :
```json
{
"errorId": 0,
"status": "ready",
"taskId": "2376919c-1863-11ec-a012-94e6f7355a0b",
"solution": {
"text": "LMResm"
}
}
```
Échec :
```json
{
"errorId": 1,
"errorCode": "ERROR_TASK_NOT_SUPPORTED",
"errorDescription": "任务类型不正确或不受支持"
}
```
## Ordre des vérifications
Le serveur vérifie la requête dans cet ordre et renvoie le code d’erreur correspondant au premier problème rencontré, sans débit de points :
1. Le corps de la requête est du JSON valide : `ERROR_REQUEST_FORMATS`
2. `clientKey` est présent : `ERROR_REQUIRED_FIELDS`
3. `clientKey` existe : `ERROR_KEY_DOES_NOT_EXIST`
4. La clé n’est pas en suspension automatique : `ERROR_IP_BLOCKED_5MIN` (voir [Limite de tâches simultanées et suspension automatique](https://docs.yescaptcha.com/fr/api/rate-limits.md))
5. Le solde est supérieur à 10 points : `ERROR_ZERO_BALANCE`
6. `task` est présent : `ERROR_TASK_ABSENT`
7. `task.type` existe : `ERROR_TASK_NOT_SUPPORTED`
8. Tous les champs obligatoires sont présents : `ERROR_REQUIRED_FIELDS` (`errorDescription` indique le champ manquant)
9. Pour les tâches d’image, l’image est valide : `ERROR_ZERO_CAPTCHA_FILESIZE`, `ERROR_IMAGE_TYPE_NOT_SUPPORTED`, etc.
## Exemple complet
Créer une tâche et interroger périodiquement (polling) le résultat (type asynchrone) :
**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 — récupérer le résultat
> POST /getTaskResult renvoie le résultat d'une tâche asynchrone. Interrogez toutes les 5 secondes, continuez d'attendre tant que le statut est processing, lisez solution quand il est ready, arrêtez en cas d'erreur ; une tâche dure environ 110 secondes au maximum, le résultat est conservé environ 10 minutes, les requêtes ne débitent aucun point.
Source: https://docs.yescaptcha.com/fr/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` renvoie le résultat d’une tâche asynchrone. Après avoir créé la tâche, appelez-le toutes les 5 secondes : si la réponse est `processing`, continuez d’attendre ; si elle est `ready`, le résultat se trouve dans `solution` ; si elle renvoie une erreur, arrêtez. Les requêtes ne débitent aucun point, quel que soit leur nombre.
- POST `https://api.yescaptcha.com/getTaskResult` (Endpoint mondial)
- POST `https://cn.yescaptcha.com/getTaskResult` (Endpoint Chine)
## Paramètres de la requête
| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `clientKey` | string | Oui | Votre ClientKey, la même que celle utilisée pour créer la tâche |
| `taskId` | string | Oui | L’ID de tâche renvoyé par [createTask](https://docs.yescaptcha.com/fr/api/create-task.md) |
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"taskId": "61138bb6-19fb-11ec-a9c8-0242ac110006"
}
```
## Réponse
| Situation | Réponse | Que faire |
| --- | --- | --- |
| En cours | `errorId` vaut 0, `status` vaut `processing` | Réessayez dans 5 secondes |
| Terminée | `errorId` vaut 0, `status` vaut `ready`, le résultat est dans `solution` | Lisez `solution` ; ses champs sont décrits sur la page de chaque type de tâche |
| Échec de la résolution | `errorId` vaut 1, `errorCode` vaut `ERROR_CAPTCHA_UNSOLVABLE` | Remboursement de points automatique ; vous pouvez créer une nouvelle tâche |
| Délai dépassé | `errorId` vaut 1, `errorCode` vaut `ERROR_TASK_TIMEOUT` | Remboursement de points automatique ; vous pouvez créer une nouvelle tâche |
| Tâche inexistante ou expirée | `errorId` vaut 1, `errorCode` vaut `ERROR_TASKID_INVALID` | Cessez d’interroger ce `taskId` |
Exemple de tâche terminée (reCAPTCHA v2) :
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"gRecaptchaResponse": "03AGdBq25SxXT-pmSeBXjzScW-EiocHwwpwqtk1QXlJnGnU..."
}
}
```
## Règles
- **Interrogez toutes les 5 secondes.** Une nouvelle requête pour le même `taskId` dans les 5 secondes renvoie directement `processing` ; interroger plus souvent n’accélère rien.
- **Une tâche est traitée pendant environ 110 secondes au maximum** (180 à 220 secondes pour quelques types). Au-delà, `ERROR_TASK_TIMEOUT` est renvoyé et les points sont remboursés automatiquement. Dans votre programme, fixez la durée maximale d’attente à environ 3 minutes.
- **Le résultat est conservé environ 10 minutes**, après quoi le `taskId` n’est plus valide et renvoie `ERROR_TASKID_INVALID`. Utilisez le résultat dès que vous l’obtenez : la durée de validité du token est plus courte (environ 120 secondes pour reCAPTCHA).
- **Arrêtez en cas d’erreur.** Après `errorId: 1`, continuer d’interroger le même `taskId` ne change pas le résultat ; à partir de la 3e requête sur une tâche déjà terminée, la fin de `errorDescription` vous invite à arrêter l’interrogation périodique (polling). `ERROR_TASKID_INVALID` compte dans les erreurs de la [suspension automatique](https://docs.yescaptcha.com/fr/api/rate-limits.md) (une seule fois par ID).
- Interrogez le endpoint sur lequel vous avez créé la tâche.
- `getTaskResult` n’est pas concerné par la suspension automatique : les tâches créées avant la suspension restent consultables.
---
# getBalance : consulter le solde
> POST /getBalance renvoie le solde du compte en points (1,000 points = ¥1) ainsi que les soldes de part développeur et de récompense de parrainage. Sans débit de points ; pratique pour vérifier votre ClientKey.
Source: https://docs.yescaptcha.com/fr/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` renvoie les points restants du compte (1,000 points = ¥1) ainsi que les soldes de part développeur et de récompense de parrainage (en yuans). Il n’y a aucun débit de points ; cette méthode sert souvent à vérifier qu’un `clientKey` est correct.
- POST `https://api.yescaptcha.com/getBalance` (Endpoint mondial)
- POST `https://cn.yescaptcha.com/getBalance` (Endpoint Chine)
## Paramètres de la requête
| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `clientKey` | string | Oui | Clé du compte |
```json
{
"clientKey": "YOUR_CLIENT_KEY"
}
```
## Réponse
```json
{
"errorId": 0,
"balance": 1071810,
"softBalance": 36.0098,
"inviteBalance": 0,
"inviteBy": 0
}
```
| Champ | Type | Description |
| --- | --- | --- |
| `balance` | integer | Solde du compte, en points (1,000 points = ¥1). Il doit être supérieur à 10 points pour créer une tâche |
| `softBalance` | number | Solde de la part développeur, en yuans ; voir [Part développeur](https://docs.yescaptcha.com/fr/account/developer.md) |
| `inviteBalance` | number | Solde des récompenses de parrainage, en yuans ; voir [Récompense de parrainage](https://docs.yescaptcha.com/fr/account/referral.md) |
| `inviteBy` | integer | ID utilisateur de la personne qui vous a invité, 0 s’il n’y en a pas |
| `keyQuotaRemaining` | integer | Limite de dépenses restante de ce `clientKey` pour la période en cours, en points. Ce champ n’existe que pour un `clientKey` ayant une limite ; `balance` est alors la plus petite valeur entre le solde du compte et la limite restante. Il est absent pour un `clientKey` sans limite |
Un `clientKey` incorrect renvoie `ERROR_KEY_DOES_NOT_EXIST` ; si le `clientKey` a une liste blanche d’IP et que la requête provient d’une IP absente de cette liste, la réponse est `ERROR_KEY_IP_NOT_ALLOWED`. `getBalance` est soumis à la [suspension automatique](https://docs.yescaptcha.com/fr/api/rate-limits.md) : pendant une suspension, il renvoie `ERROR_IP_BLOCKED_5MIN`.
## Exemples
**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 — consulter votre ID développeur
> POST /getSoftID renvoie votre ID développeur (softID) et le montant cumulé de votre part développeur ; ajoutez le softID aux requêtes createTask que votre logiciel envoie pour d'autres utilisateurs afin de percevoir une part.
Source: https://docs.yescaptcha.com/fr/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` renvoie votre ID développeur (`softID`) et le montant cumulé de votre part développeur (en yuans). Lorsque d’autres personnes utilisent votre logiciel ou votre extension, ajoutez cet ID à leurs requêtes `createTask` : vous recevez une part de ce qu’elles dépensent. Règles de calcul et retrait : [Part développeur](https://docs.yescaptcha.com/fr/account/developer.md).
- POST `https://api.yescaptcha.com/getSoftID` (Endpoint mondial)
- POST `https://cn.yescaptcha.com/getSoftID` (Endpoint Chine)
## Paramètres de la requête
| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `clientKey` | string | Oui | Votre propre ClientKey (celle du développeur) |
```json
{
"clientKey": "YOUR_CLIENT_KEY"
}
```
## Réponse
```json
{
"errorId": 0,
"softID": 3,
"balance": 0.004
}
```
| Champ | Type | Description |
| --- | --- | --- |
| `softID` | integer | Votre ID développeur |
| `balance` | number | Solde cumulé de la part développeur, en yuans |
## Utilisation
Dans les requêtes `createTask` envoyées par les utilisateurs de votre logiciel, ajoutez le champ de premier niveau `softID` :
```json
{
"clientKey": "THE_USERS_CLIENT_KEY",
"task": {
"type": "ImageToTextTaskOcrBase",
"body": "BASE64_IMAGE"
},
"softID": 3
}
```
> **Attention:** Placez `softID` au premier niveau du corps de la requête, au même niveau que `clientKey` et `task`, avec exactement la même casse. À l’intérieur de `task`, il n’a aucun effet.
`clientKey` est la ClientKey de l’utilisateur, et les points sont débités de son compte ; `softID` est votre ID développeur.
---
# report — signaler le résultat
> POST /report indique à YesCaptcha si les résultats des tâches étaient corrects ; signalez honnêtement les succès comme les échecs ; les tâches de reconnaissance d'images signalées comme échouées dans l'heure suivant leur création font l'objet d'un remboursement de points après environ 24 heures.
Source: https://docs.yescaptcha.com/fr/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/
`report` nous indique si le résultat d’un groupe de tâches était correct. **Signalez les succès comme les échecs.** Lorsqu’une tâche de reconnaissance d’images est signalée comme erronée, les points sont remboursés après environ 24 heures si elle remplit les conditions ; les signalements servent aussi à évaluer et à améliorer la reconnaissance.
- POST `https://api.yescaptcha.com/report` (Endpoint mondial)
- POST `https://cn.yescaptcha.com/report` (Endpoint Chine)
## Paramètres de la requête
| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `id` | array of string | Oui | Liste d’ID de tâche ; vous pouvez en signaler plusieurs à la fois |
| `isSuccess` | boolean | Oui | `true` si le résultat était correct, `false` s’il était erroné |
`clientKey` n’est pas nécessaire : l’ID de tâche suffit à identifier la tâche.
```json
{
"id": ["610ff5e0-68eb-11ef-95a6-22e70a0b794d", "65b88c06-68eb-11ef-8e9a-52540023ccb3"],
"isSuccess": false
}
```
## Réponse
```json
{
"errorId": 0,
"status": "success"
}
```
## Signalez honnêtement
Les signalements servent à la fois à calculer le remboursement de points et à évaluer et améliorer la reconnaissance. Signalez le résultat réel :
- Signalez `isSuccess: true` pour les tâches reconnues correctement et `false` pour les erreurs. Les signalements qui ne contiennent que des échecs, ou qui déclarent tout en échec quel que soit le résultat, ne sont pas pris en compte dans les statistiques ni dans le règlement.
- Le taux d’échec est calculé sur l’ensemble des tâches que vous avez créées pendant la période, et pas seulement sur celles que vous avez signalées. Signaler davantage d’échecs ne rapporte pas davantage de remboursement : si votre taux d’échec est nettement supérieur à celui de la même période, le remboursement est calculé uniquement au taux d’échec de la période.
- Lorsqu’une vérification utilise plusieurs images (par exemple FunCaptcha, qui demande 5 tours) et que vous ne savez pas laquelle était erronée, vous pouvez signaler tout le groupe de tâches comme échoué ; lorsque la vérification est réussie, signalez de la même façon tout le groupe comme réussi.
## Remboursement après signalement d’un échec
- Seuls 5 types de reconnaissance d’images donnent droit à un remboursement : `FunCaptchaClassification`, `HCaptchaClassification`, `ReCaptchaV2Classification`, `AwsClassification` et `bCaptchaClassification`.
- Seuls les signalements effectués **dans l’heure** suivant la création de la tâche sont pris en compte ; une même tâche n’est remboursée qu’une seule fois.
- Le remboursement n’est pas immédiat : il est réglé en une fois **après environ 24 heures**.
- Lors du règlement, votre taux d’échec signalé est comparé à celui des autres utilisateurs sur les mêmes questions pendant la même période ; s’il est nettement supérieur au niveau de la période, le remboursement est calculé au taux d’échec de la période.
- Si vous contestez un règlement, [contactez le support](https://docs.yescaptcha.com/fr/help/contact.md).
Pour les types qui renvoient un token (reCAPTCHA, hCaptcha, Turnstile, FunCaptcha, etc.), c’est le site cible qui décide si le token est accepté ; les signalements ne donnent donc pas lieu à un remboursement. Récapitulatif des règles de facturation : [Facturation et remboursement de points](https://docs.yescaptcha.com/fr/getting-started/billing.md).
---
# useragent — obtenir le User-Agent
> GET https://api.yescaptcha.com/useragent renvoie le User-Agent de navigateur à utiliser (texte brut). Le champ userAgent des tâches hCaptcha n'accepte que cette valeur.
Source: https://docs.yescaptcha.com/fr/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` renvoie le User-Agent de navigateur actuellement recommandé, en texte brut. Il ne nécessite pas de `clientKey` et n’entraîne aucun débit de points. Le champ `userAgent` des tâches [hCaptcha](https://docs.yescaptcha.com/fr/tasks/hcaptcha.md) n’accepte que cette valeur ; l’utiliser aussi pour visiter le site cible aide les tokens à passer plus facilement.
- GET `https://api.yescaptcha.com/useragent` (Endpoint mondial)
- GET `https://cn.yescaptcha.com/useragent` (Endpoint Chine)
## Exemple
```bash
curl -s https://api.yescaptcha.com/useragent
```
Réponse (valeur du 2026-10-15, mise à jour avec les versions du navigateur) :
```text
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/155.0.0.0 Safari/537.36
```
> **Note:** La valeur change régulièrement. Ne l’écrivez pas en dur dans votre code : récupérez-la une fois au démarrage.
- Si le résultat contient un `userAgent`, utilisez cette valeur pour soumettre le token.
---
# Codes d'erreur
> Tous les codes d'erreur de l'API YesCaptcha avec leur signification et la marche à suivre : format de la requête, compte et solde, tâches simultanées et suspension, résultat de la tâche, paramètres du site, images, proxy, serveur. Les requêtes qui renvoient une erreur ne sont pas débitées.
Source: https://docs.yescaptcha.com/fr/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/
En cas d’échec, l’API renvoie `errorId: 1`, un code d’erreur dans `errorCode` et une description textuelle dans `errorDescription`. Les requêtes qui renvoient une erreur ne sont pas débitées : aucun débit de points si l’erreur survient à la création de la tâche, et remboursement automatique de points si la tâche échoue ou expire après sa création.
> **Astuce:** Dans votre code, testez `errorCode` et non le texte de `errorDescription`, qui peut changer.
```json
{
"errorId": 1,
"errorCode": "ERROR_ZERO_BALANCE",
"errorDescription": "帐户余额不足"
}
```
## Marche à suivre
1. **Erreurs de paramètres** (format de la requête, ClientKey, type de tâche, paramètres du site, images) : renvoyer la même requête ne changera rien, corrigez-la d’abord.
2. **Échecs de reconnaissance et expirations** (`ERROR_CAPTCHA_UNSOLVABLE`, `ERROR_TASK_TIMEOUT`) : vous pouvez créer une nouvelle tâche.
3. Après une erreur, **arrêtez l’interrogation périodique (polling)** de ce `taskId` et ne renvoyez pas la même requête à haute fréquence.
4. Pour les erreurs marquées « compte pour la suspension automatique », un même `clientKey` qui en accumule 100 en une minute voit la création de tâches suspendue pendant 5 minutes. Les erreurs marquées « en cache » ne comptent pas, mais pendant la durée du cache, la même requête renvoie directement la même erreur. Voir [Limite de tâches simultanées et suspension automatique](https://docs.yescaptcha.com/fr/api/rate-limits.md).
## Tous les codes d’erreur
### Format de la requête
| Code d'erreur | Signification | Que faire |
| --- | --- | --- |
| `ERROR_REQUIRED_FIELDS` | Un champ obligatoire est manquant (par exemple `clientKey`, ou `websiteURL` / `websiteKey` pour le type de tâche), ou le corps de la requête n'est pas du JSON | Ajoutez les champs manquants indiqués sur la page du type de tâche, et envoyez du JSON avec `POST` et `Content-Type: application/json` |
| `ERROR_REQUEST_FORMATS` (Compte pour la suspension) | Le corps de la requête n'est pas du JSON valide | Construisez le corps avec une bibliothèque JSON plutôt que par concaténation de chaînes ; le JSON ne doit pas contenir de commentaires `//` |
| `ERROR_TASK_ABSENT` (Compte pour la suspension) | Le champ `task` est manquant dans un appel à `createTask` | Placez les paramètres de la tâche dans un objet `task`. Avec Python requests, utilisez `json=data` et non `data=data` |
| `ERROR_TASK_NOT_SUPPORTED` (Compte pour la suspension) | `task.type` est mal orthographié ou le type a été retiré | Copiez le nom du type depuis « Types de tâches et tarifs » ; les noms sont sensibles à la casse |
| `ERROR_PAGE_NOT_FOUND` | Le chemin demandé n'existe pas | Vérifiez l'URL de l'endpoint, par ex. `https://api.yescaptcha.com/createTask` ; les noms de méthodes sont sensibles à la casse |
| `ERROR_BAD_REQUEST` | La requête ne peut pas être traitée, généralement à cause d'une méthode HTTP incorrecte (GET au lieu de POST) ou de valeurs de paramètres invalides | Envoyez du JSON avec `POST`, et vérifiez les types et les valeurs des paramètres |
| `ERROR_ILLEGAL_PARAMETERS` | La valeur d'un paramètre est invalide. Cas typique pour la page de vérification Cloudflare : `websiteURL` n'est pas une URL publique en `http://` / `https://`, `postData` n'est pas un objet, ou `requiredCookies` n'est pas un tableau de chaînes (renvoyé par createTask, sans débit de points) ; ou le domaine cible n'a pas pu être résolu via le proxy (renvoyé par getTaskResult, remboursement de points automatique) | Corrigez la valeur en vous aidant du tableau des paramètres sur la page du type de tâche. Si le domaine n'a pas pu être résolu, vérifiez l'orthographe de l'URL et si le proxy peut accéder au site |
### Compte et solde
| Code d'erreur | Signification | Que faire |
| --- | --- | --- |
| `ERROR_KEY_DOES_NOT_EXIST` (Compte pour la suspension) | La `clientKey` n'existe pas : des caractères ont été ajoutés ou perdus lors de la copie, ou la clé a été réinitialisée dans le tableau de bord | Copiez à nouveau la clé depuis le tableau de bord de yescaptcha.com, sans espaces ni sauts de ligne |
| `ERROR_KEY_EXPIRED` (Compte pour la suspension) | La `clientKey` a expiré (renvoyée par createTask et getBalance, sans débit de points). Soit elle est restée inutilisée pendant longtemps et le système a défini une date d'expiration pour protéger le compte (un e-mail de rappel est envoyé avant l'expiration), soit la date d'expiration définie pour cette `clientKey` est dépassée | Connectez-vous au Tableau de bord de yescaptcha.com. Si elle a expiré après une longue période d'inutilisation, générez une nouvelle `clientKey` ; le solde est transféré automatiquement vers la nouvelle. Si une date d'expiration a été définie, modifiez-la ou utilisez une autre `clientKey`. Mettez ensuite à jour votre programme avec la nouvelle `clientKey` |
| `ERROR_KEY_IP_NOT_ALLOWED` | Ce `clientKey` a une liste d'adresses IP autorisées et l'IP d'où provient la requête n'y figure pas (renvoyée par createTask et getBalance, aucun débit de points, ne compte pas pour la suspension automatique) | Connectez-vous au Tableau de bord sur yescaptcha.com et ajoutez l'IP publique de la machine qui envoie les requêtes à la liste d'adresses autorisées de ce `clientKey`, ou utilisez un autre `clientKey`. Si plusieurs machines appellent l'API, ajoutez l'IP publique de chacune (il s'agit de l'IP qui appelle l'API YesCaptcha, pas du proxy indiqué dans les paramètres de la tâche) |
| `ERROR_KEY_QUOTA_EXCEEDED` | Ce `clientKey` a une limite de dépenses et ce qu'il en reste pour la période en cours est inférieur au coût de cette tâche (renvoyée par createTask, aucun débit de points, ne compte pas pour la suspension automatique). La limite compte les points réellement débités ; les points remboursés pour les tâches échouées ou expirées sont recrédités à la limite | Connectez-vous au Tableau de bord sur yescaptcha.com et augmentez la limite de ce `clientKey`, attendez la période suivante (elle est remise à zéro chaque jour, chaque lundi ou le 1er de chaque mois, heure de Pékin ; une limite ponctuelle n'est pas remise à zéro), ou utilisez un autre `clientKey`. `getBalance` renvoie la limite restante de ce `clientKey` (`keyQuotaRemaining`) |
| `ERROR_ZERO_BALANCE` | Solde insuffisant. Le solde doit être supérieur à 10 points pour créer une tâche | Rechargez votre compte puis réessayez. Utilisez `getBalance` pour consulter le solde |
### Tâches simultanées et suspensions
| Code d'erreur | Signification | Que faire |
| --- | --- | --- |
| `ERROR_THREADS_MAXIMUM` (Compte parfois pour la suspension) | Trop de tâches de ce type sont en cours pour le compte. `limit` dans la réponse est la limite actuelle. La requête n'a pas été traitée et aucun débit de points n'a eu lieu | Attendez que les requêtes en cours reviennent, ou attendez 1–2 secondes puis réessayez ; limitez le nombre de requêtes en attente simultanément |
| `ERROR_IP_BLOCKED_5MIN` | Cette `clientKey` a produit trop d'erreurs en peu de temps et a été suspendue automatiquement. `retryAfter` est le nombre de secondes restantes et `blockReason` est l'erreur à l'origine de la suspension | Corrigez la requête en fonction de `blockReason` et attendez `retryAfter` secondes ; envoyer des requêtes pendant la suspension ne la prolonge pas |
| `ERROR_NO_SLOT_AVAILABLE` | Le service de résolution est temporairement surchargé. Lorsque l'erreur est renvoyée par createTask, aucun point n'est débité ; une tâche restée trop longtemps dans la file d'attente la renvoie aussi depuis getTaskResult, et ses points sont remboursés automatiquement | Attendez quelques secondes, puis créez à nouveau la tâche |
### Tâches et résultats
| Code d'erreur | Signification | Que faire |
| --- | --- | --- |
| `ERROR_TASKID_INVALID` (Compte pour la suspension) | Le `taskId` n'existe pas, a expiré (les résultats sont conservés environ 10 minutes), appartient à un autre `clientKey` ou a été créé sur l'autre endpoint | Arrêtez l'interrogation périodique (polling) de cette tâche. Interrogez-la avec le même endpoint et le même `clientKey` que ceux qui l'ont créée |
| `ERROR_TASK_TIMEOUT` | La tâche ne s'est pas terminée dans le délai imparti (généralement 110 secondes) ; les points ont été remboursés automatiquement | Créez une nouvelle tâche ; si le délai est systématiquement dépassé, essayez un autre type de tâche pour le même captcha |
| `ERROR_CAPTCHA_UNSOLVABLE` | Le captcha n'a pas pu être résolu cette fois ; les points ont été remboursés. Cette erreur ne compte pas pour la suspension automatique | Créez une nouvelle tâche. Si les échecs persistent, vérifiez `websiteURL`, `websiteKey` et les autres paramètres, ou essayez un autre type de tâche pour le même captcha |
| `ERROR_SETTLEMENT_FAILED` (Compte pour la suspension) | Le solde était insuffisant lors du règlement, donc aucun résultat n'a été renvoyé | Rechargez votre compte, puis créez une nouvelle tâche |
| `ERROR_NO_SUCH_CAPCHA_ID` | La tâche n'est plus valide | Arrêtez l'interrogation périodique (polling) de cette tâche et créez-en une nouvelle |
| `ERROR_RECAPTCHA_TIMEOUT` | La résolution du captcha a expiré ; les points ont été remboursés | Créez une nouvelle tâche |
### Paramètres du site cible
| Code d'erreur | Signification | Que faire |
| --- | --- | --- |
| `ERROR_RECAPTCHA_INVALID_SITEKEY` (En cache, sans suspension) | Le `websiteKey` est invalide | Retrouvez le sitekey dans la page (voir les guides pour trouver les paramètres). Pendant la période de cache, les requêtes identiques renvoient directement cette erreur, avec `cached: true` |
| `ERROR_RECAPTCHA_INVALID_DOMAIN` (En cache, sans suspension) | Le domaine de `websiteURL` ne correspond pas au `websiteKey` | Renseignez dans `websiteURL` la page qui affiche le captcha |
| `ERROR_INVALID_KEY_TYPE` (En cache, sans suspension) | Le sitekey appartient à un autre captcha, par exemple une clé v3 utilisée avec un type de tâche v2 | Identifiez d'abord le captcha (voir « Identifier le type de captcha »), puis choisissez le type de tâche correspondant ; pour la version v2 invisible, renseignez `isInvisible` |
| `ERROR_DOMAIN_NOT_ALLOWED` (En cache, sans suspension) | Ce site n'est pas pris en charge | Essayez un autre type de tâche pour le même captcha, ou contactez le support |
| `ERROR_HIGH_DEMAND_DOMAIN` (Compte pour la suspension) | Ce site n'est pas pris en charge | Arrêtez d'envoyer des tâches pour ce site et contactez le support |
| `ERROR_FAILED_LOADING_WIDGET` | Le captcha n'a pas pu être chargé avec les paramètres fournis | Vérifiez `websiteURL` et `websiteKey` ; pour les types de tâche avec votre propre proxy, vérifiez que le proxy peut accéder au site |
### Images
| Code d'erreur | Signification | Que faire |
| --- | --- | --- |
| `ERROR_ZERO_CAPTCHA_FILESIZE` (Compte pour la suspension) | L'image est vide ou trop petite | Vérifiez que les données Base64 sont complètes et sans préfixe `data:image/...;base64,` |
| `ERROR_TOO_BIG_CAPTCHA_FILESIZE` (Compte pour la suspension) | L'image est trop volumineuse | Compressez ou réduisez l'image ; le corps complet de la requête ne doit pas dépasser 6 MB |
| `ERROR_IMAGE_TYPE_NOT_SUPPORTED` (Compte pour la suspension) | Le format de l'image n'est pas pris en charge, ou l'image n'est pas de celles que ce type de tâche peut traiter. Une seule occurrence suspend la clé pendant 30 minutes | Utilisez du JPG ou du PNG et vérifiez que l'image correspond au type de tâche, par exemple la reconnaissance d'images reCAPTCHA exige 100x100, 300x300 ou 450x450 |
| `ERROR_ILLEGAL_IMAGE` (Compte pour la suspension) | La taille de l'image ne respecte pas les exigences de ce type de tâche | Redimensionnez l'image comme indiqué sur la page du type de tâche |
| `ERROR_PARSE_IMAGE_FAIL` | L'image n'a pas pu être décodée, souvent parce que le Base64 est tronqué ou comporte un préfixe | Vérifiez l'encodage Base64 et supprimez le préfixe `data:` ainsi que les sauts de ligne |
| `ERROR_UNKNOWN_QUESTION` | Le champ `question` est incorrect, ou cette question n'est pas encore prise en charge | Comparez-le avec la liste des questions de la page du type de tâche. Pour les questions non prises en charge, contactez le support ; les nouvelles questions sont généralement prises en charge sous 3 jours ouvrés |
| `ERROR_UNKNOW_450x450_QUESTION` | Cette question n'est pas encore prise en charge pour les images 4x4 (450x450) | Rechargez le défi dans la page pour obtenir une autre question |
### Proxys
| Code d'erreur | Signification | Que faire |
| --- | --- | --- |
| `ERROR_PROXY_CONNECT_REFUSED` | Le proxy a refusé la connexion | Vérifiez l'adresse, le port et le protocole du proxy, et assurez-vous qu'il accepte les connexions externes (pas une adresse locale comme 127.0.0.1) |
| `ERROR_PROXY_CONNECT_TIMEOUT` | La connexion au proxy a expiré | Utilisez un proxy plus fiable |
| `ERROR_PROXY_READ_TIMEOUT` | La lecture via le proxy a expiré | Utilisez un proxy plus rapide |
| `ERROR_PROXY_BANNED` | Le proxy est indisponible, ou son IP est bloquée par le site cible | Utilisez un autre proxy |
| `ERROR_PROXY_INCORRECT` | Les paramètres du proxy sont mal formés | Vérifiez le format de `proxyType`, `proxyAddress`, `proxyPort` (ou de la chaîne `proxy`) |
| `ERROR_PROXY_TRANSPARENT` | Le proxy est transparent et expose la vraie IP | Utilisez un proxy anonyme (élite) |
| `ERROR_PROXY_NOT_AUTHORISED` | Le nom d'utilisateur ou le mot de passe du proxy est incorrect | Vérifiez `proxyLogin` et `proxyPassword` (ou les identifiants dans la chaîne `proxy`) |
| `ERROR_PROXY_TLS_ERROR` | La négociation TLS avec le proxy a échoué, souvent parce que `proxyType` est incorrect (par exemple https renseigné pour un proxy http) | Vérifiez le protocole du proxy |
| `ERROR_PROXY_CONNECTION_FAILED` | Impossible de se connecter au serveur proxy | Vérifiez l'adresse et le port du proxy, et assurez-vous que le proxy fonctionne |
### Serveur
| Code d'erreur | Signification | Que faire |
| --- | --- | --- |
| `ERROR_SERVICE_UNAVALIABLE` | Le service est temporairement indisponible (le code s'écrit `UNAVALIABLE`) | Réessayez plus tard ; contactez le support si le problème persiste |
| `ERROR_INTERNAL_SERVER_ERROR` | Une erreur interne du serveur s'est produite | Réessayez plus tard ; si le problème persiste, contactez le support en indiquant le `taskId` |
| `ERROR_UNKNOWN` | Une erreur non classée | Réessayez plus tard ; si le problème persiste, contactez le support en indiquant le `taskId` |
## Champs supplémentaires
Certaines réponses d’erreur contiennent des champs supplémentaires :
| Champ | Présent avec | Description |
| --- | --- | --- |
| `retryAfter` | `ERROR_IP_BLOCKED_5MIN`, erreurs en cache | Nombre de secondes à attendre |
| `blockReason` | `ERROR_IP_BLOCKED_5MIN` | Code d’erreur à l’origine de la suspension |
| `blockDetail` | `ERROR_IP_BLOCKED_5MIN` | Type, URL et sitekey des requêtes à l’origine de la suspension, pour faciliter le diagnostic |
| `cached` | Erreurs en cache | `true` indique une réponse en cache, aucune reconnaissance n’a eu lieu |
| `badRequest` | Erreurs en cache | Paramètres ayant déclenché le cache |
| `limit` | `ERROR_THREADS_MAXIMUM` | Votre limite actuelle de tâches simultanées |
Pour la langue de `errorDescription`, voir [Requêtes et réponses](https://docs.yescaptcha.com/fr/api/overview.md).
---
# Limite de tâches simultanées et suspension automatique
> Limite de tâches simultanées de YesCaptcha (ERROR_THREADS_MAXIMUM, sans débit de points ni comptage pour la suspension), suspension automatique en cas d'erreurs trop nombreuses (100 par minute entraînent 5 minutes de suspension, ERROR_IP_BLOCKED_5MIN) et cache des paramètres invalides (cached).
Source: https://docs.yescaptcha.com/fr/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/
Pour que la reconnaissance reste rapide pour tous les utilisateurs, YesCaptcha applique trois règles de protection : une limite du **nombre de tâches en cours de traitement simultanément** par compte (limite de tâches simultanées) ; une **suspension de quelques minutes** pour un `clientKey` qui génère trop d’erreurs en peu de temps (suspension automatique) ; et un **cache des paramètres déjà jugés invalides**, qui renvoie l’erreur d’origine pendant un certain temps (cache des paramètres invalides). Aucun de ces trois cas n’entraîne de débit de points.
## Limite de tâches simultanées
Nous limitons, par compte et par type de tâche, le nombre de tâches en cours de traitement au même instant. Il s’agit d’une limite de tâches simultanées, pas d’un nombre de requêtes par minute.
- Une tâche est « en cours » depuis l’appel de `createTask` jusqu’au retour de cet appel. Les types de reconnaissance d’images renvoient le résultat directement dans `createTask`, donc **nombre de tâches simultanées ≈ tâches envoyées par seconde × durée de chaque tâche**. Par exemple, avec 0.5 seconde par tâche et 40 tâches par seconde, on obtient environ 20 tâches simultanées.
- Les requêtes d’un même compte sont comptées ensemble ; chaque type de tâche est compté séparément.
- Les requêtes au-delà du quota renvoient immédiatement `ERROR_THREADS_MAXIMUM`, et `limit` dans la réponse indique votre limite actuelle. **Aucun débit de points, et la requête n’est pas comptée pour la suspension automatique.**
- Quand les serveurs de reconnaissance sont surchargés, pour le compte qui consomme le plus de temps de reconnaissance, la limite de ce type de tâche est **temporairement divisée par deux, puis rétablie automatiquement après 10 minutes**. Il s’agit seulement d’un ralentissement ; le compte n’est pas suspendu.
- Pour obtenir un quota plus élevé, [contactez le support](https://docs.yescaptcha.com/fr/help/contact.md). Une fois les quotas par défaut de chaque type définis, ils seront publiés sur cette page et dans le [journal des mises à jour du service](https://docs.yescaptcha.com/fr/changelog.md).
```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
}
```
(Les nombres de l’exemple sont donnés à titre indicatif.)
### Bonnes pratiques
1. Limitez dans votre programme le « nombre de requêtes en attente de résultat en même temps », par exemple avec un sémaphore (Semaphore) ou un pool de threads de taille fixe, plutôt que de ne contrôler que le nombre de requêtes par seconde.
2. Après un `ERROR_THREADS_MAXIMUM`, attendez que les requêtes déjà envoyées reviennent avant d’en envoyer de nouvelles, ou patientez 1 à 2 secondes avant de réessayer. Ne réessayez pas immédiatement en boucle.
3. Répartissez les tâches en lot de façon régulière ; n’envoyez pas des milliers de tâches d’un coup.
Exemple en 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
```
## Suspension automatique
Lorsqu’un même `clientKey` génère un grand nombre de requêtes en erreur en peu de temps, la création de tâches est automatiquement suspendue :
| Condition de déclenchement | Durée de la suspension |
| --- | --- |
| 100 erreurs de la liste ci-dessous au cours de la même minute calendaire | 5 minutes |
| 1 occurrence de `ERROR_IMAGE_TYPE_NOT_SUPPORTED` | 30 minutes |
| 1,000 correspondances avec le « cache des paramètres invalides » au cours de la même minute calendaire | 5 minutes |
Erreurs comptant pour la suspension :
- [`ERROR_REQUEST_FORMATS`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_REQUEST_FORMATS)
- [`ERROR_TASK_ABSENT`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_TASK_ABSENT)
- [`ERROR_TASK_NOT_SUPPORTED`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_TASK_NOT_SUPPORTED)
- [`ERROR_KEY_DOES_NOT_EXIST`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_KEY_DOES_NOT_EXIST)
- [`ERROR_KEY_EXPIRED`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_KEY_EXPIRED)
- [`ERROR_TASKID_INVALID`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_TASKID_INVALID)
- [`ERROR_SETTLEMENT_FAILED`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_SETTLEMENT_FAILED)
- [`ERROR_HIGH_DEMAND_DOMAIN`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_HIGH_DEMAND_DOMAIN)
- [`ERROR_ZERO_CAPTCHA_FILESIZE`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_ZERO_CAPTCHA_FILESIZE)
- [`ERROR_TOO_BIG_CAPTCHA_FILESIZE`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_TOO_BIG_CAPTCHA_FILESIZE)
- [`ERROR_IMAGE_TYPE_NOT_SUPPORTED`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_IMAGE_TYPE_NOT_SUPPORTED)
- [`ERROR_ILLEGAL_IMAGE`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_ILLEGAL_IMAGE)
L’erreur `ERROR_THREADS_MAXIMUM` renvoyée lorsque la limite de tâches simultanées du compte est dépassée (avec le champ `limit`) n’est pas comptée ; l’erreur du même nom renvoyée quand le service de reconnaissance est surchargé (sans `limit`) l’est. Les échecs de reconnaissance (`ERROR_CAPTCHA_UNSOLVABLE`), le solde insuffisant (`ERROR_ZERO_BALANCE`), les champs manquants (`ERROR_REQUIRED_FIELDS`), les questions non prises en charge (`ERROR_UNKNOWN_QUESTION`) et autres ne sont pas comptés.
Pendant la suspension :
- Seuls `createTask` et `getBalance` sont concernés, et renvoient `ERROR_IP_BLOCKED_5MIN`. `getTaskResult` n’est pas affecté : les tâches créées avant la suspension peuvent toujours être consultées.
- La réponse contient `retryAfter` (nombre de secondes restantes), `blockReason` (le code d’erreur qui a déclenché la suspension) et `blockDetail` (le type, l’URL et le sitekey de ces requêtes) ; utilisez-les pour corriger votre programme.
- Continuer à envoyer des requêtes ne prolonge pas la suspension, qui se termine automatiquement à l’échéance ; il n’est pas nécessaire de contacter le support.
- Le Tableau de bord sur [yescaptcha.com](https://yescaptcha.com/) affiche les suspensions des dernières 24 heures.
```json
{
"errorId": 1,
"errorCode": "ERROR_IP_BLOCKED_5MIN",
"errorDescription": "...",
"retryAfter": 182,
"blockReason": "ERROR_TASK_NOT_SUPPORTED"
}
```
## Cache des paramètres invalides
Certaines erreurs dépendent des paramètres de la requête : renvoyer les mêmes paramètres donnera le même résultat :
- [`ERROR_RECAPTCHA_INVALID_SITEKEY`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_RECAPTCHA_INVALID_SITEKEY)
- [`ERROR_RECAPTCHA_INVALID_DOMAIN`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_RECAPTCHA_INVALID_DOMAIN)
- [`ERROR_INVALID_KEY_TYPE`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_INVALID_KEY_TYPE)
- [`ERROR_DOMAIN_NOT_ALLOWED`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_DOMAIN_NOT_ALLOWED)
Ces erreurs ne comptent pas pour la suspension automatique ; elles sont mises en cache pour l’ensemble du site : 2 minutes après le premier constat, et 10 minutes si elles sont de nouveau confirmées dans l’heure. Pendant la durée du cache, une requête identique (même type de tâche et même `websiteKey`, ou même nom de domaine) renvoie directement l’erreur d’origine, sans débit de points, avec `"cached": true`, `retryAfter` (secondes restantes dans le cache) et `badRequest` (le paramètre concerné). La correction du `websiteKey` ou le changement de type de tâche prend effet immédiatement.
## Différence entre limite de tâches simultanées et suspension automatique
| | Limite de tâches simultanées | Suspension automatique |
| --- | --- | --- |
| Cause | Trop de tâches en cours de traitement en même temps | Trop de requêtes en erreur en peu de temps |
| Effet | Seules les requêtes excédentaires sont rejetées, avec `ERROR_THREADS_MAXIMUM` | Ce `clientKey` ne peut plus créer de tâches, `ERROR_IP_BLOCKED_5MIN` |
| Rétablissement | Dès qu’une requête est terminée, vous pouvez en envoyer une nouvelle ; la réduction de moitié est levée après 10 minutes | Levée automatique à l’échéance |
| Débit de points | Non | Non |
---
# Types de tâches et tarifs
> Tarifs de tous les types de tâches publics de YesCaptcha (en points, 1,000 points = ¥1) et mode de retour : token pour reCAPTCHA, hCaptcha et Turnstile, Cookie pour la page de vérification Cloudflare, résultat de reconnaissance pour le texte dans une image et la reconnaissance d'images.
Source: https://docs.yescaptcha.com/fr/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/
Chaque tâche débite un nombre fixe de points selon son type (1,000 points = ¥1) ; en cas d’échec ou de délai dépassé, les points sont remboursés automatiquement. Le tableau ci-dessous liste tous les types de tâches publics et peut être filtré par nom. Version lisible par machine : [/data/task-types.json](https://docs.yescaptcha.com/data/task-types.json).
| Captcha | Type de tâche | Prix | Mode |
| --- | --- | --- | --- |
| [reCAPTCHA v2](https://docs.yescaptcha.com/fr/tasks/recaptcha-v2.md) | `NoCaptchaTaskProxyless` | $2.25 / 1k; 15 points/tâche · ¥15 / 1k | Asynchrone |
| [reCAPTCHA v2](https://docs.yescaptcha.com/fr/tasks/recaptcha-v2.md) | `RecaptchaV2TaskProxyless` | $3.00 / 1k; 20 points/tâche · ¥20 / 1k | Asynchrone |
| [reCAPTCHA v2](https://docs.yescaptcha.com/fr/tasks/recaptcha-v2.md) | `NoCaptchaTask` Proxy fourni | $2.25 / 1k; 15 points/tâche · ¥15 / 1k | Asynchrone |
| [reCAPTCHA v2](https://docs.yescaptcha.com/fr/tasks/recaptcha-v2.md) | `RecaptchaV2EnterpriseTaskProxyless` | $3.00 / 1k; 20 points/tâche · ¥20 / 1k | Asynchrone |
| [reCAPTCHA v2](https://docs.yescaptcha.com/fr/tasks/recaptcha-v2.md) | `RecaptchaV2EnterpriseTask` Proxy fourni | $3.00 / 1k; 20 points/tâche · ¥20 / 1k | Asynchrone |
| [reCAPTCHA v3](https://docs.yescaptcha.com/fr/tasks/recaptcha-v3.md) | `RecaptchaV3TaskProxyless` | $3.00 / 1k; 20 points/tâche · ¥20 / 1k | Asynchrone |
| [reCAPTCHA v3](https://docs.yescaptcha.com/fr/tasks/recaptcha-v3.md) | `RecaptchaV3TaskProxylessM1` | $3.75 / 1k; 25 points/tâche · ¥25 / 1k | Asynchrone |
| [reCAPTCHA v3](https://docs.yescaptcha.com/fr/tasks/recaptcha-v3.md) | `RecaptchaV3TaskProxylessM1S7` | $4.50 / 1k; 30 points/tâche · ¥30 / 1k | Asynchrone |
| [reCAPTCHA v3](https://docs.yescaptcha.com/fr/tasks/recaptcha-v3.md) | `RecaptchaV3TaskProxylessM1S9` | $5.25 / 1k; 35 points/tâche · ¥35 / 1k | Asynchrone |
| [reCAPTCHA v3](https://docs.yescaptcha.com/fr/tasks/recaptcha-v3.md) | `RecaptchaV3EnterpriseTask` | $3.00 / 1k; 20 points/tâche · ¥20 / 1k | Asynchrone |
| [reCAPTCHA v3](https://docs.yescaptcha.com/fr/tasks/recaptcha-v3.md) | `RecaptchaV3EnterpriseTaskM1` | $3.75 / 1k; 25 points/tâche · ¥25 / 1k | Asynchrone |
| [hCaptcha](https://docs.yescaptcha.com/fr/tasks/hcaptcha.md) | `HCaptchaTaskProxyless` | $4.50 / 1k; 30 points/tâche · ¥30 / 1k | Asynchrone |
| [hCaptcha](https://docs.yescaptcha.com/fr/tasks/hcaptcha.md) | `HCaptchaTaskProxylessM1` | $4.50 / 1k; 30 points/tâche · ¥30 / 1k | Asynchrone |
| [hCaptcha](https://docs.yescaptcha.com/fr/tasks/hcaptcha.md) | `HCaptchaTask` Proxy fourni | $2.25 / 1k; 15 points/tâche · ¥15 / 1k | Asynchrone |
| [Cloudflare Turnstile](https://docs.yescaptcha.com/fr/tasks/turnstile.md) | `TurnstileTaskProxyless` | $3.75 / 1k; 25 points/tâche · ¥25 / 1k | Asynchrone |
| [Cloudflare Turnstile](https://docs.yescaptcha.com/fr/tasks/turnstile.md) | `TurnstileTaskProxylessM1` | $4.50 / 1k; 30 points/tâche · ¥30 / 1k | Asynchrone |
| [Cloudflare Turnstile](https://docs.yescaptcha.com/fr/tasks/turnstile.md) | `TurnstileTask` Proxy fourni | $3.75 / 1k; 25 points/tâche · ¥25 / 1k | Asynchrone |
| [Page de vérification Cloudflare](https://docs.yescaptcha.com/fr/tasks/cloudflare-challenge.md) | `CloudFlareTaskS2` Proxy fourni | $3.75 / 1k; 25 points/tâche · ¥25 / 1k | Asynchrone |
| [Page de vérification Cloudflare](https://docs.yescaptcha.com/fr/tasks/cloudflare-challenge.md) | `CloudFlareTaskS3` Proxy fourni | $3.00 / 1k; 20 points/tâche · ¥20 / 1k | Asynchrone |
| [Image vers texte](https://docs.yescaptcha.com/fr/tasks/image-to-text.md) | `ImageToTextTaskOcrBase` | $0.30 / 1k; 2 points/tâche · ¥2 / 1k | Synchrone |
| [Image vers texte](https://docs.yescaptcha.com/fr/tasks/image-to-text.md) | `ImageToTextTaskMuggle` | $0.30 / 1k; 2 points/tâche · ¥2 / 1k | Synchrone |
| [Image vers texte](https://docs.yescaptcha.com/fr/tasks/image-to-text.md) | `ImageToTextTask` | $0.60 / 1k; 4 points/tâche · ¥4 / 1k | Asynchrone |
| [Image vers texte](https://docs.yescaptcha.com/fr/tasks/image-to-text.md) | `ImageToTextTaskM1` | $2.25 / 1k; 15 points/tâche · ¥15 / 1k | Asynchrone |
| [Reconnaissance d'images reCAPTCHA v2](https://docs.yescaptcha.com/fr/tasks/recaptcha-classification.md) | `ReCaptchaV2Classification` | $0.90 / 1k; 6 points/tâche · ¥6 / 1k | Synchrone |
| [Reconnaissance d'images hCaptcha](https://docs.yescaptcha.com/fr/tasks/hcaptcha-classification.md) | `HCaptchaClassification` | $1.20 / 1k; 8 points/tâche · ¥8 / 1k | Synchrone |
| [Reconnaissance d'images FunCaptcha](https://docs.yescaptcha.com/fr/tasks/funcaptcha-classification.md) | `FunCaptchaClassification` | $0.45 / 1k; 3 points/tâche · ¥3 / 1k | Synchrone |
| [Reconnaissance d'images AWS WAF / bCaptcha](https://docs.yescaptcha.com/fr/tasks/aws-bcaptcha-classification.md) | `AwsClassification` | $1.20 / 1k; 8 points/tâche · ¥8 / 1k | Synchrone |
| [Reconnaissance d'images AWS WAF / bCaptcha](https://docs.yescaptcha.com/fr/tasks/aws-bcaptcha-classification.md) | `bCaptchaClassification` | $1.20 / 1k; 8 points/tâche · ¥8 / 1k | Synchrone |
Les prix en dollars américains sont des estimations avec 1 USD ≈ ¥6.67 (2026-10-27). Les tâches sont facturées en points : 1,000 points = ¥1 pour une recharge en CNY ; les recharges en dollars américains (PayPal, cryptomonnaies) sont converties en CNY au taux de change du moment du paiement, puis en points.
## Comment choisir
| Ce que vous voulez faire | Quel type utiliser | Ce que vous obtenez |
| --- | --- | --- |
| Obtenir un token et le soumettre directement, sans cliquer sur les images | [reCAPTCHA v2](https://docs.yescaptcha.com/fr/tasks/recaptcha-v2.md), [reCAPTCHA v3](https://docs.yescaptcha.com/fr/tasks/recaptcha-v3.md), [hCaptcha](https://docs.yescaptcha.com/fr/tasks/hcaptcha.md), [Turnstile](https://docs.yescaptcha.com/fr/tasks/turnstile.md) | Un token, en asynchrone |
| Passer la page de vérification Cloudflare (« Un instant… ») | [Page de vérification Cloudflare](https://docs.yescaptcha.com/fr/tasks/cloudflare-challenge.md) | Cookie, User-Agent et contenu de la page, en asynchrone |
| Cliquer vous-même sur les images dans le navigateur | [Reconnaissance d’images reCAPTCHA v2](https://docs.yescaptcha.com/fr/tasks/recaptcha-classification.md), [reconnaissance d’images hCaptcha](https://docs.yescaptcha.com/fr/tasks/hcaptcha-classification.md), [reconnaissance d’images FunCaptcha](https://docs.yescaptcha.com/fr/tasks/funcaptcha-classification.md), [reconnaissance d’images AWS WAF / bCaptcha](https://docs.yescaptcha.com/fr/tasks/aws-bcaptcha-classification.md) | Les images ou la position où cliquer, en synchrone |
| Lire les caractères d’une image | [Texte dans une image](https://docs.yescaptcha.com/fr/tasks/image-to-text.md) | Du texte, le plus souvent en synchrone |
Vous ne savez pas de quel captcha il s’agit ? Consultez [Identifier le type de captcha](https://docs.yescaptcha.com/fr/guides/identify-captcha.md).
## Logique des noms
- **`Proxyless`** : le captcha est chargé depuis notre réseau, aucun proxy n’est nécessaire. Les types dont le nom ne contient pas `Proxyless` (comme `NoCaptchaTask`, `HCaptchaTask`) utilisent votre propre proxy et exigent les champs de proxy ; ils conviennent quand le site cible vérifie l’IP du visiteur.
- **Suffixes comme `M1`** : une autre voie pour le même captcha, avec les mêmes paramètres et un prix différent. Si le taux de réussite d’un type n’est pas satisfaisant, essayez l’autre ; ils peuvent aussi se servir mutuellement de secours.
- **`Classification`** : reconnaissance d’images ; renvoie où cliquer, pas un token.
- **`Enterprise`** : reCAPTCHA Enterprise.
## Remarques
- La reconnaissance d’images reCAPTCHA v2 est facturée selon la taille de l’image, et la reconnaissance d’images hCaptcha ne débite aucun point quand aucune cible n’est trouvée ; voir leurs pages respectives.
- Les prix de cette page font foi ; seule la création d’une tâche débite des points, la consultation du résultat est gratuite. Règles de facturation : [Facturation et remboursement de points](https://docs.yescaptcha.com/fr/getting-started/billing.md).
---
# reCAPTCHA v2
> Obtenez des tokens reCAPTCHA v2 (version case à cocher, invisible et Enterprise) avec YesCaptcha : types de tâche et prix, paramètres de requête, exemples curl/Python/Node.js et format du résultat.
Source: https://docs.yescaptcha.com/fr/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/
Une tâche reCAPTCHA v2 renvoie un token (`gRecaptchaResponse`) que vous soumettez au site cible pour réussir la vérification, sans cliquer sur des images. Le type le plus courant, `NoCaptchaTaskProxyless`, coûte 15 points (≈ $2.25 / 1k) par tâche et fonctionne en mode asynchrone : créez la tâche avec `createTask`, puis appelez `getTaskResult` toutes les 5 secondes pour obtenir le résultat. Les tâches en échec ou expirées donnent lieu à un remboursement de points automatique.
- POST `https://api.yescaptcha.com/createTask` (Endpoint mondial)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint Chine)
Le corps de la requête est du JSON, authentifié avec votre `clientKey` (à copier depuis le tableau de bord de [yescaptcha.com](https://yescaptcha.com/)). Interrogez le résultat sur le même endpoint que celui où vous avez créé la tâche.
## Cas d’usage
- La page affiche une case « Je ne suis pas un robot » (I’m not a robot) : version case à cocher.
- Il n’y a pas de case à cocher, et l’épreuve d’images n’apparaît qu’après un clic sur le bouton d’envoi : version invisible. Ajoutez `"isInvisible": true`.
- La page charge `recaptcha/enterprise.js`, ou les URL de requête contiennent `enterprise` : version Enterprise. Utilisez un type dont le nom contient `Enterprise`.
Si vous ne savez pas de quelle version il s’agit, consultez [Identifier le type de captcha](https://docs.yescaptcha.com/fr/guides/identify-captcha.md). Si le taux de réussite des tokens n’est pas satisfaisant, essayez la [reconnaissance d’images reCAPTCHA v2](https://docs.yescaptcha.com/fr/tasks/recaptcha-classification.md) : l’API vous indique les images sur lesquelles cliquer, et vous cliquez dans le navigateur.
## Types et prix
| Type de tâche | Prix | Mode | Remarques |
| --- | --- | --- | --- |
| `NoCaptchaTaskProxyless` | $2.25 / 1k; 15 points/tâche · ¥15 / 1k | Asynchrone | |
| `RecaptchaV2TaskProxyless` | $3.00 / 1k; 20 points/tâche · ¥20 / 1k | Asynchrone | Mêmes paramètres que NoCaptchaTaskProxyless sur une autre route ; l'un peut servir de solution de secours à l'autre |
| `NoCaptchaTask` | $2.25 / 1k; 15 points/tâche · ¥15 / 1k | Asynchrone | Proxy fourni |
| `RecaptchaV2EnterpriseTaskProxyless` | $3.00 / 1k; 20 points/tâche · ¥20 / 1k | Asynchrone | |
| `RecaptchaV2EnterpriseTask` | $3.00 / 1k; 20 points/tâche · ¥20 / 1k | Asynchrone | Proxy fourni |
Les prix en dollars américains sont des estimations avec 1 USD ≈ ¥6.67 ; les tâches sont facturées en points.
- `NoCaptchaTaskProxyless` et `RecaptchaV2TaskProxyless` ont les mêmes paramètres mais passent par des routes différentes. Si l’un a un taux de réussite insuffisant, essayez l’autre.
- Les types sans `Proxyless` dans le nom (`NoCaptchaTask`, `RecaptchaV2EnterpriseTask`) chargent le captcha via votre propre proxy et nécessitent les champs `proxyType`, `proxyAddress`, `proxyPort`, etc. Utilisez-les lorsque le site cible contrôle l’IP du visiteur.
## Paramètres de requête
Champs de l’objet `task` de `createTask` :
| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `type` | string | Oui | Type de tâche ; voir « Types de tâches et prix » sur cette page |
| `websiteURL` | string | Oui | URL complète de la page qui affiche le captcha. Indiquez le site sur lequel vous voyez le captcha, pas le domaine du fournisseur du captcha |
| `websiteKey` | string | Oui | La clé du site (sitekey), à trouver dans le code source de la page ou dans les requêtes réseau ; elle ne change généralement pas |
| `isInvisible` | boolean | Non | Indiquez true pour la variante invisible ; omettez-le sinon |
| `proxyType` | string | Certains types | Protocole du proxy : `http`, `https`, `socks4` ou `socks5` (Obligatoire pour NoCaptchaTask, RecaptchaV2EnterpriseTask) |
| `proxyAddress` | string | Certains types | Adresse IP ou nom d'hôte du proxy. Les adresses locales ou privées telles que 127.0.0.1 ou 192.168.x.x ne fonctionneront pas, car nos serveurs ne peuvent pas y accéder (Obligatoire pour NoCaptchaTask, RecaptchaV2EnterpriseTask) |
| `proxyPort` | integer | Certains types | Port du proxy (Obligatoire pour NoCaptchaTask, RecaptchaV2EnterpriseTask) |
| `proxyLogin` | string | Non | Nom d'utilisateur du proxy, si le proxy exige une authentification (NoCaptchaTask, RecaptchaV2EnterpriseTask uniquement) |
| `proxyPassword` | string | Non | Mot de passe du proxy, si le proxy exige une authentification (NoCaptchaTask, RecaptchaV2EnterpriseTask uniquement) |
| `userAgent` | string | Non | User-Agent du navigateur. Si le résultat contient un `userAgent`, utilisez cette valeur lorsque vous soumettez le token (NoCaptchaTask, RecaptchaV2EnterpriseTask uniquement) |
| `enterprisePayload` | object | Non | Paramètres supplémentaires de la version Enterprise, comme la valeur `s` de reCAPTCHA Enterprise : `{"s": "..."}`. Omettez-le si la page ne l'utilise pas (RecaptchaV2EnterpriseTaskProxyless, RecaptchaV2EnterpriseTask uniquement) |
Pour trouver `websiteURL` et `websiteKey`, consultez [Trouver les paramètres reCAPTCHA](https://docs.yescaptcha.com/fr/guides/find-recaptcha-parameters.md).
## Exemple de requête
Avec la page de démonstration officielle de 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-"
}
}
```
Code complet qui crée la tâche, interroge le résultat toutes les 5 secondes et affiche le token. Avant de l’exécuter, placez votre ClientKey dans la variable d’environnement `YESCAPTCHA_CLIENT_KEY` :
**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);
```
Pour la version Enterprise, si la page transmet une valeur `s` à reCAPTCHA, placez-la dans `enterprisePayload` :
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"
}
}
}
```
Avec votre propre 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"
}
}
```
## Résultat
`createTask` renvoie un ID de tâche :
```json
{
"errorId": 0,
"taskId": "61138bb6-19fb-11ec-a9c8-0242ac110006"
}
```
Utilisez-le pour appeler `getTaskResult`. Tant que la tâche est en cours, la réponse est `{"errorId": 0, "status": "processing"}` ; interrogez à nouveau 5 secondes plus tard. Lorsque la tâche est terminée :
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"gRecaptchaResponse": "03AGdBq25SxXT-pmSeBXjzScW-EiocHwwpwqtk1QXlJnGnU..."
}
}
```
| Champ | Type | Description |
| --- | --- | --- |
| `gRecaptchaResponse` | string | Le token à soumettre au site cible. Usage unique, valable environ 120 secondes ; utilisez-le dans les 60 secondes |
Une tâche est traitée pendant 110 secondes environ au maximum ; au-delà, elle renvoie `ERROR_TASK_TIMEOUT` et les points sont remboursés. En cas d’erreur, `errorId` vaut 1 ; traitez-la selon `errorCode`, voir [Codes d’erreur](https://docs.yescaptcha.com/fr/api/errors.md). Pour savoir comment soumettre le token, consultez [Réussir un reCAPTCHA avec un token](https://docs.yescaptcha.com/fr/guides/submit-recaptcha-token.md).
> **Astuce:** Un token est à usage unique et valable environ 120 secondes ; soumettez-le dans les 60 secondes suivant sa réception.
## FAQ
### Pourquoi les tokens d’un même site réussissent-ils parfois et échouent-ils parfois ?
C’est le site cible qui décide. Il attribue un score à chaque vérification et applique un seuil qu’il peut modifier à tout moment : le taux de réussite varie donc selon les sites, et tous les tokens ne passent pas. Comparez avec un autre type de tâche pour le même captcha, ou passez à la [reconnaissance d’images](https://docs.yescaptcha.com/fr/tasks/recaptcha-classification.md).
### Combien de temps un token reste-t-il valide ?
Un token est à usage unique et valable environ 120 secondes. Soumettez-le dans les 60 secondes. Cette durée est fixée par Google.
### Les points sont-ils débités en cas d’échec ?
Non. Les tâches qui renvoient `ERROR_CAPTCHA_UNSOLVABLE` ou qui expirent donnent lieu à un remboursement de points automatique. Voir [Facturation et remboursements](https://docs.yescaptcha.com/fr/getting-started/billing.md).
## Guides associés
- [Identifier le type de captcha](https://docs.yescaptcha.com/fr/guides/identify-captcha.md)
- [Trouver les paramètres reCAPTCHA](https://docs.yescaptcha.com/fr/guides/find-recaptcha-parameters.md)
- [Réussir un reCAPTCHA avec un token](https://docs.yescaptcha.com/fr/guides/submit-recaptcha-token.md)
- [reCAPTCHA : cliquer sur les images avec Selenium](https://docs.yescaptcha.com/fr/guides/recaptcha-click-selenium.md)
---
# reCAPTCHA v3
> Obtenez des tokens reCAPTCHA v3 (y compris Enterprise) avec YesCaptcha : comment renseigner pageAction, les types à score fixe 0.7 et 0.9, types de tâche et prix, paramètres, exemples et résultat renvoyé.
Source: https://docs.yescaptcha.com/fr/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 n’a ni case à cocher ni images : la page attribue un score aux visiteurs en arrière-plan. YesCaptcha renvoie un token (`gRecaptchaResponse`) que vous soumettez au site cible. `RecaptchaV3TaskProxyless` coûte 20 points (≈ $3.00 / 1k) par tâche et fonctionne en mode asynchrone : appelez `createTask`, puis `getTaskResult` toutes les 5 secondes. Les tâches en échec ou expirées donnent lieu à un remboursement de points automatique.
- POST `https://api.yescaptcha.com/createTask` (Endpoint mondial)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint Chine)
Le corps de la requête est du JSON, authentifié avec votre `clientKey`. Interrogez le résultat sur le même endpoint que celui où vous avez créé la tâche.
## Cas d’usage
- Le code source de la page contient `grecaptcha.execute(...)`, ou charge `recaptcha/api.js?render=CLÉ_DU_SITE` : reCAPTCHA v3 standard.
- La page appelle `grecaptcha.enterprise.execute(...)` ou charge `recaptcha/enterprise.js` : reCAPTCHA v3 Enterprise. Utilisez `RecaptchaV3EnterpriseTask` ou `RecaptchaV3EnterpriseTaskM1`.
Pour les distinguer, consultez [Identifier le type de captcha](https://docs.yescaptcha.com/fr/guides/identify-captcha.md).
## Types de tâche et prix
| Type de tâche | Prix | Mode | Remarques |
| --- | --- | --- | --- |
| `RecaptchaV3TaskProxyless` | $3.00 / 1k; 20 points/tâche · ¥20 / 1k | Asynchrone | |
| `RecaptchaV3TaskProxylessM1` | $3.75 / 1k; 25 points/tâche · ¥25 / 1k | Asynchrone | |
| `RecaptchaV3TaskProxylessM1S7` | $4.50 / 1k; 30 points/tâche · ¥30 / 1k | Asynchrone | Demande un score de 0.7 ; aucun paramètre supplémentaire n'est nécessaire |
| `RecaptchaV3TaskProxylessM1S9` | $5.25 / 1k; 35 points/tâche · ¥35 / 1k | Asynchrone | Demande un score de 0.9 ; aucun paramètre supplémentaire n'est nécessaire |
| `RecaptchaV3EnterpriseTask` | $3.00 / 1k; 20 points/tâche · ¥20 / 1k | Asynchrone | |
| `RecaptchaV3EnterpriseTaskM1` | $3.75 / 1k; 25 points/tâche · ¥25 / 1k | Asynchrone | |
Les prix en dollars américains sont des estimations avec 1 USD ≈ ¥6.67 ; les tâches sont facturées en points.
- `RecaptchaV3TaskProxyless` et `RecaptchaV3TaskProxylessM1` acceptent les mêmes paramètres mais passent par des routes différentes ; vous pouvez utiliser l’un comme solution de secours de l’autre.
- Si le site cible exige un score élevé, utilisez `RecaptchaV3TaskProxylessM1S7` (0.7) ou `RecaptchaV3TaskProxylessM1S9` (0.9) : aucun paramètre supplémentaire n’est nécessaire.
## Paramètres de la requête
| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `type` | string | Oui | Type de tâche ; voir « Types de tâches et prix » sur cette page |
| `websiteURL` | string | Oui | URL complète de la page qui affiche le captcha. Indiquez le site sur lequel vous voyez le captcha, pas le domaine du fournisseur du captcha |
| `websiteKey` | string | Oui | La clé du site (sitekey), à trouver dans le code source de la page ou dans les requêtes réseau ; elle ne change généralement pas |
| `pageAction` | string | Non | L'action reCAPTCHA v3 ; elle doit correspondre à la valeur que la page transmet à `grecaptcha.execute`, sinon le token risque d'être rejeté |
`pageAction` doit correspondre à l’`action` que la page transmet à `grecaptcha.execute(CLÉ_DU_SITE, {action: '...'})`, sinon le site risque de rejeter le token. Pour le trouver, consultez [Trouver les paramètres reCAPTCHA](https://docs.yescaptcha.com/fr/guides/find-recaptcha-parameters.md).
## Exemple de requête
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);
```
Remplacez `websiteURL`, `websiteKey` et `pageAction` par les valeurs du site cible.
## Résultat
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"gRecaptchaResponse": "03AGdBq25SxXT-pmSeBXjzScW-EiocHwwpwqtk1QXlJnGnU..."
}
}
```
| Champ | Type | Description |
| --- | --- | --- |
| `gRecaptchaResponse` | string | Le token à soumettre au site cible. Usage unique, valable environ 120 secondes ; utilisez-le dans les 60 secondes |
Pendant le traitement, la réponse est `{"errorId": 0, "status": "processing"}` ; interrogez à nouveau 5 secondes plus tard. En cas d’erreur, traitez-la selon `errorCode`, comme décrit dans [Codes d’erreur](https://docs.yescaptcha.com/fr/api/errors.md). Pour savoir comment soumettre le token, consultez [Valider un reCAPTCHA avec un token](https://docs.yescaptcha.com/fr/guides/submit-recaptcha-token.md).
## FAQ
### Pourquoi certains tokens sont-ils refusés par le site ?
Avec la v3, c’est le site cible qui décide d’après le score, et il peut modifier son seuil à tout moment : tous les tokens ne sont donc pas acceptés. Vérifiez que `pageAction` est correct, essayez `M1S7` ou `M1S9` si le site exige un score élevé, ou comparez avec d’autres types similaires.
### Comment renseigner la version Enterprise de la v3 ?
Comme pour la version standard : `websiteURL`, `websiteKey`, `pageAction`, avec le type `RecaptchaV3EnterpriseTask` ou `RecaptchaV3EnterpriseTaskM1`.
### Combien de temps un token reste-t-il valide ?
Il est à usage unique et valable environ 120 secondes. Soumettez-le dans les 60 secondes.
## Tutoriels associés
- [Identifier le type de captcha](https://docs.yescaptcha.com/fr/guides/identify-captcha.md)
- [Trouver les paramètres reCAPTCHA](https://docs.yescaptcha.com/fr/guides/find-recaptcha-parameters.md) (dont la méthode pour `pageAction`)
- [Valider un reCAPTCHA avec un token](https://docs.yescaptcha.com/fr/guides/submit-recaptcha-token.md)
---
# hCaptcha
> Obtenez des tokens hCaptcha avec YesCaptcha : HCaptchaTaskProxyless, HCaptchaTaskProxylessM1 et HCaptchaTask avec votre propre proxy, comment renseigner userAgent et rqdata, et comment utiliser le respKey renvoyé.
Source: https://docs.yescaptcha.com/fr/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/
Une tâche hCaptcha renvoie un token (`gRecaptchaResponse`). Envoyez-le au site cible avec le `userAgent` renvoyé (et le `respKey`, s’il est présent) pour passer la vérification. `HCaptchaTaskProxyless` coûte 30 points (≈ $4.50 / 1k) par tâche et `HCaptchaTask` (avec votre propre proxy) coûte 15 points (≈ $2.25 / 1k) par tâche ; les deux sont asynchrones : `createTask`, puis `getTaskResult` toutes les 5 secondes. Les tâches échouées ou expirées donnent lieu à un remboursement de points automatique.
- POST `https://api.yescaptcha.com/createTask` (Endpoint mondial)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint Chine)
Le corps de la requête est du JSON, authentifié avec votre `clientKey`. Interrogez le résultat sur le même endpoint que celui où vous avez créé la tâche.
## Cas d’usage
La page affiche la case à cocher hCaptcha « Je suis humain » ou une épreuve d’images hCaptcha. Pour obtenir un token et le soumettre directement, utilisez les types de cette page ; pour cliquer vous-même sur les images dans un navigateur, utilisez [la reconnaissance d’images hCaptcha](https://docs.yescaptcha.com/fr/tasks/hcaptcha-classification.md).
> **Note:** Le taux de réussite de hCaptcha varie beaucoup d’un site à l’autre ; testez d’abord sur un petit lot.
## Types de tâche et prix
| Type de tâche | Prix | Mode | Remarques |
| --- | --- | --- | --- |
| `HCaptchaTaskProxyless` | $4.50 / 1k; 30 points/tâche · ¥30 / 1k | Asynchrone | |
| `HCaptchaTaskProxylessM1` | $4.50 / 1k; 30 points/tâche · ¥30 / 1k | Asynchrone | Mêmes paramètres que HCaptchaTaskProxyless sur une autre route ; l'un peut servir de solution de secours à l'autre |
| `HCaptchaTask` | $2.25 / 1k; 15 points/tâche · ¥15 / 1k | Asynchrone | Proxy fourni |
Les prix en dollars américains sont des estimations avec 1 USD ≈ ¥6.67 ; les tâches sont facturées en points.
- `HCaptchaTaskProxyless` et `HCaptchaTaskProxylessM1` ont les mêmes paramètres mais passent par des routes différentes ; ils peuvent se servir mutuellement de secours.
- `HCaptchaTask` charge le captcha via votre propre proxy et nécessite les champs de proxy ; utilisez-le quand le site cible vérifie l’IP du visiteur.
## Paramètres de la requête
| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `type` | string | Oui | Type de tâche ; voir « Types de tâches et prix » sur cette page |
| `websiteURL` | string | Oui | URL complète de la page qui affiche le captcha. Indiquez le site sur lequel vous voyez le captcha, pas le domaine du fournisseur du captcha |
| `websiteKey` | string | Oui | La clé du site hCaptcha (sitekey), généralement un UUID |
| `userAgent` | string | Non | User-Agent du navigateur. Recommandé, mais seule la valeur renvoyée par `GET https://api.yescaptcha.com/useragent` est acceptée ; soumettez le token avec le `userAgent` du résultat |
| `isInvisible` | boolean | Non | Indiquez true pour la variante invisible ; omettez-le sinon |
| `rqdata` | string | Non | rqdata pour hCaptcha Enterprise ; requis par certains sites et généralement présent dans la requête qui charge le captcha |
| `proxyType` | string | Certains types | Protocole du proxy : `http`, `https`, `socks4` ou `socks5` (Obligatoire pour HCaptchaTask) |
| `proxyAddress` | string | Certains types | Adresse IP ou nom d'hôte du proxy. Les adresses locales ou privées telles que 127.0.0.1 ou 192.168.x.x ne fonctionneront pas, car nos serveurs ne peuvent pas y accéder (Obligatoire pour HCaptchaTask) |
| `proxyPort` | integer | Certains types | Port du proxy (Obligatoire pour HCaptchaTask) |
| `proxyLogin` | string | Non | Nom d'utilisateur du proxy, si le proxy exige une authentification (HCaptchaTask uniquement) |
| `proxyPassword` | string | Non | Mot de passe du proxy, si le proxy exige une authentification (HCaptchaTask uniquement) |
- `websiteURL` est la page où le captcha apparaît, **et non** hcaptcha.com.
- `userAgent` est recommandé, mais seule la valeur renvoyée par [/useragent](https://docs.yescaptcha.com/fr/api/useragent.md) est acceptée.
- `rqdata` : exigé par la version Enterprise de hCaptcha (par exemple sur certains sites sociaux et de messagerie) ; on le trouve généralement dans la requête qui charge le captcha. Ne le transmettez pas pour les sites ordinaires.
Pour savoir comment trouver ces paramètres, consultez [Trouver les paramètres hCaptcha](https://docs.yescaptcha.com/fr/guides/find-hcaptcha-parameters.md).
## Exemple de requête
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);
```
Avec votre propre 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"
}
}
```
## Résultat
```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..."
}
}
```
| Champ | Type | Description |
| --- | --- | --- |
| `gRecaptchaResponse` | string | Le token à soumettre au site cible. Usage unique, valable environ 120 secondes ; utilisez-le dans les 60 secondes |
| `userAgent` | string | Le User-Agent utilisé pour obtenir le token. Utilisez cette valeur lorsque vous soumettez le token, même si elle diffère de celle que vous avez envoyée |
| `respKey` | string | Une valeur que certains sites exigent en plus du token ; soumettez-la si elle est présente |
Pour la soumission :
1. Placez le token dans le champ `h-captcha-response` de la page (et dans `g-recaptcha-response`, s’il existe), ou dans le champ attendu par l’API du site cible.
2. Envoyez la requête de soumission avec le `userAgent` renvoyé comme User-Agent.
3. Si un `respKey` a été renvoyé, soumettez-le aussi, selon les exigences du site.
Pendant le traitement, la réponse est `{"errorId": 0, "status": "processing"}` ; interrogez de nouveau 5 secondes plus tard. En cas d’erreur, traitez-la selon `errorCode`, voir [Codes d’erreur](https://docs.yescaptcha.com/fr/api/errors.md).
## FAQ
### Pourquoi le taux de réussite est-il irrégulier ?
hCaptcha se base sur les paramètres du site, l’IP du visiteur et l’environnement du navigateur, donc le taux de réussite varie selon les sites. Vérifiez que vous utilisez le `userAgent` renvoyé ; pour les sites sensibles à l’IP, utilisez `HCaptchaTask` avec votre propre proxy et effectuez aussi la soumission via ce même proxy ; vous pouvez aussi comparer avec `HCaptchaTaskProxylessM1`.
### Combien de temps un token reste-t-il valide ?
Il est à usage unique et valable environ 120 secondes. Soumettez-le dès que possible après l’avoir obtenu.
## Tutoriels associés
- [Trouver les paramètres hCaptcha](https://docs.yescaptcha.com/fr/guides/find-hcaptcha-parameters.md)
- [Clics sur les images hCaptcha avec Selenium](https://docs.yescaptcha.com/fr/guides/hcaptcha-click-selenium.md)
---
# Cloudflare Turnstile
> Obtenez des tokens Cloudflare Turnstile avec YesCaptcha : TurnstileTaskProxyless, TurnstileTaskProxylessM1 et TurnstileTask avec votre propre proxy, paramètres, exemples et résultat renvoyé, et différence avec la page de vérification Cloudflare.
Source: https://docs.yescaptcha.com/fr/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/
Une tâche Cloudflare Turnstile renvoie un token (`token`) à soumettre au site cible pour passer la vérification. `TurnstileTaskProxyless` coûte 25 points (≈ $3.75 / 1k) par tâche et fonctionne en mode asynchrone : appelez `createTask`, puis `getTaskResult` toutes les 5 secondes. Les tâches en échec ou expirées donnent lieu à un remboursement de points automatique.
- POST `https://api.yescaptcha.com/createTask` (Endpoint mondial)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint Chine)
Le corps de la requête est du JSON, authentifié avec votre `clientKey`. Interrogez le résultat sur le même endpoint que celui où vous avez créé la tâche.
## Cas d’usage
Un widget de vérification Cloudflare (« Confirmez que vous êtes humain ») est intégré dans un formulaire de la page, et la page charge un script depuis `challenges.cloudflare.com/turnstile`.
Si toute la page est bloquée par Cloudflare et affiche « Veuillez patienter… » ou « Vérification de votre navigateur en cours », il s’agit de la page de vérification Cloudflare, pas de Turnstile : utilisez [Page de vérification Cloudflare](https://docs.yescaptcha.com/fr/tasks/cloudflare-challenge.md). La différence est expliquée dans [Identifier le type de captcha](https://docs.yescaptcha.com/fr/guides/identify-captcha.md).
## Types de tâche et prix
| Type de tâche | Prix | Mode | Remarques |
| --- | --- | --- | --- |
| `TurnstileTaskProxyless` | $3.75 / 1k; 25 points/tâche · ¥25 / 1k | Asynchrone | |
| `TurnstileTaskProxylessM1` | $4.50 / 1k; 30 points/tâche · ¥30 / 1k | Asynchrone | |
| `TurnstileTask` | $3.75 / 1k; 25 points/tâche · ¥25 / 1k | Asynchrone | Proxy fourni |
Les prix en dollars américains sont des estimations avec 1 USD ≈ ¥6.67 ; les tâches sont facturées en points.
- `TurnstileTaskProxyless` et `TurnstileTaskProxylessM1` ont les mêmes paramètres mais passent par des routes différentes ; l’un peut servir de secours à l’autre.
- `TurnstileTask` charge le captcha via votre propre proxy et nécessite les champs de proxy.
## Paramètres de la requête
| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `type` | string | Oui | Type de tâche ; voir « Types de tâches et prix » sur cette page |
| `websiteURL` | string | Oui | URL complète de la page qui affiche le captcha. Indiquez le site sur lequel vous voyez le captcha, pas le domaine du fournisseur du captcha |
| `websiteKey` | string | Oui | La clé du site Turnstile (sitekey), commençant généralement par 0x |
| `pageAction` | string | Non | L'`action` que la page transmet à Turnstile (une option de `turnstile.render`, ou `data-action` sur l'élément du widget), par exemple `login`. Inutile dans la plupart des cas ; ajoutez-la uniquement si les tâches échouent systématiquement |
| `data` | string | Non | Le `cData` que la page transmet à Turnstile (une option de `turnstile.render`, ou `data-cdata` sur l'élément du widget), par exemple `c0bd4b36-7419-4e18-83c6-378699f2a9a2`. Inutile dans la plupart des cas ; ajoutez-le uniquement si les tâches échouent systématiquement |
| `proxyType` | string | Certains types | Protocole du proxy : `http`, `https`, `socks4` ou `socks5` (Obligatoire pour TurnstileTask) |
| `proxyAddress` | string | Certains types | Adresse IP ou nom d'hôte du proxy. Les adresses locales ou privées telles que 127.0.0.1 ou 192.168.x.x ne fonctionneront pas, car nos serveurs ne peuvent pas y accéder (Obligatoire pour TurnstileTask) |
| `proxyPort` | integer | Certains types | Port du proxy (Obligatoire pour TurnstileTask) |
| `proxyLogin` | string | Non | Nom d'utilisateur du proxy, si le proxy exige une authentification (TurnstileTask uniquement) |
| `proxyPassword` | string | Non | Mot de passe du proxy, si le proxy exige une authentification (TurnstileTask uniquement) |
| `userAgent` | string | Non | User-Agent du navigateur. Si le résultat contient un `userAgent`, utilisez cette valeur lorsque vous soumettez le token (TurnstileTask uniquement) |
`websiteKey` commence généralement par `0x`. Pour la trouver, consultez [Trouver les paramètres Turnstile](https://docs.yescaptcha.com/fr/guides/find-turnstile-parameters.md).
### Si les tâches échouent toujours : pageAction et data
Dans la plupart des cas, `websiteURL` et `websiteKey` suffisent, et ces deux paramètres ne sont pas nécessaires. Si vous êtes certain que `websiteURL` et `websiteKey` sont corrects et que la tâche échoue quand même, vérifiez si la page transmet `action` et `cData` à Turnstile (options de `turnstile.render`, ou `data-action` et `data-cdata` sur l’élément du widget). Si c’est le cas, transmettez-les tels quels :
- `pageAction` : l’`action` de la page, par exemple `login`
- `data` : le `cData` de la page, par exemple `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"
}
}
```
## Exemple de requête
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);
```
Remplacez `websiteURL` et `websiteKey` par les valeurs du site cible.
## Résultat renvoyé
```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"
}
}
```
| Champ | Type | Description |
| --- | --- | --- |
| `token` | string | Le token à soumettre au site cible. Usage unique ; soumettez-le dès que possible |
| `userAgent` | string | Le User-Agent utilisé pour obtenir le token. Utilisez cette valeur lorsque vous soumettez le token, même si elle diffère de celle que vous avez envoyée |
Placez le `token` dans le champ `cf-turnstile-response` de la page (ou dans le champ attendu par l’API du site cible) et soumettez-le, en utilisant le `userAgent` renvoyé comme User-Agent de la requête.
Tant que la tâche est en cours, la réponse est `{"errorId": 0, "status": "processing"}` ; interrogez à nouveau 5 secondes plus tard. En cas d’erreur, traitez-la selon `errorCode` : voir [Codes d’erreur](https://docs.yescaptcha.com/fr/api/errors.md).
## Questions fréquentes
### Combien de temps un token reste-t-il valide ?
Il est à usage unique. Soumettez-le dès que possible ; un token Turnstile expire généralement au bout de quelques minutes (c’est Cloudflare qui décide).
### Le site refuse toujours la soumission
Vérifiez que `websiteURL` est bien la page qui affiche le widget, que `websiteKey` est correct, et soumettez avec le `userAgent` renvoyé. Si la page transmet `action` et `cData`, ajoutez-les en tant que `pageAction` et `data` : voir [Si les tâches échouent toujours](#si-les-t%C3%A2ches-%C3%A9chouent-toujours--pageaction-et-data). Si le site vérifie aussi l’IP, utilisez `TurnstileTask` et soumettez via le même proxy.
## Tutoriels associés
- [Identifier le type de captcha](https://docs.yescaptcha.com/fr/guides/identify-captcha.md)
- [Trouver les paramètres Turnstile](https://docs.yescaptcha.com/fr/guides/find-turnstile-parameters.md)
---
# Page de vérification Cloudflare
> Passez la page de vérification « Just a moment... » de Cloudflare avec YesCaptcha et récupérez cf_clearance et les autres cookies, le User-Agent et le contenu de la page : paramètres de CloudFlareTaskS2 et CloudFlareTaskS3, exigences sur le proxy, résultat, utilisation du résultat et erreurs courantes.
Source: https://docs.yescaptcha.com/fr/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/
La page de vérification Cloudflare (le « 5 secondes ») est une page d’attente qui bloque tout le site et affiche « Just a moment… » ou « Checking your browser ». YesCaptcha ouvre la page via le proxy que vous fournissez, passe la vérification et renvoie les cookies (comme `cf_clearance`), le User-Agent utilisé, les en-têtes de requête et de réponse, ainsi que le HTML de la page une fois la vérification passée. `CloudFlareTaskS2` coûte 25 points (≈ $3.75 / 1k) par tâche et `CloudFlareTaskS3` coûte 20 points (≈ $3.00 / 1k) par tâche ; les deux types ont les mêmes paramètres, le même résultat et la même efficacité, seul le prix diffère. Les tâches sont asynchrones et prennent généralement de 6 à 35 secondes, avec de grandes différences selon les sites. Les tâches échouées ou expirées donnent lieu à un remboursement de points automatique.
- POST `https://api.yescaptcha.com/createTask` (Endpoint mondial)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint Chine)
## Cas d’utilisation
- Le code source de la page contient `__cf_chl_rt_tk` ou `cdn-cgi/challenge-platform`, et le titre est `Just a moment...` : c’est la page de vérification Cloudflare. Les pages qui demandent de cocher « Confirmez que vous êtes un humain » relèvent aussi de cette page.
- Si seul un widget Cloudflare est intégré dans un formulaire, il s’agit de [Turnstile](https://docs.yescaptcha.com/fr/tasks/turnstile.md) : cette page ne s’applique pas.
- Si une requête avec une bibliothèque comme requests renvoie un 403 avec « Just a moment… » alors qu’un navigateur ouvre la page normalement, c’est probablement l’empreinte TLS qui est bloquée. Une bibliothèque qui imite l’empreinte TLS d’un navigateur (comme curl\_cffi) suffit alors, sans résoudre de vérification.
## Types et prix
| Type de tâche | Prix | Mode | Remarques |
| --- | --- | --- | --- |
| `CloudFlareTaskS2` | $3.75 / 1k; 25 points/tâche · ¥25 / 1k | Asynchrone | Proxy fourni |
| `CloudFlareTaskS3` | $3.00 / 1k; 20 points/tâche · ¥20 / 1k | Asynchrone | Proxy fourni |
Les prix en dollars américains sont des estimations avec 1 USD ≈ ¥6.67 ; les tâches sont facturées en points.
## Paramètres de la requête
| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `type` | string | Oui | Type de tâche ; voir « Types de tâches et prix » sur cette page |
| `websiteURL` | string | Oui | URL complète de la page protégée par la vérification. Doit être une URL publique commençant par `http://` ou `https://` ; les adresses IP privées et les noms d'hôte locaux ou internes tels que `localhost` sont refusés |
| `proxy` | string | Oui | Proxy sous forme d'une seule chaîne : `http://user:pass@proxy.example.com:8080` (proxy HTTP, identifiants facultatifs) ou `socks5://proxy.example.com:1080` (sans identifiants). Les proxys `https://` et SOCKS5 avec identifiants ne sont pas pris en charge, et les adresses locales ou privées sont refusées. Toutes les requêtes vers la page cible passent par ce proxy |
| `userAgent` | string | Non | En général, ne l'indiquez pas. Seul un User-Agent de Chrome pour ordinateur sous Linux est pris en compte ; tout le reste (Windows, macOS, mobile, autres navigateurs) est ignoré. Utilisez toujours `user_agent` du résultat pour les requêtes suivantes |
| `waitLoad` | boolean | Non | Par défaut, false. Si true, après la réussite de la vérification, la tâche attend que l'activité réseau de la page se calme avant de renvoyer le résultat, de sorte que `content` contient davantage de contenu chargé dynamiquement ; cela prend quelques secondes de plus |
| `requiredCookies` | array | Non | Noms des cookies à obtenir obligatoirement, sous forme de tableau de chaînes, par exemple `["cf_clearance"]`. S'il est renseigné, la tâche ne réussit que si tous les cookies sont obtenus ; sinon elle renvoie `ERROR_CAPTCHA_UNSOLVABLE` et les points sont remboursés. S'il est omis, la tâche essaie quand même d'obtenir `cf_clearance`, mais réussit (avec débit de points) même si elle n'obtient que d'autres cookies ; indiquez-le donc explicitement si vous avez besoin de `cf_clearance` |
| `blockImage` | boolean | Non | Si true, les images de la page cible ne sont pas chargées (sauf celles dont la vérification Cloudflare elle-même a besoin), ce qui économise du trafic proxy |
| `postData` | object | Non | S'il est renseigné, il est envoyé à `websiteURL` comme un formulaire HTML classique en POST (`application/x-www-form-urlencoded`) : chaque clé est un champ du formulaire et les valeurs sont envoyées sous forme de chaînes, par exemple `{"name": "hi"}`. Doit être un objet |
### Exigences sur le proxy
`proxy` est obligatoire, et toutes les requêtes vers la page cible passent par ce proxy. `cf_clearance` est lié à l’IP de sortie : utilisez donc le même proxy pour accéder ensuite au site cible.
| Format | Pris en charge |
| --- | --- |
| `http://user:pass@proxy.example.com:8080` | Oui : proxy HTTP avec identifiants |
| `http://proxy.example.com:8080` | Oui : proxy HTTP sans identifiants |
| `socks5://proxy.example.com:1080` | Oui : proxy SOCKS5 sans identifiants ; `socks5h://` est traité comme `socks5://` |
| `socks5://user:pass@proxy.example.com:1080` | Non, renvoie `ERROR_PROXY_INCORRECT` ; si vous avez besoin d’identifiants, utilisez un proxy HTTP |
| `https://proxy.example.com:443` ou tout autre protocole, ou port manquant | Non, renvoie `ERROR_PROXY_INCORRECT` |
| Adresses locales, de réseau interne ou réservées comme `127.0.0.1`, `192.168.x.x`, `10.x.x.x`, ou un nom de domaine qui résout vers l’une d’elles | Refusé, renvoie `ERROR_PROXY_BANNED` |
> **Vérifié à la création de la tâche:** Si l’URL ou le proxy n’est pas valide, `createTask` renvoie directement l’erreur, sans débit de points. Si un même proxy échoue plusieurs fois à se connecter sur une courte période, la création de tâches avec ce proxy renvoie aussi `ERROR_PROXY_BANNED` pendant un certain temps ; changez de proxy ou réessayez plus tard.
### User-Agent
En général, ne transmettez pas `userAgent`. La vérification est passée avec Chrome de bureau sous Linux : seul un User-Agent de Chrome de bureau sous Linux est utilisé, tous les autres (Windows, macOS, mobile ou autres navigateurs) sont ignorés, car lors de nos tests la vérification de Cloudflare échoue quand le User-Agent ne correspond pas à l’environnement réel du navigateur. Pour les requêtes suivantes, utilisez toujours le `user_agent` du résultat.
## Exemple de requête
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"]
}
}
```
- Pour utiliser `CloudFlareTaskS2`, changez uniquement `type`.
- Avec `requiredCookies` défini à `["cf_clearance"]`, la tâche échoue et les points sont remboursés si `cf_clearance` n’est pas obtenu. Sans ce paramètre, une tâche qui obtient d’autres cookies mais pas `cf_clearance` est considérée comme réussie et débitée.
- Pour soumettre un formulaire, ajoutez `postData`, par exemple `{"name": "hi"}` ; il est envoyé à `websiteURL` sous forme de formulaire POST.
Après la création, appelez `getTaskResult` toutes les 5 secondes ; le déroulement est le même que pour les autres tâches asynchrones, voir [getTaskResult](https://docs.yescaptcha.com/fr/api/get-task-result.md).
## Résultat
```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": "..."
}
}
```
La valeur du cookie et les en-têtes ci-dessus sont donnés à titre d’illustration ; utilisez ce que renvoie l’API.
| Champ | Type | Description |
| --- | --- | --- |
| `cookies` | object | Tous les cookies du navigateur après la réussite de la vérification (objet nom-valeur), incluant généralement `cf_clearance` ; si vous avez défini `requiredCookies`, chacun d'eux est inclus. Utilisez-les avec le `user_agent` renvoyé et le proxy que vous avez fourni |
| `user_agent` | string | Le User-Agent que le navigateur a réellement utilisé pour réussir la vérification (Chrome de bureau sous Linux). `cf_clearance` y est lié ; utilisez-le donc pour toutes les requêtes suivantes |
| `request_headers` | object | En-têtes de requête envoyés par le navigateur lors de sa dernière requête vers la page cible ; réutilisez-les dans les requêtes suivantes |
| `headers` | object | En-têtes de réponse de la page cible après la réussite de la vérification |
| `content` | string | Code source HTML de la page cible après la réussite de la vérification |
## Utiliser le résultat
1. Pour les requêtes suivantes, utilisez **à la fois** les `cookies` renvoyés, le `user_agent` renvoyé et le même proxy que celui de la tâche. `cf_clearance` est lié au User-Agent et à l’IP de sortie : si l’un des trois change, la page de vérification réapparaît.
2. Envoyez si possible les en-têtes de `request_headers`, et utilisez une empreinte TLS cohérente avec celle d’un navigateur (par exemple l’option `impersonate` de curl\_cffi).
3. `cf_clearance` a une durée de validité (définie par le site cible, jusqu’à 1 heure sur certains sites) ; pendant cette durée, il n’est pas nécessaire de repasser la vérification. Une fréquence de requêtes trop élevée peut faire bloquer l’IP par Cloudflare.
4. Si vous n’avez besoin que du contenu de la page, utilisez directement `content` au lieu de refaire une requête.
## Erreurs courantes
Les erreurs renvoyées à la création de la tâche ne donnent lieu à aucun débit de points ; les tâches qui échouent ou expirent après leur création sont remboursées automatiquement. L’API ne renvoie que le code d’erreur et une description générale : utilisez le tableau ci-dessous pour trouver la cause.
| Code d’erreur | Quand | Que faire |
| --- | --- | --- |
| `ERROR_REQUIRED_FIELDS` | À la création de la tâche : `websiteURL` ou `proxy` manquant | Ajoutez les deux champs obligatoires |
| `ERROR_ILLEGAL_PARAMETERS` | À la création de la tâche : `websiteURL` n’est pas une URL publique commençant par `http://` ou `https://`, `postData` n’est pas un objet, ou `requiredCookies` n’est pas un tableau de chaînes. À la consultation du résultat : le nom de domaine cible n’a pas pu être résolu via le proxy | Corrigez les paramètres ; vérifiez l’orthographe de l’URL et que le proxy peut accéder au site |
| `ERROR_PROXY_INCORRECT` | À la création de la tâche : format de proxy incorrect, port manquant, proxy `https://` ou SOCKS5 avec identifiants | Utilisez l’un des formats de la section « Exigences sur le proxy » ; si vous avez besoin d’identifiants, utilisez un proxy HTTP |
| `ERROR_PROXY_BANNED` | À la création de la tâche : le proxy est une adresse locale, de réseau interne ou réservée, ou il a échoué à se connecter plusieurs fois sur une courte période. À la consultation du résultat : le Cloudflare du site cible a directement bloqué l’IP de ce proxy (pages « Sorry, you have been blocked », « Access denied ») | Changez de proxy ; plus la qualité de l’IP est bonne, plus la vérification passe facilement |
| `ERROR_PROXY_CONNECT_REFUSED` | Connexion au proxy impossible (connexion refusée, nom de domaine du proxy non résolu), ou connexion refusée ou réinitialisée à l’ouverture de la page via le proxy | Vérifiez l’adresse et le port du proxy, assurez-vous qu’il est en ligne et accepte les connexions externes ; si l’erreur persiste, changez de proxy |
| `ERROR_PROXY_CONNECT_TIMEOUT` | Délai dépassé lors de la connexion au proxy ou de l’ouverture de la page via le proxy | Utilisez un proxy plus rapide et plus stable |
| `ERROR_PROXY_NOT_AUTHORISED` | Identifiant ou mot de passe du proxy incorrect | Vérifiez les identifiants dans `proxy` ; encodez les caractères spéciaux en URL |
| `ERROR_PROXY_TLS_ERROR` | Échec de la négociation TLS à l’ouverture de la page via le proxy | Vérifiez que l’adresse, le port et le protocole du proxy sont corrects ; si l’erreur persiste, changez de proxy |
| `ERROR_CAPTCHA_UNSOLVABLE` | La vérification n’a pas été passée dans le délai, la page est restée sur la vérification après son passage, ou un cookie demandé dans `requiredCookies` n’a pas été obtenu | Réessayez d’abord avec un autre proxy ; pour certains sites, contactez le support |
| `ERROR_NO_SLOT_AVAILABLE` | À la création de la tâche : la file d’attente est pleine. À la consultation du résultat : la tâche a attendu trop longtemps sans démarrer, les points ont été remboursés | Attendez quelques secondes puis recréez la tâche |
| `ERROR_TASK_TIMEOUT` | La tâche n’a pas été terminée dans le délai imparti | Recréez la tâche ; des délais dépassés répétés indiquent en général un proxy trop lent |
Pour tous les codes d’erreur, voir [Codes d’erreur](https://docs.yescaptcha.com/fr/api/errors.md).
## Voir aussi
- [Identifier le type de captcha](https://docs.yescaptcha.com/fr/guides/identify-captcha.md) : différence entre la page de vérification Cloudflare et Turnstile
- [Cloudflare Turnstile](https://docs.yescaptcha.com/fr/tasks/turnstile.md)
---
# Reconnaissance de texte dans une image
> Lisez les lettres et les chiffres d'une image avec YesCaptcha. ImageToTextTaskOcrBase et ImageToTextTaskMuggle renvoient le résultat de façon synchrone ; ImageToTextTask et ImageToTextTaskM1 sont asynchrones et gèrent la casse, les chiffres seuls, les opérations et la longueur ; modèles personnalisés disponibles.
Source: https://docs.yescaptcha.com/fr/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/
Envoyez l’image d’un captcha texte en Base64 et récupérez les lettres et chiffres qu’elle contient (`solution.text`). `ImageToTextTaskOcrBase` coûte 2 points (≈ $0.30 / 1k) par image et fonctionne de façon synchrone : une seule requête `createTask` renvoie le résultat. Si vous devez préciser la casse, des chiffres uniquement, une opération à calculer, etc., utilisez le type asynchrone `ImageToTextTask`.
- POST `https://api.yescaptcha.com/createTask` (Endpoint mondial)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint Chine)
Le corps de la requête est du JSON, authentifié avec votre `clientKey`.
## Types et prix
| Type de tâche | Prix | Mode | Remarques |
| --- | --- | --- | --- |
| `ImageToTextTaskOcrBase` | $0.30 / 1k; 2 points/tâche · ¥2 / 1k | Synchrone | |
| `ImageToTextTaskMuggle` | $0.30 / 1k; 2 points/tâche · ¥2 / 1k | Synchrone | Ne prend pas en charge les options case/numeric ; utilisez project\_name pour choisir un modèle personnalisé |
| `ImageToTextTask` | $0.60 / 1k; 4 points/tâche · ¥4 / 1k | Asynchrone | |
| `ImageToTextTaskM1` | $2.25 / 1k; 15 points/tâche · ¥15 / 1k | Asynchrone | |
Les prix en dollars américains sont des estimations avec 1 USD ≈ ¥6.67 ; les tâches sont facturées en points.
| Besoin | Type à utiliser |
| --- | --- |
| Captchas alphanumériques ordinaires, le moins cher et le plus rapide | `ImageToTextTaskOcrBase`, `ImageToTextTaskMuggle` (synchrones) |
| Un modèle personnalisé pour vous | `ImageToTextTaskMuggle` avec `project_name` |
| Respect de la casse, chiffres uniquement, calcul d’une opération, longueur limitée | `ImageToTextTask`, `ImageToTextTaskM1` (asynchrones) |
Les modèles et les routes diffèrent selon les types : le résultat peut varier pour un même type d’image. Testez-les et choisissez le meilleur.
## Paramètres de la requête
| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `type` | string | Oui | Type de tâche ; voir « Types de tâches et prix » sur cette page |
| `body` | string | Oui | Image encodée en Base64, sans le préfixe `data:image/...;base64,` et sans saut de ligne |
| `project_name` | string | Non | Nom d'un modèle personnalisé, pris en charge uniquement par `ImageToTextTaskMuggle`. Omettez-le pour utiliser le modèle alphanumérique général. Contactez le support pour obtenir un modèle personnalisé (ImageToTextTaskMuggle uniquement) |
| `phrase` | boolean | Non | true signifie que la réponse contient au moins un espace (ImageToTextTask, ImageToTextTaskM1 uniquement) |
| `case` | boolean | Non | true signifie que la réponse est sensible à la casse (ImageToTextTask, ImageToTextTaskM1 uniquement) |
| `numeric` | integer | Non | 0 aucune contrainte ; 1 chiffres uniquement ; 2 sans chiffres (ImageToTextTask, ImageToTextTaskM1 uniquement) |
| `math` | boolean | Non | true signifie que l'image est une expression mathématique et que la réponse en est le résultat (ImageToTextTask, ImageToTextTaskM1 uniquement) |
| `minLength` | integer | Non | Longueur minimale de la réponse ; 0 signifie aucune limite (ImageToTextTask, ImageToTextTaskM1 uniquement) |
| `maxLength` | integer | Non | Longueur maximale de la réponse ; 0 signifie aucune limite (ImageToTextTask, ImageToTextTaskM1 uniquement) |
`body` est l’encodage Base64 du fichier image. Les images WebP sont converties automatiquement.
> **Attention:** N’incluez ni le préfixe `data:image/...;base64,` ni de saut de ligne dans le Base64.
## Exemple de requête
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "ImageToTextTaskOcrBase",
"body": "BASE64_IMAGE"
}
}
```
Code complet (lit `captcha.png` dans le répertoire courant) :
**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);
```
Tâche asynchrone avec options :
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
}
}
```
## Résultat
Les types synchrones renvoient le résultat directement dans `createTask` :
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"text": "LMResm"
},
"taskId": "2376919c-1863-11ec-a012-94e6f7355a0b"
}
```
Les types asynchrones (`ImageToTextTask`, `ImageToTextTaskM1`) renvoient d’abord un `taskId`. Interrogez ensuite `getTaskResult` toutes les 5 secondes ; à la fin de la tâche, `solution` a le même format.
| Champ | Type | Description |
| --- | --- | --- |
| `text` | string | Le texte reconnu |
## Modèle personnalisé
Le modèle générique fonctionne sur tous les captchas alphanumériques, mais sa précision est légèrement inférieure à celle d’un modèle entraîné pour un style précis. Si vos images ont toujours le même style, [contactez le support](https://docs.yescaptcha.com/fr/help/contact.md) pour obtenir un modèle personnalisé, puis sélectionnez-le avec `ImageToTextTaskMuggle` et `project_name`.
## Questions fréquentes
### Les points sont-ils débités si le résultat est faux ?
Pour les types synchrones, les points sont débités dès qu’un résultat est renvoyé, même s’il est faux. Comparez avec un autre type ou demandez un modèle personnalisé.
### J’obtiens `ERROR_ZERO_CAPTCHA_FILESIZE` ou `ERROR_PARSE_IMAGE_FAIL`
Le Base64 de l’image est incomplet, ou il contient le préfixe `data:` ou des sauts de ligne. Vérifiez l’encodage ; voir [Codes d’erreur](https://docs.yescaptcha.com/fr/api/errors.md).
## Voir aussi
- [Démarrage rapide](https://docs.yescaptcha.com/fr/getting-started/quickstart.md) : première requête avec `ImageToTextTaskOcrBase`
- [Exemples Python](https://docs.yescaptcha.com/fr/samples/python.md)
---
# Reconnaissance d'images reCAPTCHA v2
> Reconnaissez les défis d'images reCAPTCHA v2 avec YesCaptcha (ReCaptchaV2Classification) : envoyez une image 3x3, 4x4 ou 1x1 avec l'ID de la question et recevez de façon synchrone les cases à cliquer ; tarif selon la taille de l'image ; table des ID de questions.
Source: https://docs.yescaptcha.com/fr/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` reconnaît les défis d’images de reCAPTCHA v2 : envoyez l’image et l’ID de la question, et vous obtenez les cases à cliquer ; votre programme effectue les clics dans le navigateur. Ce type **ne renvoie pas de token**. Il est synchrone : une seule requête `createTask` renvoie le résultat. Une image 3x3 ou 4x4 coûte 6 points (≈ $0.90 / 1k), et une petite image 1x1 coûte moins cher (voir le tableau).
> **Astuce:** Si vous ne voulez pas écrire la logique de clic, utilisez l’[extension de navigateur](https://docs.yescaptcha.com/fr/extension.md), qui clique automatiquement en s’appuyant sur cette même API.
- POST `https://api.yescaptcha.com/createTask` (Endpoint mondial)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint Chine)
## Types et tarifs
| Type de tâche | Prix | Mode | Remarques |
| --- | --- | --- | --- |
| `ReCaptchaV2Classification` | $0.90 / 1k; 6 points/tâche · ¥6 / 1k | Synchrone | 2 points pour une vignette 1x1 (100x100) ; 6 points pour 3x3 (300x300) et 4x4 (450x450) |
Les prix en dollars américains sont des estimations avec 1 USD ≈ ¥6.67 ; les tâches sont facturées en points.
## Paramètres de la requête
| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `type` | string | Oui | Type de tâche ; voir « Types de tâches et prix » sur cette page |
| `image` | string | Oui | Image de la question encodée en Base64, sans le préfixe `data:` |
| `question` | string | Oui | ID de la question, par exemple `/m/0k4j` ; voir « ID des questions » sur cette page |
| `confidence` | number | Non | Seuil de confiance de 0 à 1, utilisé uniquement pour les images 3x3. S'il est défini (0.5 est un bon point de départ), toutes les cases au-dessus de ce seuil sont renvoyées ; s'il est omis, les 3 cases les plus probables sont renvoyées |
> **Attention:** L’image doit être redimensionnée à l’une des tailles standard du tableau ci-dessous : le serveur détermine le type de défi d’après la taille.
| Type de défi | Taille de l’image | Retour |
| --- | --- | --- |
| Grille 3x3 (« Sélectionnez toutes les images ») | 300 × 300 | `objects` : les cases à cliquer |
| Grille 4x4 (« Sélectionnez toutes les cases ») | 450 × 450 | `objects` : les cases à cliquer |
| Petite image 1x1 (image unique qui apparaît après un clic dans une grille 3x3) | 100 × 100 | `hasObject` : cliquer ou non sur cette image |
Si vous travaillez avec des captures d’écran, distinguez-les d’après la question : en 3x3, elle commence par « Sélectionnez toutes les images » (Select all images with …) ; en 4x4, par « Sélectionnez toutes les cases » (Select all squares with …).
## Exemple de requête
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "ReCaptchaV2Classification",
"image": "BASE64_IMAGE",
"question": "/m/0k4j"
}
}
```
## Résultat
3x3 et 4x4 :
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"objects": [1, 5, 8],
"type": "multi"
},
"taskId": "3a9e8cb8-3871-11ec-9794-94e6f7355a0b"
}
```
Petite image 1x1 :
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"hasObject": true,
"type": "single"
}
}
```
| Champ | Type | Description |
| --- | --- | --- |
| `objects` | array | Indices des cases à cliquer, à partir de 0, de gauche à droite et de haut en bas |
| `hasObject` | boolean | Renvoyé pour une vignette 1x1 ; indique si la vignette contient la cible |
| `type` | string | Type de question : `multi` (image 3x3 ou 4x4, voir `objects`), `single` (vignette 1x1, voir `hasObject`) ; `drag` pour les questions de glisser-déposer de hCaptcha |
Les cases sont numérotées à partir de 0, de gauche à droite et de haut en bas :
## confidence : obtenir en une fois toutes les cases correspondantes
Après les clics sur une grille 3x3, reCAPTCHA affiche généralement de nouvelles petites images 1x1 qu’il faut encore évaluer. Si elles sont difficiles à récupérer (par exemple en développement mobile), envoyez `confidence` :
- Sans ce paramètre, une image 3x3 renvoie les 3 cases ayant le meilleur score (reCAPTCHA exige au moins 3 clics).
- Avec ce paramètre (essayez `0.5`), toutes les cases dont le score dépasse cette valeur sont renvoyées, soit plus, soit moins de 3 ; un tableau vide si aucune ne correspond. Vous n’avez alors plus besoin de capturer les images 1x1.
- Il n’a aucun effet sur les images 4x4 et 1x1.
## ID de questions
`question` reçoit l’ID de la question (commençant par `/m/`), et non le texte de la question. L’ID se trouve, avec l’image, dans la réponse de la requête par laquelle reCAPTCHA charge le défi (`reload` ou `userverify`). Le tableau ci-dessous liste les questions courantes ; les libellés chinois sont donnés à titre indicatif :
16 au total
| ID de la question | Question (anglais) |
| --- | --- |
| `/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` |
Aucune question correspondante
`ERROR_UNKNOWN_QUESTION` signifie que l’ID est incorrect ou que cette question n’est pas encore prise en charge. `ERROR_UNKNOW_450x450_QUESTION` signifie que cette question n’est pas encore prise en charge pour les images 4x4 ; rechargez le défi sur la page pour en obtenir un autre.
## Signalement et remboursement
Si la vérification échoue après vos clics, vous pouvez signaler les tâches avec [report](https://docs.yescaptcha.com/fr/api/report.md) dans un délai de 1 heure ; le remboursement après signalement est réglé environ 24 heures plus tard. Les règles sont décrites dans [Facturation et remboursement de points](https://docs.yescaptcha.com/fr/getting-started/billing.md). Si la vérification réussit, signalez-le aussi avec report en envoyant `isSuccess: true`.
## Tutoriels associés
- [Reconnaissance d’images reCAPTCHA v2 avec clics simulés (Selenium)](https://docs.yescaptcha.com/fr/guides/recaptcha-click-selenium.md)
- [reCAPTCHA v2 (renvoie un token)](https://docs.yescaptcha.com/fr/tasks/recaptcha-v2.md)
---
# Reconnaissance d'images hCaptcha
> Reconnaissez les défis d'images hCaptcha avec YesCaptcha (HCaptchaClassification) : sélection dans une grille, clic sur une position, glisser vers une position et questions animées ; réponse synchrone, sans débit de points quand aucune cible n'est trouvée.
Source: https://docs.yescaptcha.com/fr/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` reconnaît les défis d’images hCaptcha : envoyez la question et les images, et obtenez en retour les images à sélectionner, la position à cliquer, ou le point de départ et d’arrivée d’un glissement ; votre programme effectue l’action dans le navigateur. Il **ne renvoie pas de token**. La réponse est synchrone, chaque requête coûte 8 points (≈ $1.20 / 1k), et aucun point n’est débité quand aucune cible n’est trouvée (résultat vide).
> **Astuce:** Si vous ne voulez pas écrire la logique de clic, utilisez l’[extension de navigateur](https://docs.yescaptcha.com/fr/extension.md) : elle prend en charge tous ces types de questions. Pour obtenir un token plutôt que des positions de clic, utilisez [hCaptcha](https://docs.yescaptcha.com/fr/tasks/hcaptcha.md).
- POST `https://api.yescaptcha.com/createTask` (Endpoint mondial)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint Chine)
## Types et prix
| Type de tâche | Prix | Mode | Remarques |
| --- | --- | --- | --- |
| `HCaptchaClassification` | $1.20 / 1k; 8 points/tâche · ¥8 / 1k | Synchrone | Aucun débit de points lorsqu'aucune cible n'est trouvée |
Les prix en dollars américains sont des estimations avec 1 USD ≈ ¥6.67 ; les tâches sont facturées en points.
## Paramètres de la requête
| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `type` | string | Oui | Type de tâche ; voir « Types de tâches et prix » sur cette page |
| `queries` | array | Oui | Liste des images de la question encodées en Base64, dans l'ordre de la page (9 vignettes pour une grille 3×3) |
| `question` | string | Non | La question complète telle qu'affichée sur la page (chinois simplifié ou anglais recommandé), par ex. `Please click each image containing a bicycle`. Envoyez au moins l'un de `question` et `anchors` ; il est recommandé d'envoyer les deux |
| `anchors` | array | Non | Images d'exemple encodées en Base64, affichées à côté de la question ; obligatoires pour les questions qui en comportent |
- Envoyez dans `question` la question telle qu’elle s’affiche sur la page, sans la traduire ; il est recommandé de passer hCaptcha en chinois simplifié ou en anglais. Les nouvelles formulations sont généralement prises en charge très vite, et les catégories entièrement nouvelles sous 3 jours ouvrés.
> **Attention:** Si la question affiche une image d’exemple en haut à droite, placez-la dans `anchors`. Les questions qui ne peuvent être résolues qu’avec l’image d’exemple ne sont pas reconnues sans `anchors`.
## Sélection dans une grille
La question est du type « Please click each image containing … », avec 9 petites images en dessous. Placez dans `queries` les 9 images en Base64, dans l’ordre :
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"]
}
}
```
Réponse :
```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` et `top_k` contiennent la même information : le premier indique pour chaque image si c’est une cible, le second liste les index des images cibles (à partir de 0). Cliquez sur ces images.
## Clic sur une position
La question est du type « Please click on … », avec une grande image en dessous : vous devez cliquer sur une ou plusieurs positions de cette image.
1. Prenez `question` sur la page ; s’il y a des images d’exemple, placez-les dans `anchors`.
2. Placez une image dans `queries` : idéalement l’original exporté directement du canvas (conversion en JPG recommandée). Si vous ne pouvez faire qu’une capture d’écran, capturez exactement la zone de la grande image encadrée en rouge, ni plus ni moins.
3. `box` dans la réponse contient les coordonnées à cliquer, dans l’ordre x1, y1, x2, y2, …, avec pour origine le coin supérieur gauche de l’image envoyée.
4. Si la taille de l’image envoyée diffère de sa taille affichée sur la page, convertissez : x sur la page = x renvoyé × largeur affichée ÷ largeur de l’image envoyée (idem pour y). Par exemple, pour x = 769, une largeur affichée du canvas de 350 et une image envoyée de 1000 de large, il faut cliquer à 769 × 350 ÷ 1000 ≈ 269 sur la page.
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"]
}
}
```
Réponse :
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"box": ["221", "213"]
}
}
```
Quand plusieurs cibles sont à cliquer, `box` contient plusieurs paires de coordonnées à la suite : `["221", "213", "340", "118", ...]`.
## Glisser vers une position
La question est du type « Drag … to … » : vous devez faire glisser les pièces de droite vers leur emplacement dans l’image.
1. Prenez `question` sur la page.
2. Placez dans `queries` une capture qui montre **à la fois** la pièce à déplacer et l’emplacement cible, avec chaque côté d’au moins 260 pixels.
3. Chaque élément de `box` dans la réponse est un glissement : `start` est la position de la pièce, `end` la position où la déposer. Avec plusieurs pièces, faites-les glisser une par une.
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"type": "drag",
"box": [
{
"start": [644, 218],
"end": [239, 315]
}
]
}
}
```
Si vous disposez des données du protocole (images des pièces, coordonnées des pièces et grande image de fond) plutôt que d’une capture, collez d’abord les pièces sur l’image de fond selon leurs coordonnées, de façon à obtenir le même rendu que la capture de la page, puis envoyez-la.
## Questions animées
Quand l’image de la question est une animation, placez l’animation (GIF ou format similaire) en Base64 dans `queries`. Une durée d’au moins 3 secondes, idéalement de 5 à 6 secondes, à environ 12 FPS est recommandée.
## Signalement et remboursement après signalement
Si la vérification échoue après vos clics, vous pouvez signaler la tâche avec [report](https://docs.yescaptcha.com/fr/api/report.md) dans un délai de 1 heure ; le remboursement est réglé après environ 24 heures. Les règles sont décrites dans [Facturation et remboursement de points](https://docs.yescaptcha.com/fr/getting-started/billing.md).
## Tutoriels associés
- [Clics simulés pour la reconnaissance d’images hCaptcha (Selenium)](https://docs.yescaptcha.com/fr/guides/hcaptcha-click-selenium.md)
---
# Reconnaissance d'images FunCaptcha
> Reconnaissez les épreuves d'images FunCaptcha (Arkose Labs) avec YesCaptcha (FunCaptchaClassification) : envoyez l'image de l'épreuve (grille de 6 images ou épreuve à flèches en deux moitiés) et la question en anglais, puis obtenez de façon synchrone l'image à choisir ; tous les types d'épreuves sont pris en charge.
Source: https://docs.yescaptcha.com/fr/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` reconnaît les épreuves d’images FunCaptcha (Arkose Labs) : envoyez l’image de l’épreuve et la question en anglais, et la réponse indique quelle image choisir ; votre programme clique ensuite dans le navigateur. Ce type **ne renvoie pas de token**. Il est synchrone et coûte 3 points (≈ $0.45 / 1k) par requête.
> **Astuce:** Sans écrire de code, utilisez l’[extension de navigateur](https://docs.yescaptcha.com/fr/extension.md) pour résoudre l’épreuve automatiquement sur la page.
- POST `https://api.yescaptcha.com/createTask` (Endpoint mondial)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint Chine)
## Types et prix
| Type de tâche | Prix | Mode | Remarques |
| --- | --- | --- | --- |
| `FunCaptchaClassification` | $0.45 / 1k; 3 points/tâche · ¥3 / 1k | Synchrone | |
Les prix en dollars américains sont des estimations avec 1 USD ≈ ¥6.67 ; les tâches sont facturées en points.
## Paramètres de la requête
| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `type` | string | Oui | Type de tâche ; voir « Types de tâches et prix » sur cette page |
| `image` | string | Oui | Image de la question encodée en Base64, sans le préfixe `data:` |
| `question` | string | Oui | Le texte de la question en anglais (par ex. `Pick the image that is the correct way up`) ; les questions prises en charge sont listées sur cette page |
- `image` contient uniquement la partie image de l’épreuve (grille de 6 images, ou image en deux moitiés d’une épreuve à flèches), sans le titre ni les boutons situés au-dessus. La capture doit être complète : une partie manquante nuit à la reconnaissance. Une grille de 6 images en disposition verticale peut être envoyée telle quelle.
- `question` est le texte complet de la question en anglais, tel qu’il s’affiche sur la page, avec la casse exacte ; ne la traduisez pas vous-même. Si la page est dans une autre langue, passez d’abord le captcha en anglais. Le serveur détermine le type d’épreuve à partir de la question, qui doit donc être exacte.
## Exemple de requête
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "FunCaptchaClassification",
"image": "BASE64_IMAGE",
"question": "Pick the bread"
}
}
```
## Résultat
```json
{
"errorId": 0,
"status": "ready",
"solution": {
"objects": [4],
"labels": ["parrot", "panda", "octopus", "owl", "bread", "dog"]
},
"taskId": "04a3fa76-11a0-11ed-a58c-0ef20f419382"
}
```
| Champ | Type | Description |
| --- | --- | --- |
| `objects` | array | Indice de l'image à sélectionner, à partir de 0, de gauche à droite et de haut en bas |
| `labels` | array | Libellés reconnus |
`objects: [4]` signifie qu’il faut choisir la 5e image (les indices commencent à 0, de gauche à droite et de haut en bas). Une épreuve comporte souvent plusieurs manches consécutives : capturez et envoyez chaque manche séparément.
## Questions prises en charge
**Tous les types d’épreuves sont pris en charge**, inutile de consulter une liste au préalable : envoyez directement la question en anglais et l’image de l’épreuve affichées sur la page. Si vous obtenez `ERROR_UNKNOWN_QUESTION`, [contactez le support](https://docs.yescaptcha.com/fr/help/contact.md).
Le type le plus courant aujourd’hui est l’épreuve à flèches en deux moitiés : à gauche se trouve l’exemple à reproduire, à droite l’image actuelle, que vous changez avec les flèches jusqu’à trouver celle qui correspond à la question. Envoyez l’image entière (les deux moitiés) telle qu’elle apparaît sur la page, par exemple :
`Use the arrows to change the number of objects until it matches the left image`Même nombre que sur l'image de gauche
`use the arrows to choose the image where all the darts add up to the number in the left image`La somme des fléchettes égale le nombre de l'image de gauche
`use the arrows to find the jigsaw puzzle that is missing the puzzle piece shown on the left`Il manque exactement la pièce de gauche
`find the image that has the prize on the left held by the claw in the machine on the right`La pince tient le lot de gauche
L’autre type est la grille de 6 images à choisir (par exemple `Pick the bread`) : envoyez la partie en grille de 6 images, comme dans l’exemple de requête ci-dessus.
## Signalement et remboursement
Si la soumission finale d’une série d’épreuves échoue sans que vous sachiez quelle manche était fausse, vous pouvez signaler ensemble les ID de tâche de la série avec [report](https://docs.yescaptcha.com/fr/api/report.md) dans un délai d’1 heure ; le remboursement après signalement est réglé environ 24 heures plus tard. Les règles sont décrites dans [Facturation et remboursement](https://docs.yescaptcha.com/fr/getting-started/billing.md).
---
# Reconnaissance d'images AWS WAF / bCaptcha
> Reconnaissez les captchas en grille 3×3 d'AWS WAF CAPTCHA et de bCaptcha avec YesCaptcha (AwsClassification, bCaptchaClassification) : envoyez l'image entière et la question, et obtenez de façon synchrone les cases à cliquer.
Source: https://docs.yescaptcha.com/fr/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` reconnaît les captchas en grille 3×3 d’AWS WAF CAPTCHA et `bCaptchaClassification` ceux de bCaptcha : envoyez l’image entière et la question, et vous obtenez les cases à cliquer, que votre programme clique ensuite dans le navigateur. Ces types **ne renvoient pas de token**. Ils sont synchrones et coûtent 8 points (≈ $1.20 / 1k) par requête.
Sans écrire de code, utilisez l’[extension de navigateur](https://docs.yescaptcha.com/fr/extension.md).
- POST `https://api.yescaptcha.com/createTask` (Endpoint mondial)
- POST `https://cn.yescaptcha.com/createTask` (Endpoint Chine)
## Types et prix
| Type de tâche | Prix | Mode | Remarques |
| --- | --- | --- | --- |
| `AwsClassification` | $1.20 / 1k; 8 points/tâche · ¥8 / 1k | Synchrone | |
| `bCaptchaClassification` | $1.20 / 1k; 8 points/tâche · ¥8 / 1k | Synchrone | |
Les prix en dollars américains sont des estimations avec 1 USD ≈ ¥6.67 ; les tâches sont facturées en points.
Les deux types ont les mêmes paramètres et le même format de retour ; choisissez selon l’origine du captcha : `AwsClassification` pour AWS WAF, `bCaptchaClassification` pour bCaptcha.
## Paramètres de la requête
| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `type` | string | Oui | Type de tâche ; voir « Types de tâches et prix » sur cette page |
| `queries` | string | Oui | Base64 de l'image complète de la grille 3×3 (une seule image) |
| `question` | string | Non | La question complète telle qu'affichée sur la page, par ex. `Select all hats` ; les autres langues sont traduites automatiquement |
`queries` contient l’image **entière** de la grille 3×3 (une seule image, pas 9 vignettes). Reprenez `question` telle quelle depuis la page ; le chinois et l’anglais fonctionnent, et les autres langues sont traduites automatiquement.
## Exemple de requête
POST https://api.yescaptcha.com/createTask
```json
{
"clientKey": "YOUR_CLIENT_KEY",
"task": {
"type": "AwsClassification",
"queries": "BASE64_IMAGE",
"question": "Select all hats"
}
}
```
## Résultat
```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"
}
```
| Champ | Type | Description |
| --- | --- | --- |
| `label` | string | La cible reconnue de la question |
| `objects` | array | Indique si chacune des 9 cases est une cible (true / false), de gauche à droite et de haut en bas |
| `top_k` | array | Indices (à partir de 0) des images qui sont des cibles ; même sens que `objects`, utilisez l'un ou l'autre |
| `confidences` | array | Confiance de chaque résultat |
Les 9 cases sont numérotées de 0 à 8, de gauche à droite et de haut en bas. `objects` et `top_k` contiennent la même information ; utilisez l’un ou l’autre : cliquez sur les cases dont `objects` vaut `true`, ou sur les indices listés dans `top_k`.
## Signalement et remboursement
Si la vérification échoue après vos clics, signalez les tâches avec [report](https://docs.yescaptcha.com/fr/api/report.md) dans un délai de 1 heure ; le remboursement après signalement est réglé environ 24 heures plus tard. Les règles sont détaillées dans [Facturation et remboursement de points](https://docs.yescaptcha.com/fr/getting-started/billing.md).
---
# YesCaptcha Assistant
> YesCaptcha Assistant (extension de navigateur) : reconnaît et clique automatiquement les captchas reCAPTCHA, hCaptcha, FunCaptcha, AWS WAF et autres dans Chrome et Firefox. L'extension est gratuite ; vous payez les appels API qu'elle utilise. Liens des boutiques, téléchargement des paquets et vidéos d'installation pour Chrome, BitBrowser et Kiwi Browser.
Source: https://docs.yescaptcha.com/fr/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 est une extension de navigateur pour Chrome et Firefox. Lorsqu’une page affiche un captcha, elle l’envoie à YesCaptcha pour reconnaissance, puis clique automatiquement, sans écrire de code. L’extension est gratuite ; la reconnaissance entraîne un débit de points selon les API utilisées, avec le même compte et le même solde que l’API.
## Fonctionnalités
- Reconnaît et clique automatiquement les épreuves d’images de reCAPTCHA v2, hCaptcha, FunCaptcha, AWS WAF et bCaptcha.
- Captchas de caractères ordinaires : faites un clic droit sur l’image et choisissez « Marquer comme captcha », puis un clic droit sur le champ de saisie et choisissez « Saisir le captcha » ; l’extension reconnaît le texte et le saisit.
- Chaque type de captcha peut être activé ou désactivé dans les paramètres, et vous pouvez régler la vitesse de clic, les nouvelles tentatives en cas d’échec, etc.
> **Note:** Tous les sites ne peuvent pas être franchis ; faites d’abord un essai.
## Installation
**Depuis la boutique (recommandé, mise à jour automatique) :**
- Chrome (et les navigateurs basés sur Chromium comme Edge) : [Chrome Web Store](https://chromewebstore.google.com/detail/yescaptcha-assistant/jiofmdifioeejeilfkpegipdjiopiekl)
- Firefox : [Modules complémentaires Firefox](https://addons.mozilla.org/firefox/addon/yescaptcha-assistant/)
Ouvrez la page de l’extension dans le Chrome Web Store, cliquez sur « Ajouter à Chrome », puis cliquez sur l’icône de l’extension dans la barre d’outils et saisissez votre `clientKey` :
Votre navigateur ne peut pas lire cette vidéo. Téléchargez-la plutôt : [Vidéo : installation depuis le Chrome Web Store (34 s)](https://docs.yescaptcha.com/videos/extension-chrome-store.mp4)
Vidéo : installation depuis le Chrome Web Store (34 s)
**Si vous ne pouvez pas ouvrir la boutique, téléchargez le paquet :**
Version Chrome
Version
1.4.12
Taille
1.1 MB
Mis à jour
2026-11-10
[Télécharger](https://api.yescaptcha.com/extension/chrome/latest)[Chrome Web Store](https://chromewebstore.google.com/detail/yescaptcha-assistant/jiofmdifioeejeilfkpegipdjiopiekl)
Version Firefox
Version
0.4.6
Taille
0.9 MB
Mis à jour
2026-10-31
[Télécharger](https://api.yescaptcha.com/extension/firefox/latest)[Modules complémentaires Firefox](https://addons.mozilla.org/firefox/addon/yescaptcha-assistant/)
La version de la boutique Firefox peut être plus ancienne que le paquet proposé ici ; pour obtenir la dernière version, utilisez le paquet.
### Installer le paquet Chrome
1. Téléchargez le fichier zip et décompressez-le dans un dossier permanent.
2. Ouvrez `chrome://extensions` dans la barre d’adresse et activez le « Mode développeur » en haut à droite.
3. Cliquez sur « Charger l’extension non empaquetée » et choisissez le dossier décompressé.
4. Cliquez sur l’icône de l’extension dans la barre d’outils et saisissez votre `clientKey`.
Vous pouvez aussi, avant le chargement, ouvrir le fichier `config.js` décompressé dans un éditeur de texte, saisir votre `clientKey` entre les guillemets de `clientKey: ''` et enregistrer ; la clé sera alors déjà renseignée après l’installation. C’est plus pratique lorsque vous installez l’extension dans plusieurs profils de navigateur.
Votre navigateur ne peut pas lire cette vidéo. Téléchargez-la plutôt : [Vidéo : installation du paquet Chrome, avec le clientKey renseigné au préalable dans config.js (44 s ; la vidéo montre une ancienne version, les étapes sont les mêmes)](https://docs.yescaptcha.com/videos/extension-chrome-zip.mp4)
Vidéo : installation du paquet Chrome, avec le clientKey renseigné au préalable dans config.js (44 s ; la vidéo montre une ancienne version, les étapes sont les mêmes)
> **Attention:** Ne supprimez pas et ne déplacez pas ensuite le dossier décompressé, sinon le navigateur ne pourra plus charger l’extension. Une extension installée avec le paquet ne se met pas à jour automatiquement ; téléchargez de nouveau le paquet lorsqu’une nouvelle version est disponible.
### Installer le paquet Firefox
1. Téléchargez le fichier `.xpi`.
2. Ouvrez `about:addons` dans la barre d’adresse, cliquez sur l’icône d’engrenage, choisissez « Installer un module depuis un fichier », puis sélectionnez le fichier téléchargé.
3. Cliquez sur l’icône de l’extension dans la barre d’outils et saisissez votre `clientKey`.
## Installer dans BitBrowser
Les navigateurs anti-détection (anti-detect browser) comme BitBrowser sont basés sur Chrome. L’extension s’ajoute dans son Extension Center, puis peut être activée pour tous les profils ou seulement pour certains. Les étapes et les vidéos ci-dessous ont été enregistrées avec BitBrowser 6.0 et son interface en chinois ; les versions plus récentes peuvent différer légèrement.
### Depuis le Chrome Web Store
1. Dans BitBrowser, cliquez sur « Extension Center » (扩展中心) dans la barre latérale gauche, cliquez sur « Ajouter une extension personnalisée » (添加自定义扩展), puis choisissez « Ajouter une extension du Chrome Web Store » (添加 Chrome 商店扩展).
2. Dans le champ « URL des détails de l’extension » (扩展详情 URL), collez l’adresse de l’extension dans le Chrome Web Store `https://chromewebstore.google.com/detail/yescaptcha-assistant/jiofmdifioeejeilfkpegipdjiopiekl`, cliquez sur le bouton à droite du champ pour lancer la reconnaissance, puis, une fois « YesCaptcha Assistant » reconnu, cliquez sur « OK » (确定).
3. Une fois l’extension ajoutée, cliquez sur « Paramètres » (设置) sur la carte de YesCaptcha Assistant, puis, dans le mode d’activation de l’extension, choisissez « Toutes les fenêtres » (所有窗口), ou « Fenêtres spécifiques » (指定窗口) en cochant les fenêtres voulues, et cliquez sur « OK ».
4. Ouvrez une fenêtre de navigateur, cliquez sur l’icône des extensions dans la barre d’outils, ouvrez YesCaptcha Assistant et saisissez votre `clientKey` ; lorsque le solde s’affiche, la configuration est terminée.
Votre navigateur ne peut pas lire cette vidéo. Téléchargez-la plutôt : [Vidéo : ajout depuis le Chrome Web Store dans BitBrowser (30 s)](https://docs.yescaptcha.com/videos/extension-bit-store.mp4)
Vidéo : ajout depuis le Chrome Web Store dans BitBrowser (30 s)
### Ajouter avec le paquet
1. Téléchargez le paquet Chrome ci-dessus et décompressez-le dans un dossier permanent.
2. (Facultatif) Ouvrez le fichier `config.js` du dossier dans un éditeur de texte, saisissez votre `clientKey` entre les guillemets de `clientKey: ''` et enregistrez. Vous n’aurez ainsi pas à la ressaisir dans chaque fenêtre.
3. Dans l’Extension Center, cliquez sur « Ajouter une extension personnalisée », choisissez « Ajouter une extension locale » (添加本地扩展), puis, dans « Téléverser l’extension » (上传扩展), sélectionnez le dossier décompressé (le niveau qui contient `manifest.json`) et cliquez sur « OK ».
4. Une fois le téléversement réussi, cliquez sur « Paramètres » sur la carte de YesCaptcha Assistant, choisissez le mode d’activation (toutes les fenêtres ou fenêtres spécifiques) et cliquez sur « OK ».
5. Ouvrez une fenêtre de navigateur et cliquez sur YesCaptcha Assistant sous l’icône des extensions ; lorsque la clé et le solde s’affichent, la configuration est terminée.
Votre navigateur ne peut pas lire cette vidéo. Téléchargez-la plutôt : [Vidéo : ajout du paquet dans BitBrowser (46 s ; la vidéo montre une ancienne version, les étapes sont les mêmes)](https://docs.yescaptcha.com/videos/extension-bit-zip.mp4)
Vidéo : ajout du paquet dans BitBrowser (46 s ; la vidéo montre une ancienne version, les étapes sont les mêmes)
## Sur téléphone Android (Kiwi Browser)
> **Attention:** Kiwi Browser n’est plus maintenu depuis janvier 2025 et a été retiré de Google Play ; il ne reçoit donc plus ni mises à jour ni correctifs de sécurité. Les étapes et la vidéo ci-dessous viennent de l’ancienne documentation, à titre d’information pour les utilisateurs qui utilisent encore Kiwi Browser ; la version actuelle de l’extension n’a pas été retestée sur Kiwi Browser.
1. Téléchargez le paquet Chrome (`.zip`) sur le téléphone, sans le décompresser. Pour renseigner la clé à l’avance, décompressez-le d’abord sur un ordinateur, modifiez `config.js`, puis recompressez-le en zip (`manifest.json` doit se trouver à la racine de l’archive).
2. Dans Kiwi Browser, touchez le menu en haut à droite et choisissez « Extensions ».
3. Activez le « Developer mode » (mode développeur), touchez « + (from .zip/.crx/.user.js) » et sélectionnez le paquet téléchargé.
4. Touchez de nouveau le menu en haut à droite ; YesCaptcha Assistant apparaît tout en bas. Ouvrez-le et saisissez votre `clientKey` ; lorsque le solde s’affiche, la configuration est terminée.
Votre navigateur ne peut pas lire cette vidéo. Téléchargez-la plutôt : [Vidéo : installation dans Kiwi Browser (16 s ; la vidéo montre une ancienne version, les étapes sont les mêmes)](https://docs.yescaptcha.com/videos/extension-kiwi.mp4)
Vidéo : installation dans Kiwi Browser (16 s ; la vidéo montre une ancienne version, les étapes sont les mêmes)
## Configuration
1. Créez un compte et rechargez votre solde sur [yescaptcha.com](https://yescaptcha.com/), puis copiez votre `clientKey` depuis le tableau de bord ; voir [Démarrage rapide](https://docs.yescaptcha.com/fr/getting-started/quickstart.md).
2. Cliquez sur l’icône de l’extension et saisissez la clé dans le panneau des paramètres ; lorsque le solde s’affiche, la configuration est terminée.
3. Ouvrez une page avec un captcha ; l’extension commence automatiquement la reconnaissance.
## Coût
L’extension est gratuite. La reconnaissance entraîne un débit de points selon les types utilisés : par exemple, les épreuves d’images reCAPTCHA sont facturées au tarif de [reCAPTCHA v2 reconnaissance d’images](https://docs.yescaptcha.com/fr/tasks/recaptcha-classification.md), et hCaptcha au tarif de [hCaptcha reconnaissance d’images](https://docs.yescaptcha.com/fr/tasks/hcaptcha-classification.md). Les résultats erronés peuvent être signalés pour un remboursement après signalement ; voir [Facturation et remboursement de points](https://docs.yescaptcha.com/fr/getting-started/billing.md).
---
# Identifier le type de captcha
> Comment savoir quel captcha utilise une page (reCAPTCHA v2, v2 invisible, v3, Enterprise, hCaptcha, différence entre Cloudflare Turnstile et la page de vérification Cloudflare) et quel type de tâche YesCaptcha utiliser.
Source: https://docs.yescaptcha.com/fr/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/
Pour choisir le bon type de tâche, il faut d’abord reconnaître le captcha. Le moyen le plus fiable est d’ouvrir les outils de développement du navigateur (F12) et de regarder, dans l’onglet Network (Réseau), quel script de captcha la page charge ; vous pouvez aussi vous fier à l’apparence.
## Identifier par l’apparence
Voici l’aspect de chaque captcha sur une page web (animations illustratives, pas des captures d’écran) ; cliquez sur une carte pour ouvrir la page du type correspondant. Si l’apparence ne suffit pas, confirmez avec l’aide-mémoire ci-dessous et l’onglet Network.
- [reCAPTCHA v2: Case à cocher · Invisible](https://docs.yescaptcha.com/fr/tasks/recaptcha-v2.md)
- [reCAPTCHA v3](https://docs.yescaptcha.com/fr/tasks/recaptcha-v3.md)
- [Reconnaissance d'images reCAPTCHA v2: Grille 3×3 · Grille 4×4 · Image unique 1×1](https://docs.yescaptcha.com/fr/tasks/recaptcha-classification.md)
- [hCaptcha](https://docs.yescaptcha.com/fr/tasks/hcaptcha.md)
- [Reconnaissance d'images hCaptcha: Grille d'images · Clic sur un point · Glisser-déposer · Animé](https://docs.yescaptcha.com/fr/tasks/hcaptcha-classification.md)
- [Cloudflare Turnstile: Automatique · Case à cocher](https://docs.yescaptcha.com/fr/tasks/turnstile.md)
- [Page de vérification Cloudflare: Automatique · Case à cocher](https://docs.yescaptcha.com/fr/tasks/cloudflare-challenge.md)
- [Reconnaissance d'images FunCaptcha: Flèches · Grille de 6 images](https://docs.yescaptcha.com/fr/tasks/funcaptcha-classification.md)
- [Reconnaissance d'images AWS WAF / bCaptcha: AWS WAF · bCaptcha](https://docs.yescaptcha.com/fr/tasks/aws-bcaptcha-classification.md)
- [Reconnaissance de texte dans une image: Bruité · Lignes parasites · Calcul](https://docs.yescaptcha.com/fr/tasks/image-to-text.md)
## Aide-mémoire
| Ce que vous voyez | De quoi il s’agit | Type de tâche à utiliser |
| --- | --- | --- |
| Une case « Je ne suis pas un robot » | reCAPTCHA v2 | [reCAPTCHA v2](https://docs.yescaptcha.com/fr/tasks/recaptcha-v2.md) |
| Pas de case à cocher ; une épreuve d’images apparaît après le clic sur « Envoyer » ; un petit badge reCAPTCHA en bas à droite | reCAPTCHA v2 invisible (ou v3) | Voir « Versions de reCAPTCHA » ci-dessous |
| Aucune interaction ; seulement le badge reCAPTCHA en bas à droite | reCAPTCHA v3 | [reCAPTCHA v3](https://docs.yescaptcha.com/fr/tasks/recaptcha-v3.md) |
| Une case « Je suis humain » ; épreuves d’images marquées hCaptcha | hCaptcha | [hCaptcha](https://docs.yescaptcha.com/fr/tasks/hcaptcha.md) |
| Un widget Cloudflare dans un formulaire ; la page ne change pas après la validation | Cloudflare Turnstile | [Turnstile](https://docs.yescaptcha.com/fr/tasks/turnstile.md) |
| Toute la page affiche « Veuillez patienter… » / « Vérification de votre connexion », puis redirige automatiquement | Page de vérification Cloudflare | [Page de vérification Cloudflare](https://docs.yescaptcha.com/fr/tasks/cloudflare-challenge.md) |
| Puzzles ou épreuves d’images d’Arkose Labs (par exemple « Choisissez l’image dans le bon sens ») | FunCaptcha | [Reconnaissance d’images FunCaptcha](https://docs.yescaptcha.com/fr/tasks/funcaptcha-classification.md) |
| Une image de lettres et de chiffres déformés | Captcha de caractères | [Reconnaissance de texte dans une image](https://docs.yescaptcha.com/fr/tasks/image-to-text.md) |
## Versions de reCAPTCHA
Dans l’onglet Network, cherchez `api.js` ou `enterprise.js` :
| Script chargé | Version |
| --- | --- |
| `recaptcha/api.js`, sans paramètre `render` ou avec `render=explicit` | v2 standard |
| Idem, et l’adresse de la requête `anchor` contient `size=invisible` | v2 invisible : ajoutez `"isInvisible": true` à la tâche |
| `recaptcha/api.js?render=CLÉ_DU_SITE` (`render` différent de `explicit`) | v3 standard |
| `recaptcha/enterprise.js`, sans paramètre `render` ou avec `render=explicit` | v2 Enterprise |
| `recaptcha/enterprise.js?render=CLÉ_DU_SITE` | v3 Enterprise |
Exemples :
```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
```
La v2 invisible ne passe parfois qu’avec un type v3 ; essayez les deux.
Vous pouvez aussi exécuter le code ci-dessous dans la console (Console) du navigateur. Il liste tous les reCAPTCHA de la page avec leur version, leur clé de site, l’adresse de la page et leur fonction de rappel :
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();
```
Exemple de résultat :
```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"
}
]
```
Les pages de démonstration de Google permettent de comparer : v2 standard `https://www.google.com/recaptcha/api2/demo`, v2 invisible `https://www.google.com/recaptcha/api2/demo?invisible=true`.
## Turnstile et page de vérification Cloudflare
Les deux viennent de Cloudflare, mais ce ne sont pas la même chose :
- **Turnstile** est un widget intégré au formulaire d’une page. Une fois la vérification terminée, une coche s’affiche et la page ne change pas. La page charge `challenges.cloudflare.com/turnstile/v0/api.js`. Utilisez [Turnstile](https://docs.yescaptcha.com/fr/tasks/turnstile.md).
- **La page de vérification Cloudflare** remplace toute la page par l’écran de contrôle de Cloudflare (« Veuillez patienter… », « xx.com doit d’abord vérifier la sécurité de votre connexion »), qui peut aussi contenir un widget ; une fois la vérification réussie, elle redirige vers la vraie page. Le code source contient `__cf_chl_rt_tk` ou `cdn-cgi/challenge-platform`. Utilisez [Page de vérification Cloudflare](https://docs.yescaptcha.com/fr/tasks/cloudflare-challenge.md).
Si votre programme reçoit un 403 avec « Just a moment… » alors qu’un navigateur ouvre la page directement, vous êtes probablement bloqué uniquement par l’empreinte TLS. Une bibliothèque qui imite l’empreinte TLS d’un navigateur (par exemple curl\_cffi) suffit généralement à passer, sans rien résoudre.
---
# Trouver les paramètres reCAPTCHA
> Comment trouver le websiteKey (sitekey) de reCAPTCHA, le websiteURL, le pageAction de v3 et la fonction de rappel dans les onglets Network, Sources et Console des outils de développement, avec un script de recherche automatique.
Source: https://docs.yescaptcha.com/fr/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/
Pour créer une tâche reCAPTCHA, vous avez besoin de `websiteURL` (l’adresse de la page où s’affiche le captcha) et de `websiteKey` (la clé du site) ; v3 requiert aussi `pageAction`. Si vous simulez la soumission avec Selenium ou un outil similaire, il faut en plus connaître la fonction de rappel. Tout cela se trouve dans les outils de développement du navigateur (F12).
## Le plus rapide : un script de recherche automatique
Ouvrez la page où s’affiche le captcha, appuyez sur F12 pour ouvrir la console (Console), puis collez et exécutez ce script :
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();
```
Dans le résultat, `sitekey` correspond à `websiteKey`, `pageurl` à `websiteURL`, `version` indique v2 ou v3, et `function` et `callback` désignent la fonction de rappel :
```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"
}
]
```
Un tableau vide signifie que reCAPTCHA n’est pas encore chargé sur la page ; relancez le script une fois le captcha affiché.
## websiteKey et websiteURL
Dans l’onglet Network, recherchez `anchor` et repérez une requête du type :
```text
https://www.google.com/recaptcha/api2/anchor?ar=1&k=6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9&co=...&hl=en&size=normal
```
- La valeur après `k=` est le `websiteKey`.
- Pour `websiteURL`, indiquez l’adresse complète de la page où s’affiche le captcha (c’est en général le `Referer` de cette requête).
Vous pouvez aussi rechercher `data-sitekey` dans le code source de la page.
## pageAction (v3)
`pageAction` est la valeur de `action` que la page transmet dans `grecaptcha.execute(clé du site, {action: '...'})` ; elle doit être identique à celle de la page.
**Méthode 1 : rechercher dans le code source.** Dans l’onglet Sources des outils de développement, faites un clic droit puis choisissez « Search in all files ». Pour v3 standard, recherchez `.execute(` ; pour v3 Enterprise, recherchez `.enterprise.execute`, puis lisez la valeur de `action` qui suit :
```js
grecaptcha.ready(function () {
grecaptcha.execute('6LdpS-gUAAAAAL3Qr2yP7rkrQjkKBVvEY_48JS5l', { action: 'login' }).then(function (token) {
// ...
});
});
```
Ici, `pageAction` vaut `login`.
**Méthode 2 : un point d’arrêt.** Si le code est obfusqué et que la recherche ne donne rien, exécutez `debug(grecaptcha.execute)` dans la console (`debug(grecaptcha.enterprise.execute)` pour Enterprise), puis effectuez sur la page l’action qui déclenche la vérification (par exemple cliquer sur « Se connecter »). Quand l’exécution s’arrête sur le point d’arrêt, lisez la valeur de `action` dans le panneau Scope à droite.
Un site peut utiliser des `action` différentes à chaque étape (par exemple `signup/submit_email` puis `signup/success`) ; prenez la valeur de l’étape que vous voulez franchir. Appuyez sur F8 pour poursuivre l’exécution et voir l’`action` suivante.
## Fonction de rappel
Quand vous renseignez le token dans le navigateur avec Selenium ou un outil similaire, appelez ensuite la fonction de rappel de la page pour lui indiquer que la vérification est terminée :
- Recherchez `data-callback` dans l’onglet Elements : sa valeur est le nom de la fonction de rappel, par exemple `data-callback="onSuccess"`.
- Ou recherchez `grecaptcha.render` et lisez le paramètre `callback`.
- Ou consultez `___grecaptcha_cfg.clients` dans la console, ou utilisez le script de recherche automatique ci-dessus.
Pour l’appeler :
```python
driver.execute_script("onSuccess(arguments[0])", g_recaptcha_response)
```
Certaines pages n’ont pas de fonction de rappel : placez le token dans le champ texte `g-recaptcha-response`, puis soumettez directement le formulaire. Pour le déroulement complet, consultez [Valider un reCAPTCHA avec un token](https://docs.yescaptcha.com/fr/guides/submit-recaptcha-token.md).
---
# Trouver les paramètres hCaptcha
> Comment trouver le websiteKey (sitekey) d'hCaptcha, le websiteURL et le rqdata de la version Enterprise : cherchez data-sitekey dans le code source de la page, ou les requêtes checksiteconfig et getcaptcha dans l'onglet Network.
Source: https://docs.yescaptcha.com/fr/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/
Pour créer une tâche [hCaptcha](https://docs.yescaptcha.com/fr/tasks/hcaptcha.md), vous avez besoin de `websiteURL` (l’adresse de la page où s’affiche le captcha) et de `websiteKey` (la clé du site, au format UUID) ; la version Enterprise exige parfois aussi `rqdata`. Vous trouvez tout cela dans les outils de développement du navigateur (F12).
## websiteKey
**Méthode 1 : le code source de la page.** Dans le panneau Elements, appuyez sur Ctrl+F (Cmd+F sur Mac) et cherchez `data-sitekey` :
```html
```
La valeur de `data-sitekey` est le `websiteKey`.
**Méthode 2 : les requêtes réseau.** Dans le panneau Network, cherchez `hcaptcha` et repérez la requête `checksiteconfig` ; la valeur après `sitekey=` dans l’adresse est le `websiteKey` :
```text
https://api.hcaptcha.com/checksiteconfig?v=...&host=example.com&sitekey=51829642-2cda-4b09-896c-594f89d700cc&sc=1&swa=1
```
## websiteURL
Indiquez l’adresse complète de la page où s’affiche le captcha, et **non** `hcaptcha.com`. Le `host=` de la requête ci-dessus correspond au domaine de cette page.
## rqdata (version Enterprise)
Certains sites utilisent hCaptcha Enterprise : à chaque chargement du captcha, le site envoie un `rqdata`, et sans lui le token n’est pas accepté. Il apparaît généralement dans la réponse d’une API du site lui-même (par exemple le `captcha_rqdata` renvoyé par l’API de connexion), ou il est passé lors de l’appel à `hcaptcha.render` / `hcaptcha.setData`. Une fois obtenu, placez-le dans le champ `rqdata` de la tâche. Un `rqdata` ne sert en général qu’une seule fois : récupérez-en un nouveau à chaque tentative.
## userAgent
`userAgent` doit être la valeur renvoyée par [/useragent](https://docs.yescaptcha.com/fr/api/useragent.md) ; pour soumettre le token, utilisez le `userAgent` renvoyé dans le résultat de la reconnaissance.
---
# Trouver les paramètres Turnstile
> Comment trouver le websiteKey (sitekey, commençant par 0x) et le websiteURL de Cloudflare Turnstile : cherchez data-sitekey ou turnstile.render dans le code source de la page, ou consultez les requêtes challenges.cloudflare.com dans l'onglet Network.
Source: https://docs.yescaptcha.com/fr/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/
Pour créer une tâche [Turnstile](https://docs.yescaptcha.com/fr/tasks/turnstile.md), vous avez besoin de `websiteURL` (l’adresse de la page où s’affiche le widget) et de `websiteKey` (la clé du site, qui commence généralement par `0x`). Vérifiez d’abord qu’il s’agit bien de Turnstile et non d’une page de vérification Cloudflare ; voir [Identifier le type de captcha](https://docs.yescaptcha.com/fr/guides/identify-captcha.md).
## websiteKey
**Méthode 1 : code source de la page.** Dans le panneau Elements des outils de développement (F12), cherchez `data-sitekey` :
```html
```
**Méthode 2 : scripts.** Si le widget est rendu en JavaScript, faites un clic droit dans le panneau Sources, choisissez « Search in all files », cherchez `turnstile.render` et lisez `sitekey` dans ses paramètres :
```js
turnstile.render('#container', { sitekey: '0x4AAAAAAAxxxxxxxxxxxxxx', callback: onDone });
```
**Méthode 3 : requêtes réseau.** Cherchez `challenges.cloudflare.com` dans le panneau Network ; l’URL de l’iframe du widget contient la clé du site, qui commence par `0x`.
## websiteURL
L’adresse complète de la page où s’affiche le widget, par exemple `https://example.com/login`.
## action et cData (généralement inutiles)
Dans la grande majorité des cas, ils ne sont pas nécessaires. Ne les cherchez que si vous êtes sûr que `websiteKey` et `websiteURL` sont corrects et que les tâches échouent quand même : regardez dans les paramètres de `turnstile.render` ou sur l’élément du widget s’il y a `action` et `cData` (`data-action` et `data-cdata` sur l’élément) :
```js
turnstile.render('#container', { sitekey: '0x4AAAAAAAxxxxxxxxxxxxxx', action: 'login', cData: 'c0bd4b36-7419-4e18-83c6-378699f2a9a2' });
```
S’ils sont présents, lors de la création de la tâche, indiquez `action` dans `pageAction` et `cData` dans `data` ; voir [Turnstile](https://docs.yescaptcha.com/fr/tasks/turnstile.md).
## Soumettre le token
Une fois la tâche terminée, placez le `token` dans le champ caché nommé `cf-turnstile-response` du formulaire (si la page utilise `turnstile.render` avec un `callback`, appelez ce callback en lui passant le token), puis soumettez le formulaire. Utilisez le `userAgent` du résultat comme User-Agent de la requête de soumission.
---
# Utiliser un token pour valider un reCAPTCHA
> Que faire d'un token reCAPTCHA (gRecaptchaResponse) : principe, envoi direct d'une requête (champ g-recaptcha-response), remplissage dans le navigateur avec appel du callback, avec des exemples Python complets sur la page de démonstration de Google.
Source: https://docs.yescaptcha.com/fr/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/
Le `gRecaptchaResponse` renvoyé par YesCaptcha est la même valeur que Google remet à la page une fois le captcha résolu. Une fois que vous l’avez, vous devez le **soumettre au site cible** (et non à Google ni à YesCaptcha), comme le ferait un navigateur ; le site le vérifie auprès de Google, puis vous laisse passer. Deux méthodes sont possibles : envoyer directement la requête, ou renseigner le token dans la page dans un navigateur réel puis la soumettre.
## Principe
Lors d’un accès normal :
1. La page charge reCAPTCHA et l’utilisateur le résout ;
2. Google remet un token à la page, qui le place dans la zone de texte `g-recaptcha-response` (ou le transmet à un callback) ;
3. L’utilisateur soumet le formulaire et le token part avec lui vers le serveur du site ;
4. Le serveur du site vérifie le token auprès de Google, puis laisse passer l’utilisateur.
Avec YesCaptcha, nous nous occupons des étapes 1 et 2 : vous créez une tâche avec `websiteURL` et `websiteKey`, vous obtenez le token, puis vous continuez à partir de l’étape 3.
> **Attention:** Un token est à usage unique et reste valide environ 120 secondes ; soumettez-le dans les 60 secondes suivant son obtention. Les sites rejettent les tokens expirés.
## Méthode 1 : envoyer directement la requête (recommandé)
1. Faites une fois l’opération à la main dans un navigateur : ouvrez le panneau Network avec F12, résolvez le captcha, soumettez, puis repérez la requête qui envoie le formulaire.
2. Dans son Payload (ou Form Data), trouvez le champ qui contient le token, généralement `g-recaptcha-response`, dont la valeur commence par `03A`. Certains sites le renomment, par exemple `grecaptcharesponse` ou `captcha`.
3. Envoyez la même requête depuis votre programme, en remplaçant la valeur du champ par le token renvoyé par YesCaptcha. Les autres champs, les cookies et les en-têtes doivent aussi correspondre à ceux du navigateur, car les sites les vérifient souvent également.
Un exemple complet sur la page de démonstration de Google : obtenir un token, puis le renvoyer à la page de démonstration dans le champ `g-recaptcha-response` :
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)
```
## Méthode 2 : le renseigner dans le navigateur (Selenium, etc.)
Lorsque vous pilotez un navigateur réel avec Selenium, Playwright ou un outil similaire :
1. Lisez `data-sitekey` dans la page et utilisez-le pour créer une tâche et obtenir un token.
2. Écrivez le token dans la zone de texte `g-recaptcha-response` de la page.
3. Si la page définit un callback (`data-callback="..."`), appelez-le en lui passant le token ; sur certains sites, le bouton d’envoi ne devient cliquable qu’après l’exécution du callback.
4. Soumettez le formulaire.
```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');
```
Lorsque la page contient plusieurs reCAPTCHA, l’id de la zone de texte peut être de la forme `g-recaptcha-response-1`. Si vous ne la trouvez pas, résolvez le captcha à la main une fois, puis cherchez `03A` dans le panneau Elements pour voir où le résultat est placé. Pour trouver le callback, voir [Trouver les paramètres reCAPTCHA](https://docs.yescaptcha.com/fr/guides/find-recaptcha-parameters.md).
Exemple complet (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
reCAPTCHA v3 n’a pas de case à cocher. La page appelle `grecaptcha.execute(clé du site, {action: '...'})` quand elle a besoin d’un token, puis place ce token dans sa propre requête (le nom du champ dépend du site ; les plus courants sont `g-recaptcha-response`, `token` et `recaptchaToken`). La démarche est la même que pour la méthode 1 : repérez dans Network la requête qui contient le token et reproduisez-la ; lors de la création de la tâche, `pageAction` doit correspondre à l’`action` de la page.
## Ça ne passe toujours pas
- Le token a expiré : soumettez-le dès que vous l’obtenez, sans dépasser 60 secondes.
- Vous avez soumis un autre champ que celui vérifié par le site, ou il manque d’autres champs ou des cookies : comparez point par point avec la requête du navigateur.
- Le site vérifie aussi l’IP, le User-Agent, etc. : utilisez un type avec votre propre proxy (par exemple `NoCaptchaTask`) et soumettez via le même proxy.
- Score v3 insuffisant : vérifiez `pageAction`, ou utilisez un type à score élevé fixe, voir [reCAPTCHA v3](https://docs.yescaptcha.com/fr/tasks/recaptcha-v3.md).
- Le système anti-fraude du site examine aussi d’autres signaux de comportement. Si le taux de réussite par token est faible, passez à la [reconnaissance d’images](https://docs.yescaptcha.com/fr/tasks/recaptcha-classification.md) avec de vrais clics dans le navigateur, ou utilisez l’[extension de navigateur](https://docs.yescaptcha.com/fr/extension.md).
---
# Clic automatique sur les images reCAPTCHA v2 avec Selenium
> Utilisez Python, Selenium 4 et ReCaptchaV2Classification pour cliquer sur les images d'un reCAPTCHA v2 dans un vrai navigateur : déclenchez le captcha, lisez la question et l'image, appelez l'API, cliquez sur les cases et validez. Code d'exemple complet.
Source: https://docs.yescaptcha.com/fr/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/
Ce tutoriel ouvre la page de démonstration reCAPTCHA de Google avec Selenium 4 et résout l’épreuve d’images dans un vrai navigateur : il lit la question et l’image, demande à [la reconnaissance d’images reCAPTCHA v2](https://docs.yescaptcha.com/fr/tasks/recaptcha-classification.md) (`ReCaptchaV2Classification`) quelles cases cliquer, puis simule les clics. Contrairement à la méthode par token, la vérification se fait réellement dans le navigateur, ce qui convient aux sites où le taux de réussite des tokens est faible.
Si vous ne voulez pas écrire de code, utilisez directement l’[extension de navigateur](https://docs.yescaptcha.com/fr/extension.md) : elle clique automatiquement via le même endpoint.
## Préparation
```bash
pip install requests selenium pillow
export YESCAPTCHA_CLIENT_KEY=your_client_key
```
Chrome doit être installé. Selenium 4 télécharge automatiquement le chromedriver correspondant.
## Étapes
1. **Cliquez sur la case à cocher.** Elle se trouve dans l’iframe `title="reCAPTCHA"` : basculez dedans, puis cliquez sur `#recaptcha-anchor`.
2. **Basculez vers l’iframe de l’épreuve.** L’épreuve se trouve dans une autre iframe (dont le title contient « challenge »).
3. **Lisez la question.** Le texte en gras dans `.rc-imageselect-desc-wrapper strong` est la cible à trouver, par exemple « traffic lights ». L’API attend l’ID de la question : convertissez le nom en ID (`/m/015qff`) avec la table de correspondance, voir [ID de question](https://docs.yescaptcha.com/fr/tasks/recaptcha-classification.md). L’interface du navigateur en anglais est la plus pratique pour la comparaison.
4. **Récupérez l’image.** Les images des cases sont en fait une seule grande image : téléchargez le `src` de `td.rc-imageselect-tile img`. Redimensionnez à 300×300 pour 9 cases (3x3) ou à 450×450 pour 16 cases (4x4), puis encodez en Base64.
5. **Reconnaissance.** Appelez `createTask` avec le type `ReCaptchaV2Classification`, en passant `image` et `question`. Avec `"confidence": 0.5`, les images 3x3 renvoient toutes les cases correspondantes en une seule fois : il n’y a plus à traiter les petites images qui apparaissent après les clics.
6. **Cliquez.** Les `objects` renvoyés sont des numéros de cases, à partir de 0, de gauche à droite et de haut en bas ; cliquez sur les `td` correspondants dans l’ordre.
7. **Vérifiez.** Cliquez sur `#recaptcha-verify-button`. Si une nouvelle série d’images apparaît, revenez à l’étape 3 ; si la fenêtre de l’épreuve se ferme, c’est réussi.
8. **Envoyez le formulaire.** Revenez à la page principale et cliquez sur le bouton d’envoi.
## Code complet
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()
```
## Remarques
- La structure de la page reCAPTCHA change au fil du temps : si les sélecteurs du code ne fonctionnent plus, adaptez-les à la page réelle.
- Chaque image reconnue entraîne un débit de points (tarifs sur [reCAPTCHA v2 reconnaissance d’images](https://docs.yescaptcha.com/fr/tasks/recaptcha-classification.md)). Les tâches dont la vérification a échoué après les clics peuvent être [signalées](https://docs.yescaptcha.com/fr/api/report.md) dans l’heure qui suit pour demander un remboursement après signalement.
- Si la question ne figure pas dans la table de correspondance, cliquez sur le bouton de rechargement pour obtenir une autre épreuve, ou contactez le support pour demander l’ajout de cette question.
---
# Clic sur hCaptcha par reconnaissance d'images avec Selenium
> Utilisez Python, Selenium 4 et HCaptchaClassification pour résoudre les grilles d'images 3×3 de hCaptcha dans un vrai navigateur : cliquer sur la case, lire la question et les 9 images, appeler l'API de reconnaissance, cliquer et valider. Code d'exemple complet.
Source: https://docs.yescaptcha.com/fr/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/
Ce tutoriel ouvre la page de démonstration de hCaptcha avec Selenium 4 et résout la grille d’images 3×3 dans un vrai navigateur : il lit la question et les 9 images, demande à la [reconnaissance d’images hCaptcha](https://docs.yescaptcha.com/fr/tasks/hcaptcha-classification.md) (`HCaptchaClassification`) lesquelles sont des cibles, puis simule les clics.
hCaptcha propose aussi des questions du type « cliquer à un endroit précis » ou « glisser », qui renvoient des coordonnées plutôt que des cases ; consultez la [reconnaissance d’images hCaptcha](https://docs.yescaptcha.com/fr/tasks/hcaptcha-classification.md) pour les traiter. Si vous ne voulez pas écrire de code, utilisez directement l’[extension de navigateur](https://docs.yescaptcha.com/fr/extension.md), qui prend en charge tous ces types de questions.
## Préparation
```bash
pip install requests selenium
export YESCAPTCHA_CLIENT_KEY=your_client_key
```
## Étapes
1. **Cliquez sur la case.** La case se trouve dans l’iframe hCaptcha dont l’URL contient `frame=checkbox` ; passez dans cette iframe et cliquez sur `#checkbox`.
2. **Passez à l’iframe de la question.** La question se trouve dans l’iframe dont l’URL contient `frame=challenge`.
3. **Lisez la question.** Le texte de `.prompt-text` est la question ; transmettez-la telle quelle à l’API (il est recommandé de régler la langue de l’interface hCaptcha sur le chinois simplifié ou l’anglais). Si une petite image d’exemple s’affiche à côté de la question, ajoutez-la aussi dans `anchors`.
4. **Récupérez les images.** Le fond de `.task-image .image` de chaque case est une petite image ; téléchargez-les dans l’ordre, convertissez-les en Base64 et construisez la liste `queries`.
5. **Reconnaissance.** Appelez `createTask` avec le type `HCaptchaClassification`. Les `objects` renvoyés correspondent un à un aux cases ; `true` indique une cible.
6. **Cliquez et validez.** Cliquez sur les cases cibles, puis sur le bouton de validation. Plusieurs tours peuvent se suivre ; répétez alors les étapes 3 à 6.
7. **Terminé.** Une fois la vérification réussie, le champ `h-captcha-response` de la page contient le token ; envoyez-le avec le formulaire.
## Code complet
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()
```
## Remarques
- La structure des pages hCaptcha change souvent ; si les sélecteurs du code ne fonctionnent plus, adaptez-les à la page réelle.
- Chaque tour de reconnaissance entraîne un débit de points ; un tour sans cible reconnue n’est pas débité. Si la vérification échoue après les clics, vous pouvez la [signaler](https://docs.yescaptcha.com/fr/api/report.md) dans un délai d’1 heure pour demander un remboursement après signalement.
- Si une nouvelle question renvoie `ERROR_UNKNOWN_QUESTION`, actualisez la page pour obtenir une autre question, ou contactez le support.
---
# Exemples de code et SDK
> Exemples de code YesCaptcha exécutables (Python, Node.js, curl, C#, Easy Language) et SDK communautaires non officiels (Python, Node.js, Go).
Source: https://docs.yescaptcha.com/fr/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/
Les exemples ci-dessous sont des fichiers complets, exécutables tels quels, qui lisent la ClientKey dans la variable d’environnement `YESCAPTCHA_CLIENT_KEY`. Chaque page de type de tâche contient aussi des exemples curl, Python et Node.js générés pour ce type.
[Python](https://docs.yescaptcha.com/fr/samples/python.md)Solde, première requête, client réutilisable, contrôle des tâches simultanées, Selenium
[Node.js](https://docs.yescaptcha.com/fr/samples/nodejs.md)Node.js 18+, sans dépendance
[C#](https://docs.yescaptcha.com/fr/samples/csharp.md).NET 6+
[Easy Language](https://docs.yescaptcha.com/fr/samples/easy-language.md)Exemples de clic simulé fournis par des utilisateurs
Pour tester uniquement en ligne de commande, consultez les exemples curl dans [Démarrage rapide](https://docs.yescaptcha.com/fr/getting-started/quickstart.md) et [getBalance](https://docs.yescaptcha.com/fr/api/get-balance.md).
## SDK communautaires
Ces SDK ont été fournis par des utilisateurs et sont **non officiels**. Nous n’avons pas vérifié leur code : évaluez-les avant de les utiliser et contactez leurs auteurs en cas de problème.
| Langage | Projet |
| --- | --- |
| 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) |
Quel que soit le SDK utilisé, vérifiez qu’il appelle `api.yescaptcha.com` ou `cn.yescaptcha.com` et que les noms de types de tâche sont identiques à ceux de ce site.
---
# Python
> Exemples Python pour YesCaptcha : consulter le solde, lire un captcha image, une classe cliente réutilisable (création de tâche, interrogation périodique (polling) toutes les 5 secondes), contrôle des tâches simultanées avec asyncio, et envoi de reCAPTCHA avec requests et Selenium.
Source: https://docs.yescaptcha.com/fr/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/
Prérequis : Python 3.8 ou supérieur, et `pip install requests`. Définissez la variable d’environnement avant l’exécution :
```bash
export YESCAPTCHA_CLIENT_KEY=your_client_key
```
## Consulter le solde
Gratuit ; permet de vérifier que le ClientKey est correct :
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"])
```
## Lire un captcha image
Le type synchrone `ImageToTextTaskOcrBase` renvoie le résultat en une seule requête. Image d’exemple : [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"])
```
## Un client réutilisable
Copiez ce fichier dans votre projet ; il gère les types synchrones comme asynchrones :
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"])
```
En cas d’erreur, `YesCaptchaError` est levée ; `e.code` contient le code d’erreur (voir [Codes d’erreur](https://docs.yescaptcha.com/fr/api/errors.md)).
## Contrôler les tâches simultanées
Lorsque vous envoyez des tâches en lot, limitez le nombre de requêtes en cours de traitement en même temps, et patientez avant de réessayer si vous recevez `ERROR_THREADS_MAXIMUM` (nécessite `pip install aiohttp`). Voir [Limite de tâches simultanées et suspension automatique](https://docs.yescaptcha.com/fr/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([])))
```
## Envoyer un token reCAPTCHA
- Envoyer directement avec requests : voir [Valider un reCAPTCHA avec un token](https://docs.yescaptcha.com/fr/guides/submit-recaptcha-token.md)
- Remplir le token dans le navigateur avec Selenium : voir [Valider un reCAPTCHA avec un token](https://docs.yescaptcha.com/fr/guides/submit-recaptcha-token.md)
- Simuler les clics sur les épreuves d’images avec Selenium : voir [Clics simulés pour la reconnaissance d’images reCAPTCHA v2](https://docs.yescaptcha.com/fr/guides/recaptcha-click-selenium.md), [Clics simulés pour la reconnaissance d’images hCaptcha](https://docs.yescaptcha.com/fr/guides/hcaptcha-click-selenium.md)
---
# Node.js
> Exemples Node.js pour YesCaptcha (Node.js 18+ avec le fetch intégré, sans dépendance) : consulter le solde, lire un captcha image, et une classe client réutilisable (création de tâche, interrogation périodique toutes les 5 secondes).
Source: https://docs.yescaptcha.com/fr/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/
Prérequis : Node.js 18 ou version ultérieure (`fetch` intégré). Les exemples sont des modules ES (`.mjs`) et n’ont aucune dépendance. Définissez la variable d’environnement avant l’exécution :
```bash
export YESCAPTCHA_CLIENT_KEY=your_client_key
```
## Consulter le solde
Sans débit de points ; permet de vérifier que votre ClientKey est correcte :
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);
}
```
## Lire un captcha image
Le type synchrone `ImageToTextTaskOcrBase` renvoie le résultat en une seule requête. Image d’exemple : [captcha.jpg](https://docs.yescaptcha.com/samples/captcha.jpg). Exécutez `node quickstart.mjs captcha.jpg`.
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);
```
## Un client réutilisable
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);
```
En cas d’erreur, `YesCaptchaError` est levée ; `err.code` contient le code d’erreur (voir [Codes d’erreur](https://docs.yescaptcha.com/fr/api/errors.md)).
---
# C#
> Exemple C# pour YesCaptcha (.NET 6+, HttpClient et System.Text.Json) : consultez le solde, puis créez une tâche reCAPTCHA v2 et interrogez le résultat toutes les 5 secondes.
Source: https://docs.yescaptcha.com/fr/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/
Environnement : .NET 6 ou supérieur, bibliothèque standard uniquement (`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"]);
}
}
```
Pour un autre type de tâche, modifiez uniquement l’objet de tâche dans `Solve` ; les champs sont décrits dans chaque page de [type de tâche](https://docs.yescaptcha.com/fr/tasks.md). Les types synchrones (reconnaissance d’images, `ImageToTextTaskOcrBase`) renvoient le résultat directement dans `createTask`, ce que `Solve` gère déjà.
---
# Easy Language (易语言)
> Exemples YesCaptcha en Easy Language (易语言) fournis par des utilisateurs : clics simulés pour reCAPTCHA et hCaptcha, reconnaissance d'images FunCaptcha, envoi de token reCAPTCHA ; téléchargements et points clés pour appeler l'API.
Source: https://docs.yescaptcha.com/fr/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 (易语言) est un langage de programmation en chinois, répandu en Chine. Ces exemples ont été fournis par des utilisateurs (南方填表, 松, etc.) et sont donnés à titre indicatif : nous ne les avons pas relus ligne par ligne. Ils comprennent :
- les clics simulés pour reCAPTCHA et hCaptcha (le navigateur est lancé, puis le captcha est reconnu et cliqué automatiquement)
- la reconnaissance d’images FunCaptcha
- l’envoi de token reCAPTCHA
> **Téléchargements:** Les paquets d’exemples (le plus volumineux fait environ 87 MB et inclut un navigateur) sont en cours de migration vers une nouvelle adresse de téléchargement. En attendant, [contactez le support](https://docs.yescaptcha.com/fr/help/contact.md) pour les obtenir.
## Appeler l’API depuis Easy Language
Les paquets ne sont pas nécessaires pour appeler l’API : la commande d’accès web d’Easy Language (POST) suffit :
1. URL `https://api.yescaptcha.com/createTask`, méthode `POST`, en-tête `Content-Type: application/json`.
2. Le corps est un texte JSON, par exemple `{"clientKey":"YOUR_CLIENT_KEY","task":{"type":"ImageToTextTaskOcrBase","body":"BASE64_IMAGE"}}`.
3. Dans la réponse JSON, `errorId` à 0 indique un succès. Pour les types asynchrones, récupérez `taskId`, puis envoyez toutes les 5 secondes `{"clientKey":"…","taskId":"…"}` à `https://api.yescaptcha.com/getTaskResult` jusqu’à ce que `status` vaille `ready`.
4. Le Base64 de l’image ne doit contenir ni le préfixe `data:image/...;base64,` ni saut de ligne.
Formats de requête et de réponse : [Requêtes et réponses](https://docs.yescaptcha.com/fr/api/overview.md).
## Si un exemple ne fonctionne pas
- Message indiquant qu’il est impossible de créer le navigateur : utilisez d’abord le navigateur fourni dans le paquet d’exemples, désinstallez les autres navigateurs susceptibles d’entrer en conflit, ou compilez le programme avant de l’exécuter.
- Un code d’erreur est renvoyé : vérifiez les paramètres à l’aide des [codes d’erreur](https://docs.yescaptcha.com/fr/api/errors.md).
---
# Plusieurs ClientKey : limites, liste blanche d'IP et expiration
> Un compte YesCaptcha peut avoir jusqu'à 20 ClientKey, qui débitent toutes le même solde. Chacune peut avoir sa propre limite de dépenses (par jour, par semaine, par mois ou en total unique, remise à zéro à l'heure de Pékin), sa liste blanche d'IP et son expiration, appliquées en quelques secondes.
Source: https://docs.yescaptcha.com/fr/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/
Un compte YesCaptcha peut avoir jusqu’à 20 `clientKey` (y compris la première), gérées dans la page « Clés et sécurité » du tableau de bord [yescaptcha.com](https://yescaptcha.com/security). Chaque `clientKey` peut créer des tâches et consulter le solde, et toutes débitent le même solde du compte. Chacune peut avoir sa propre limite de dépenses, sa liste blanche d’IP et son expiration, appliquées en quelques secondes.
Cas d’usage typiques : séparer les environnements de test et de production, ou les différents projets ; confier une clé à vos clients ou partenaires, chacun avec sa propre limite ; et si une `clientKey` fuit, ne supprimer que celle-ci sans toucher aux autres programmes.
## Clé principale et sous-clés
| | Clé principale | Sous-clé |
| --- | --- | --- |
| Définition | La `clientKey` d’origine, une par compte | Toute clé créée en plus de la clé principale, 19 au maximum |
| Limite, liste blanche d’IP, expiration | Possible | Possible |
| Réinitialisation | Oui : l’ancienne cesse de fonctionner immédiatement et le solde passe à la nouvelle | Non ; supprimez-la et créez-en une autre |
| Suppression | Non | Oui : cesse de fonctionner en quelques secondes, irréversible |
- Toutes ont le même format : les 40 premiers caractères forment le secret, suivis de votre ID utilisateur.
- Réinitialiser la clé principale n’affecte pas les sous-clés.
- Quelle que soit la `clientKey` utilisée pour créer des tâches ou consulter le solde, l’API et ses réponses sont identiques ; seules s’ajoutent les vérifications de limite, de liste blanche d’IP et d’expiration.
## Créer une clé
1. Connectez-vous sur [yescaptcha.com](https://yescaptcha.com/) et ouvrez la page « Clés et sécurité » ([yescaptcha.com/security](https://yescaptcha.com/security)).
2. Dans « Toutes les clés », cliquez sur « Nouvelle sous-clé ». Le nom (40 caractères maximum), la limite, la liste blanche d’IP et l’expiration sont facultatifs et modifiables plus tard.
3. Confirmez de nouveau votre identité lorsque c’est demandé. La création, la modification et la suppression l’exigent toutes.
4. Copiez la `clientKey` complète et configurez-la dans votre programme. Vous pourrez la consulter de nouveau plus tard avec l’icône en forme d’œil dans la liste.
> **Note:** La création, la modification et la suppression sont appliquées en quelques secondes. Un appel effectué juste après la création peut renvoyer `ERROR_KEY_DOES_NOT_EXIST` ; attendez quelques secondes et réessayez. Pendant quelques secondes après une suppression ou un durcissement des réglages, les requêtes déjà en cours peuvent encore être traitées avec les anciens réglages.
## Limite de dépenses
La limite plafonne le nombre de points qu’une `clientKey` peut dépenser sur une période (1,000 points = ¥1), de 1 à 10,000,000,000 points. Il existe quatre périodes, remises à zéro à l’heure de Pékin (UTC+8) :
| Période | Remise à zéro |
| --- | --- |
| Par jour | Chaque jour à 00:00 |
| Par semaine | Chaque lundi à 00:00 |
| Par mois | Le 1er de chaque mois à 00:00 |
| Total unique | Jamais. Une fois épuisée, cette `clientKey` ne peut plus créer de tâches ; augmentez la limite pour continuer à l’utiliser |
- Le calcul porte sur les points réellement débités : les points remboursés pour les tâches échouées ou expirées sont aussi rendus à la limite.
- Si le reste de la limite de la période en cours est inférieur au coût de la tâche, `createTask` renvoie [`ERROR_KEY_QUOTA_EXCEEDED`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_KEY_QUOTA_EXCEEDED). Aucun point n’est débité et l’erreur ne compte pas pour la [suspension automatique](https://docs.yescaptcha.com/fr/api/rate-limits.md).
- La liste du tableau de bord indique, pour chaque `clientKey`, ce qui a été utilisé sur la période en cours et la prochaine remise à zéro.
- La limite n’est pas un solde distinct : toutes les `clientKey` débitent le même solde du compte, et quand le solde du compte est épuisé, vous obtenez `ERROR_ZERO_BALANCE` comme d’habitude.
Si vous appelez [`getBalance`](https://docs.yescaptcha.com/fr/api/get-balance.md) avec une `clientKey` qui a une limite, `balance` est la plus petite valeur entre le solde du compte et le reste de la limite de la période en cours, et un champ supplémentaire `keyQuotaRemaining` (limite restante, en points) est renvoyé. Une `clientKey` sans limite n’a pas ce champ et la réponse reste identique à avant.
```json
{
"errorId": 0,
"balance": 20000,
"softBalance": 0,
"inviteBalance": 0,
"inviteBy": 0,
"keyQuotaRemaining": 20000
}
```
## Liste blanche d’IP
Une `clientKey` avec une liste blanche d’IP ne fonctionne que pour les requêtes envoyées depuis les adresses IP de la liste. Laissez-la vide pour ne mettre aucune restriction.
- Saisissez l’**IP publique de la machine qui appelle l’API YesCaptcha** (son IP de sortie), et non le proxy indiqué dans les paramètres de la tâche. Si plusieurs machines appellent l’API, ajoutez l’IP publique de chacune.
- Une adresse IPv4 ou IPv6, ou une plage CIDR, par ligne, 50 entrées au maximum. Une adresse seule n’autorise que cette IP.
- Écrivez les plages avec l’adresse réseau : `203.0.113.0/24` est accepté, `203.0.113.5/24` ne l’est pas (les bits d’hôte ne sont pas à 0).
```text
203.0.113.10
198.51.100.0/24
2001:db8::/32
```
- Si la requête provient d’une IP absente de la liste, `createTask` et `getBalance` renvoient [`ERROR_KEY_IP_NOT_ALLOWED`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_KEY_IP_NOT_ALLOWED). Aucun point n’est débité et l’erreur ne compte pas pour la suspension automatique.
- Si votre IP de sortie change (box domestique, fonctions cloud, sorties en rotation), ne définissez pas de liste blanche, ou autorisez toute la plage.
## Expiration
- Toute `clientKey`, clé principale comprise, peut avoir une date d’expiration dans les dix ans à venir. Vous pouvez la modifier ou la retirer à tout moment.
- Après l’expiration, `createTask` et `getBalance` avec cette clé renvoient [`ERROR_KEY_EXPIRED`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_KEY_EXPIRED) et aucun point n’est débité. Les tâches déjà créées peuvent toujours être récupérées avec `getTaskResult`.
- Si une `clientKey` reste inutilisée pendant longtemps, le système lui attribue une date d’expiration pour protéger votre compte et vous envoie un e-mail avant l’échéance. Cette date ne peut pas être modifiée : générez une nouvelle clé principale (le solde y est transféré automatiquement) ou créez une autre `clientKey`, puis mettez à jour votre programme.
## Solde, limite de tâches simultanées et suspension automatique
- **Solde** : toutes les `clientKey` débitent le même solde du compte. Les recharges, les bonus VIP, les récompenses de parrainage et la part développeur sont rattachés au compte, quelle que soit la `clientKey` utilisée.
- **Limite de tâches simultanées** : calculée par compte ; toutes vos `clientKey` partagent la même limite. Voir [Limite de tâches simultanées et suspension automatique](https://docs.yescaptcha.com/fr/api/rate-limits.md).
- **Suspension automatique** : calculée par `clientKey`. Si une `clientKey` est suspendue pour trop d’erreurs, les autres ne sont pas affectées.
## Codes d’erreur associés
| Code d’erreur | Quand il est renvoyé |
| --- | --- |
| [`ERROR_KEY_QUOTA_EXCEEDED`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_KEY_QUOTA_EXCEEDED) | Le reste de la limite de la période en cours est inférieur au coût de cette tâche (`createTask`) |
| [`ERROR_KEY_IP_NOT_ALLOWED`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_KEY_IP_NOT_ALLOWED) | L’IP de la requête n’est pas dans la liste blanche d’IP de cette `clientKey` (`createTask`, `getBalance`) |
| [`ERROR_KEY_EXPIRED`](https://docs.yescaptcha.com/fr/api/errors.md#ERROR_KEY_EXPIRED) | La `clientKey` a expiré (`createTask`, `getBalance`) |
Aucun de ces codes ne débite de points. Voir [Codes d’erreur](https://docs.yescaptcha.com/fr/api/errors.md) pour savoir quoi faire.
---
# Recharge et VIP
> Comment recharger YesCaptcha (WeChat Pay, Alipay, PayPal, cryptomonnaies) ; 1,000 points = ¥1. Votre recharge cumulée vous fait passer automatiquement de VIP 1 à VIP 10, puis chaque recharge suivante reçoit des points bonus.
Source: https://docs.yescaptcha.com/fr/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/
Rechargez depuis la page de recharge du tableau de bord [yescaptcha.com](https://yescaptcha.com/) ([yescaptcha.com/payment.html](https://yescaptcha.com/payment.html)). 1,000 points = ¥1, disponibles immédiatement. Lorsque votre recharge cumulée atteint certains montants, vous passez automatiquement à un niveau VIP, et chaque recharge suivante reçoit des points supplémentaires selon le taux de bonus de ce niveau.
## Moyens de paiement
| Moyen | Description |
| --- | --- |
| WeChat Pay | Paiement par QR code |
| Alipay | Paiement par QR code ou par redirection |
| PayPal | Pour les clients hors de Chine |
| Cryptomonnaies | Via Cryptomus ; BTC, ETH, USDT, etc. |
| Virement bancaire | Contactez le support ; crédité manuellement après confirmation du service financier |
L’historique de vos paiements est disponible sur la page de recharge. En cas de problème de paiement, [contactez le support](https://docs.yescaptcha.com/fr/help/contact.md) en indiquant les informations de la commande.
## Niveaux VIP
Lorsque votre recharge cumulée atteint l’un des seuils ci-dessous, vous passez automatiquement au niveau correspondant ; ensuite, chaque recharge reçoit le pourcentage de bonus en points supplémentaires.
| Niveau | Total des recharges | Bonus à chaque recharge |
| --- | --- | --- |
| 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% |
- **Cumul** : quel que soit le nombre de recharges, le total est pris en compte.
- **Calculé après la recharge** : par exemple, si votre première recharge est de ¥1,000, votre total atteint le seuil de VIP 4 et cette recharge reçoit déjà le bonus de VIP 4.
- En vous inscrivant via le lien de parrainage d’un ami, vous obtenez immédiatement un niveau VIP ; voir [Récompenses de parrainage](https://docs.yescaptcha.com/fr/account/referral.md).
- Votre niveau actuel et votre taux de bonus sont affichés sur la page de recharge.
---
# Programme de parrainage
> Programme de parrainage YesCaptcha. Les utilisateurs parrainés obtiennent un niveau VIP dès l'inscription (votre niveau moins 1, de VIP 1 à VIP 6), et vous recevez 20% de leurs dépenses (10% chacun lorsqu'une part développeur s'applique aussi), à convertir en solde ou à retirer dès ¥100 depuis le tableau de bord.
Source: https://docs.yescaptcha.com/fr/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/
Parrainez des amis sur YesCaptcha : ils obtiennent un niveau VIP dès leur inscription, et vous recevez 20% de leurs dépenses. Les récompenses peuvent être converties en solde du compte, ou retirées depuis le tableau de bord une fois qu’elles atteignent ¥100.
## Comment parrainer
Connectez-vous au tableau de bord de [yescaptcha.com](https://yescaptcha.com/). Le panneau « Programme de parrainage » affiche votre lien de parrainage, le nombre de personnes parrainées et le total de vos récompenses. Envoyez le lien à vos amis ; ils s’inscrivent via ce lien.
## Règles
1. **Le niveau VIP de votre filleul** : à l’inscription, votre filleul obtient votre niveau VIP moins 1, avec un minimum de VIP 1 et un maximum de VIP 6. Par exemple, si vous êtes VIP 6, votre filleul démarre à VIP 5. Les taux de bonus de chaque niveau sont indiqués dans [Recharge et VIP](https://docs.yescaptcha.com/fr/account/recharge.md).
2. **Votre récompense** : **20%** du montant dépensé par votre filleul (débit de points pour les tâches).
3. **En cas de part développeur** : si les tâches de votre filleul portent aussi l’ID d’un développeur (voir [Part développeur](https://docs.yescaptcha.com/fr/account/developer.md)), le parrain et le développeur **reçoivent chacun 10%**.
4. Si votre filleul signale un résultat de reconnaissance erroné et obtient un remboursement de points pour une tâche, la récompense correspondante est retirée.
5. Consultez le solde de vos récompenses (en CNY) avec `inviteBalance` dans [getBalance](https://docs.yescaptcha.com/fr/api/get-balance.md).
## Utiliser les récompenses
- **Convertir en solde** : transférez vos récompenses vers le solde de votre compte depuis le tableau de bord, au taux de 1,000 points = ¥1.
- **Retirer** : dès que vos récompenses atteignent **¥100**, envoyez une demande de retrait depuis le tableau de bord ; le versement est effectué après vérification.
- Vous êtes responsable de la déclaration de l’impôt sur le revenu applicable aux retraits.
## Écrire à propos de nous
Si vous publiez des recommandations, des tutoriels, des retours d’expérience, des extensions ou des bibliothèques à propos de YesCaptcha sur des forums, des blogs ou des réseaux sociaux, envoyez le lien au support. Nous l’examinerons et pourrons vous accorder des points ou un niveau VIP supérieur, selon la qualité du contenu.
Toute modification de ces règles sera publiée sur cette page et dans l’[historique des mises à jour du service](https://docs.yescaptcha.com/fr/changelog.md).
---
# Part développeur
> Part développeur YesCaptcha : ajoutez votre softID dans les requêtes que votre logiciel ou votre extension envoie pour ses utilisateurs et recevez 20% de leurs dépenses (10% chacun lorsqu'un parrain est aussi concerné) ; convertissez-la en solde ou retirez-la dès ¥100 dans le tableau de bord.
Source: https://docs.yescaptcha.com/fr/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/
Si votre logiciel, votre script ou votre extension utilise YesCaptcha, ajoutez votre ID développeur (`softID`) dans les requêtes qu’il envoie pour d’autres utilisateurs : vous recevez une part de leurs dépenses. Les utilisateurs continuent d’utiliser leur propre `clientKey` et leurs propres points ; cette part ne leur coûte rien de plus.
## Intégration
1. Appelez [getSoftID](https://docs.yescaptcha.com/fr/api/get-soft-id.md) avec votre propre `clientKey` pour obtenir votre ID développeur :
```json
{
"errorId": 0,
"softID": 3,
"balance": 0.004
}
```
2. Dans chaque requête `createTask` envoyée par votre logiciel, ajoutez le champ de premier niveau `softID` (au même niveau que `clientKey` et `task` ; attention à la casse) :
```json
{
"clientKey": "THE_USERS_CLIENT_KEY",
"task": {
"type": "NoCaptchaTaskProxyless",
"websiteURL": "https://www.google.com/recaptcha/api2/demo",
"websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
},
"softID": 3
}
```
`clientKey` est la clé propre à l’utilisateur.
## Règles de la part développeur
- Les tâches qui portent votre `softID` créditent votre part développeur à hauteur de **20%** des dépenses réelles de l’utilisateur.
- Si l’utilisateur a aussi été invité par quelqu’un (voir [Récompense de parrainage](https://docs.yescaptcha.com/fr/account/referral.md)), le développeur et le parrain **reçoivent 10% chacun**.
- Seules les tâches avec débit de points donnent droit à une part ; les tâches échouées ou expirées, dont les points sont remboursés, n’en donnent pas. Si l’utilisateur signale un résultat erroné et obtient un remboursement, la part correspondant à cette tâche est reprise.
- Consultez votre solde de part développeur (en yuans) avec `balance` de [getSoftID](https://docs.yescaptcha.com/fr/api/get-soft-id.md) ou `softBalance` de [getBalance](https://docs.yescaptcha.com/fr/api/get-balance.md).
## Utiliser votre part
- **Convertir en solde** : dans le tableau de bord, transférez-la vers le solde de votre compte, à raison de 1,000 points = ¥1, pour l’utiliser en reconnaissance.
- **Retirer** : une fois la part arrivée à **¥100**, envoyez une demande de retrait depuis le tableau de bord ; le versement a lieu après vérification.
- Vous êtes responsable de la déclaration de l’impôt sur le revenu correspondant aux retraits.
---
# FAQ
> Questions fréquentes sur YesCaptcha : débit de points en cas d'échec, durée de validité d'un token, taux de réussite, reconnaissance humaine ou automatique, risque de blocage de compte, utilisation d'un même ClientKey à plusieurs endroits, choix de l'endpoint, extension ou API.
Source: https://docs.yescaptcha.com/fr/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/
## Les points sont-ils débités quand YesCaptcha ne résout pas un captcha ?
Non. Les tâches en échec (`ERROR_CAPTCHA_UNSOLVABLE`) ou expirées (`ERROR_TASK_TIMEOUT`) donnent lieu à un remboursement de points automatique, et les requêtes qui renvoient un code d’erreur (paramètres incorrects, par exemple) ne sont pas débitées. Si vous obtenez un token mais que le site cible le refuse, la tâche est facturée comme réussie, car nous ne pouvons pas connaître la décision du site. Pour la reconnaissance d’images, vous pouvez signaler un mauvais clic afin d’obtenir un remboursement après signalement. Voir [Facturation et remboursement de points](https://docs.yescaptcha.com/fr/getting-started/billing.md).
## Combien coûte une résolution ?
Chaque type de tâche a un nombre de points fixe débité à chaque résolution (1,000 points = ¥1), et les prix varient selon le type. Tous les prix figurent dans [Types de tâches et prix](https://docs.yescaptcha.com/fr/tasks.md) ; la version lisible par machine est disponible à l’adresse [/data/task-types.json](https://docs.yescaptcha.com/data/task-types.json).
## Combien de temps un token reste-t-il valide ?
Les tokens reCAPTCHA, hCaptcha et Turnstile sont à usage unique. Un token reCAPTCHA reste valide environ 120 secondes ; nous vous conseillons de le soumettre dans les 60 secondes suivant sa réception. La durée de validité est fixée par l’éditeur du captcha.
## Pourquoi certains tokens ne passent-ils pas ?
C’est le site cible qui décide si un token est accepté. Il tient compte du score, de l’IP, de l’environnement du navigateur, etc., et peut modifier son seuil à tout moment : le taux de réussite varie donc d’un site à l’autre. Vous pouvez comparer avec d’autres types de tâche pour le même captcha, utiliser un type avec votre propre proxy et soumettre le token via ce même proxy, ou passer à la reconnaissance d’images avec de vrais clics dans le navigateur.
## Combien de temps dure une résolution ?
Les tâches asynchrones prennent en général de quelques secondes à quelques dizaines de secondes, et au maximum environ 110 secondes (180 à 220 secondes pour quelques types) ; au-delà, elles expirent et les points sont remboursés automatiquement. La reconnaissance d’images et la reconnaissance de texte dans une image sont synchrones : une seule requête renvoie le résultat.
## La reconnaissance est-elle humaine ou automatique ?
Automatique, à l’aide de modèles d’apprentissage automatique.
## L’utilisation de YesCaptcha peut-elle entraîner le blocage de mon compte ?
Nous ne renvoyons que le résultat de la reconnaissance et n’accédons jamais à votre compte sur le site cible. C’est le site cible qui décide de la façon dont il évalue l’activité et de bloquer ou non un compte ; respectez ses règles. YesCaptcha ne peut être utilisé qu’à des fins légales ; toute utilisation illégale est interdite.
## Un même ClientKey peut-il être utilisé simultanément dans plusieurs programmes ou navigateurs ?
Oui. Les requêtes d’un même compte sont comptabilisées ensemble pour la [limite de tâches simultanées](https://docs.yescaptcha.com/fr/api/rate-limits.md) et partagent le même solde.
## Faut-il utiliser l’endpoint mondial ou l’endpoint Chine ?
Si votre serveur se trouve en Chine continentale, utilisez `cn.yescaptcha.com` ; ailleurs, utilisez `api.yescaptcha.com`. Interrogez le résultat d’une tâche sur l’endpoint où elle a été créée. Voir [Adresses d’accès](https://docs.yescaptcha.com/fr/getting-started/endpoints.md).
## Quelle est la différence entre l’extension de navigateur et l’API ?
L’extension appelle la même API pour résoudre les captchas. Son installation est gratuite et les points sont débités selon les appels d’API utilisés ; elle convient pour travailler dans le navigateur sans écrire de code, alors que l’API convient au traitement par lots dans un programme. Voir [Extension de navigateur](https://docs.yescaptcha.com/fr/extension.md).
## Pourquoi mon compte est-il suspendu avec ERROR\_IP\_BLOCKED\_5MIN ?
Votre ClientKey a généré trop de requêtes en erreur en une minute et fait l’objet d’une suspension automatique de quelques minutes ; elle se lève d’elle-même à l’échéance. Le champ `blockReason` de la réponse indique le code d’erreur à l’origine de la suspension : corrigez votre programme en conséquence. Voir [Limite de tâches simultanées et suspension automatique](https://docs.yescaptcha.com/fr/api/rate-limits.md).
## Quels sites sont pris en charge ?
Nous proposons la reconnaissance par type de captcha, et non pour des sites précis. La réussite dépend des paramètres du site cible ; nous vous conseillons de tester d’abord sur un petit lot. Si un site n’est pas encore pris en charge, l’API renvoie `ERROR_DOMAIN_NOT_ALLOWED`.
---
# Problèmes de connexion et de réseau
> Que faire quand vous ne parvenez pas à joindre l'API YesCaptcha : Failed to establish a new connection, échec de résolution DNS, interférence d'un logiciel de proxy, erreurs SSL (Certificate has expired, SSLEOFError) et étapes de diagnostic.
Source: https://docs.yescaptcha.com/fr/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/
Les erreurs de connexion lors d’un appel à l’API (par exemple `Failed to establish a new connection`, `getaddrinfo failed`, timeouts ou erreurs SSL) proviennent généralement du réseau de votre machine, du DNS ou d’un logiciel de proxy. Suivez les étapes ci-dessous dans l’ordre.
## 1\. Essayer l’autre endpoint
YesCaptcha propose deux endpoints : `https://api.yescaptcha.com` (mondial) et `https://cn.yescaptcha.com` (Chine). Utilisez l’endpoint Chine sur les serveurs situés en Chine continentale, et l’endpoint mondial partout ailleurs. Si vous changez d’endpoint, interrogez aussi les résultats sur le même endpoint.
```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"}'
```
Si l’un des deux renvoie du JSON, votre réseau fonctionne et le problème vient de la route vers l’autre endpoint.
## 2\. Vérifier les logiciels de proxy
L’accès à YesCaptcha ne nécessite pas de proxy. Si un logiciel de proxy ou de VPN est actif sur votre machine :
- Désactivez-le et réessayez ;
- Si vous devez le garder actif, passez en mode basé sur des règles (mode PAC) plutôt qu’en mode global, ou ajoutez `api.yescaptcha.com` et `cn.yescaptcha.com` à la liste de connexion directe ;
- Si Python signale `SSLEOFError(8, 'EOF occurred in violation of protocol')` alors qu’un proxy est actif, le proxy en est le plus souvent la cause : désactivez-le ou faites en sorte que ces deux domaines se connectent directement.
## 3\. Vérifier le réseau et le DNS
```bash
ping api.yescaptcha.com
```
- Si l’hôte est introuvable : la résolution DNS a échoué. Videz le cache DNS (Windows : `ipconfig /flushdns` ; macOS : `sudo dscacheutil -flushcache; sudo killall -HUP mDNSResponder`), ou remplacez le DNS de votre machine par un DNS public (par exemple `223.5.5.5`, `119.29.29.29`, `8.8.8.8`) et réessayez.
- Si le ping échoue mais que l’adresse est résolue : le réseau bloque peut-être ICMP, ce qui ne signifie pas que l’API est inaccessible. Fiez-vous au résultat du curl de l’étape 1.
## 4\. Erreurs de certificat SSL
- En cas de `Certificate has expired` ou `certificate verify failed` : vérifiez d’abord que l’**heure système** de votre machine est correcte, puis mettez à jour le système d’exploitation, le paquet `certifi` de Python, Postman et les autres outils pour qu’ils disposent des certificats racine les plus récents.
- Utilisez toujours `https://`. Ne passez pas à `http://` et ne désactivez pas la vérification des certificats pour contourner l’erreur.
## 5\. Toujours bloqué ?
[Contactez le support](https://docs.yescaptcha.com/fr/help/contact.md) en joignant : le message d’erreur complet, l’endpoint que vous utilisez, la région de votre serveur et la sortie du curl de l’étape 1.
---
# Nous contacter
> Contactez le support YesCaptcha par WeChat, QQ, WhatsApp, LINE, Telegram @yescaptcha_official ou e-mail yescaptcha@gmail.com, de 9:00 à 21:00 UTC+8.
Source: https://docs.yescaptcha.com/fr/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/
Le support YesCaptcha est disponible de **9:00 à 21:00 UTC+8** (heure de Pékin). Si notre réponse tarde, laissez un message et nous le traiterons dès que possible.
- E-mail : [yescaptcha@gmail.com](mailto:yescaptcha@gmail.com)
- Telegram : [@yescaptcha\_official](https://t.me/yescaptcha_official)
Scannez le code pour nous ajouter :
**WeChat**Scannez avec WeChat pour nous ajouter ; nous pouvons vous inviter dans le groupe des utilisateurs
**QQ**Scannez avec QQ pour nous ajouter
**WhatsApp**Scannez avec l'appareil photo de WhatsApp
**LINE**Scannez depuis « Ajouter des amis » dans LINE
**[Telegram](https://t.me/yescaptcha_official)**@yescaptcha\_official
Lorsque vous nous contactez, indiquez :
- l’e-mail de votre compte ou votre ID utilisateur (**n’envoyez jamais** votre `clientKey`) ;
- le `taskId`, le code d’erreur et l’heure concernés ;
- le type de tâche et l’endpoint (`api.yescaptcha.com` ou `cn.yescaptcha.com`) que vous utilisez.
Beaucoup de questions trouvent une réponse dans la [FAQ](https://docs.yescaptcha.com/fr/help/faq.md), les [codes d’erreur](https://docs.yescaptcha.com/fr/api/errors.md) et la page [Problèmes de connexion et de réseau](https://docs.yescaptcha.com/fr/help/troubleshooting.md).
---
# Journal des modifications du service
> Les changements qui concernent les utilisateurs de YesCaptcha, par date : types de tâche ajoutés et retirés, règles de facturation et de remboursement, limite de tâches simultanées, migration de la documentation. Journal tenu à partir d'octobre 2026.
Source: https://docs.yescaptcha.com/fr/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/
Cette page recense par date les changements qui concernent les utilisateurs : types de tâche ajoutés ou retirés, règles de facturation, règles de limitation, etc. Les plus récents figurent en haut.
## 2026-10-19
- **La page de vérification Cloudflare n’est plus marquée « Non recommandé »** : le service derrière `CloudFlareTaskS2` et `CloudFlareTaskS3` a été reconstruit ; une tâche prend en général de 6 à 35 secondes. Les deux types ont les mêmes paramètres, les mêmes résultats et la même efficacité ; les prix ne changent pas (25 points et 20 points). Le proxy doit être en `http://` (identifiants facultatifs) ou en `socks5://` sans identifiants ; les proxys `https://` ainsi que les adresses locales et privées sont refusés à la création de la tâche (sans débit de points). `userAgent` n’est pris en compte que s’il s’agit de Chrome de bureau sous Linux ; pour les requêtes suivantes, utilisez le `user_agent` du résultat. Si vous renseignez `requiredCookies`, la tâche ne réussit que si tous les cookies sont obtenus. Voir [page de vérification Cloudflare](https://docs.yescaptcha.com/fr/tasks/cloudflare-challenge.md).
## 2026-10-16
- **Les types FunCaptcha qui renvoient un token ne sont pas recommandés pour le moment** : ils sont coûteux et n’ont pas de solution stable. `FunCaptchaTask` passe à 30 points par tâche (15 auparavant). `FunCaptchaTaskProxyless` n’aboutit toujours pas ; les tâches échouées sont remboursées automatiquement. Pour passer FunCaptcha, utilisez la [reconnaissance d’images FunCaptcha](https://docs.yescaptcha.com/fr/tasks/funcaptcha-classification.md) ou l’extension de navigateur.
## 2026-10-15
- **Migration de la documentation** : la documentation a quitté Confluence pour ce site (docs.yescaptcha.com), en chinois et en anglais, le chinois faisant foi. [llms.txt](https://docs.yescaptcha.com/llms.txt), [OpenAPI](https://docs.yescaptcha.com/openapi.json) et une version Markdown de chaque page sont disponibles pour les outils d’IA et les programmes.
- **Remboursement après signalement réglé après environ 24 heures** : lorsqu’une erreur de reconnaissance d’images est signalée, le remboursement n’est plus immédiat mais réglé après environ 24 heures ; si votre taux d’échec est nettement supérieur à celui des autres sur la même période, le remboursement se fait au taux d’échec de la période. Voir [Facturation et remboursement de points](https://docs.yescaptcha.com/fr/getting-started/billing.md).
- **Limite de tâches simultanées** : les tâches en cours de traitement sont désormais comptées par compte et par type de tâche ; au-delà de la limite, la requête renvoie `ERROR_THREADS_MAXIMUM`, sans débit de points ni prise en compte dans la suspension automatique. Les limites de chaque type seront publiées dans [Limite de tâches simultanées et suspension automatique](https://docs.yescaptcha.com/fr/api/rate-limits.md) une fois fixées.
- **Types de tâche rendus publics** : `HCaptchaTask`, `NoCaptchaTask`, `TurnstileTask` et `RecaptchaV2EnterpriseTask` (proxy fourni par vous), ainsi que `FunCaptchaTaskProxylessM1`, `FunCaptchaTask` et `HCaptchaTaskProxylessM1`, sont désormais documentés.
- **Types FunCaptcha qui renvoient un token** : `FunCaptchaTaskProxylessM1` et `FunCaptchaTask` sont disponibles. La ligne de `FunCaptchaTaskProxyless` n’aboutit plus depuis environ le 2026-09-10 ; les tâches échouées sont remboursées automatiquement.
- **Retraits** : la série reCAPTCHA K1 à empreinte personnalisée, `FunCaptchaTaskS1`, `CloudFlareTaskS1`, `TurnstileTaskS2`, `TurnstileTaskProxylessS2`, `bCaptcha2Classification` et `GeneralClassification` ne sont plus proposés.
## Avant le 2026-10-15
- Le service de location en libre-service de **serveurs dédiés** a été arrêté.