Gérer les CAPTCHAs lors du scraping

Pourquoi CAPTCHAs Est le plus gros obstacle du gratte-ciel

Les CAPTCHA existent pour distinguer les humains des robots, et ils y sont de plus en plus efficaces. Lorsque votre racleur rencontre un CAPTCHA, cela signifie que le site cible a détecté un comportement automatisé — votre fréquence de demande était trop élevée, votre IP a une faible confiance, ou votre empreinte digitale du navigateur semblait suspecte. La meilleure stratégie du CAPTCHA est la prévention et non la résolution.

Ce guide couvre les types de CAPTCHA que vous rencontrerez, pourquoi la prévention est plus efficace et moins coûteuse que la résolution, et comment les mandataires jouent un rôle crucial dans l'élimination complète des CAPTCHA.

Cet article fait partie de notre Guide complet des produits de scraping Web série. Pour comprendre les systèmes de détection, voir Comment les systèmes anti-bot détectent les proxies.

Types de CAPTCHA en 2026

CAPTCHA invisibles La véritable menace

Les CAPTCHA les plus dangereux pour les racleurs sont ceux que vous ne voyez jamais. ReCAPTCHA v3 et Turnsile nuageux Exécuter en arrière-plan, analyser les mouvements de la souris, faire défiler le comportement, taper les modèles et l'environnement du navigateur. Ils attribuent un score de confiance sans montrer aucun défi — et si le score est trop bas, la requête est silencieusement bloquée ou redirigée.

Prévention et résolution : pourquoi la prévention gagne

À l'échelle, la prévention permet d'économiser de l'argent et du temps. Résoudre 100 000 CAPTCHA par jour coûte de 100 à 500 $ et ajoute des heures de latence. Les prévenir ne coûte rien de plus qu'une bonne gestion des procurations et des demandes.

Stratégie de prévention 1 : Utiliser des solutions résidentielles de haute qualité

La mesure de prévention la plus efficace est l'utilisation de procurations résidentielles avec des scores de confiance élevés. Les IP résidentielles sont assignées aux ménages réels par les FAI, de sorte que les sites Web ne peuvent pas facilement distinguer vos demandes du trafic réel des utilisateurs.

import requests
# Residential proxy — high trust score, fewer CAPTCHAs
PROXY = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
def scrape_with_residential(url: str) -> str:
    """Use residential proxies to avoid triggering CAPTCHAs."""
    session = requests.Session()
    session.proxies = {"http": PROXY, "https": PROXY}
    session.headers.update({
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                      "AppleWebKit/537.36 (KHTML, like Gecko) "
                      "Chrome/120.0.0.0 Safari/537.36",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.9",
        "Accept-Encoding": "gzip, deflate, br",
    })
    resp = session.get(url, timeout=30)
    return resp.text

La piscine résidentielle de ProxyHat fournit des IP des FAI réels dans 190 pays et plus, donnant à chaque demande le score de confiance le plus élevé possible. Voir Proxies résidentielles vs datacenter pour le scraping pour une comparaison détaillée.

Stratégie de prévention 2 : Modèles de demandes réalistes

Les CAPTCHA sont souvent déclenchés par des modèles de comportement robotique, et pas seulement par la réputation IP. Faites en sorte que votre racleur soit humain :

Mise en œuvre de Python

import requests
import random
import time
PROXY = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 Safari/605.1.15",
]
REFERRERS = [
    "https://www.google.com/",
    "https://www.bing.com/",
    "https://duckduckgo.com/",
    None,  # Direct visit
]
def human_like_scrape(urls: list[str]) -> list[str]:
    """Scrape with realistic human behavior patterns."""
    results = []
    session = requests.Session()
    session.proxies = {"http": PROXY, "https": PROXY}
    for url in urls:
        # Randomize headers per request
        headers = {
            "User-Agent": random.choice(USER_AGENTS),
            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
            "Accept-Language": "en-US,en;q=0.9",
            "Accept-Encoding": "gzip, deflate, br",
            "Connection": "keep-alive",
            "Upgrade-Insecure-Requests": "1",
        }
        referrer = random.choice(REFERRERS)
        if referrer:
            headers["Referer"] = referrer
        try:
            resp = session.get(url, headers=headers, timeout=30)
            results.append(resp.text)
        except requests.RequestException:
            results.append(None)
        # Human-like delays: 1-5 seconds with occasional longer pauses
        if random.random() < 0.1:
            time.sleep(random.uniform(5, 15))  # 10% chance of long pause
        else:
            time.sleep(random.uniform(1, 4))
    return results

Mise en œuvre de Node.js

const HttpsProxyAgent = require('https-proxy-agent');
const fetch = require('node-fetch');
const agent = new HttpsProxyAgent('http://USERNAME:PASSWORD@gate.proxyhat.com:8080');
const USER_AGENTS = [
  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
  'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
];
function randomDelay() {
  const isLongPause = Math.random() < 0.1;
  const ms = isLongPause
    ? 5000 + Math.random() * 10000
    : 1000 + Math.random() * 3000;
  return new Promise(r => setTimeout(r, ms));
}
async function humanLikeScrape(urls) {
  const results = [];
  for (const url of urls) {
    const headers = {
      'User-Agent': USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)],
      'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
      'Accept-Language': 'en-US,en;q=0.9',
    };
    try {
      const res = await fetch(url, { agent, headers, timeout: 30000 });
      results.push(await res.text());
    } catch {
      results.push(null);
    }
    await randomDelay();
  }
  return results;
}

Stratégie de prévention 3 : Rotation intelligente de la propriété intellectuelle

La façon dont vous faites tourner les IP affecte directement les taux de CAPTCHA. Une rotation agressive (nouvelle IP chaque requête) peut en fait augmenter les CAPTCHA sur certains sites, car une série de requêtes de différentes IP accédant au même chemin de session semble suspecte.

import requests
import uuid
def create_session_for_site(site_id: str):
    """Create a sticky session that maintains the same IP per site.
    This avoids the suspicious pattern of different IPs accessing the same flow."""
    session_id = uuid.uuid5(uuid.NAMESPACE_URL, site_id).hex[:8]
    proxy = f"http://USERNAME-session-{session_id}:PASSWORD@gate.proxyhat.com:8080"
    session = requests.Session()
    session.proxies = {"http": proxy, "https": proxy}
    return session
# Same IP for all requests to a specific product section
session = create_session_for_site("example.com-electronics")
page1 = session.get("https://example.com/electronics?page=1")
page2 = session.get("https://example.com/electronics?page=2")
page3 = session.get("https://example.com/electronics?page=3")
# Different IP for a different section
session2 = create_session_for_site("example.com-clothing")
clothes1 = session2.get("https://example.com/clothing?page=1")

Pour plus de modèles de rotation, voir Stratégies de rotation par procuration pour le scrapage à grande échelle.

Stratégie de prévention 4 : Respecter les limites de taux

Les CAPTCHA sont souvent l'escalade après la limitation du taux. Si vous manipulez correctement les signaux limites de vitesse, vous voyez rarement les CAPTCHA :

import requests
import time
PROXY = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
CAPTCHA_INDICATORS = [
    "captcha",
    "recaptcha",
    "hcaptcha",
    "challenge",
    "verify you are human",
    "please complete the security check",
]
def is_captcha_page(html: str) -> bool:
    """Detect if the response is a CAPTCHA challenge page."""
    html_lower = html.lower()
    return any(indicator in html_lower for indicator in CAPTCHA_INDICATORS)
def scrape_with_captcha_detection(urls: list[str]) -> list[dict]:
    results = []
    session = requests.Session()
    session.proxies = {"http": PROXY, "https": PROXY}
    captcha_count = 0
    backoff = 2.0
    for url in urls:
        try:
            resp = session.get(url, timeout=30)
            if resp.status_code == 200 and not is_captcha_page(resp.text):
                results.append({"url": url, "status": "success", "body": resp.text})
                captcha_count = 0
                backoff = max(backoff * 0.9, 1.0)  # Reduce backoff on success
            elif is_captcha_page(resp.text) or resp.status_code == 403:
                captcha_count += 1
                results.append({"url": url, "status": "captcha"})
                if captcha_count >= 3:
                    # Too many CAPTCHAs — increase backoff significantly
                    backoff = min(backoff * 3, 60)
                    print(f"CAPTCHA streak: {captcha_count}. Backing off to {backoff:.0f}s")
                else:
                    backoff = min(backoff * 1.5, 30)
        except requests.RequestException as e:
            results.append({"url": url, "status": "error", "error": str(e)})
        time.sleep(backoff)
    return results

Pour des stratégies globales de limitation des taux, voir Limites de vitesse expliquées.

Quand vous devez manipuler CAPTCHAs : Détection et routage

Même avec une prévention parfaite, certains CAPTCHA sont inévitables. Construisez la détection dans votre pipeline afin que vous puissiez parcourir les pages CAPTCHA pour une manipulation spéciale:

import requests
from enum import Enum
PROXY = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
class ResponseType(Enum):
    SUCCESS = "success"
    CAPTCHA = "captcha"
    BLOCKED = "blocked"
    ERROR = "error"
def classify_response(resp: requests.Response) -> ResponseType:
    """Classify a response to determine next action."""
    if resp.status_code == 403:
        return ResponseType.BLOCKED
    if resp.status_code == 429:
        return ResponseType.BLOCKED
    if resp.status_code == 200:
        html = resp.text.lower()
        captcha_signals = ["captcha", "recaptcha", "hcaptcha", "cf-challenge"]
        if any(s in html for s in captcha_signals):
            return ResponseType.CAPTCHA
        return ResponseType.SUCCESS
    return ResponseType.ERROR
def scrape_with_routing(urls: list[str]) -> dict:
    """Scrape URLs and route based on response classification."""
    session = requests.Session()
    session.proxies = {"http": PROXY, "https": PROXY}
    results = {"success": [], "captcha": [], "blocked": [], "error": []}
    for url in urls:
        try:
            resp = session.get(url, timeout=30)
            response_type = classify_response(resp)
            results[response_type.value].append(url)
            if response_type == ResponseType.CAPTCHA:
                # Route to CAPTCHA queue for manual or service-based solving
                print(f"CAPTCHA detected: {url}")
            elif response_type == ResponseType.BLOCKED:
                # Rotate IP and retry
                print(f"Blocked: {url}")
        except requests.RequestException:
            results["error"].append(url)
    print(f"Success: {len(results['success'])}, "
          f"CAPTCHAs: {len(results['captcha'])}, "
          f"Blocked: {len(results['blocked'])}")
    return results

Liste de contrôle pour la prévention du CAPTCHA

• Utilisez des procurations résidentielles. Ils ont les scores de confiance les plus élevés et déclenchent les plus rares CAPTCHA. ProxyHat proxies résidentielles fournir des millions de PI propres.
• Définir des en-têtes réalistes. Toujours envoyer User-Agent, Accepter, Accepter-Langue, et d'autres en-têtes de navigateur standard.
• Ajoutez des retards humains. Aléatoire 1-5 secondes de retard entre les demandes avec des pauses occasionnelles plus longues.
• Maintenez les séances correctement. Utiliser des cookies et des IP cohérents pour les requêtes connexes via des sessions collantes.
• Respectez robots.txt. Les sites qui détectent les violations de robots.txt s'aggravent vers CAPTCHAs plus rapidement.
• Surveiller les taux de CAPTCHA. Si votre taux CAPTCHA dépasse 5 %, votre approche doit être corrigée.
• Évitez de gratter pendant les heures de pointe. Les systèmes anti-bots sont plus agressifs pendant les périodes de forte circulation.
• Rotation des agents utilisateurs correctement. Utilisez des chaînes de navigateur récentes et réalistes. Ne mélangez pas les UA mobiles et de bureau sur la même session.

Pour la configuration de proxy dans votre langue préférée, voir Utilisation de Proxies dans Python, Utilisation de Proxies dans Node.jsou Utilisation de Proxies dans Go. Explorer ProxyHat pour le scraping Web pour commencer.

Foire aux questions

Les procurations peuvent-elles aider à éviter les CAPTCHA?

Oui, de façon significative. Les mandataires résidentiels de haute qualité ont une réputation IP propre qui déclenche rarement les CAPTCHA. Les IP des centres de données sont signalés plus souvent parce qu'ils sont des sources automatisées connues. La combinaison de procurations résidentielles et de modèles de demande appropriés élimine pratiquement les CAPTCHA pour la plupart des cibles.

Quelle est la façon la moins chère de traiter les CAPTCHA à l'échelle?

Prévention. Investir dans des solutions résidentielles et des modèles de démolition adéquats coûte beaucoup moins cher que les services de résolution CAPTCHA à l'échelle. Si vous devez résoudre les CAPTCHA, les services tiers coûtent 1-3 $ par 1 000 $, mais ajoutez 10-60 secondes de latence par demande.

Les navigateurs sans tête aident-ils les CAPTCHA?

Ils aident avec les CAPTCHA invisibles (reCAPTCHA v3, Turnstile) en fournissant un environnement de navigateur réel avec l'exécution JavaScript. Toutefois, ils sont plus lents et nécessitent davantage de ressources. Utilisez-les uniquement pour les cibles qui nécessitent spécifiquement une vérification au niveau du navigateur.

Comment puis-je savoir si je reçois des pages de la CAPTCHA?

Vérifiez la réponse HTML pour les indicateurs CAPTCHA: "captcha", "recaptcha", "hcaptcha", "challenge", ou "vérifier que vous êtes humain". Regardez également les réponses inattendues 403 et redirige vers les URLs de défi. Construisez une détection automatisée dans votre pipeline de démolition.

Pourquoi ai-je toujours des CAPTCHA avec des procurations résidentielles ?

Habituellement en raison des modèles de requête, pas la qualité IP. Causes courantes : trop de requêtes par minute, des en-têtes de navigateur manquants, des problèmes de gestion des cookies ou des modèles de grattage trop systématiques. Ralentissez, ajoutez des jitters et utilisez des sessions collantes pour les demandes connexes.