La plupart des codes de proxy n'ont qu'un seul chemin d'erreur — tout attraper, tourner, réessayer — et ce chemin unique est la raison pour laquelle les pools s'épuisent et les cibles escaladent. Une requête proxy échouée est l'un de cinq événements différents : le proxy lui-même était injoignable ; le proxy a refusé vos identifiants ; la cible a refusé cette IP ; la cible vous a limité en débit ; ou la cible a répondu 200 avec une page de défi au lieu du contenu. La rotation aide avec exactement un de ceux-là. Réessayer immédiatement n'aide avec aucun. Ce guide classe les échecs, puis construit une couche de réessai Python compacte qui répond correctement à chacun, avec backoff exponentiel, rotation uniquement là où elle s'applique, et un disjoncteur pour qu'une cible qui a dit « stop » soit réellement laissée tranquille. Les extraits utilisent requests ; la logique se porte directement vers httpx et aiohttp (noms de paramètres dans Proxies in Python).
Les cinq échecs
| # | Ce qui s'est passé | Comment cela se manifeste en Python | Réponse appropriée |
|---|---|---|---|
| 1 | Proxy injoignable — mauvais hôte/port, panne du fournisseur, réseau | ProxyError enveloppant une erreur de connexion ; ConnectTimeout avant tout HTTP | Réessayer avec backoff ; après N échecs, marquer le point de terminaison du proxy comme hors service et alerter. La rotation au sein de la même passerelle n'aidera pas si la passerelle est en panne. |
| 2 | Le proxy vous a rejeté — mauvais identifiants, IP non autorisée, plan épuisé | ProxyError avec 407 ; parfois 4xx spécifique au fournisseur depuis la passerelle | Ne réessayez pas. Corrigez la configuration ; réessayer un 407 en boucle peut faire limiter votre compte par le fournisseur. |
| 3 | La cible a refusé cette IP — réputation, ASN, blocage géographique | 403, parfois 401/451 ; occasionnellement une réinitialisation de connexion | Tournez vers une nouvelle sortie (nouvel ID de session) et un nouveau cookie jar ; réessayez une ou deux fois ; si cela persiste à travers les IP, le problème est l'empreinte ou le type, pas l'IP — arrêtez et réévaluez (pourquoi). |
| 4 | La cible vous a limité en débit | 429, ou 503 avec Retry-After | Dormez Retry-After (ou backoff) sur cette sortie ; puis continuez dessus. Tourner au lieu d'attendre propage le blocage. Voir signaux de limite de débit. |
| 5 | Défi servi en 200 — page CAPTCHA/interstitielle | Statut 200 mais le corps n'est pas le contenu attendu | Traitez comme un échec de type 3. Détectez-le par le contenu (texte marqueur, élément attendu manquant, corps trop petit), jamais par le statut seul. |
| — | Réseau transitoire / 5xx de la cible | ReadTimeout, ConnectionError en cours de flux, 500/502/504 | Réessayez avec backoff sur la même sortie ; ce n'est généralement pas à cause de vous. |
Le tableau est tout l'article ; tout ce qui suit consiste à faire obéir un programme à ce tableau.
Classifiez d'abord
import requests
from enum import Enum
class Fail(Enum):
NONE = 0; PROXY_DOWN = 1; PROXY_AUTH = 2; IP_BLOCKED = 3; RATE_LIMITED = 4; CHALLENGE = 5; TRANSIENT = 6
CHALLENGE_MARKERS = (b"captcha", b"cf-chl", b"challenge-platform", b"datadome", b"px-captcha")
def classify(resp: requests.Response | None, exc: Exception | None, min_bytes: int = 2000) -> Fail:
if exc is not None:
if isinstance(exc, requests.exceptions.ProxyError):
return Fail.PROXY_AUTH if "407" in str(exc) else Fail.PROXY_DOWN
if isinstance(exc, (requests.exceptions.ConnectTimeout,)):
return Fail.PROXY_DOWN # n'a jamais atteint le proxy (ou il n'a jamais répondu à CONNECT)
if isinstance(exc, (requests.exceptions.ReadTimeout, requests.exceptions.ConnectionError)):
return Fail.TRANSIENT
return Fail.TRANSIENT
s = resp.status_code
if s == 429 or (s == 503 and "Retry-After" in resp.headers):
return Fail.RATE_LIMITED
if s in (401, 403, 451):
return Fail.IP_BLOCKED
if s >= 500:
return Fail.TRANSIENT
if s == 200:
body = resp.content[:20000].lower()
if len(resp.content) < min_bytes or any(m in body for m in CHALLENGE_MARKERS):
return Fail.CHALLENGE
return Fail.NONE
return Fail.TRANSIENT
Réglez CHALLENGE_MARKERS et min_bytes par cible : le contrôle fiable est « la page contient-elle l'élément que je suis venu chercher ? » — un titre de produit, une clé JSON — et son absence est le signal de défi.
Backoff, fait correctement
Backoff exponentiel avec jitter : les délais de doublement étalent les nouvelles tentatives ; le jitter empêche une centaine de travailleurs de réessayer en synchronisation. Honorez Retry-After lorsqu'il existe.
import random, time, email.utils
def backoff_delay(attempt: int, base: float = 1.0, cap: float = 60.0) -> float:
return random.uniform(0, min(cap, base * (2 ** attempt))) # "full jitter"
def retry_after_seconds(resp: requests.Response | None) -> float | None:
if resp is None or "Retry-After" not in resp.headers:
return None
v = resp.headers["Retry-After"].strip()
if v.isdigit():
return float(v)
dt = email.utils.parsedate_to_datetime(v) # forme HTTP-date
return max(0.0, dt.timestamp() - time.time()) if dt else None
Un disjoncteur par (cible, sortie)
Lorsqu'une cible a refusé une sortie plusieurs fois de suite, arrêtez de proposer cette sortie à cette cible pendant un certain temps au lieu de découvrir le blocage à chaque requête. Même idée pour un point de terminaison de proxy en panne.
import time
from collections import defaultdict
class Breaker:
def __init__(self, threshold=3, cooldown=300):
self.fail = defaultdict(int); self.open_until = {}
self.threshold, self.cooldown = threshold, cooldown
def allow(self, key) -> bool:
return time.time() >= self.open_until.get(key, 0)
def ok(self, key):
self.fail[key] = 0
def bad(self, key):
self.fail[key] += 1
if self.fail[key] >= self.threshold:
self.open_until[key] = time.time() + self.cooldown
self.fail[key] = 0
Assemblage
import secrets
GATE, PORT, PASS = "gate.provider.com", 7777, "PASSWORD"
breaker = Breaker()
def proxies_for(session_id: str) -> dict:
url = f"http://customer-session-{session_id}:{PASS}@{GATE}:{PORT}"
return {"http": url, "https": url}
def fetch(url: str, host: str, max_attempts: int = 5, timeout=(10, 30)) -> requests.Response | None:
sid = secrets.token_hex(4)
sess = requests.Session()
for attempt in range(max_attempts):
key = (host, sid)
if not breaker.allow(key) or not breaker.allow(("gateway", GATE)):
sid = secrets.token_hex(4); sess = requests.Session(); continue # choisir une sortie différente
resp = exc = None
try:
resp = sess.get(url, proxies=proxies_for(sid), timeout=timeout)
except requests.RequestException as e:
exc = e
kind = classify(resp, exc)
if kind is Fail.NONE:
breaker.ok(key); breaker.ok(("gateway", GATE)); return resp
if kind is Fail.PROXY_AUTH:
raise RuntimeError("proxy a rejeté les identifiants/la liste blanche — corrigez la config, pas les réessais")
if kind is Fail.PROXY_DOWN:
breaker.bad(("gateway", GATE)); time.sleep(backoff_delay(attempt, base=2)); continue
if kind is Fail.RATE_LIMITED:
time.sleep(retry_after_seconds(resp) or backoff_delay(attempt, base=5)); continue # même sortie
if kind in (Fail.IP_BLOCKED, Fail.CHALLENGE):
breaker.bad(key)
sid = secrets.token_hex(4); sess = requests.Session() # nouvelle sortie + cookies frais
time.sleep(backoff_delay(attempt)); continue
# TRANSIENT
time.sleep(backoff_delay(attempt)); continue
return None
Ce que cela fait que la boucle naïve ne fait pas : cela ne réessaie jamais un 407 ; cela attend sur les limites de débit au lieu de sauter ; cela ne tourne que sur les refus au niveau IP et les défis, et associe chaque rotation à un nouveau cookie jar (les mêmes cookies sur une nouvelle IP, c'est le même visiteur) ; cela cesse de proposer une sortie qui échoue continuellement sur un hôte ; et cela fait un backoff avec jitter partout. Branchez les compteurs Fail dans vos métriques — un taux de IP_BLOCKED en hausse à travers des sorties différentes signifie que l'empreinte ou le type d'IP est incorrect, et aucune politique de réessai ne corrigera cela (voir l'empreinte TLS et le choix du type d'IP).
Utiliser une bibliothèque à la place
tenacity vous donne des décorateurs pour les conditions de réessai/backoff/arrêt et constitue une bonne base — mais gardez la classification et la décision « tourner vs attendre vs arrêter » dans votre propre code ; les bibliothèques de réessai génériques traitent toutes les exceptions de la même manière, ce qui est précisément l'erreur. L'objet Retry d'urllib3 (montable sur un HTTPAdapter de requests) gère bien les réessais au niveau de la connexion et Retry-After pour 429/503, et vaut la peine d'être utilisé pour les classes TRANSIENT et RATE_LIMITED ; il ne peut pas faire tourner votre proxy ni détecter un corps de défi, donc il complète plutôt qu'il ne remplace la couche ci-dessus.
Note asynchrone
Dans aiohttp/httpx.AsyncClient, la structure est identique avec await asyncio.sleep() ; la seule addition est un sémaphore par hôte pour que le backoff sur un hôte ne bloque pas les autres, et que la concurrence par hôte reste polie. Un sémaphore global seul permet à une centaine de coroutines de s'empiler sur une seule cible dès qu'elle est la seule à ne pas dormir.
Questions fréquemment posées
Dois-je faire tourner le proxy à chaque erreur ?
Non. Tournez sur les refus au niveau IP (classe 403) et les pages de défi, toujours avec un nouveau cookie jar. Attendez — ne tournez pas — sur 429/Retry-After. Corrigez la configuration sur 407. Réessayez la même sortie sur les erreurs transitoires et les 5xx.
Combien de fois dois-je réessayer ?
Trois à cinq tentatives avec backoff exponentiel et jitter est l'enveloppe habituelle ; au-delà, vous faites face soit à un blocage persistant (limite de rotation atteinte) soit à une panne (le disjoncteur devrait être ouvert). Plafonnez le temps total par requête.
Comment détecter une page CAPTCHA dans le code ?
Par le contenu, pas le statut : vérifiez l'élément attendu (un titre, une clé JSON), les marqueurs de défi connus dans le corps, et une réponse anormalement petite. Un 200 sans votre contenu est un échec.
Qu'est-ce qu'un disjoncteur pour les proxies ?
Un compteur par (cible, sortie) qui, après plusieurs échecs consécutifs, cesse d'utiliser cette sortie pour cette cible pendant une période de refroidissement — afin de ne pas redécouvrir le blocage à chaque requête et de ne pas continuer à marteler un hôte qui vous a refusé.
Pourquoi ne pas simplement utiliser tenacity ou urllib3 Retry ?
Utilisez-les pour les réessais transitoires et de limite de débit ; mais ils ne peuvent pas distinguer un 407 d'un 403 d'un défi, ne peuvent pas faire tourner votre ID de session, et ne peuvent pas réinitialiser les cookies. Gardez cette logique de décision dans votre code.
Que signifie un taux de blocage en hausse à travers de nombreuses IP ?
Que les IP ne sont pas le problème : la cible vous identifie par l'empreinte TLS/HTTP, les en-têtes ou le comportement, ou le type d'IP est incorrect pour ce site. Arrêtez de tourner et corrigez la couche qui échoue réellement.