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

Resolva questões de tempo. Uma diferença de 10 segundos por solução resulta em horas de atraso em milhares de tarefas. Este guia fornece benchmarks reproduzíveis para cada tipo de CAPTCHACaptchaAIsuporta, além de scripts para executar suas próprias medições.

Tempos de resolução típicos

Esses benchmarks refletem os tempos médios de 100 soluções consecutivas por tipo, medidos desde o envio da API até a recuperação dos resultados:

Os tempos variam de acordo com a qualidade do proxy, carga do servidor e complexidade do CAPTCHA.

Fatores que afetam o tempo de resolução

Latência de rede

Sua distância dos endpoints da API do CaptchaAI adiciona tempo de ida e volta. Um RTT de 200 ms adiciona aproximadamente 1 segundo no total (envio + 3–4 enquetes × 200 ms).

Qualidade do proxy

Ao usar proxies, os proxies residenciais normalmente produzem soluções com menor latência do que os proxies de datacenter porque desencadeiam menos desafios secundários.

Complexidade CAPTCHA

Os desafios de imagem reCAPTCHA v2 variam em dificuldade. Um desafio de “selecionar semáforos” com imagens desbotadas leva mais tempo do que uma simples verificação de caixa de seleção.

Estratégia de votação

A pesquisa agressiva (a cada 2 segundos) detecta resultados com menor latênciamente, mas aumenta as chamadas de API. A pesquisa conservadora (a cada 10 segundos) reduz a carga, mas adiciona latência.

Script de referência Python

# 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 de referência JavaScript

// 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);
})();

Interpretando Resultados

Mediana vs P90

• Mediana — A experiência típica. Use isso para planejamento de capacidade.
• P90 — O "pior caso" para 9 entre 10 soluções. Use isto para configurações de tempo limite.
• P99 — O verdadeiro caso extremo. Defina seu tempo limite máximo superior a este.

Intervalos de pesquisa ideais

Com base nos benchmarks acima, configure a pesquisa por tipo de CAPTCHA:

Solução de problemas

Perguntas frequentes

Os tempos de resolução variam de acordo com a hora do dia?

Sim. Os horários de pico (horário comercial nos EUA) podem apresentar tempos de resolução um pouco mais longos devido à maior demanda. Execute benchmarks em momentos diferentes para obter uma imagem completa.

Devo usar esses dados para configurações de tempo limite de produção?

Utilize os valores P90 para timeouts padrão e P99 para timeouts máximos. Adicione um buffer de 20% para compensar a variabilidade da rede.

Como as configurações de proxy afetam os tempos de resolução?

Se você fornecer um proxy, CaptchaAI encaminhará a solução através dele. Proxies lentos ou distantes podem adicionar de 5 a 15 segundos ao tempo total de resolução. Para benchmarking, teste com e sem proxies separadamente.

Artigos relacionados

• Resolver fluxo de trabalho de vários tipos de Captcha
• Matriz de recursos de tipos de Captcha com suporte para Captchaai

Próximas etapas

Execute os scripts de benchmark em sua própria conta e alvos CAPTCHA —obtenha sua chave API CaptchaAI.

Guias relacionados:

• Otimizando Velocidade e Custo
• Otimização de latência CaptchaAI
• Resolução paralela de CAPTCHA