La clave para resolver 10.000 CAPTCHA por hora no es un solver más rápido: es la concurrencia. Una resolución individual de reCAPTCHA v2 tarda unos 15 segundos, así que un solo hilo que trabaje en secuencia apenas llega a 240 por hora. Para alcanzar el objetivo hace falta mantener alrededor de 42 resoluciones en curso al mismo tiempo. En esta guía verás el cálculo exacto, la arquitectura del pipeline, el código en Python y JavaScript, y qué plan por threads de CaptchaAI sostiene ese ritmo sin sorpresas en la factura.
El cálculo: cuánta concurrencia necesitas
Empieza por el número que manda: 10.000 CAPTCHA por hora son unas 2,8 resoluciones por segundo sostenidas. Con una mediana de 15 segundos por resolución de reCAPTCHA v2, el reparto sale así:
- En secuencia: 3.600 s / 15 s = 240 resoluciones por hora.
- Para llegar a 10.000/hora: necesitas ~42 resoluciones simultáneas en vuelo en todo momento.
La idea que lo cambia todo: no estás esperando a que CaptchaAI vaya más rápido, estás solapando suficientes solicitudes para que 42 resoluciones se completen dentro de la misma ventana de 15 segundos. El rendimiento total es concurrencia dividida entre latencia por resolución, no la velocidad de una sola tarea. Por eso el trabajo real es de arquitectura: mantener esas decenas de solicitudes vivas en paralelo sin bloquear tu proceso.
Arquitectura del pipeline
┌──────────┐ ┌────────────┐ ┌─────────────┐ ┌──────────┐
│ Task │────▶│ Submit │────▶│ CaptchaAI │────▶│ Result │
│ Queue │ │ Workers │ │ API │ │ Store │
│ (Redis) │ │ (async) │ │ │ │ (DB) │
└──────────┘ └────────────┘ └─────────────┘ └──────────┘
│ ▲
│ ┌──────────┐ │
└───▶│ Poll │────┘
│ Workers │
└──────────┘
Cuatro piezas, cada una con una responsabilidad clara:
- Cola de tareas (Redis): mantiene las tareas CAPTCHA pendientes con su sitekey y su URL.
- Workers de envío: mandan tareas a la API de CaptchaAI en paralelo.
- Workers de sondeo: consultan el resultado a intervalos optimizados en lugar de bloquear a la espera.
- Almacén de resultados: guarda los tokens a medida que llegan.
Separar envío y sondeo es lo que permite escalar: mientras unas tareas esperan a resolverse, los workers de envío ya están lanzando las siguientes. Nada se queda parado esperando a un único resultado.
Python: pipeline asíncrono con aiohttp
Esta implementación usa asyncio y un Semaphore para limitar la concurrencia, más aiohttp con un pool de conexiones reutilizadas. Envía la tarea, espera antes del primer sondeo y consulta el resultado en un bucle hasta que llega el token:
# 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())
El Semaphore es el freno de mano: aunque lances 100 tareas a la vez, solo 50 estarán en vuelo simultáneamente. Ajusta ese número y el pipeline entero cambia de marcha.
JavaScript: pipeline concurrente con Node.js
La versión en Node.js reproduce la misma lógica con axios y un agente HTTPS con keep-alive, controlando la concurrencia mediante un Set de promesas en ejecución:
// 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();
})();
Cuánto cuesta: threads y plan de CaptchaAI
Aquí es donde el cálculo de concurrencia se traduce en dinero. CaptchaAI factura por threads concurrentes, no por resolución: un thread es un CAPTCHA en curso y, en cuanto termina, queda libre para el siguiente. Como tu MAX_CONCURRENT marca cuántas resoluciones mantienes en vuelo, se corresponde casi uno a uno con los threads que necesitas:
- Objetivo de 10.000/hora con concurrencia de 50: el plan ADVANCE ($90/mes, 50 threads) encaja con margen.
- Configuración agresiva de 100 resoluciones en paralelo: PREMIUM ($170/mes, 100 threads) te cubre.
Todos los planes incluyen resoluciones ilimitadas por thread, sin cargos por CAPTCHA ni recargos según el tipo, así que el coste mensual en USD es predecible. Para agencias y freelancers que facturan en monedas locales volátiles pero pagan la herramienta en dólares, un precio fijo mensual es mucho más fácil de presupuestar que un pago por resolución que sube con cada pico de tráfico.
Problemas comunes y cómo resolverlos
Cuando el rendimiento no llega al objetivo, casi siempre es uno de estos cuatro casos:
| Problema | Causa | Solución |
|---|---|---|
| El rendimiento se estanca en ~5.000/hora | Concurrencia insuficiente | Sube MAX_CONCURRENT a 80–100 |
| Tasa de error > 10% | API sobrecargada o proxies en mal estado | Reduce la concurrencia y revisa el estado de los proxies |
| El uso de memoria crece | Acumulación ilimitada de tareas | Procesa los resultados según llegan; no los almacenes en búfer |
ERROR_NO_SLOT_AVAILABLE |
Cola de CaptchaAI llena | Aplica retroceso y reintenta tras 5 segundos |
Métricas que debes vigilar
- Resoluciones por minuto: deben mantenerse en torno a 167 para el objetivo de 10.000/hora.
- Tasa de error: mantenla por debajo del 5%. Si se dispara, baja la concurrencia.
- Profundidad de la cola: si crece, añade workers; si se vacía, estás sobreaprovisionado y pagando threads que no usas.
- Tiempo de resolución P90: si sube de forma sostenida, puede que CaptchaAI esté aplicando límite de solicitudes y convenga espaciar los envíos.
Parámetros de ajuste del rendimiento
No existe una única configuración correcta; depende de tu tolerancia al error y de la latencia de tu red. Estos tres perfiles sirven de punto de partida:
| Parámetro | Conservador | Equilibrado | Agresivo |
|---|---|---|---|
| MAX_CONCURRENT | 20 | 50 | 100 |
| INITIAL_WAIT | 15s | 12s | 10s |
| POLL_INTERVAL | 7s | 5s | 3s |
| MAX_POLL_ATTEMPTS | 30 | 25 | 20 |
| Rendimiento esperado | ~4.800/hora | ~10.000/hora | ~18.000/hora |
Empieza en modo conservador y sube MAX_CONCURRENT de forma gradual hasta que veas rendimientos decrecientes o suba la tasa de error.
Preguntas frecuentes
¿Qué plan de CaptchaAI necesito para 10.000 CAPTCHA por hora?
Con una concurrencia de 50 (la configuración equilibrada), el plan ADVANCE ($90/mes, 50 threads) es suficiente para el objetivo de 10.000/hora. Si empujas la concurrencia a 100, PREMIUM ($170/mes, 100 threads) te da margen. Como las resoluciones por thread son ilimitadas, solo pagas por la concurrencia que mantienes en vuelo.
¿Puedo repartir la carga entre varios servidores?
Sí. Usa una cola compartida (Redis o RabbitMQ) y ejecuta el mismo script de worker en varias máquinas. Cada worker toma tareas de forma independiente y la concurrencia total es la suma de todas las instancias, así que puedes escalar horizontalmente sin cambiar el código.
¿Por qué mi rendimiento se estanca aunque suba la concurrencia?
Casi siempre el cuello de botella está fuera del solver: pocas conexiones reutilizadas, un sondeo tan frecuente que satura la API, o proxies lentos. Revisa el keep-alive de tus conexiones y el tiempo de resolución P90 antes de seguir subiendo MAX_CONCURRENT; a partir de cierto punto, más concurrencia solo añade errores.
¿Este pipeline sirve para reCAPTCHA v3 y Turnstile, no solo v2?
Sí. La lógica de envío y sondeo es idéntica; solo cambian el method y los parámetros de la tarea. CaptchaAI resuelve reCAPTCHA v2 y v3, Cloudflare Turnstile y Challenge, GeeTest v3 e imágenes/OCR con el mismo flujo asíncrono, sin tocar la arquitectura.
Monta tu pipeline de alto rendimiento y mide el resultado desde el primer lote: crea tu cuenta y obtén tu API key en CaptchaAI.
Guías relacionadas:
