Connexion Keep-Alive et HTTP/2 pour des appels API CAPTCHA plus rapides (guide complet)

Chaque résolution CAPTCHA implique plusieurs requêtes HTTP : une soumission et 3 à 10 interrogations. Sans réutilisation de connexion, chaque requête paie le coût d'une nouvelle prise de contact TCP et d'une nouvelle négociation TLS – 100 à 300 ms par connexion. Ce guide montre comment éliminer cette surcharge en utilisant des connexions persistantes et le multiplexage HTTP/2 avecCaptchaAI.

Pourquoi la réutilisation des connexions est importante

Une résolution typique de reCAPTCHA v2 nécessite :

1 soumettre une demande à in.php
4 à 6 demandes de sondage à res.php
Total : 5 à 7 requêtes HTTP

Sans keep-alive :

5 × (prise de contact TCP ~ 50 ms + TLS ~ 100 ms) = 750 ms de surcharge

Avec keep-alive :

1 × (TCP + TLS) + 4 × (réutilisation d'environ 5 ms) = 170 ms de surcharge

Économies : environ 580 ms par résolution. À 10 000 résolutions/day, cela représente 1,6 heure de latence économisée.

Python : Utilisation de requêtes.Session

La bibliothèque requests prend en charge le maintien par défaut lorsque vous utilisez un objet Session :

# keepalive_solver.py
import os
import time
import requests

API_KEY = os.environ.get("CAPTCHAAI_KEY", "YOUR_API_KEY")

# Create a session — reuses TCP connections across requests
session = requests.Session()
session.headers.update({"Connection": "keep-alive"})

def solve_captcha(sitekey, pageurl):
    """Solve reCAPTCHA v2 using a persistent connection."""
    # Submit — uses existing connection if available
    resp = session.get("https://ocr.captchaai.com/in.php", params={
        "key": API_KEY,
        "method": "userrecaptcha",
        "googlekey": sitekey,
        "pageurl": pageurl,
        "json": "1",
    })
    result = resp.json()

    if result.get("status") != 1:
        raise Exception(f"Submit failed: {result.get('request')}")

    task_id = result["request"]

    # Poll — reuses the same connection
    time.sleep(15)
    for _ in range(25):
        poll = session.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:
            return poll_result["request"]
        if poll_result.get("request") != "CAPCHA_NOT_READY":
            raise Exception(f"Error: {poll_result.get('request')}")

        time.sleep(5)

    raise Exception("Timeout")

# Solve multiple CAPTCHAs reusing the same connection
for i in range(5):
    token = solve_captcha(
        "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
        "https://www.google.com/recaptcha/api2/demo"
    )
    print(f"Solve {i+1}: {token[:30]}...")

Python : HTTP/2 avec httpx

Pour la prise en charge de HTTP/2, utilisez httpx :

# http2_solver.py
import os
import time
import httpx

API_KEY = os.environ.get("CAPTCHAAI_KEY", "YOUR_API_KEY")
BASE_URL = "https://ocr.captchaai.com"

# HTTP/2 client with connection pooling
client = httpx.Client(http2=True, timeout=30.0)

def solve_captcha(sitekey, pageurl):
    """Solve using HTTP/2 multiplexed connections."""
    resp = client.get(f"{BASE_URL}/in.php", params={
        "key": API_KEY,
        "method": "userrecaptcha",
        "googlekey": sitekey,
        "pageurl": pageurl,
        "json": "1",
    })
    result = resp.json()

    if result.get("status") != 1:
        raise Exception(f"Submit failed: {result.get('request')}")

    task_id = result["request"]
    time.sleep(15)

    for _ in range(25):
        poll = client.get(f"{BASE_URL}/res.php", params={
            "key": API_KEY, "action": "get",
            "id": task_id, "json": "1",
        })
        poll_result = poll.json()

        if poll_result.get("status") == 1:
            return poll_result["request"]
        if poll_result.get("request") != "CAPCHA_NOT_READY":
            raise Exception(f"Error: {poll_result.get('request')}")

        time.sleep(5)

    raise Exception("Timeout")

# Multiple solves over a single HTTP/2 connection
for i in range(5):
    token = solve_captcha(
        "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
        "https://www.google.com/recaptcha/api2/demo"
    )
    print(f"Solve {i+1}: {token[:30]}...")

client.close()

JavaScript : utilisation d'une instance Axios avec Keep-Alive

// keepalive_solver.js
const axios = require('axios');
const http = require('http');
const https = require('https');

const API_KEY = process.env.CAPTCHAAI_KEY || 'YOUR_API_KEY';

// Create agents with keep-alive enabled
const httpAgent = new http.Agent({ keepAlive: true, maxSockets: 10 });
const httpsAgent = new https.Agent({ keepAlive: true, maxSockets: 10 });

// Axios instance with persistent connections
const api = axios.create({
  baseURL: 'https://ocr.captchaai.com',
  httpAgent,
  httpsAgent,
  timeout: 30000,
});

async function solveCaptcha(sitekey, pageurl) {
  // Submit — reuses connection
  const submit = await api.get('/in.php', {
    params: {
      key: API_KEY, method: 'userrecaptcha',
      googlekey: sitekey, pageurl, json: '1',
    },
  });

  if (submit.data.status !== 1) throw new Error(submit.data.request);
  const taskId = submit.data.request;

  // Poll — reuses same connection
  await new Promise(r => setTimeout(r, 15000));
  for (let i = 0; i < 25; i++) {
    const poll = await api.get('/res.php', {
      params: { key: API_KEY, action: 'get', id: taskId, json: '1' },
    });

    if (poll.data.status === 1) return poll.data.request;
    if (poll.data.request !== 'CAPCHA_NOT_READY') throw new Error(poll.data.request);
    await new Promise(r => setTimeout(r, 5000));
  }
  throw new Error('Timeout');
}

(async () => {
  for (let i = 0; i < 5; i++) {
    const token = await solveCaptcha(
      '6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-',
      'https://www.google.com/recaptcha/api2/demo'
    );
    console.log(`Solve ${i + 1}: ${token.slice(0, 30)}...`);
  }

  // Clean up agents
  httpAgent.destroy();
  httpsAgent.destroy();
})();

HTTP/2 vs HTTP/1.1 pour la résolution de CAPTCHA

Caractéristique	HTTP/1.1 Keep-Alive	HTTP/2
Réutilisation des connexions	Oui (séquentiel)	Oui (multiplexé)
Flux simultanés	1 par connexion	Jusqu'à 100+ par connexion
Compression d'en-tête	Non	Compression HPACK
Réduction de la latence	~60%	~70%
Prise en charge du navigateur nécessaire	Non	Non (appels API)
Idéal pour	Résolutions séquentielles	Résolutions parallèles

Pour une résolution séquentielle (un CAPTCHA à la fois), le keep-alive HTTP/1.1 est suffisant. Pour la résolution parallèle (plusieurs CAPTCHA simultanément), le multiplexage HTTP/2 offre un avantage supplémentaire en partageant une seule connexion.

Dimensionnement du pool de connexions

Faites correspondre la taille de votre pool à votre niveau de simultanéité :

Résolutions simultanées	Taille de piscine recommandée
1–5	5 connexions
5-20	10 connexions
20-50	25 connexions
50-100	50 connexions
100+	Utiliser HTTP/2 (1 connexion)

Les pools surdimensionnés gaspillent de la mémoire. Les pools sous-dimensionnés obligent à de nouvelles connexions, annulant ainsi les avantages du maintien en vie.

Dépannage

Problème	Parce que	Corriger
Connexions fermées entre les sondages	Expiration du délai du serveur ou du proxy	Définissez le délai d'expiration `keep-alive` > 30 s dans la configuration du client.
Aucune amélioration des performances	Vous utilisez déjà keep-alive (par défaut dans certaines bibliothèques)	Vérifiez avec les outils de surveillance du réseau
Erreurs de connexion refusée	Piscine épuisée	Augmentez `maxSockets` ou réduisez la simultanéité
HTTP/2 non négocié	Le serveur ne prend pas en charge h2	Revenez à HTTP/1.1 keep-alive

FAQ

CaptchaAI prend-il en charge HTTP/2 ?

Testez avec curl --http2 https://ocr.captchaai.com/res.php pour vérifier. Si le serveur négocie h2, votre client HTTP/2 en bénéficiera. Sinon, revenez à HTTP/1.1 keep-alive.