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 istWie es sich in Python zeigtRichtige Reaktion
1Proxy nicht erreichbar — falscher Host/Port, Provider-Ausfall, NetzwerkProxyError, der einen Verbindungsfehler umschließt; ConnectTimeout vor jedem HTTPMit 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.
2Proxy hat Sie abgelehnt — falsche Anmeldeinformationen, IP nicht whitelisted, Plan erschöpftProxyError mit 407; manchmal provider-spezifisches 4xx vom GatewayNicht erneut versuchen. Konfiguration korrigieren; das Wiederholen einer 407 in einer Schleife kann dazu führen, dass Ihr Konto vom Provider gedrosselt wird.
3Ziel hat diese IP abgelehnt — Reputation, ASN, Geo-Block403, manchmal 401/451; gelegentlich ein VerbindungsresetAuf 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).
4Ziel hat Sie rate-limitiert429 oder 503 mit Retry-AfterRetry-After (oder Backoff) auf diesem Exit schlafen; dann darauf fortfahren. Statt zu warten zu rotieren, verteilt den Block. Siehe Rate-Limit-Signale.
5Challenge als 200 ausgeliefert — CAPTCHA/Interstitial-SeiteStatus 200, aber der Body ist nicht der erwartete InhaltAls Fehlertyp 3 behandeln. Durch Inhalt erkennen (Markierungstext, fehlendes erwartetes Element, zu kleiner Body), niemals nur durch den Status.
—Transientes Netzwerk / Ziel 5xxReadTimeout, ConnectionError mitten im Stream, 500/502/504Mit 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.