Como lidar com o reCAPTCHA v2 em fluxos de trabalho de coleta autorizada

Um reCAPTCHA v2 no meio da coleta de dados não trava seu script por falta de solução técnica — falta uma peça específica: o token que prova ao back-end do site que a verificação foi concluída.

A automação lê o googlekey e o pageurl da página, envia os dois para a CaptchaAI e recebe o token pronto para injetar de volta no campo g-recaptcha-response (ou acionar o callback do widget).

Este guia traz o fluxo completo, com código testado em Python (Selenium + requests) e Node.js (Puppeteer), além de uma alternativa somente HTTP para quando você não precisa abrir navegador nenhum.

Os dois parâmetros que sua automação precisa extrair

Todo widget reCAPTCHA v2 expõe dois valores que sua automação precisa capturar antes de chamar a API:

Envie os dois para a API da CaptchaAI, aguarde o token resolvido e injete-o no campo g-recaptcha-response (ou dispare o callback do widget). O back-end do site de destino valida o token junto ao Google e libera a requisição — a partir daí, sua automação segue normalmente.

Dois jeitos de rodar o mesmo fluxo

Os dois exemplos abaixo fazem exatamente a mesma coisa — abrem a página, extraem a sitekey, resolvem com a CaptchaAI e injetam o token de volta — um em Python com Selenium, outro em Node.js com Puppeteer. Escolha pelo stack que sua automação já usa.

Python: Selenium + CaptchaAI

Pronto para rodar no seu próprio ambiente de teste:

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

# Step 1: Open the page with Selenium
driver = webdriver.Chrome()
driver.get("https://example.com/protected-page")

# Step 2: Extract the sitekey
sitekey = driver.find_element(By.CSS_SELECTOR, ".g-recaptcha").get_attribute("data-sitekey")
page_url = driver.current_url

# Step 3: Submit to CaptchaAI
response = requests.get("https://ocr.captchaai.com/in.php", params={
    "key": "YOUR_API_KEY",
    "method": "userrecaptcha",
    "googlekey": sitekey,
    "pageurl": page_url,
    "json": 1
}).json()

task_id = response["request"]

# Step 4: Poll for result
token = None
for _ in range(40):
    time.sleep(5)
    result = requests.get("https://ocr.captchaai.com/res.php", params={
        "key": "YOUR_API_KEY",
        "action": "get",
        "id": task_id,
        "json": 1
    }).json()

    if result.get("status") == 1:
        token = result["request"]
        break
    if result.get("request") != "CAPCHA_NOT_READY":
        raise RuntimeError(f"Solve failed: {result['request']}")

# Step 5: Inject the token and submit
driver.execute_script(
    f'document.getElementById("g-recaptcha-response").innerHTML = "{token}";'
)

# Check for callback
callback = driver.execute_script(
    'var el = document.querySelector(".g-recaptcha"); '
    'return el ? el.getAttribute("data-callback") : null;'
)
if callback:
    driver.execute_script(f'{callback}("{token}");')
else:
    driver.find_element(By.CSS_SELECTOR, "form").submit()

# Step 6: Scrape the data
print(driver.page_source[:500])
driver.quit()

Node.js: Puppeteer + CaptchaAI

A mesma lógica, usando fetch nativo para falar com a API da CaptchaAI:

const puppeteer = require("puppeteer");

async function scrapeWithCaptcha(url) {
  const browser = await puppeteer.launch({ headless: "new" });
  const page = await browser.newPage();
  await page.goto(url, { waitUntil: "networkidle2" });

  // Extract sitekey
  const sitekey = await page.$eval(".g-recaptcha", (el) => el.dataset.sitekey);

  // Submit to CaptchaAI
  const submitRes = await fetch(
    `https://ocr.captchaai.com/in.php?${new URLSearchParams({
      key: "YOUR_API_KEY",
      method: "userrecaptcha",
      googlekey: sitekey,
      pageurl: url,
      json: 1,
    })}`
  );
  const { request: taskId } = await submitRes.json();

  // Poll for result
  let token;
  for (let i = 0; i < 40; i++) {
    await new Promise((r) => setTimeout(r, 5000));
    const res = await fetch(
      `https://ocr.captchaai.com/res.php?${new URLSearchParams({
        key: "YOUR_API_KEY",
        action: "get",
        id: taskId,
        json: 1,
      })}`
    );
    const data = await res.json();
    if (data.status === 1) {
      token = data.request;
      break;
    }
    if (data.request !== "CAPCHA_NOT_READY")
      throw new Error(`Solve failed: ${data.request}`);
  }

  // Inject token
  await page.evaluate((t) => {
    document.getElementById("g-recaptcha-response").innerHTML = t;
    const cb = document.querySelector(".g-recaptcha")?.dataset.callback;
    if (cb && window[cb]) window[cb](t);
  }, token);

  // Wait for navigation after form submit
  await page.waitForNavigation({ waitUntil: "networkidle2" });
  const content = await page.content();
  await browser.close();
  return content;
}

scrapeWithCaptcha("https://example.com/protected-page").then(console.log);

Navegador headless vs. navegador com interface

Alguns sites detectam navegadores headless e bloqueiam a requisição antes mesmo do reCAPTCHA aparecer. Se isso acontecer no seu ambiente de QA, ajuste a configuração do navegador antes de mexer na integração com a CaptchaAI:

Quando dá para pular o navegador: fluxo somente HTTP

Nem sempre você precisa abrir um navegador. Isso funciona quando:

• O site aceita o g-recaptcha-response dentro de um envio de formulário comum
• Você já tem as cookies de sessão necessárias para reproduzir o envio
• O site não decide o fluxo por um evento JavaScript disparado no clique do botão

Nesses casos, você pode ignorar o navegador inteiro e falar direto com os endpoints:

import requests
import time

session = requests.Session()
session.headers["User-Agent"] = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0"

# Load the page to get cookies
session.get("https://example.com/protected-page")

# Solve the CAPTCHA
sitekey = "6Le-wvkSAAAAAN..."  # extracted from page HTML
solve_resp = requests.get("https://ocr.captchaai.com/in.php", params={
    "key": "YOUR_API_KEY", "method": "userrecaptcha",
    "googlekey": sitekey, "pageurl": "https://example.com/protected-page",
    "json": 1
}).json()

task_id = solve_resp["request"]
time.sleep(15)

# Poll
for _ in range(30):
    result = requests.get("https://ocr.captchaai.com/res.php", params={
        "key": "YOUR_API_KEY", "action": "get", "id": task_id, "json": 1
    }).json()
    if result.get("status") == 1:
        token = result["request"]
        break
    time.sleep(5)

# Submit with token
resp = session.post("https://example.com/protected-page", data={
    "g-recaptcha-response": token,
    "other_field": "value"
})
print(resp.text[:500])

Escalando o volume sem estourar a latência

Em produção, o gargalo raramente é a resolução do CAPTCHA em si — é o round-trip até a API. Se seus workers rodam na região sa-east-1 da AWS (São Paulo), o tempo de rede até os endpoints da CaptchaAI já entra no seu orçamento de latência; meça antes de otimizar o resto do pipeline.

Cada plano CaptchaAI é cobrado por thread simultânea, não por resolução — resoluções ilimitadas por thread dentro do mês:

Se a coleta cresce, o upgrade de plano aumenta apenas o número de threads disponíveis, não a lógica de integração. E se ela envolve informações pessoais — nomes, e-mails, CPFs, dados de perfil —, trate as obrigações da LGPD desde o desenho do pipeline: defina finalidade, tempo de retenção e quem tem acesso aos dados coletados.

Perguntas frequentes

Estas são as dúvidas mais comuns de quem integra o reCAPTCHA v2 no scraping com a CaptchaAI:

Preciso de um navegador para lidar com o reCAPTCHA v2?

Nem sempre — depende de como o site aceita o token:

• Se o g-recaptcha-response for aceito como campo de um POST comum, a abordagem somente HTTP funciona.
• Se o token só for aceito via evento JavaScript disparado no navegador, você precisa de Selenium, Puppeteer ou equivalente.

E se o site usar reCAPTCHA v2 Enterprise?

Adicione enterprise=1 à sua requisição para a CaptchaAI. Consulte Como resolver reCAPTCHA v2 Enterprise usando API para o parâmetro completo.

Como extraio a sitekey sem abrir o DevTools toda vez?

Automatize a extração em vez de inspecionar manualmente a cada execução:

• Seletor CSS fixo, como .g-recaptcha
• Atributo data-sitekey do elemento — é exatamente o que os exemplos de Selenium e Puppeteer acima fazem

Quantas resoluções simultâneas cabem num plano BASIC?

Até 5 — o plano BASIC (US$ 15/mês) inclui 5 threads simultâneas, com resoluções ilimitadas por thread dentro do mês. Para volumes maiores, o STANDARD (US$ 30/mês, 15 threads) e os planos acima escalam a mesma integração sem mudar o código.

O reCAPTCHA v2 Invisible exige um fluxo diferente?

Não. O reCAPTCHA v2 Invisible usa a mesma googlekey, o mesmo pageurl e o mesmo campo g-recaptcha-response — a diferença é só visual, sem caixa de seleção na tela. O código dos exemplos acima funciona sem alteração.

Coloque em produção: primeiros passos

Guias relacionados

• Como resolver reCAPTCHA v2 usando API
• Como tratar CAPTCHA no Selenium com Python
• Como resolver CAPTCHA com Puppeteer em Node.js
• Erros comuns ao resolver reCAPTCHA v2