Perbandingan Waktu Penyelesaian CAPTCHA per Jenis di CaptchaAI

Selesaikan masalah waktu. Perbedaan 10 detik untuk setiap penyelesaian digabungkan menjadi beberapa jam penundaan di ribuan tugas. Panduan ini memberikan tolok ukur yang dapat direproduksi untuk setiap jenis CAPTCHA yang didukung CaptchaAI, ditambah skrip untuk menjalankan pengukuran Anda sendiri.

Catatan: Angka-angka di bawah adalah estimasi berdasarkan pengujian tipikal. Waktu aktual bervariasi tergantung kondisi jaringan, beban server, dan kompleksitas CAPTCHA. Selalu jalankan benchmark Anda sendiri sebelum menggunakan data ini untuk pengaturan timeout produksi.

Waktu Penyelesaian Khas

Tolok ukur ini mencerminkan waktu median dari 100 penyelesaian berturut-turut per jenis, diukur dari penyerahan API hingga pengambilan hasil:

Waktu bervariasi berdasarkan kualitas proxy, beban server, dan kompleksitas CAPTCHA.

Faktor-Faktor yang Mempengaruhi Waktu Penyelesaian

Latensi Jaringan

Jarak Anda dari titik akhir API CaptchaAI menambah waktu pulang pergi. RTT 200 md menambahkan total ~1 detik (kirim + 3–4 jajak pendapat × 200 md).

Proksi

Saat menggunakan proxy, egress jaringan yang diotorisasi biasanya menghasilkan penyelesaian yang lebih cepat dibandingkan proxy datacenter karena memicu lebih sedikit tantangan sekunder.

Kompleksitas CAPTCHA

Tantangan gambar reCAPTCHA v2 memiliki tingkat kesulitan yang bervariasi. Tantangan "pilih lampu lalu lintas" dengan gambar memudar membutuhkan waktu lebih lama daripada verifikasi kotak centang sederhana.

Strategi Polling

Polling agresif (setiap 2 detik) mendeteksi hasil lebih cepat tetapi meningkatkan panggilan API. Polling konservatif (setiap 10 detik) mengurangi beban tetapi menambah latensi.

Skrip Tolok Ukur Python

# 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 Tolok Ukur JavaScript

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

Menafsirkan Hasil

Median vs P90

• Median — Pengalaman yang khas. Gunakan ini untuk perencanaan kapasitas.
• P90 — "Kasus terburuk" untuk 9 dari 10 penyelesaian. Gunakan ini untuk pengaturan batas waktu.
• P99 — Kasus edge sebenarnya. Tetapkan batas waktu maksimum Anda lebih tinggi dari ini.

Interval Pemungutan Suara Optimal

Berdasarkan tolok ukur di atas, konfigurasikan polling per jenis CAPTCHA:

Pemecahan Masalah

Pertanyaan Umum

Apakah waktu penyelesaian berbeda-beda menurut waktu?

Ya. Jam sibuk (jam kerja AS) mungkin menunjukkan waktu penyelesaian yang sedikit lebih lama karena permintaan yang lebih tinggi. Jalankan benchmark pada waktu yang berbeda untuk mendapatkan gambaran yang lengkap.

Haruskah saya menggunakan data ini untuk pengaturan batas waktu produksi?

Gunakan nilai P90 untuk batas waktu standar dan P99 untuk batas waktu maksimum. Tambahkan buffer 20% untuk memperhitungkan variabilitas jaringan.

Bagaimana pengaturan proxy mempengaruhi waktu penyelesaian?

Jika Anda menyediakan proxy, CaptchaAI merutekan penyelesaian melalui proxy tersebut. Proksi yang lambat atau jauh dapat menambahkan 5–15 detik ke total waktu penyelesaian. Untuk pembandingan, uji dengan dan tanpa proxy secara terpisah.

Artikel Terkait

• Optimasi Latensi API CaptchaAI
• Pemecahan CAPTCHA Paralel vs Sekuensial

Langkah Selanjutnya

Jalankan skrip benchmark terhadap akun Anda sendiri dan target CAPTCHA — dapatkan kunci API CaptchaAI Anda.