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

Sur les types pris en charge, CaptchaAI résout la plupart des CAPTCHA en quelques secondes : moins de 4 s pour reCAPTCHA v3, moins de 10 s pour Cloudflare Turnstile, sous la seconde pour l'image/OCR. Mais ces chiffres ne comptent vraiment que mesurés dans votre environnement. Cet article donne les temps observés par type — médiane, P90 et P99 — et les scripts Python et JavaScript pour les mesurer sur votre compte CaptchaAI.

Temps de résolution observés par type

Les chiffres ci-dessous reposent sur des mesures observées et des retours d'utilisateurs. Les résultats varient selon l'environnement, le volume et le moment de la journée.

La colonne « Plafond SLA » reprend le plafond contractuel annoncé par CaptchaAI ; la médiane et les percentiles sont observés en production avec des proxys réalistes.

Le plafond SLA est une limite contractuelle, pas une moyenne : si une résolution le dépasse durablement, ouvrez un ticket de support.

Ce qui change vos temps de résolution

Quatre facteurs pèsent sur chaque mesure ; isolez-les avant de comparer deux exécutions :

• Latence réseau — votre distance aux endpoints de l'API s'ajoute au total. Depuis un worker en Europe (OVHcloud à Roubaix, Scaleway à Paris, région AWS eu-west-3), comptez environ 1 s de plus pour un RTT de 200 ms. Mesurez depuis l'infrastructure qui exécutera les résolutions, pas votre poste local.
• Qualité du proxy — les proxys résidentiels donnent des résolutions plus rapides que les proxys datacenter, car ils déclenchent moins de défis secondaires ; un proxy lent ou distant ajoute plusieurs secondes.
• Complexité du CAPTCHA — un défi d'images reCAPTCHA v2 « feux de circulation » avec images qui s'estompent prend bien plus de temps qu'une case à cocher : la médiane lisse cette variabilité, le P90 la rend visible.
• Stratégie de polling — interroger toutes les 2 s détecte le résultat plus tôt mais multiplie les appels d'API ; toutes les 10 s allège la charge mais rallonge la latence perçue. Le bon rythme dépend du type (voir le tableau).

Lire la médiane, le P90 et le P99

Trois valeurs suffisent à dimensionner une intégration :

• Médiane — l'expérience typique. Utilisez-la pour le dimensionnement des capacités.
• P90 — le pire cas pour 9 résolutions sur 10. La bonne base pour vos timeouts standards.
• P99 — le vrai cas extrême. Placez votre timeout maximal au-dessus, sinon vous couperez des résolutions qui allaient aboutir.

Mesurez vos propres temps en Python

Ce script soumet une tâche, interroge le résultat, puis calcule médiane, P90, min et max. Renseignez votre clé via la variable d'environnement CAPTCHAAI_KEY.

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

Le même benchmark en JavaScript (Node.js)

La logique est identique côté Node.js, avec axios pour les appels.

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

Réglez vos intervalles de polling par type

Dépannage

FAQ

Combien de résolutions faut-il mesurer pour un benchmark représentatif ?

Au moins 50 par type. En dessous, la variation de difficulté fausse la médiane et rend le P90 instable. Répétez la mesure à différents moments : les heures ouvrables aux États-Unis allongent légèrement les temps.

Quelles valeurs utiliser pour régler mes timeouts en production ?

Prenez le P90 pour vos timeouts standards et le P99 pour le timeout maximal, puis ajoutez une marge d'environ 20 % pour la variabilité réseau. Ne dérivez pas un timeout unique de la médiane : vous couperiez trop de résolutions lentes mais valides.

Un benchmark entame-t-il mon solde CaptchaAI ?

La facturation est basée sur les threads, avec des résolutions illimitées par thread : un benchmark occupe vos threads le temps des résolutions, sans frais par résolution. Prévoyez un solde actif, sinon vous verrez ERROR_ZERO_BALANCE.

reCAPTCHA v3 est-il réellement plus rapide que reCAPTCHA v2 ?

Oui, nettement. reCAPTCHA v3 se résout en général en 1 à 3 s (plafond < 4 s), là où reCAPTCHA v2 demande 12 à 18 s en médiane à cause des défis d'images. Réglez donc vos timeouts par type, pas une valeur unique pour tout le trafic.

Articles connexes

• Résoudre plusieurs types de CAPTCHA dans un même workflow
• La matrice des types de CAPTCHA pris en charge
• Optimiser la vitesse et le coût de résolution
• Optimiser la latence de l'API
• La résolution parallèle des CAPTCHA

Pour commencer

Lancez les scripts ci-dessus sur votre propre compte et vos cibles CAPTCHA : récupérez votre clé API CaptchaAI.