Comparando tempos de resolução de CAPTCHA entre tipos com CaptchaAI

Quanto tempo leva para resolver um CAPTCHA pela API da CaptchaAI? Depende do tipo: um Cloudflare Turnstile fecha em menos de 10 segundos, enquanto um reCAPTCHA v2 completo pode chegar ao teto de SLA de 60 segundos. Multiplique essa diferença por milhares de tarefas e ela decide se o seu pipeline fica dentro do orçamento de tempo. Este guia reúne benchmarks reproduzíveis para cada tipo que a CaptchaAI suporta, com mediana, P90, P99 e os scripts para medir no seu próprio ambiente.

Quanto tempo cada tipo de CAPTCHA leva para resolver

Os números vêm de uma amostra interna de 100 soluções consecutivas por tipo, do envio à API até a recuperação do resultado. Teto do SLA é o limite contratual; Mediana, P90 e P99 refletem o comportamento em produção. Os resultados variam conforme ambiente, volume e horário — use como ponto de partida.

Os tempos variam de acordo com a qualidade do proxy, a carga do servidor e a complexidade do desafio. O teto do SLA é o limite contratual — se você observar tempos consistentemente acima dele, abra um chamado de suporte.

Como interpretar mediana, P90 e P99

• Mediana — a experiência típica; use para planejamento de capacidade.
• P90 — o "pior caso" em 9 de cada 10 soluções; use como timeout padrão.
• P99 — o caso extremo; defina o timeout máximo acima desse valor, com um buffer de 20% para variação de rede.

Intervalos de polling recomendados por tipo

Com base nos benchmarks acima, ajuste o polling por tipo de CAPTCHA:

O que influencia o tempo de resolução

• Latência de rede até a API — um RTT de 200 ms adiciona cerca de 1 s ao total (envio + 3–4 consultas de polling × 200 ms). Se sua operação está no Brasil, rodar os workers perto do destino — por exemplo em AWS sa-east-1 (São Paulo) — reduz esse custo fixo.
• Qualidade do proxy — proxies residenciais costumam produzir soluções com menor latência do que proxies de datacenter, porque disparam menos desafios secundários.
• Complexidade do desafio — desafios de imagem do reCAPTCHA v2 variam em dificuldade: "selecione os semáforos" com imagens desbotadas leva mais tempo do que uma simples verificação de caixa.
• Estratégia de polling — polling agressivo (a cada 2 s) detecta o resultado mais rápido, mas aumenta as chamadas à API; polling conservador (a cada 10 s) reduz a carga, mas adiciona latência percebida.

Script Python para medir o tempo de resolução

# benchmark_captchaai.py
import os
import time
import statistics
import requests

API_KEY = os.environ.get("CAPTCHAAI_KEY", "YOUR_API_KEY")

def benchmark_solve(method, params, runs=10):
    """Benchmark a CAPTCHA type over multiple runs."""
    times = []
    successes = 0

    for i in range(runs):
        start = time.time()

        # Submit
        submit_params = {"key": API_KEY, "json": "1", **params}
        resp = requests.get("https://ocr.captchaai.com/in.php",
                            params=submit_params)
        result = resp.json()

        if result.get("status") != 1:
            print(f"  Run {i+1}: Submit failed - {result.get('request')}")
            continue

        task_id = result["request"]

        # Poll
        time.sleep(10)
        solved = False
        for _ in range(30):
            poll = requests.get("https://ocr.captchaai.com/res.php", params={
                "key": API_KEY, "action": "get",
                "id": task_id, "json": "1",
            })
            poll_result = poll.json()

            if poll_result.get("status") == 1:
                elapsed = time.time() - start
                times.append(elapsed)
                successes += 1
                solved = True
                print(f"  Run {i+1}: {elapsed:.1f}s")
                break
            if poll_result.get("request") != "CAPCHA_NOT_READY":
                print(f"  Run {i+1}: Error - {poll_result.get('request')}")
                break

            time.sleep(5)

        if not solved and poll_result.get("request") == "CAPCHA_NOT_READY":
            print(f"  Run {i+1}: Timeout")

    if times:
        return {
            "runs": runs,
            "successes": successes,
            "success_rate": f"{successes/runs*100:.0f}%",
            "median": f"{statistics.median(times):.1f}s",
            "p90": f"{sorted(times)[int(len(times)*0.9)]:.1f}s" if len(times) >= 10 else "N/A",
            "min": f"{min(times):.1f}s",
            "max": f"{max(times):.1f}s",
        }
    return {"error": "No successful solves"}

# Benchmark reCAPTCHA v2
print("=== reCAPTCHA v2 ===")
recaptcha_v2 = benchmark_solve("userrecaptcha", {
    "method": "userrecaptcha",
    "googlekey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
    "pageurl": "https://www.google.com/recaptcha/api2/demo",
})
print(recaptcha_v2)

# Benchmark Image/OCR
print("\n=== Image CAPTCHA ===")
# Submit a base64-encoded test image
import base64
# Use a test image for benchmarking
image_result = benchmark_solve("post", {
    "method": "base64",
    "body": "BASE64_ENCODED_CAPTCHA_IMAGE",
})
print(image_result)

Script Node.js para medir o tempo de resolução

// benchmark_captchaai.js
const axios = require('axios');

const API_KEY = process.env.CAPTCHAAI_KEY || 'YOUR_API_KEY';

async function benchmarkSolve(params, runs = 10) {
  const times = [];
  let successes = 0;

  for (let i = 0; i < runs; i++) {
    const start = Date.now();

    // Submit
    const submit = await axios.get('https://ocr.captchaai.com/in.php', {
      params: { key: API_KEY, json: '1', ...params },
    });

    if (submit.data.status !== 1) {
      console.log(`  Run ${i + 1}: Submit failed - ${submit.data.request}`);
      continue;
    }

    // Poll
    await new Promise(r => setTimeout(r, 10000));
    let solved = false;

    for (let j = 0; j < 30; j++) {
      const poll = await axios.get('https://ocr.captchaai.com/res.php', {
        params: { key: API_KEY, action: 'get', id: submit.data.request, json: '1' },
      });

      if (poll.data.status === 1) {
        const elapsed = (Date.now() - start) / 1000;
        times.push(elapsed);
        successes++;
        solved = true;
        console.log(`  Run ${i + 1}: ${elapsed.toFixed(1)}s`);
        break;
      }
      if (poll.data.request !== 'CAPCHA_NOT_READY') {
        console.log(`  Run ${i + 1}: Error - ${poll.data.request}`);
        break;
      }
      await new Promise(r => setTimeout(r, 5000));
    }

    if (!solved) console.log(`  Run ${i + 1}: Timeout`);
  }

  if (times.length === 0) return { error: 'No successful solves' };

  times.sort((a, b) => a - b);
  return {
    runs, successes,
    successRate: `${((successes / runs) * 100).toFixed(0)}%`,
    median: `${times[Math.floor(times.length / 2)].toFixed(1)}s`,
    min: `${times[0].toFixed(1)}s`,
    max: `${times[times.length - 1].toFixed(1)}s`,
  };
}

(async () => {
  console.log('=== reCAPTCHA v2 ===');
  const v2 = await benchmarkSolve({
    method: 'userrecaptcha',
    googlekey: '6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-',
    pageurl: 'https://www.google.com/recaptcha/api2/demo',
  });
  console.log(v2);

  console.log('\n=== Cloudflare Turnstile ===');
  const turnstile = await benchmarkSolve({
    method: 'turnstile',
    sitekey: 'YOUR_TURNSTILE_SITEKEY',
    pageurl: 'https://example.com',
  });
  console.log(turnstile);
})();

Problemas comuns no benchmark

Perguntas frequentes

O reCAPTCHA v3 é sempre mais rápido que o v2?

Sim, por design: roda em segundo plano sem desafio visual, com teto de SLA de 4 s contra 60 s do v2 completo.

Os tempos de resolução variam conforme o horário do dia?

Sim, um pouco, nos horários de pico (horário comercial nos EUA). Rode o benchmark em horários diferentes antes de fixar timeouts definitivos.

Que intervalo de polling evita estourar o rate limit da API?

Espera inicial de 5–15 s com consultas a cada 3–5 s (tabela acima) equilibra latência e volume de chamadas. Abaixo de 2 s por task, o ganho de latência raramente compensa o excesso de requisições.

Rodar os workers em sa-east-1 (São Paulo) reduz a latência?

Sim, se sua base está no Brasil. Aproximar os workers do endpoint corta o RTT somado a cada polling — o ganho é mais visível em tipos rápidos, como Turnstile, do que no reCAPTCHA v2, cuja mediana já é dominada pelo próprio desafio.

Artigos relacionados

• Como resolver múltiplos tipos de CAPTCHA no mesmo fluxo
• Matriz de tipos suportados pela CaptchaAI

Como começar

Rode os scripts contra seus próprios alvos — obtenha sua chave de API da CaptchaAI.

Guias relacionados:

• Otimizando velocidade e custo
• Otimização de latência na API da CaptchaAI
• Resolução paralela de CAPTCHA