Die meisten Proxy-Codes haben einen Fehlerpfad — alles abfangen, rotieren, erneut versuchen — und genau dieser eine Pfad ist der Grund, warum Pools ausbrennen und Ziele eskalieren. Eine fehlgeschlagene Proxy-Anfrage ist eines von fünf verschiedenen Ereignissen: Der Proxy selbst war nicht erreichbar; der Proxy hat Ihre Anmeldeinformationen abgelehnt; das Ziel hat diese IP abgelehnt; das Ziel hat Sie rate-limitiert; oder das Ziel hat mit 200 und einer Challenge-Seite statt mit Inhalt geantwortet. Rotation hilft bei genau einem davon. Sofortiges Wiederholen hilft bei keinem. Dieser Leitfaden klassifiziert die Fehler und baut dann eine kompakte Python-Retry-Schicht auf, die auf jede korrekt reagiert, mit exponentiellem Backoff, Rotation nur dort, wo sie anwendbar ist, und einem Circuit Breaker, damit ein Ziel, das “Stopp” gesagt hat, tatsächlich in Ruhe gelassen wird. Die Snippets verwenden requests; die Logik lässt sich direkt auf httpx und aiohttp übertragen (Parameternamen in Proxies in Python).
Die fünf Fehlerarten
| # | Was passiert ist | Wie es sich in Python zeigt | Richtige Reaktion |
|---|---|---|---|
| 1 | Proxy nicht erreichbar — falscher Host/Port, Provider-Ausfall, Netzwerk | ProxyError, der einen Verbindungsfehler umschließt; ConnectTimeout vor jedem HTTP | Mit Backoff erneut versuchen; nach N Fehlern den Proxy-Endpunkt als down markieren und alarmieren. Rotation innerhalb desselben Gateways hilft nicht, wenn das Gateway down ist. |
| 2 | Proxy hat Sie abgelehnt — falsche Anmeldeinformationen, IP nicht whitelisted, Plan erschöpft | ProxyError mit 407; manchmal provider-spezifisches 4xx vom Gateway | Nicht erneut versuchen. Konfiguration korrigieren; das Wiederholen einer 407 in einer Schleife kann dazu führen, dass Ihr Konto vom Provider gedrosselt wird. |
| 3 | Ziel hat diese IP abgelehnt — Reputation, ASN, Geo-Block | 403, manchmal 401/451; gelegentlich ein Verbindungsreset | Auf einen neuen Exit (neue Session-ID) rotieren und einen frischen Cookie-Jar verwenden; ein- oder zweimal erneut versuchen; wenn es über IPs hinweg anhält, ist das Problem Fingerprint oder Typ, nicht die IP — stoppen und neu bewerten (warum). |
| 4 | Ziel hat Sie rate-limitiert | 429 oder 503 mit Retry-After | Retry-After (oder Backoff) auf diesem Exit schlafen; dann darauf fortfahren. Statt zu warten zu rotieren, verteilt den Block. Siehe Rate-Limit-Signale. |
| 5 | Challenge als 200 ausgeliefert — CAPTCHA/Interstitial-Seite | Status 200, aber der Body ist nicht der erwartete Inhalt | Als Fehlertyp 3 behandeln. Durch Inhalt erkennen (Markierungstext, fehlendes erwartetes Element, zu kleiner Body), niemals nur durch den Status. |
| — | Transientes Netzwerk / Ziel 5xx | ReadTimeout, ConnectionError mitten im Stream, 500/502/504 | Mit Backoff auf demselben Exit erneut versuchen; diese sind normalerweise nicht Ihre Schuld. |
Die Tabelle ist der ganze Artikel; alles unten macht ein Programm, das ihr gehorcht.
Zuerst klassifizieren
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 # Proxy nie erreicht (oder nie auf CONNECT geantwortet)
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
Passen Sie CHALLENGE_MARKERS und min_bytes pro Ziel an: Der zuverlässige Check ist “Enthält die Seite das Element, das ich haben wollte?” — einen Produkttitel, einen JSON-Schlüssel — und dessen Abwesenheit ist das Challenge-Signal.
Backoff, richtig gemacht
Exponentieller Backoff mit Jitter: Verdoppelte Verzögerungen verteilen Wiederholungen; Jitter verhindert, dass hundert Worker im Gleichschritt wiederholen. Beachten Sie Retry-After, wenn es vorhanden ist.
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) # HTTP-Datum-Form
return max(0.0, dt.timestamp() - time.time()) if dt else None
Ein Circuit Breaker pro (Ziel, Exit)
Wenn ein Ziel einen Exit mehrmals hintereinander abgelehnt hat, hören Sie auf, diesen Exit diesem Ziel für eine Weile anzubieten, anstatt den Block bei jeder Anfrage neu zu entdecken. Gleiche Idee für einen Proxy-Endpunkt, der down ist.
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
Alles zusammenfügen
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 # anderen Exit wählen
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 hat Anmeldeinformationen/Whitelist abgelehnt — Konfiguration korrigieren, nicht wiederholen")
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 # gleicher Exit
if kind in (Fail.IP_BLOCKED, Fail.CHALLENGE):
breaker.bad(key)
sid = secrets.token_hex(4); sess = requests.Session() # neuer Exit + frische Cookies
time.sleep(backoff_delay(attempt)); continue
# TRANSIENT
time.sleep(backoff_delay(attempt)); continue
return None
Was das tut, was die naive Schleife nicht tut: Es wiederholt niemals eine 407; es wartet bei Rate-Limits, anstatt zu hüpfen; es rotiert nur bei IP-Level-Ablehnung und Challenges und kombiniert jede Rotation mit einem frischen Cookie-Jar (gleiche Cookies auf einer neuen IP sind derselbe Besucher); es hört auf, einen Exit anzubieten, der bei einem Host weiterhin fehlschlägt; und es verwendet überall Backoff mit Jitter. Verdrahten Sie die Fail-Zähler in Ihre Metriken — eine steigende IP_BLOCKED-Rate über verschiedene Exits hinweg bedeutet, dass der Fingerprint oder der IP-Typ falsch ist, und keine Retry-Policy wird das beheben (siehe TLS-Fingerprinting und Wahl des IP-Typs).
Stattdessen eine Bibliothek verwenden
tenacity bietet Dekoratoren für Retry/Backoff/Stop-Bedingungen und ist eine gute Basis — aber behalten Sie die Klassifizierung und die Entscheidung “Rotieren vs. Warten vs. Stopp” in Ihrem eigenen Code; generische Retry-Bibliotheken behandeln alle Ausnahmen gleich, was genau der Fehler ist. Das Retry-Objekt von urllib3 (auf einen requests HTTPAdapter montierbar) behandelt Verbindungs-Level-Retries und Retry-After für 429/503 gut und ist für die TRANSIENT- und RATE_LIMITED-Klassen zu empfehlen; es kann Ihren Proxy nicht rotieren oder einen Challenge-Body erkennen, also ergänzt es die obige Schicht, ersetzt sie aber nicht.
Async-Hinweis
In aiohttp/httpx.AsyncClient ist die Struktur identisch mit await asyncio.sleep(); die eine Ergänzung ist ein Semaphor pro Host, damit das Zurückweichen auf einem Host die anderen nicht aufhält und die Parallelität pro Host höflich bleibt. Ein globales Semaphor allein lässt hundert Koroutinen auf ein Ziel los, sobald es das einzige ist, das nicht schläft.
Häufig gestellte Fragen
Sollte ich den Proxy bei jedem Fehler rotieren?
Nein. Rotieren Sie bei IP-Level-Ablehnung (403-Klasse) und Challenge-Seiten, immer mit einem frischen Cookie-Jar. Warten Sie — nicht rotieren — bei 429/Retry-After. Korrigieren Sie die Konfiguration bei 407. Wiederholen Sie denselben Exit bei transienten Fehlern und 5xx.
Wie oft sollte ich es erneut versuchen?
Drei bis fünf Versuche mit exponentiellem Backoff und Jitter sind die übliche Hülle; darüber hinaus stehen Sie entweder vor einem dauerhaften Block (Rotationslimit erreicht) oder einem Ausfall (Breaker sollte offen sein). Begrenzen Sie die gesamte Wandzeit pro Anfrage.
Wie erkenne ich eine CAPTCHA-Seite im Code?
Durch Inhalt, nicht durch Status: Prüfen Sie auf das erwartete Element (einen Titel, einen JSON-Schlüssel), auf bekannte Challenge-Marker im Body und auf eine unplausibel kleine Antwort. Eine 200 ohne Ihren Inhalt ist ein Fehler.
Was ist ein Circuit Breaker für Proxies?
Ein Zähler pro (Ziel, Exit), der nach mehreren aufeinanderfolgenden Fehlern die Verwendung dieses Exits für dieses Ziel für eine Abkühlzeit stoppt — damit Sie den Block nicht bei jeder Anfrage neu entdecken und keinen Host weiter hämmern, der Sie abgelehnt hat.
Warum nicht einfach tenacity oder urllib3 Retry verwenden?
Verwenden Sie sie für transiente und Rate-Limit-Retries; aber sie können eine 407 nicht von einer 403 oder einer Challenge unterscheiden, können Ihre Session-ID nicht rotieren und Cookies nicht zurücksetzen. Behalten Sie diese Entscheidungslogik in Ihrem Code.
Was bedeutet eine steigende Blockrate über viele IPs?
Dass die IPs nicht das Problem sind: Das Ziel identifiziert Sie über TLS/HTTP-Fingerprint, Header oder Verhalten, oder der IP-Typ ist für diese Website falsch. Hören Sie auf zu rotieren und beheben Sie die Schicht, die tatsächlich fehlschlägt.