Analyse comparative des temps de résolution de CAPTCHA pour tous les types avec CaptchaAI

Dix secondes de délai supplémentaire par résolution se traduit par des heures de retard sur des milliers de tâches. Ce guide fournit des références reproductibles pour chaque type de CAPTCHA pris en charge par CaptchaAI, ainsi que des scripts pour exécuter vos propres mesures.

Temps de résolution typiques

Ces benchmarks reflètent les temps médians de 100 résolutions consécutives par type, mesurés depuis la soumission de l'API jusqu'à la récupération des résultats :

Les délais varient en fonction de la qualité du proxy, de la charge du serveur et de la complexité du CAPTCHA.

Facteurs affectant le temps de résolution

Latence du réseau

Votre distance par rapport aux points de terminaison de l'API de CaptchaAI ajoute du temps aller-retour. Un RTT de 200 ms ajoute environ 1 seconde au total (soumission + 3 à 4 sondages × 200 ms).

Qualité du proxy

Lors de l'utilisation de proxys, les proxys résidentiels produisent généralement des résolutions plus rapides que les proxys de centre de données, car ils déclenchent moins de défis secondaires.

Complexité du CAPTCHA

Les défis d'image reCAPTCHA v2 varient en difficulté. Un défi « sélectionner des feux de circulation » avec des images qui s'estompent prend plus de temps qu'une simple vérification d'une case à cocher.

Stratégie de sondage

Une interrogation agressive (toutes les 2 secondes) détecte les résultats plus rapidement mais augmente les appels d'API. Une interrogation conservatrice (toutes les 10 secondes) réduit la charge mais ajoute de la latence.

Script de référence 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)

Script de référence 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);
})();

Interprétation des résultats

Médiane vs P90

• Médiane — L'expérience typique. Utilisez-le pour la planification des capacités.
• P90 — Le « pire des cas » pour 9 résolutions sur 10. Utilisez-le pour les paramètres de délai d'attente.
• P99 — Le véritable cas de pointe. Définissez votre délai d'attente maximum plus haut que cela.

Intervalles d'interrogation optimaux

Sur la base des tests ci-dessus, configurez l'interrogation par type CAPTCHA :

Dépannage

FAQ

Les temps de résolution varient-ils selon l’heure de la journée ?

Oui. Les heures de pointe (heures ouvrables aux États-Unis) peuvent afficher des temps de résolution légèrement plus longs en raison d'une demande plus élevée. Exécutez des benchmarks à différents moments pour une image complète.

Dois-je utiliser ces données pour les paramètres de délai d’expiration de la production ?

Utilisez les valeurs P90 pour les délais d'attente standard et P99 pour les délais d'attente maximum. Ajoutez un tampon de 20 % pour tenir compte de la variabilité du réseau.

Comment les paramètres de proxy affectent-ils les temps de résolution ?

Si vous fournissez un proxy, CaptchaAI achemine la résolution via celui-ci. Les proxys lents ou distants peuvent ajouter 5 à 15 secondes au temps de résolution total. Pour l’analyse comparative, testez séparément avec et sans proxy.

Articles connexes

• Résoudre le flux de travail de plusieurs types de Captcha
• Matrice des fonctionnalités des types de Captcha pris en charge par Captchaai

Prochaines étapes

Exécutez les scripts de référence sur votre propre compte et les cibles CAPTCHA – récupérez votre clé API CaptchaAI.

Guides associés :

• Optimiser la vitesse et les coûts
• Optimisation de la latence CaptchaAI
• Résolution parallèle de CAPTCHA