# Usar el token para completar reCAPTCHA

> Qué hacer con el token de reCAPTCHA (gRecaptchaResponse): cómo funciona, enviarlo con una solicitud directa (campo g-recaptcha-response) o rellenarlo en el navegador y llamar al callback, con ejemplos completos en Python sobre la página de demostración de Google.

Source: https://docs.yescaptcha.com/es/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/

El `gRecaptchaResponse` que devuelve YesCaptcha es el mismo resultado que Google entrega a la página cuando alguien completa el captcha. Una vez que lo tienes, debes **enviarlo al sitio de destino** (no a Google ni a YesCaptcha) igual que lo haría un navegador; el sitio lo verifica con Google y te deja pasar. Hay dos formas: enviar la solicitud directamente, o rellenarlo en la página dentro de un navegador real y enviar el formulario.

## Cómo funciona

El flujo normal es este:

1.  La página carga reCAPTCHA y el usuario completa la verificación;
2.  Google entrega a la página un token, que la página coloca en el cuadro de texto `g-recaptcha-response` (o pasa a un callback);
3.  El usuario envía el formulario y el token viaja con él al servidor del sitio;
4.  El servidor del sitio verifica el token con Google y, si es válido, deja pasar.

Con YesCaptcha, nosotros hacemos los pasos 1 y 2: creas una tarea con `websiteURL` y `websiteKey`, obtienes el token y continúas desde el paso 3.

> **Precaución:** El token es de un solo uso y es válido unos 120 segundos; te recomendamos enviarlo en los 60 segundos siguientes a recibirlo. El sitio rechaza los tokens caducados.

## Método 1: enviar la solicitud directamente (recomendado)

1.  Haz el proceso una vez a mano en el navegador: abre el panel Network con F12, completa el captcha, envía el formulario y localiza la solicitud que lo envía.
2.  En el Payload (o Form Data) de la solicitud, busca el campo que lleva el token, normalmente `g-recaptcha-response`, con un valor que empieza por `03A`. Algunos sitios lo renombran, por ejemplo `grecaptcharesponse` o `captcha`.
3.  Envía desde tu programa una solicitud idéntica, cambiando el valor de ese campo por el token que devolvió YesCaptcha. Los demás campos, las cookies y los encabezados también deben coincidir con los del navegador, porque los sitios suelen comprobarlos a la vez.

Ejemplo completo con la página de demostración de Google: primero se resuelve el captcha y luego se envía el token a la página de demostración en el campo `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étodo 2: rellenarlo en el navegador (Selenium y similares)

Si controlas un navegador real con herramientas como Selenium o Playwright:

1.  Lee `data-sitekey` de la página y úsalo para crear una tarea y obtener un token.
2.  Escribe el token en el cuadro de texto `g-recaptcha-response` de la página.
3.  Si la página define un callback (`data-callback="..."`), llámalo pasándole el token; en algunos sitios el botón de envío solo se habilita después de llamar al callback.
4.  Envía el formulario.

```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');
```

Cuando la página tiene varios reCAPTCHA, el id del cuadro de texto puede ser algo como `g-recaptcha-response-1`. Si no encuentras el cuadro de texto, completa el captcha una vez a mano, busca `03A` en Elements y comprueba dónde se guarda el resultado. Para saber cómo encontrar el callback, consulta [Buscar los parámetros de reCAPTCHA](https://docs.yescaptcha.com/es/guides/find-recaptcha-parameters.md).

Ejemplo completo (Selenium 4):

recaptcha_selenium.py

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

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

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

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

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

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

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

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

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

## reCAPTCHA v3

v3 no tiene casilla de verificación. La página llama a `grecaptcha.execute(clave del sitio, {action: '...'})` cuando necesita un token y lo incluye en su propia solicitud (el nombre del campo lo decide el sitio; los más comunes son `g-recaptcha-response`, `token` y `recaptchaToken`). Se procede igual que en el Método 1: localiza en Network la solicitud que lleva el token y reprodúcela. Al crear la tarea, `pageAction` debe coincidir con el `action` de la página.

## Lo envié y sigue sin pasar

-   El token caducó: envíalo lo antes posible, sin pasar de 60 segundos.
-   Enviaste un campo distinto del que comprueba el sitio, o faltan otros campos o cookies: compáralo con la solicitud del navegador campo por campo.
-   El sitio también comprueba la IP, el User-Agent, etc.: usa un tipo con proxy propio (como `NoCaptchaTask`) y envía por el mismo proxy.
-   Puntuación de v3 insuficiente: confirma `pageAction`, o usa un tipo de puntuación alta fija; consulta [reCAPTCHA v3](https://docs.yescaptcha.com/es/tasks/recaptcha-v3.md).
-   El control de riesgos del sitio también mira otras señales de comportamiento. Si la tasa de éxito con tokens es baja, usa [reconocimiento de imágenes](https://docs.yescaptcha.com/es/tasks/recaptcha-classification.md) y haz clic en un navegador real, o usa la [extensión del navegador](https://docs.yescaptcha.com/es/extension.md).