Optimisation de la latence de l'API CaptchaAI : résolutions plus rapides

Une résolution CAPTCHA comporte quatre composants de latence : soumission de la demande, attente dans la file d'attente, exécution du solveur et récupération de l'interrogation. Vous ne pouvez pas contrôler le temps d’exécution du solveur, mais vous pouvez optimiser tout le reste.

Latence de base par type CAPTCHA

La colonne « meilleur réalisable » reflète ce que vous obtenez après avoir appliqué les optimisations ci-dessous.

1. Optimiser les intervalles d'interrogation

L'intervalle d'interrogation par défaut de 5 secondes fait perdre du temps lorsque la résolution se termine entre les interrogations. Utilisez l'interrogation adaptative : démarrez rapidement, puis reculez :

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

Permet d'économiser 1 à 4 secondes en moyenne par rapport à un intervalle fixe de 5 secondes.

2. Regroupement de connexions

Réutilisez les connexions HTTP au lieu d’en ouvrir de nouvelles pour chaque sondage :

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

Économise environ 50 à 100 ms par requête en ignorant les poignées de main TCP/TLS.

3. Prélecture des CAPTCHA

Soumettez des tâches CAPTCHA avant d’avoir besoin des jetons. Pendant que votre scraper traite la page N, soumettez le CAPTCHA pour la page 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)

Élimine le temps d'attente complet en chevauchant la résolution et le traitement.

4. Utilisez la bonne méthode CAPTCHA

CaptchaAI prend parfois en charge des méthodes plus rapides pour des scénarios spécifiques :

5. Ignorez le proxy lorsque vous n'en avez pas besoin

Le routage proxy ajoute de la latence. N'envoyez les paramètres de proxy que lorsque le site cible nécessite des requêtes provenant d'adresses IP spécifiques :

# 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. Utilisez des URL de rappel au lieu d'interroger

Éliminez complètement l'interrogation avec le paramètre 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 envoie le résultat à votre URL une fois la résolution terminée. Aucune boucle d’interrogation nécessaire. Il s'agit de la méthode de récupération la plus rapide.

7. Comparez vos optimisations

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

Dépannage

FAQ

Quelle est la plus grande optimisation ?

Prélecture. Il chevauche le temps de résolution avec le temps de traitement, réduisant ainsi la latence perçue à près de zéro pour les flux de travail séquentiels.

L'interrogation adaptative est-elle utile pour les CAPTCHA d'image ?

Moins. Les CAPTCHA d'image se résolvent en 2 à 5 secondes, donc le premier sondage à 3 secondes les détecte souvent. L'amélioration est plus visible pour reCAPTCHA (15-30 secondes).

Obtenez la résolution CAPTCHA la plus rapide avec CaptchaAI

Obtenez votre clé API surcaptchaai.com.

Guides associés

• Optimiser la vitesse et les coûts
• Résolution parallèle de CAPTCHA
• Paramètres de délai d'expiration personnalisés pour différents types de CAPTCHA