CaptchaAI API-Latenzoptimierung: Schnellere Lösungen

Eine CAPTCHA-Lösung besteht aus vier Latenzkomponenten: Anforderung senden, Warten in der Warteschlange, Solver-Ausführung und Abfrageabruf. Sie können die Ausführungszeit des Solvers nicht steuern, aber Sie können alles andere optimieren.

Grundlatenz nach CAPTCHA-Typ

Die Spalte „Bestmögliches“ gibt an, was Sie nach Anwendung der unten aufgeführten Optimierungen erhalten.

1. Optimieren Sie die Abfrageintervalle

Das standardmäßige Abfrageintervall von 5 Sekunden verschwendet Zeit, wenn die Lösung zwischen den Abfragen abgeschlossen ist. Nutzen Sie adaptives Polling – schnell beginnen und dann wieder aufhören:

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

Spart durchschnittlich 1–4 Sekunden im Vergleich zu einem festen 5-Sekunden-Intervall.

2. Verbindungspooling

Verwenden Sie HTTP-Verbindungen wieder, anstatt für jede Umfrage neue zu öffnen:

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

Spart ca. 50–100 ms pro Anfrage, indem TCP/TLS-Handshakes übersprungen werden.

3. CAPTCHAs vorab abrufen

Senden Sie CAPTCHA-Aufgaben, bevor Sie die Token benötigen. Während Ihr Scraper Seite N verarbeitet, senden Sie das CAPTCHA für Seite 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)

Eliminiert die gesamte Wartezeit durch Überlappung der Lösung mit der Verarbeitung.

4. Verwenden Sie die richtige CAPTCHA-Methode

CaptchaAI unterstützt manchmal schnellere Methoden für bestimmte Szenarien:

5. Überspringen Sie den Proxy, wenn er nicht benötigt wird

Proxy-Routing erhöht die Latenz. Senden Sie Proxy-Parameter nur, wenn die Zielsite Anforderungen von bestimmten IPs erfordert:

# 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. Verwenden Sie Rückruf-URLs anstelle von Abfragen

Eliminieren Sie die Abfrage vollständig mit dem 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 sendet das Ergebnis an Ihre URL, wenn die Lösung abgeschlossen ist. Keine Abfrageschleife erforderlich. Dies ist die schnellste Abrufmethode.

7. Benchmarken Sie Ihre Optimierungen

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

Fehlerbehebung

FAQ

Was ist die größte Einzeloptimierung?

Vorabholen. Es überlappt die Lösungszeit mit der Verarbeitungszeit und reduziert so die wahrgenommene Latenz bei sequentiellen Arbeitsabläufen effektiv auf nahezu Null.

Hilft adaptives Polling bei Bild-CAPTCHAs?

Weniger. Bild-CAPTCHAs lösen sich in 2–5 Sekunden auf, daher werden sie oft schon bei der ersten Umfrage nach 3 Sekunden erkannt. Die Verbesserung ist bei reCAPTCHA deutlicher spürbar (15–30 Sekunden).

Holen Sie sich die schnellste CAPTCHA-Lösung mit CaptchaAI

Holen Sie sich Ihren API-Schlüssel unter captchaai.com.

Verwandte Leitfäden

• Parallele vs. sequenzielle CAPTCHA-Leistung
• Connection-Keepalive und HTTP/2 für CAPTCHA-API
• Rate-Limits und Drosselung