# 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).