Optimasi Latensi API CaptchaAI: Solve Lebih Cepat

Solve CAPTCHA memiliki empat komponen latensi: submit request, menunggu antrean, eksekusi solver, dan pengambilan polling. Anda tidak dapat mengontrol waktu eksekusi solver, namun Anda bisa mengoptimalkan yang lainnya.

Latensi Dasar Berdasarkan Jenis CAPTCHA

Kolom "terbaik yang bisa dicapai" mencerminkan hasil setelah menerapkan optimasi di bawah.

1. Optimalkan Interval Polling

Interval polling default 5 detik membuang waktu ketika solve selesai di antara dua poll. Gunakan adaptive polling — mulai cepat, lalu bertahap mundur:

Python

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

Menghemat rata-rata 1–4 detik dibandingkan interval tetap 5 detik.

2. Connection Pooling

Gunakan kembali koneksi HTTP alih-alih membuka koneksi baru untuk setiap poll:

Python

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

Menghemat ~50–100 ms per request dengan melewati TCP/TLS handshake.

3. Pre-Fetch CAPTCHA

Submit task CAPTCHA sebelum token dibutuhkan. Saat scraper memproses halaman N, submit CAPTCHA untuk halaman 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)

Menghilangkan waktu tunggu penuh dengan menumpang-tindihkan solve dengan pemrosesan.

4. Gunakan Metode CAPTCHA yang Tepat

CaptchaAI terkadang mendukung metode yang lebih cepat untuk skenario tertentu:

5. Lewati Proxy Bila Tidak Diperlukan

Routing proxy menambah latensi. Kirimkan parameter proxy hanya ketika situs target memerlukan request dari IP tertentu:

# 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. Gunakan Callback URL daripada Polling

Hilangkan polling sepenuhnya dengan parameter 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 mengirimkan hasil ke URL Anda saat solve selesai. Tidak diperlukan putaran polling — ini adalah metode pengambilan respons kompetitif.

7. Benchmark Optimasi Anda

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

Pemecahan Masalah

Pertanyaan Umum

Apa optimasi tunggal terbesar?

Pre-fetch. Ini menumpang-tindihkan waktu solve dengan waktu pemrosesan, secara efektif mengurangi latensi yang dirasakan mendekati nol untuk alur kerja sekuensial.

Apakah adaptive polling membantu CAPTCHA gambar?

Kurang begitu. Gambar CAPTCHA diselesaikan dalam 2–5 detik, sehingga poll pertama pada 3 detik sering langsung berhasil. Peningkatannya lebih terlihat pada reCAPTCHA (15–30 detik).

Dapatkan Solve CAPTCHA Tercepat dengan CaptchaAI

Dapatkan API key Anda di captchaai.com.

Panduan Terkait

• Pengaturan Timeout Kustom untuk Berbagai Jenis CAPTCHA