# Usar o token para concluir o reCAPTCHA

> O que fazer com o token do reCAPTCHA (gRecaptchaResponse) depois de obtê-lo: como funciona, envio direto por requisição (campo g-recaptcha-response) e preenchimento no navegador com chamada da função de callback, com exemplos completos em Python na página de demonstração do Google.

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

O `gRecaptchaResponse` retornado pelo YesCaptcha é o mesmo resultado que o Google entrega à página depois que alguém conclui o captcha. Depois de obtê-lo, você precisa **enviá-lo ao site de destino** (não ao Google nem ao YesCaptcha), como um navegador faria; o site o verifica com o Google e libera o acesso. Há duas formas: enviar a requisição diretamente ou preencher o token na página, em um navegador, e enviar o formulário.

## Como funciona

No acesso normal, o fluxo é:

1.  A página carrega o reCAPTCHA e o usuário conclui a verificação;
2.  O Google entrega um token à página, que o coloca no campo de texto `g-recaptcha-response` (ou o passa a uma função de callback);
3.  O usuário envia o formulário e o token segue com ele para o servidor do site;
4.  O servidor do site verifica o token com o Google e, se for válido, libera o acesso.

Com o YesCaptcha, os passos 1 e 2 são feitos por nós: você cria uma tarefa com `websiteURL` e `websiteKey`, obtém o token e continua a partir do passo 3.

> **Cuidado:** O token é de uso único e válido por cerca de 120 segundos; recomendamos enviá-lo em até 60 segundos após obtê-lo. Sites não aceitam tokens expirados.

## Método 1: enviar a requisição diretamente (recomendado)

1.  Faça o processo uma vez manualmente no navegador: abra o painel Network (F12), conclua o captcha, envie o formulário e localize a requisição que o submete.
2.  No Payload (ou Form Data) da requisição, encontre o campo que carrega o token, geralmente `g-recaptcha-response`, com valor começando por `03A`. Alguns sites o renomeiam, por exemplo `grecaptcharesponse` ou `captcha`.
3.  No seu programa, envie uma requisição idêntica, trocando o valor desse campo pelo token retornado pelo YesCaptcha. Os demais campos, cookies e cabeçalhos também devem ser iguais aos do navegador, pois os sites costumam verificá-los em conjunto.

Exemplo completo na página de demonstração do Google: primeiro obtém-se o token e depois ele é enviado de volta à página de demonstração no 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: preencher no navegador (Selenium etc.)

Ao controlar um navegador real com ferramentas como Selenium ou Playwright:

1.  Leia o `data-sitekey` da página e use-o para criar uma tarefa e obter o token.
2.  Escreva o token no campo de texto `g-recaptcha-response` da página.
3.  Se a página define uma função de callback (`data-callback="..."`), chame-a passando o token; em alguns sites o botão de envio só fica clicável depois que o callback é chamado.
4.  Envie o formulário.

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

Quando há vários reCAPTCHAs na página, o id do campo de texto pode ser algo como `g-recaptcha-response-1`. Se não encontrar o campo, conclua a verificação manualmente uma vez, procure por `03A` em Elements e veja onde o resultado foi colocado. Para saber como encontrar a função de callback, veja [Encontrar os parâmetros do reCAPTCHA](https://docs.yescaptcha.com/pt/guides/find-recaptcha-parameters.md).

Exemplo 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

O v3 não tem caixa de seleção. A página chama `grecaptcha.execute(chave do site, {action: '...'})` quando precisa de um token e o coloca em sua própria requisição (o nome do campo é definido pelo site; os mais comuns são `g-recaptcha-response`, `token` e `recaptchaToken`). O procedimento é o mesmo do Método 1: encontre no Network a requisição que carrega o token e reproduza-a; ao criar a tarefa, `pageAction` deve ser igual ao `action` da página.

## Enviei e ainda não passa

-   O token expirou: envie-o assim que obtê-lo, sem passar de 60 segundos.
-   O campo enviado não é o que o site verifica, ou faltam outros campos ou cookies: compare item por item com a requisição do navegador.
-   O site também verifica IP, User-Agent etc.: use um tipo com proxy próprio (como `NoCaptchaTask`) e envie pelo mesmo proxy.
-   Pontuação do v3 insuficiente: confirme o `pageAction` ou use um tipo de pontuação alta fixa; veja [reCAPTCHA v3](https://docs.yescaptcha.com/pt/tasks/recaptcha-v3.md).
-   O controle de risco do site também considera outros sinais de comportamento. Se a taxa de aprovação com token for baixa, use [reconhecimento de imagem](https://docs.yescaptcha.com/pt/tasks/recaptcha-classification.md) com cliques reais no navegador, ou a [extensão do navegador](https://docs.yescaptcha.com/pt/extension.md).