Optimización de latencia API CaptchaAI: resoluciones más rápidas

Una resolución CAPTCHA tiene cuatro componentes de latencia: envío de solicitud, espera en cola, ejecución del solucionador y recuperación de sondeo. No puedes controlar el tiempo de ejecución del solucionador, pero puedes optimizar todo lo demás.

Latencia inicial por tipo CAPTCHA

La columna "lo mejor que se puede lograr" refleja lo que se obtiene después de aplicar las optimizaciones siguientes.

1. Optimice los intervalos de consulta

El intervalo de sondeo predeterminado de 5 segundos hace perder tiempo cuando se completa la resolución entre sondeos. Utilice el sondeo adaptativo: comience rápido y luego retroceda:

pitón

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`);
}

Ahorra entre 1 y 4 segundos en promedio en comparación con un intervalo fijo de 5 segundos.

2. Agrupación de conexiones

Reutilice las conexiones HTTP en lugar de abrir otras nuevas para cada consulta:

pitón

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

Ahorra entre 50 y 100 ms por solicitud omitiendo los apretones de manos TCP/TLS.

3. Captura previa de CAPTCHA

Envíe las tareas CAPTCHA antes de necesitar los tokens. Mientras su raspador procesa la página N, envíe el CAPTCHA para la 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 el tiempo de espera total al superponer la resolución con el procesamiento.

4. Utilice el método CAPTCHA correcto

CaptchaAI a veces admite métodos más rápidos para escenarios específicos:

5. Omita el proxy cuando no sea necesario

El enrutamiento proxy agrega latencia. Solo envíe parámetros de proxy cuando el sitio de destino requiera solicitudes de IP específicas:

# 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. Utilice URL de devolución de llamada en lugar de consultas

Elimine el sondeo por completo con el 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 envía el resultado a su URL cuando se completa la resolución. No se necesita ningún bucle de votación. Este es el método de recuperación más rápido.

7. Compare sus optimizaciones

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")

Solución de problemas

Preguntas frecuentes

¿Cuál es la mayor optimización individual?

Precarga. Superpone el tiempo de resolución con el tiempo de procesamiento, lo que reduce efectivamente la latencia percibida a casi cero para flujos de trabajo secuenciales.

¿Ayuda el sondeo adaptativo para los CAPTCHA de imágenes?

Menos aún. Los CAPTCHA de imágenes se resuelven en 2 a 5 segundos, por lo que la primera consulta a los 3 segundos a menudo los detecta. La mejora es más notable para reCAPTCHA (15-30 segundos).

Obtener las resoluciones CAPTCHA más rápidas con CaptchaAI

Obtén tu clave API en captchaai.com.

Guías relacionadas

• Configuraciones de timeout personalizadas por tipo de CAPTCHA