Yang menahan throughput Anda bukan kecepatan solver, melainkan berapa banyak solve yang berjalan bersamaan. Untuk menembus 10.000 CAPTCHA per jam, Anda tidak perlu menunggu CaptchaAI jadi lebih cepat — cukup overlap request yang cukup banyak agar puluhan solve selesai dalam jendela waktu yang sama.
Yang akan Anda susun di panduan ini:
- Rumus concurrency untuk menghitung berapa thread yang dibutuhkan.
- Pipeline async siap pakai di Python dan Node.js.
- Tabel tuning, metrik monitoring, dan tabel troubleshooting.
Berapa concurrency yang dibutuhkan untuk 10.000 per jam
Anggap satu penyelesaian reCAPTCHA v2 memakan waktu 15 detik (nilai median). Dari sini semua angka lain mengikuti:
- Secara berurutan (satu per satu): 3.600 detik / 15 detik = 240 solve per jam. Jauh dari cukup.
- Untuk mencapai 10.000 per jam, Anda butuh ~42 solve concurrent yang selalu berjalan setiap saat.
Jadi targetnya bukan "solve lebih cepat", tapi menjaga ~42 solve selalu in-flight. Selama jumlah itu terjaga, waktu 15 detik per solve berjalan paralel, bukan antre.
Angka ini juga menentukan paket Anda. CaptchaAI menagih per thread (satu thread = satu solve berjalan), jadi 42 solve concurrent berarti minimal 50 thread. Paket ADVANCE ($90/bulan, 50 thread, solve tanpa batas per thread) pas untuk beban ini, dan harga flat per thread membuat lonjakan volume tidak menambah tagihan.
Arsitektur pipeline throughput tinggi
Pola yang skalabel memisahkan pengiriman task dari pengambilan hasil, sehingga worker tidak saling menunggu:
┌──────────┐ ┌────────────┐ ┌─────────────┐ ┌──────────┐
│ Task │────▶│ Submit │────▶│ CaptchaAI │────▶│ Result │
│ Queue │ │ Workers │ │ API │ │ Store │
│ (Redis) │ │ (async) │ │ │ │ (DB) │
└──────────┘ └────────────┘ └─────────────┘ └──────────┘
│ ▲
│ ┌──────────┐ │
└───▶│ Poll │────┘
│ Workers │
└──────────┘
Empat komponennya:
- Task queue – Menampung task CAPTCHA yang menunggu, lengkap dengan sitekey dan URL.
- Submit workers – Mengirim task ke CaptchaAI API secara concurrent.
- Poll workers – Memeriksa hasil pada interval polling yang sudah dioptimalkan.
- Result store – Menyimpan token begitu tiba.
Begitu satu task dikirim, worker langsung mengambil task berikutnya sementara polling berjalan terpisah.
Python: pipeline async dengan aiohttp
Di Python, asyncio plus aiohttp menjalankan puluhan solve dalam satu event loop; sebuah Semaphore membatasi jumlah concurrent agar tidak melewati alokasi thread Anda:
# 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())
INITIAL_WAIT menunda polling pertama sampai token kemungkinan besar siap, agar Anda tidak membuang request pada respons CAPCHA_NOT_READY.
Node.js: pipeline concurrent dengan axios
Pola setara di Node.js memakai Promise.race plus HTTPS agent keep-alive agar koneksi dipakai ulang:
// 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();
})();
Tuning parameter: konservatif, seimbang, agresif
Tiga knob menentukan throughput Anda. Mulai dari kolom konservatif, lalu naikkan bertahap sambil mengamati error rate.
Angka throughput di bawah bersumber dari pengamatan dan laporan pengguna. Hasil nyata bergantung pada lingkungan, tipe CAPTCHA, dan waktu pengujian Anda.
| Parameter | Konservatif | Seimbang | Agresif |
|---|---|---|---|
| MAX_CONCURRENT | 20 | 50 | 100 |
| INITIAL_WAIT | 15 dtk | 12 dtk | 10 dtk |
| POLL_INTERVAL | 7 dtk | 5 dtk | 3 dtk |
| MAX_POLL_ATTEMPTS | 30 | 25 | 20 |
| Throughput perkiraan | ~4.800/jam | ~10.000/jam | ~18.000/jam |
Naikkan MAX_CONCURRENT sampai hasil mulai stagnan atau error rate naik — di titik itulah batas praktis pipeline Anda.
Metrik yang wajib dipantau
Pantau empat angka ini secara real-time agar bisa bereaksi sebelum throughput anjlok:
- Solve per menit – Harus stabil di ~167 untuk target 10.000/jam.
- Error rate – Jaga di bawah 5%. Kalau melonjak, turunkan concurrency.
- Kedalaman queue – Kalau terus bertambah, tambah worker. Kalau kosong, Anda over-provisioning.
- Waktu solve P90 – Kalau meningkat, kemungkinan Anda sedang kena rate limiting.
Pantau juga saldo dengan ketat: satu batch besar bisa menghabiskannya lebih cepat dari dugaan. Endpoint res.php?action=getbalance cocok dipasangi peringatan otomatis.
Troubleshooting throughput
| Masalah | Penyebab | Solusi |
|---|---|---|
| Throughput mentok di ~5K/jam | Concurrency kurang | Naikkan MAX_CONCURRENT ke 80–100 |
| Error rate > 10% | API kelebihan beban atau proxy buruk | Turunkan concurrency; cek kesehatan proxy |
| Pemakaian memory naik terus | Task menumpuk tanpa batas | Proses hasil begitu tiba, jangan di-buffer |
ERROR_NO_SLOT_AVAILABLE |
Queue CaptchaAI penuh | Backoff, lalu coba ulang setelah 5 detik |
FAQ
Berapa thread CaptchaAI yang dibutuhkan untuk 10.000 solve per jam?
Untuk reCAPTCHA v2 dengan median ~15 detik, Anda butuh ~42 solve concurrent, jadi minimal 50 thread. Paket ADVANCE ($90/bulan, 50 thread) memenuhinya; naik ke PREMIUM ($170/bulan, 100 thread) bila ingin ruang untuk lonjakan.
Apakah target 10.000 per jam sama untuk semua tipe CAPTCHA?
Tidak. Concurrency bergantung pada waktu solve per tipe: Turnstile yang lebih cepat butuh lebih sedikit thread, tipe yang lebih lambat butuh lebih banyak. Rumusnya: (target per jam × detik per solve) / 3.600 = concurrent yang dibutuhkan.
Bagaimana latency memengaruhi throughput dari region seperti Jakarta?
Latency menambah beberapa milidetik per request, bukan per solve, jadi dampaknya ke throughput kecil. Deploy worker dekat sumber task Anda — misalnya ap-southeast-3 (Jakarta) atau ap-southeast-1 (Singapura) — dan andalkan keep-alive.
Bisakah pipeline ini dijalankan di beberapa server sekaligus?
Ya. Pakai queue bersama (Redis, RabbitMQ) dan jalankan worker di beberapa server. Tiap worker menarik task secara independen, sehingga concurrency total terbagi tanpa saling bertabrakan.
Mulai sekarang
Bangun pipeline CAPTCHA throughput tinggi Anda — dapatkan kunci API CaptchaAI.
Panduan terkait:
