Evaluación comparativa de CAPTCHA para resolver tiempos entre tipos con CaptchaAI

Resuelve cuestiones de tiempo. Una diferencia de 10 segundos por resolución se traduce en horas de retraso en miles de tareas. Esta guía proporciona puntos de referencia reproducibles para cada tipo de CAPTCHA.CaptchaAIadmite, además de scripts para ejecutar sus propias mediciones.

Tiempos de resolución típicos

Estos puntos de referencia reflejan los tiempos medios de 100 soluciones consecutivas por tipo, medidos desde el envío de API hasta la recuperación de resultados:

Los tiempos varían según la calidad del proxy, la carga del servidor y la complejidad del CAPTCHA.

Factores que afectan el tiempo de resolución

Latencia de red

Su distancia de los puntos finales API de CaptchaAI agrega tiempo de ida y vuelta. Un RTT de 200 ms agrega aproximadamente 1 segundo en total (enviar + 3 a 4 consultas × 200 ms).

Calidad del proxy

Cuando se utilizan proxies, los proxies residenciales suelen producir soluciones más rápidas que los proxies de centros de datos porque desencadenan menos desafíos secundarios.

Complejidad CAPTCHA

Los desafíos de imágenes reCAPTCHA v2 varían en dificultad. Un desafío de "semáforo seleccionado" con imágenes descoloridas lleva más tiempo que una simple verificación de casilla de verificación.

Estrategia de consulta

El polling agresivo (cada 2 segundos) puede detectar resultados antes, pero aumenta las llamadas a la API. El polling conservador (cada 10 segundos) reduce la carga pero agrega latencia.

Secuencia de comandos de referencia de 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)

Secuencia de comandos de referencia de 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);
})();

Interpretación de resultados

Mediana frente a P90

• Mediana: la experiencia típica. Utilice esto para la planificación de capacidad.
• P90 — El "peor caso" para 9 de cada 10 soluciones. Utilice esto para configurar el tiempo de espera.
• P99 — El verdadero caso límite. Establezca su tiempo de espera máximo más alto que esto.

Intervalos de sondeo óptimos

Según los puntos de referencia anteriores, configure el sondeo por tipo de CAPTCHA:

Solución de problemas

Preguntas frecuentes

¿Los tiempos de resolución varían según la hora del día?

Sí. Las horas pico (horario comercial de EE. UU.) pueden mostrar tiempos de resolución ligeramente más largos debido a una mayor demanda. Ejecute puntos de referencia en diferentes momentos para obtener una imagen completa.

¿Debo utilizar estos datos para configurar el tiempo de espera de producción?

Utilice los valores P90 para tiempos de espera estándar y P99 para tiempos de espera máximos. Agregue un búfer del 20 % para tener en cuenta la variabilidad de la red.

¿Cómo afecta la configuración del proxy a los tiempos de resolución?

Si proporciona un proxy, CaptchaAI dirige la resolución a través de él. Los proxies lentos o distantes pueden agregar entre 5 y 15 segundos al tiempo total de resolución. Para realizar evaluaciones comparativas, pruebe con y sin proxies por separado.

Artículos relacionados

• Optimización de latencia de la API CaptchaAI
• Resolución CAPTCHA paralela

Ejecuta los scripts de benchmark con tu propia cuenta y objetivos CAPTCHA. Obtén tu API key de CaptchaAI.