Perbandingan Waktu Penyelesaian CAPTCHA per Jenis di CaptchaAI

Timeout production asal tebak punya dua risiko: terlalu ketat sehingga Anda retry padahal solve masih berjalan, atau terlalu longgar sehingga worker menganggur tanpa alasan. Kedua risiko hilang begitu Anda punya angka nyata: berapa detik CaptchaAI biasanya butuh per jenis CAPTCHA, dan seberapa jauh angka itu bisa melebar di kasus terburuk.

Panduan ini membagikan data tersebut — median, P90, P99 — plus skrip Python dan JavaScript untuk mengukur akun dan target Anda sendiri, bukan sekadar memercayai angka orang lain.

Metodologi: median berasal dari 100 percobaan berturut-turut per jenis, dari task dikirim hingga hasil diambil. "Batas SLA" adalah batas kontraktual CaptchaAI, bukan rata-rata — solve yang konsisten melewatinya layak dilaporkan ke support.

Data Waktu Penyelesaian per Jenis CAPTCHA

Waktu aktual bervariasi tergantung kualitas jaringan, beban server, dan kompleksitas CAPTCHA saat itu.

Cara Membaca Median, P90, dan P99

• Median — pengalaman tipikal, untuk perencanaan kapasitas.
• P90 — kasus buruk yang dialami 1 dari 10 penyelesaian. Dasar timeout standar.
• P99 — kasus ekstrem. Set timeout maksimum di atas angka ini.

Faktor yang Memengaruhi Waktu Penyelesaian CAPTCHA

Empat variabel ini paling menentukan cepat-lambatnya solve:

Worker di region AWS ap-southeast-1/ap-southeast-3 atau GCP asia-southeast2 (Singapura/Jakarta) biasanya punya RTT jauh lebih rendah ke CaptchaAI dibanding region AS/Eropa — beda yang terasa di ribuan task per hari.

Skrip Benchmark: Python

Menjalankan satu jenis CAPTCHA berulang kali dan mencetak median, P90, min, maks — ganti method dan payload sesuai jenis yang diukur:

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

Skrip Benchmark: JavaScript

Versi Node.js-nya: kirim, tunggu, polling, catat waktunya.

// 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);
})();

Interval Polling yang Direkomendasikan

Jangan pakai satu konfigurasi generik untuk semua jenis:

Mengatasi Waktu Solve yang Tidak Sesuai Ekspektasi

Pertanyaan Umum tentang Benchmark CaptchaAI

Apakah latensi dari Indonesia ke server CaptchaAI berpengaruh besar terhadap hasil?

Cukup terasa. Region Asia Tenggara (AWS ap-southeast-1/ap-southeast-3, GCP asia-southeast2) biasanya punya RTT lebih rendah dari region AS/Eropa, langsung memangkas total waktu polling.

Berapa thread yang cukup untuk menjalankan benchmark ini tanpa mengganggu traffic produksi?

Untuk 100 percobaan per jenis, BASIC ($15/bulan, 5 thread) biasanya cukup — tidak perlu ADVANCE ($90/bulan, 50 thread) hanya untuk benchmark. Naikkan thread untuk menjalankan beberapa jenis paralel.

Apakah waktu penyelesaian berubah tergantung jam sibuk?

Ya. Jam kerja AS (malam–dini hari WIB) kadang sedikit lebih lambat karena permintaan lebih tinggi. Jalankan benchmark di jam berbeda untuk gambaran representatif.

Interval polling seperti apa yang paling hemat panggilan API tapi tetap responsif?

Samakan dengan median jenisnya — 1 detik untuk Gambar/OCR, 5 detik untuk reCAPTCHA v2. Tabel interval di atas adalah titik awal yang aman.

Bagaimana saya memastikan waktu solve yang lambat itu masalah jaringan saya, bukan CaptchaAI?

Bandingkan RTT murni ke https://ocr.captchaai.com dengan waktu solve end-to-end skrip benchmark. Selisih kecil berarti jaringan Anda; jauh lebih tinggi baru layak dilaporkan ke support.

Artikel Terkait

• Optimasi latensi API CaptchaAI
• Solve paralel vs sekuensial: mana yang lebih cepat?

Langkah Selanjutnya

Jangan berhenti di angka artikel ini — jalankan skrip benchmark terhadap akun dan target Anda sendiri. Dapatkan kunci API CaptchaAI Anda dan mulai ukur dalam hitungan menit.