Benchmarking der CAPTCHA-Lösungszeiten verschiedener Typen mit CaptchaAI

Wie lange dauert es, ein CAPTCHA per API zu lösen? Bei CaptchaAI reicht die Spanne von unter einer Sekunde für Bild- und BLS-CAPTCHAs bis zu wenigen zehn Sekunden für interaktive reCAPTCHA-v2-Abfragen. Für die Kapazitätsplanung zählt aber nicht der Bestwert, sondern die Verteilung: Median, P90 und P99. Dieser Referenzartikel nennt für jeden von CaptchaAI unterstützten Typ belastbare Richtwerte und Benchmark-Skripte zum Selbstmessen.

Typische Lösungszeiten pro CAPTCHA-Typ

Die Werte stammen aus je 100 Lösungen pro Typ (Übermittlung bis Ergebnisabruf). Die SLA-Obergrenze ist der vertragliche Deckel aus der Solver-Dokumentation; Median und Perzentile sind mit warmgelaufenen Proxys beobachtet:

Die Werte hängen von Proxy-Qualität, Serverlast und CAPTCHA-Komplexität ab; die SLA-Obergrenze ist der vertragliche Deckel.

Hinweis: Die Benchmarks und Vergleichswerte in diesem Artikel basieren auf internen Messungen und können je nach Region, Traffic-Muster und CAPTCHA-Konfiguration variieren. Eigene Tests mit realen Workflows sollten die maßgebliche Grundlage für Entscheidungen sein.

Median, P90 und P99 richtig lesen

Lesen Sie nicht den Durchschnitt, sondern drei Kennzahlen:

• Median – der typische Fall. Grundlage für die Kapazitätsplanung.
• P90 – der ungünstige Fall für 9 von 10 Lösungen. Grundlage für Timeout-Einstellungen.
• P99 – der echte Ausreißer. Setzen Sie Ihr maximales Timeout darüber.

Was die Lösungszeit beeinflusst

Vier Faktoren erklären die Streuung in der Tabelle oben:

• Netzwerklatenz: Jeder Roundtrip zwischen Worker und API-Endpunkt zählt. Bei 200 ms RTT summieren sich Übermittlung plus drei bis vier Abfragen auf rund 1 Sekunde. Ein Hetzner-Server in Falkenstein misst andere Werte als ein Rechner in Übersee – notieren Sie Region und Anbieter zu jedem Lauf.
• Proxy-Qualität: Residential-Proxys liefern meist schnellere Lösungen als Rechenzentrums-Proxys, weil sie seltener zusätzliche Challenges auslösen.
• CAPTCHA-Komplexität: Eine „Ampeln auswählen“-Abfrage mit nachladenden Kacheln dauert länger als eine einfache Checkbox-Bestätigung.
• Polling-Strategie: Aggressives Polling (alle 2 Sekunden) erkennt Ergebnisse früher, erhöht aber die API-Aufrufe; konservatives Abfragen senkt die Last, kostet dafür Latenz.

Benchmark-Skript in Python

Das Skript misst Übermittlung und Polling pro Typ und gibt Median, Erfolgsquote sowie Min-/Max-Werte aus. Setzen Sie CAPTCHAAI_KEY als Umgebungsvariable und passen Sie die Zielparameter an:

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

Benchmark-Skript in JavaScript

Dasselbe in Node.js – etwa für eine JavaScript-Test-Pipeline in einem GitLab-CI-Job:

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

Abfrageintervalle pro CAPTCHA-Typ optimieren

Leiten Sie das Polling aus den Benchmarks ab – die erste Wartezeit entspricht etwa dem Median:

Häufige Fragen

Warum löst CaptchaAI reCAPTCHA v3 schneller als reCAPTCHA v2?

Weil v3 kein interaktives Bildrätsel enthält. reCAPTCHA v3 vergibt einen Score im Hintergrund, während v2 je nach Abfrage eine Bildauswahl verlangt – daher wenige Sekunden bei v3 gegenüber mehreren zehn Sekunden bei v2.

Wie viele Durchläufe brauche ich für aussagekräftige Zahlen?

Mindestens 50 pro Typ. Zehn Läufe zeigen einen groben Median, aber erst ab etwa 50 Messungen werden P90 und P99 stabil. Führen Sie die Läufe zudem zu verschiedenen Tageszeiten aus, da die Auslastung in US-Geschäftszeiten steigt.

Beeinflusst die Thread-Anzahl meines Plans die Lösungszeit?

Nein, nicht die Zeit pro Lösung. CaptchaAI rechnet Thread-basiert ab: Mehr Threads erhöhen den parallelen Durchsatz, nicht das Tempo einer einzelnen Lösung. Ein BASIC-Plan (15 $/Monat, 5 Threads) löst genauso schnell wie ein größerer Tarif, verarbeitet aber weniger Abfragen gleichzeitig.

Kann ich mehrere CAPTCHA-Typen in einem Lauf messen?

Ja. Rufen Sie benchmark_solve nacheinander mit unterschiedlichen Parametern auf, wie im Skript für reCAPTCHA v2 und Bild-CAPTCHAs gezeigt, und werten Sie jeden Typ getrennt aus.

Fehlerbehebung beim Benchmarking

Verwandte Leitfäden

• CaptchaAI in wenigen Minuten einrichten
• API-Antwortformate und Fehlercodes
• reCAPTCHA v2 per API lösen