Benchmarking der CAPTCHA-Lösungszeiten verschiedener Typen mit CaptchaAI

Lösen Sie Zeitprobleme. Ein Unterschied von 10 Sekunden pro Lösung führt zu einer Verzögerung von mehreren Stunden bei Tausenden von Aufgaben. Dieser Leitfaden bietet reproduzierbare Benchmarks für jeden CAPTCHA-Typ, den CaptchaAI unterstützt, plus Skripte zum Ausführen eigener Messungen.

Typische Lösungszeiten

Diese Benchmarks spiegeln die mittlere Zeit von 100 aufeinanderfolgenden Lösungen pro Typ wider, gemessen von der API-Übermittlung bis zum Abruf der Ergebnisse:

Die Zeiten variieren je nach Proxy-Qualität, Serverlast und CAPTCHA-Komplexität.

Hinweis: Alle Erfolgsquoten basieren auf internen Stichproben. Tatsächliche Werte können je nach Umgebung abweichen.

Faktoren, die die Lösungszeit beeinflussen

Netzwerklatenz

Ihre Entfernung von den API-Endpunkten von CaptchaAI erhöht die Hin- und Rücklaufzeit. Eine 200-ms-RTT fügt insgesamt ca. 1 Sekunde hinzu (Senden + 3–4 Umfragen × 200 ms).

Proxy-Qualität

Bei der Verwendung von Proxys liefern Privat-Proxys in der Regel schnellere Lösungen als Rechenzentrums-Proxys, da sie weniger sekundäre Herausforderungen auslösen.

CAPTCHA-Komplexität

Die Bildherausforderungen von reCAPTCHA v2 variieren im Schwierigkeitsgrad. Eine „Ampel auswählen“-Challenge mit verblassenden Bildern dauert länger als eine einfache Checkbox-Überprüfung.

Umfragestrategie

Aggressives Polling (alle 2 Sekunden) erkennt Ergebnisse schneller, erhöht jedoch die Anzahl der API-Aufrufe. Konservative Abfragen (alle 10 Sekunden) reduzieren die Last, erhöhen jedoch die Latenz.

Python-Benchmark-Skript

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

JavaScript-Benchmark-Skript

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

Ergebnisse interpretieren

Median vs. P90

• Median – Das typische Erlebnis. Nutzen Sie dies für die Kapazitätsplanung.
• P90 – Der „schlimmste Fall“ für 9 von 10 Lösungen. Verwenden Sie dies für Timeout-Einstellungen.
• P99 – Der echte Edge-Fall. Stellen Sie Ihr maximales Timeout höher ein.

Optimale Abfrageintervalle

Konfigurieren Sie die Abfrage basierend auf den oben genannten Benchmarks pro CAPTCHA-Typ:

Fehlerbehebung

Verwandte Leitfäden

• CaptchaAI Schnellstart
• API-Antwortformate und Fehlercodes
• reCAPTCHA v2 per API lösen