Scripts de automação CAPTCHA com CaptchaAI

Pare de reescrever a mesma lógica de envio e consulta para cada CAPTCHA. Esta página reúne seis scripts prontos — reCAPTCHA v2, Turnstile, CAPTCHA de imagem, resolução em lote, um solucionador universal em Node.js e consulta de saldo — todos no mesmo padrão: enviar → consultar → usar o token.

Troque a chave de API e a URL do formulário, rode o script e você já tem um token válido para injetar no campo esperado pelo CAPTCHA. Nenhum deles depende de biblioteca própria da CaptchaAI: só requests em Python e axios em Node.js, então funcionam em qualquer ambiente que já tenha essas dependências instaladas.

Antes de começar

O que você precisa ter em mãos

• Uma chave de API da CaptchaAI (substitui YOUR_API_KEY em cada script).
• A sitekey do CAPTCHA que você quer resolver — normalmente no atributo data-sitekey do HTML da página ou visível na aba de rede do navegador.

Ambiente local

• Python 3.8+ com requests instalado (pip install requests), ou Node.js 18+ com axios (npm install axios).
• Um ambiente de staging ou teste. Nunca aponte esses scripts para produção sem autorização explícita do dono do site.

Script 1: resolver reCAPTCHA v2 em Python

Envia a sitekey e a URL da página ao in.php, consulta res.php a cada 5 s e devolve o token para o campo g-recaptcha-response. Rode como script standalone pela linha de comando, passando a sitekey e a URL da página como argumentos — útil para testar rapidamente antes de integrar ao seu pipeline de automação.

#!/usr/bin/env python3
"""Solve reCAPTCHA v2 and print the token."""
import requests
import time
import sys

API_KEY = "YOUR_API_KEY"

def solve_recaptcha_v2(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
    })
    if not resp.text.startswith("OK|"):
        print(f"Error: {resp.text}", file=sys.stderr)
        sys.exit(1)

    task_id = resp.text.split("|")[1]
    print(f"Task ID: {task_id}")

    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":
            print(".", end="", flush=True)
            continue
        if result.text.startswith("OK|"):
            print()
            return result.text.split("|")[1]
        print(f"\nError: {result.text}", file=sys.stderr)
        sys.exit(1)

    print("\nTimeout", file=sys.stderr)
    sys.exit(1)

if __name__ == "__main__":
    if len(sys.argv) != 3:
        print(f"Usage: {sys.argv[0]} <site_key> <page_url>")
        sys.exit(1)
    token = solve_recaptcha_v2(sys.argv[1], sys.argv[2])
    print(token)

Como executar:

python solve_recaptcha.py "6Le-wvkS..." "https://example.com/form"

Script 2: resolver Cloudflare Turnstile

Mesma estrutura do anterior, só muda o método e o sitekey. O token vai no campo cf-turnstile-response. Como o Turnstile costuma responder mais rápido que o reCAPTCHA, a maioria das consultas retorna na primeira ou segunda tentativa do polling.

#!/usr/bin/env python3
"""Solve Cloudflare Turnstile and print the token."""
import requests
import time

API_KEY = "YOUR_API_KEY"

def solve_turnstile(site_key, page_url):
    resp = requests.get("https://ocr.captchaai.com/in.php", params={
        "key": API_KEY,
        "method": "turnstile",
        "sitekey": 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()

token = solve_turnstile("0x4AAAAA...", "https://example.com")
print(token)

Script 3: resolver CAPTCHA de imagem

Para texto distorcido sem desafio interativo: aceita arquivo local ou URL, converte para base64 e envia pelo método base64. Funciona bem para formulários legados que ainda usam CAPTCHA de texto puro, sem componente JavaScript — cadastro simples, downloads protegidos, painéis administrativos antigos.

#!/usr/bin/env python3
"""Solve an image CAPTCHA from a file or URL."""
import requests
import base64
import time
import sys

API_KEY = "YOUR_API_KEY"

def solve_image(image_source):
    # Load image
    if image_source.startswith("http"):
        img_data = requests.get(image_source).content
    else:
        with open(image_source, "rb") as f:
            img_data = f.read()

    img_b64 = base64.b64encode(img_data).decode()

    resp = requests.get("https://ocr.captchaai.com/in.php", params={
        "key": API_KEY,
        "method": "base64",
        "body": img_b64
    })
    task_id = resp.text.split("|")[1]

    for _ in range(30):
        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()

if __name__ == "__main__":
    text = solve_image(sys.argv[1])
    print(text)

Como executar:

python solve_image.py captcha.png
python solve_image.py "https://example.com/captcha.jpg"

Script 4: resolver vários CAPTCHAs em paralelo

Para vários formulários de staging em paralelo: dispara as tarefas com ThreadPoolExecutor e devolve o status de cada uma, sem que uma falha derrube as demais. Ajuste max_workers conforme o limite de threads do seu plano CaptchaAI — rodar mais workers do que threads contratadas não acelera a resolução, só enfileira as tarefas extras.

#!/usr/bin/env python3
"""Solve multiple CAPTCHAs concurrently."""
import requests
import time
from concurrent.futures import ThreadPoolExecutor, as_completed

API_KEY = "YOUR_API_KEY"

def solve_one(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()

def solve_batch(tasks, max_workers=5):
    """
    tasks: list of (site_key, page_url) tuples
    Returns: list of tokens
    """
    results = []
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        futures = {
            executor.submit(solve_one, sk, url): (sk, url)
            for sk, url in tasks
        }
        for future in as_completed(futures):
            sk, url = futures[future]
            try:
                token = future.result()
                results.append({"url": url, "token": token, "status": "ok"})
            except Exception as e:
                results.append({"url": url, "error": str(e), "status": "failed"})
    return results

# Example
tasks = [
    ("6Le-wvkS...", "https://example.com/page1"),
    ("6Le-wvkS...", "https://example.com/page2"),
    ("6Le-wvkS...", "https://example.com/page3"),
]
results = solve_batch(tasks)
for r in results:
    print(f"{r['url']}: {r['status']}")

Script 5: solucionador universal em Node.js

Para times Node.js: a mesma função solve() aceita qualquer combinação de parâmetros — reCAPTCHA, Turnstile ou imagem — sem duplicar a lógica de polling em cada projeto. Importe o módulo como está — const { solve } = require("./universal-solver") — e mantenha os parâmetros específicos de cada tipo de CAPTCHA no arquivo que faz a chamada, não dentro da função genérica.

#!/usr/bin/env node
// Solve any CAPTCHA type from the command line
const axios = require("axios");

const API_KEY = "YOUR_API_KEY";

async function solve(params) {
  params.key = API_KEY;
  const submit = await axios.get("https://ocr.captchaai.com/in.php", {
    params,
  });
  if (!submit.data.startsWith("OK|")) throw new Error(submit.data);
  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);
  }
}

// Usage examples:
// Solve reCAPTCHA v2
// solve({ method: "userrecaptcha", googlekey: "SITE_KEY", pageurl: "URL" })

// Solve Turnstile
// solve({ method: "turnstile", sitekey: "SITE_KEY", pageurl: "URL" })

module.exports = { solve };

Script bônus: consultar o saldo da conta

Automatize a checagem de saldo antes de escalar — assim você evita ficar sem crédito no meio de um lote grande. Rode em cron a cada poucas horas e dispare um alerta quando o saldo cair abaixo de um limite: sai muito mais barato do que descobrir o problema com um lote de produção parado.

#!/usr/bin/env python3
"""Check CaptchaAI account balance."""
import requests

API_KEY = "YOUR_API_KEY"

resp = requests.get("https://ocr.captchaai.com/res.php", params={
    "key": API_KEY,
    "action": "getbalance"
})
print(f"Balance: ${resp.text}")

Qual script usar em cada situação

Boas práticas para produção

• Troque o intervalo fixo de 5 s por backoff exponencial nas consultas a res.php, principalmente sob rate limit.
• Registre o task_id e o tempo de resolução de cada chamada — ajuda a identificar CAPTCHAs lentos ou que expiram antes de você consultar o resultado.
• Separe a chave de API por ambiente (staging vs. produção) para não misturar saldo e métricas dos dois.
• Monitore o saldo com o script bônus e configure um alerta antes que ele chegue a zero.
• Se os workers rodam em contêineres na região sa-east-1 (São Paulo) da AWS, meça o RTT até ocr.captchaai.com antes de fixar o timeout do polling — a latência de rede varia conforme a região de origem.

Perguntas frequentes

Esses scripts funcionam com Selenium, Playwright ou Puppeteer?

Sim. São funções independentes de framework — chame solve_recaptcha_v2() ou solve_turnstile() antes de submeter o formulário e injete o token.

Qual script eu uso se o site tem Turnstile em vez de reCAPTCHA?

O Script 2. Muda só o parâmetro method e o sitekey; a consulta e o tratamento de erro são idênticos.

Os scripts tratam timeout e erro de conexão automaticamente?

Parcialmente. Cada um já limita as tentativas e levanta exceção em falha; para produção, adicione backoff e log — o lote já isola erros por tarefa.

Dá para rodar esses scripts em um cron job, ou só via linha de comando?

Dos dois jeitos. Chame o script por subprocess ou importe a função diretamente no seu código; o script de saldo, por exemplo, é comum rodar em cron a cada poucas horas para monitorar o consumo.

Quanto custa rodar esses scripts em produção?

A CaptchaAI cobra por thread simultânea, com resoluções ilimitadas por thread: de BASIC (US$ 15/mês, 5 threads) até ENTERPRISE (US$ 300/mês, 200 threads).

Guias relacionados

• Tratamento automatizado de CAPTCHA no login
• CAPTCHA em bots de automação
• Como resolver vários CAPTCHAs em paralelo