Tutoriales

Rendimiento CAPTCHA a gran escala: cómo procesar 10.000 tareas por hora

Automatización Python Todos los tipos de CAPTCHA Rendimiento
Por Equipo de CaptchaAI en Español
Publicado en May 22, 2026
Rendimiento CAPTCHA a gran escala: cómo procesar 10.000 tareas por hora
Imagen destacada no disponible

Procesar 10.000 CAPTCHA por hora significa aproximadamente 2,8 resoluciones por segundo sostenidas. Esto se puede lograr con la arquitectura adecuada. Esta guía explica las matemáticas, el código y el ajuste necesarios para alcanzar este rendimiento usando CaptchaAI.

las matemáticas

Si una única resolución de reCAPTCHA v2 tarda 15 segundos (mediana):

  • Secuencial: 3600s/15s = 240 solves/hour
  • Para llegar a 10,000/hour: necesitas ~42 resoluciones simultáneas en vuelo en todo momento

La idea clave: no está esperando a que CaptchaAI sea más rápido; está superponiendo suficientes solicitudes para que se completen 42 soluciones durante la misma ventana de 15 segundos.

Arquitectura

┌──────────┐     ┌────────────┐     ┌─────────────┐     ┌──────────┐
│  Task     │────▶│  Submit    │────▶│  CaptchaAI  │────▶│  Result  │
│  Queue    │     │  Workers   │     │  API        │     │  Store   │
│  (Redis)  │     │  (async)   │     │             │     │  (DB)    │
└──────────┘     └────────────┘     └─────────────┘     └──────────┘
                       │                    ▲
                       │    ┌──────────┐    │
                       └───▶│  Poll    │────┘
                            │  Workers │
                            └──────────┘

Componentes:

  1. Cola de tareas: mantiene tareas CAPTCHA pendientes con claves de sitio y URL
  2. Enviar trabajadores: envía tareas a la API CaptchaAI simultáneamente
  3. Trabajadores electorales: compruebe los resultados a intervalos optimizados
  4. Almacenamiento de resultados: guarda los tokens a medida que llegan

Python: pipeline asíncrono

# high_throughput_solver.py
import os
import asyncio
import time
import aiohttp

API_KEY = os.environ.get("CAPTCHAAI_KEY", "YOUR_API_KEY")
BASE_URL = "https://ocr.captchaai.com"
MAX_CONCURRENT = 50  # Max simultaneous solves
POLL_INTERVAL = 5    # Seconds between polls
INITIAL_WAIT = 12    # Seconds before first poll

semaphore = asyncio.Semaphore(MAX_CONCURRENT)
stats = {"submitted": 0, "solved": 0, "failed": 0, "start": 0}

async def solve_one(session, sitekey, pageurl, task_num):
    """Submit and poll a single CAPTCHA."""
    async with semaphore:
        try:
            # Submit
            async with session.get(f"{BASE_URL}/in.php", params={
                "key": API_KEY, "method": "userrecaptcha",
                "googlekey": sitekey, "pageurl": pageurl, "json": "1",
            }) as resp:
                result = await resp.json(content_type=None)

            if result.get("status") != 1:
                stats["failed"] += 1
                return None

            stats["submitted"] += 1
            task_id = result["request"]

            # Wait before first poll
            await asyncio.sleep(INITIAL_WAIT)

            # Poll
            for _ in range(25):
                async with session.get(f"{BASE_URL}/res.php", params={
                    "key": API_KEY, "action": "get",
                    "id": task_id, "json": "1",
                }) as resp:
                    poll_result = await resp.json(content_type=None)

                if poll_result.get("status") == 1:
                    stats["solved"] += 1
                    return poll_result["request"]

                if poll_result.get("request") != "CAPCHA_NOT_READY":
                    stats["failed"] += 1
                    return None

                await asyncio.sleep(POLL_INTERVAL)

            stats["failed"] += 1
            return None

        except Exception as e:
            stats["failed"] += 1
            return None

async def run_batch(tasks):
    """Process a batch of CAPTCHA tasks concurrently."""
    connector = aiohttp.TCPConnector(
        limit=MAX_CONCURRENT,
        keepalive_timeout=60,
    )
    async with aiohttp.ClientSession(connector=connector) as session:
        coros = [
            solve_one(session, task["sitekey"], task["pageurl"], i)
            for i, task in enumerate(tasks)
        ]
        results = await asyncio.gather(*coros)
    return results

async def main():
    # Generate test tasks (replace with your task source)
    tasks = [
        {
            "sitekey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
            "pageurl": "https://www.google.com/recaptcha/api2/demo",
        }
        for _ in range(100)  # Start with 100 tasks
    ]

    stats["start"] = time.time()
    print(f"Processing {len(tasks)} tasks with {MAX_CONCURRENT} concurrent workers")

    results = await run_batch(tasks)
    elapsed = time.time() - stats["start"]

    print(f"\nCompleted in {elapsed:.0f}s")
    print(f"Submitted: {stats['submitted']}")
    print(f"Solved: {stats['solved']}")
    print(f"Failed: {stats['failed']}")
    print(f"Throughput: {stats['solved'] / (elapsed / 3600):.0f} solves/hour")

asyncio.run(main())

JavaScript: pipeline concurrente

// high_throughput_solver.js
const axios = require('axios');
const https = require('https');

const API_KEY = process.env.CAPTCHAAI_KEY || 'YOUR_API_KEY';
const BASE = 'https://ocr.captchaai.com';
const MAX_CONCURRENT = 50;

const agent = new https.Agent({ keepAlive: true, maxSockets: MAX_CONCURRENT });
const api = axios.create({ baseURL: BASE, httpsAgent: agent, timeout: 30000 });

const stats = { submitted: 0, solved: 0, failed: 0 };

async function solveOne(sitekey, pageurl) {
  try {
    const submit = await api.get('/in.php', {
      params: { key: API_KEY, method: 'userrecaptcha', googlekey: sitekey, pageurl, json: '1' },
    });
    if (submit.data.status !== 1) { stats.failed++; return null; }
    stats.submitted++;

    await new Promise(r => setTimeout(r, 12000));

    for (let i = 0; i < 25; i++) {
      const poll = await api.get('/res.php', {
        params: { key: API_KEY, action: 'get', id: submit.data.request, json: '1' },
      });
      if (poll.data.status === 1) { stats.solved++; return poll.data.request; }
      if (poll.data.request !== 'CAPCHA_NOT_READY') { stats.failed++; return null; }
      await new Promise(r => setTimeout(r, 5000));
    }
    stats.failed++;
    return null;
  } catch { stats.failed++; return null; }
}

async function runWithConcurrency(tasks, limit) {
  const results = [];
  const executing = new Set();

  for (const task of tasks) {
    const p = solveOne(task.sitekey, task.pageurl).then(r => {
      executing.delete(p);
      return r;
    });
    executing.add(p);
    results.push(p);

    if (executing.size >= limit) {
      await Promise.race(executing);
    }
  }
  return Promise.all(results);
}

(async () => {
  const tasks = Array.from({ length: 100 }, () => ({
    sitekey: '6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-',
    pageurl: 'https://www.google.com/recaptcha/api2/demo',
  }));

  const start = Date.now();
  console.log(`Processing ${tasks.length} tasks, ${MAX_CONCURRENT} concurrent`);

  await runWithConcurrency(tasks, MAX_CONCURRENT);
  const elapsed = (Date.now() - start) / 1000;

  console.log(`\nDone in ${elapsed.toFixed(0)}s`);
  console.log(`Solved: ${stats.solved}, Failed: ${stats.failed}`);
  console.log(`Throughput: ${(stats.solved / (elapsed / 3600)).toFixed(0)} solves/hour`);

  agent.destroy();
})();

Parámetros de ajuste

Parámetro conservador equilibrado agresivo
MAX_CONCURRENT 20 50 100
INICIAL_ESPERA 15 12s 10
ENCUESTA_INTERVAL 7s 5s 3s
MAX_POLL_ATTEMPTS 30 25 20
Rendimiento esperado ~4,800/hr ~10,000/hr ~18,000/hr

Comience de manera conservadora y aumente MAX_CONCURRENT hasta que vea rendimientos decrecientes o mayores tasas de error.

Monitoreo del rendimiento

Realice un seguimiento de estas métricas en tiempo real:

  • Resoluciones por minuto: debe permanecer en ~167 para el objetivo 10K/hour
  • Tasa de error: manténgala por debajo del 5 %. Si aumenta, reduzca la simultaneidad.
  • Profundidad de la cola: si está creciendo, aumente los trabajadores. Si está vacío, estás sobreaprovisionado
  • Tiempo de resolución de P90: si aumenta, CaptchaAI puede limitar la velocidad

Solución de problemas

Problema causa Solución
El rendimiento se estanca en ~5K/hr Simultaneidad insuficiente Aumentar MAX_CONCURRENT a 80-100
Tasa de error > 10% Sobrecarga de API o proxies incorrectos Reduzca la concurrencia, verifique el estado del proxy
El uso de la memoria crece Acumulación ilimitada de tareas Procese los resultados a medida que llegan, no los almacene en búfer
ERROR_NO_SLOT_AVAILABLE Cola CaptchaAI llena Retroceda y vuelva a intentarlo después de 5 segundos.

Preguntas frecuentes

¿Cuál es el límite de simultaneidad de CaptchaAI?

No hay un límite estricto para las solicitudes simultáneas, pero una simultaneidad extremadamente alta (más de 500) puede desencadenar una limitación de velocidad. Comience en 50 y aumente.

¿Puedo ejecutar esto en varias máquinas?

Sí. Utilice una cola compartida (Redis, RabbitMQ) y ejecute el script de trabajo en varios servidores. Cada trabajador realiza tareas de forma independiente.

¿Qué pasa con el consumo de saldo a este ritmo?

Con 10.000 solves/hour, controle de cerca su saldo. Utilice el punto final de verificación de saldo (res.php?action=getbalance) y configure alertas.

Construye tu pipeline CAPTCHA de alto rendimiento: obtén tu API key de CaptchaAI.

Guías relacionadas:

  • Conexión keep-alive y HTTP/2 para la API CAPTCHA
  • Benchmarks de tiempos de resolución
Los comentarios están deshabilitados para este artículo.