Otimização de latência da API CaptchaAI: soluções com menor latência

Uma solução CAPTCHA tem quatro componentes de latência: envio de solicitação, espera na fila, execução do solucionador e recuperação de pesquisa. Você não pode controlar o tempo de execução do solucionador, mas pode otimizar todo o resto.

Latência de linha de base por tipo de CAPTCHA

A coluna "mais adequado alcançável" reflete o que você obtém após aplicar as otimizações abaixo.

1. Otimize os intervalos das pesquisas

O intervalo de pesquisa padrão de 5 segundos desperdiça tempo quando a resolução é concluída entre as pesquisas. Use a pesquisa adaptativa – comece rápido e depois recue:

Pitão

import time
import requests

API_KEY = "YOUR_API_KEY"
RESULT_URL = "https://ocr.captchaai.com/res.php"

def adaptive_poll(task_id, timeout=120):
    """Start polling at 3s, increase to 5s after 4 polls."""
    start = time.time()
    interval = 3  # start aggressive
    polls = 0

    while time.time() - start < timeout:
        time.sleep(interval)
        polls += 1

        resp = requests.get(RESULT_URL, params={
            "key": API_KEY, "action": "get",
            "id": task_id, "json": "1"
        }).json()

        if resp["status"] == 1:
            elapsed = time.time() - start
            print(f"Solved in {elapsed:.1f}s ({polls} polls)")
            return resp["request"]

        if resp["request"] != "CAPCHA_NOT_READY":
            raise Exception(resp["request"])

        # Back off after initial fast polls
        if polls >= 4:
            interval = 5

    raise TimeoutError(f"Task {task_id} timed out")

JavaScript

async function adaptivePoll(taskId, apiKey, timeout = 120000) {
  const start = Date.now();
  let interval = 3000;
  let polls = 0;

  while (Date.now() - start < timeout) {
    await new Promise(r => setTimeout(r, interval));
    polls++;

    const resp = await fetch(
      `https://ocr.captchaai.com/res.php?key=${apiKey}&action=get&id=${taskId}&json=1`
    );
    const data = await resp.json();

    if (data.status === 1) {
      console.log(`Solved in ${((Date.now() - start) / 1000).toFixed(1)}s (${polls} polls)`);
      return data.request;
    }
    if (data.request !== 'CAPCHA_NOT_READY') {
      throw new Error(data.request);
    }

    if (polls >= 4) interval = 5000;
  }
  throw new Error(`Task ${taskId} timed out`);
}

Economiza em média de 1 a 4 segundos em comparação com um intervalo fixo de 5 segundos.

2. Pool de conexões

Reutilize conexões HTTP em vez de abrir novas para cada enquete:

Pitão

session = requests.Session()
# Use session.get() and session.post() instead of requests.get/post
# The session reuses TCP connections automatically

JavaScript (Node.js)

const { Agent } = require('http');
const axios = require('axios');

const client = axios.create({
  httpAgent: new Agent({ keepAlive: true, maxSockets: 10 }),
  timeout: 10000,
});
// Use client.get() and client.post() for all API calls

Economiza aproximadamente 50-100 ms por solicitação, ignorando os handshakes TCP/TLS.

3. Pré-busca CAPTCHAs

Envie tarefas CAPTCHA antes de precisar dos tokens. Enquanto seu scraper processa a página N, envie o CAPTCHA para a página N+1:

from concurrent.futures import ThreadPoolExecutor

SUBMIT_URL = "https://ocr.captchaai.com/in.php"

def prefetch_submit(sitekey, page_url):
    resp = session.post(SUBMIT_URL, data={
        "key": API_KEY,
        "method": "userrecaptcha",
        "googlekey": sitekey,
        "pageurl": page_url,
        "json": "1",
    })
    data = resp.json()
    if data["status"] == 1:
        return data["request"]
    raise Exception(data["request"])

# Submit next page's CAPTCHA while processing current page
with ThreadPoolExecutor(max_workers=2) as pool:
    # Submit CAPTCHA for page 2 while processing page 1
    future_task = pool.submit(prefetch_submit, "6Le-SITEKEY", "https://example.com/page/2")

    # Process page 1...
    process_page(current_data)

    # Now get the pre-submitted task ID and poll
    task_id = future_task.result()
    token = adaptive_poll(task_id)

Elimina o tempo de espera total sobrepondo a solução ao processamento.

4. Use o método CAPTCHA correto

CaptchaAI às vezes oferece suporte a métodos com menor latência para cenários específicos:

5. Ignore o proxy quando não for necessário

O roteamento proxy adiciona latência. Envie parâmetros de proxy apenas quando o site de destino exigir solicitações de IPs específicos:

# Without proxy — faster for most use cases
data = {
    "key": API_KEY,
    "method": "userrecaptcha",
    "googlekey": sitekey,
    "pageurl": page_url,
    "json": "1",
}

# With proxy — only when required
data["proxy"] = "user:pass@1.2.3.4:8080"
data["proxytype"] = "HTTP"

6. Use URLs de retorno de chamada em vez de pesquisa

Elimine totalmente a votação com o parâmetro pingback:

resp = session.post(SUBMIT_URL, data={
    "key": API_KEY,
    "method": "userrecaptcha",
    "googlekey": sitekey,
    "pageurl": page_url,
    "json": "1",
    "pingback": "https://your-server.com/captcha-callback",
})

CaptchaAI envia o resultado para sua URL quando a resolução for concluída. Nenhum ciclo de votação é necessário. Este é o método de recuperação com menor latência.

7. Compare suas otimizações

import statistics

def benchmark(solve_func, iterations=20):
    times = []
    for i in range(iterations):
        start = time.time()
        try:
            solve_func()
            times.append(time.time() - start)
        except Exception:
            pass

    if times:
        print(f"Samples: {len(times)}/{iterations}")
        print(f"Mean:    {statistics.mean(times):.1f}s")
        print(f"Median:  {statistics.median(times):.1f}s")
        print(f"P95:     {sorted(times)[int(len(times)*0.95)]:.1f}s")
        print(f"Min:     {min(times):.1f}s")
        print(f"Max:     {max(times):.1f}s")

Solução de problemas

Perguntas frequentes

Qual é a maior otimização individual?

Pré-busca. Ele sobrepõe o tempo de resolução ao tempo de processamento, reduzindo efetivamente a latência percebida a quase zero para fluxos de trabalho sequenciais.

A pesquisa adaptativa ajuda para CAPTCHAs de imagem?

Menos ainda. Os CAPTCHAs de imagem são resolvidos em 2 a 5 segundos, portanto, a primeira enquete de 3 segundos geralmente os detecta. A aprimoramento é mais perceptível para o reCAPTCHA (15-30 segundos).

Obtenha a solução CAPTCHA com menor latência com CaptchaAI

Obtenha sua chave API emcaptchaai.com.

Guias relacionados

• Otimizando Velocidade e Custo
• Resolução paralela de CAPTCHA
• Configurações personalizadas de tempo limite para diferentes tipos de CAPTCHA