Tratamento automatizado de login CAPTCHA com CaptchaAI

A resposta curta: resolva o CAPTCHA pela API antes de enviar o formulário de login — não durante o envio. É nesse ponto que a maioria das automações de login trava, seja reCAPTCHA v2, v3, Cloudflare Turnstile ou um CAPTCHA de imagem logo antes do botão "Entrar". Este guia mostra três abordagens — requisições HTTP puras, Selenium e Puppeteer — com código pronto para cada uma, além do que fazer quando o login também exige autenticação multifator.

Tipos de CAPTCHA que aparecem em telas de login

Antes de escolher a abordagem de automação, vale identificar qual CAPTCHA está na tela — o parâmetro enviado ao endpoint muda conforme o tipo:

Nas quatro linhas acima, o que muda entre um tipo e outro é só o parâmetro method enviado a in.php — o restante do fluxo (enviar, aguardar e receber o token) é idêntico.

Método 1: requisições HTTP diretas (sem navegador)

Se o formulário de login aceita um POST HTTP padrão — sem exigir JavaScript renderizado no lado do cliente — dá para pular o navegador inteiro. Envie o site_key e a page_url para in.php, faça a consulta em res.php até obter o token e envie o formulário em uma única requisição:

import requests
import time

API_KEY = "YOUR_API_KEY"

def solve_recaptcha(site_key, page_url):
    resp = requests.get("https://ocr.captchaai.com/in.php", params={
        "key": API_KEY, "method": "userrecaptcha",
        "googlekey": site_key, "pageurl": page_url
    })
    task_id = resp.text.split("|")[1]
    for _ in range(60):
        time.sleep(5)
        result = requests.get("https://ocr.captchaai.com/res.php", params={
            "key": API_KEY, "action": "get", "id": task_id
        })
        if result.text == "CAPCHA_NOT_READY": continue
        if result.text.startswith("OK|"): return result.text.split("|")[1]
        raise Exception(result.text)
    raise TimeoutError()

# Login flow
session = requests.Session()
login_url = "https://staging.example.com/qa-login"

# Load login page to get cookies and site key
page = session.get(login_url)
# Extract site_key from the page HTML...
site_key = "6Le-wvkS..."

# Solve CAPTCHA
token = solve_recaptcha(site_key, login_url)

# Submit login form
resp = session.post(login_url, data={
    "username": "user@example.com",
    "password": "your_password",
    "g-recaptcha-response": token
})

if resp.url != login_url:
    print("Login successful!")
    # session now has auth cookies for subsequent requests

Essa é a abordagem mais rápida e mais econômica em threads: sem overhead de navegador, o gargalo passa a ser só o tempo de resolução do CAPTCHA. Um time de QA rodando testes de login em staging a partir de workers em sa-east-1 (São Paulo) costuma fechar o fluxo completo — resolver e enviar — em poucos segundos, o que importa quando a suíte de regressão roda a cada deploy.

Método 2: Selenium (Python)

Quando o login depende de JavaScript — o token precisa ser injetado no DOM antes do envio, ou a página só revela a sitekey depois de renderizar — o Selenium entra no lugar das requisições diretas:

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import requests
import time

API_KEY = "YOUR_API_KEY"

options = webdriver.ChromeOptions()
options.add_argument("--disable-blink-features=AutomationControlled")
driver = webdriver.Chrome(options=options)

# Navigate to login page
driver.get("https://staging.example.com/qa-login")
wait = WebDriverWait(driver, 10)

# Fill in credentials
username_field = wait.until(EC.presence_of_element_located((By.NAME, "username")))
username_field.send_keys("user@example.com")
driver.find_element(By.NAME, "password").send_keys("your_password")

# Extract site key and solve
recaptcha = driver.find_element(By.CLASS_NAME, "g-recaptcha")
site_key = recaptcha.get_attribute("data-sitekey")

token = solve_recaptcha(site_key, driver.current_url)

# Inject token
driver.execute_script(
    f"document.getElementById('g-recaptcha-response').innerHTML = '{token}';"
)

# Submit
driver.find_element(By.CSS_SELECTOR, 'button[type="submit"]').click()
wait.until(EC.url_changes(driver.current_url))
print(f"Logged in! Now at: {driver.current_url}")

O padrão é sempre o mesmo: localizar o elemento do CAPTCHA, ler a sitekey, resolver via API e injetar o token antes de enviar. A diferença para o Método 1 é o custo — um navegador real (ou headless) consome mais CPU e memória por sessão, então reserve essa rota para quando o formulário realmente exigir JavaScript no cliente.

Método 3: Puppeteer (Node.js)

Para stacks em Node.js, o Puppeteer resolve o mesmo problema com uma API assíncrona baseada em async/await:

const puppeteer = require("puppeteer");
const axios = require("axios");

const API_KEY = "YOUR_API_KEY";

async function solveRecaptcha(siteKey, pageUrl) {
  const submit = await axios.get("https://ocr.captchaai.com/in.php", {
    params: {
      key: API_KEY,
      method: "userrecaptcha",
      googlekey: siteKey,
      pageurl: pageUrl,
    },
  });
  const taskId = submit.data.split("|")[1];

  while (true) {
    await new Promise((r) => setTimeout(r, 5000));
    const result = await axios.get("https://ocr.captchaai.com/res.php", {
      params: { key: API_KEY, action: "get", id: taskId },
    });
    if (result.data === "CAPCHA_NOT_READY") continue;
    if (result.data.startsWith("OK|")) return result.data.split("|")[1];
    throw new Error(result.data);
  }
}

(async () => {
  const browser = await puppeteer.launch({ headless: "new" });
  const page = await browser.newPage();
  await page.goto("https://staging.example.com/qa-login");

  // Fill credentials
  await page.type("#username", "user@example.com");
  await page.type("#password", "your_password");

  // Get site key and solve
  const siteKey = await page.$eval(".g-recaptcha", (el) =>
    el.getAttribute("data-sitekey")
  );
  const token = await solveRecaptcha(siteKey, page.url());

  // Inject and submit
  await page.evaluate(
    (t) => (document.getElementById("g-recaptcha-response").innerHTML = t),
    token
  );
  await page.click('button[type="submit"]');
  await page.waitForNavigation();

  console.log("Logged in:", page.url());
  await browser.close();
})();

A lógica é idêntica à do Selenium — obter a sitekey, chamar a API, injetar o token — só muda a sintaxe. Times que já mantêm testes ponta a ponta em Node.js preferem manter tudo na mesma linguagem em vez de introduzir Python só para o CAPTCHA.

Login com autenticação multifator (MFA)

Alguns fluxos de login pedem um segundo fator depois de validar usuário, senha e CAPTCHA. Nesse caso, trate o CAPTCHA e o MFA como duas etapas sequenciais, nunca simultâneas:

# Step 1: Solve CAPTCHA and submit login
token = solve_recaptcha(site_key, login_url)
resp = session.post(login_url, data={
    "username": "user@example.com",
    "password": "your_password",
    "g-recaptcha-response": token
})

# Step 2: Handle MFA page (if redirected)
if "verify" in resp.url or "mfa" in resp.url:
    # Your MFA code logic here
    mfa_code = get_mfa_code()
    resp = session.post(resp.url, data={"code": mfa_code})

# Step 3: Verify logged in
assert "dashboard" in resp.url

Repare que o CAPTCHA é resolvido uma única vez, antes do primeiro POST — a página de MFA que aparece depois normalmente não traz um novo desafio, só o campo do código de verificação.

Cenário: automação de login em QA autorizado

Um caso comum em times brasileiros: automatizar o login em staging para testes de regressão, com dados fictícios — nunca contas de produção de terceiros. Vale mapear a LGPD: se os dados de teste puderem ser tratados como dados pessoais, documente a base legal do teste e evite gravar CPF, e-mail ou senha em texto puro nos logs de CI. Do lado da CaptchaAI, o BASIC (US$ 15/mês, 5 threads) cobre a maioria das suítes que rodam logins em série; suítes maiores migram para o STANDARD (US$ 30/mês, 15 threads) sem reestruturar o pipeline.

Erros comuns e como corrigir

Os problemas mais frequentes não estão na resolução do CAPTCHA em si — estão no que acontece logo depois:

Na prática, a maior parte desses erros não vem da resolução do CAPTCHA — vem do restante do fluxo (cookies, CSRF, tempo entre resolver e enviar), que exige o mesmo cuidado.

Perguntas frequentes

Preciso de navegador para resolver o CAPTCHA no login?

Nem sempre. Se o formulário aceita POST HTTP padrão, o Método 1 resolve sem abrir navegador nenhum — é mais rápido e mais leve em recursos. Um navegador (Selenium ou Puppeteer) só entra em cena quando o login depende de JavaScript renderizado no cliente ou quando a sitekey só aparece depois da página carregar.

Posso automatizar login em qualquer site com a CaptchaAI?

A CaptchaAI resolve o componente CAPTCHA; o resto do fluxo — preencher campos, gerenciar cookies, enviar o formulário — é responsabilidade da sua automação. A legalidade depende da sua autorização para acessar a conta ou o sistema: use sempre credenciais próprias ou ambientes de staging autorizados.

Quantas threads da CaptchaAI preciso para autenticar vários logins de teste em paralelo?

Depende de quantos logins rodam ao mesmo tempo, não do total por dia — cada thread resolve um CAPTCHA por vez e fica livre assim que termina. O BASIC (US$ 15/mês, 5 threads) atende a maioria das suítes de QA; com dezenas de logins simultâneos, migre para o STANDARD (US$ 30/mês, 15 threads) ou o ADVANCE (US$ 90/mês, 50 threads).

Por que o reCAPTCHA v3 ainda bloqueia mesmo com um token válido?

O reCAPTCHA v3 não tem tela de desafio — ele retorna uma pontuação, e o site decide o limite mínimo para aceitar o login. Um token válido ainda pode ser rejeitado se a pontuação ficar abaixo desse limite; confira se o parâmetro de ação enviado bate com o esperado pelo formulário.

Preciso me preocupar com a LGPD ao automatizar login de teste?

Sim, sempre que os dados de teste puderem ser tratados como dados pessoais — mesmo em ambiente de staging. Use credenciais fictícias, evite gravar senhas ou tokens de sessão em texto puro nos logs de CI, e documente a base legal do teste se a suíte tocar qualquer dado parecido com um cadastro real.

Guias relacionados

• Como tratar CAPTCHA no Selenium com Python
• Como resolver CAPTCHA com Puppeteer em Node.js
• Tratamento de CAPTCHA no Playwright