# Python Requests Proxy-Leitfaden: Syntax, Authentifizierung, Rotation, Wiederholungen

Das proxies-Dictionary besteht aus drei Codezeilen, doch Proxy-Fehler in Requests füllen ein Jahrzehnt auf Stack Overflow. Hier ist die vollständige Einrichtung — Syntax, Authentifizierung, Umgebungsvariablen, Rotation, Wiederholungen und SOCKS5 — mit den scharfen Kanten gekennzeichnet.

Python Requests ist immer noch der Standard-HTTP-Client für Scraping und Automatisierung, und ihn auf einen Proxy zu verweisen, ist eine Aufgabe von drei Zeilen: Übergeben Sie ein proxies-Dictionary und jede Anfrage verlässt die IP des Proxys statt Ihrer. Dennoch bleibt 'python requests proxy funktioniert nicht' seit über einem Jahrzehnt eine der meistgesuchten Fragen — die ursprüngliche Stack Overflow-Frage zum proxies-Dictionary stammt aus dem Jahr 2011, die beste Antwort hat über 480 Stimmen, und sie wurde noch im Januar 2026 bearbeitet. Die Syntax hat scharfe Kanten: Ein fehlendes Schema löst eine Ausnahme aus, das falsche Schema im https-Schlüssel verursacht SSL-Fehler, und Umgebungsvariablen überschreiben stillschweigend den Code. Dieser Python Requests Proxy-Leitfaden deckt alles ab: Syntax, Authentifizierung, Umgebungsvariablen, Rotation, Wiederholungen, SOCKS5 und die Fehler, auf die Sie tatsächlich stoßen werden.

## Das proxies-Dictionary: Python Requests Proxy-Syntax

Das `proxies`-Argument ordnet ein Protokoll einer Proxy-URL zu. Zwei Schlüssel decken normales Scraping ab — einer für einfache HTTP-Ziele, einer für HTTPS-Ziele — und beide verweisen normalerweise auf denselben Proxy:

```python
import requests

proxies = {
    "http": "http://USER:PASS@residentialpremium.quantumproxies.io:8080",
    "https": "http://USER:PASS@residentialpremium.quantumproxies.io:8080",
}

r = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=(5, 30))
print(r.json())  # {'origin': '<proxy exit IP>'}
```

Drei Regeln verhindern 90% der Einrichtungsfehler:

- **Das Schema ist obligatorisch.** Seit Requests 2.0.0 löst eine Proxy-URL ohne `http://` `MissingSchema` aus. Reine `ip:port`-Strings funktionierten in 1.x und brachen überall, als 2.0 eingeführt wurde.
- **Verwenden Sie `http://` im `https`-Schlüssel.** Der Schlüssel benennt das Zielprotokoll; der Wert benennt, wie Sie den Proxy erreichen. Proxies akzeptieren einfaches HTTP und tunneln TLS durch eine CONNECT-Anfrage. `https://` dort zu schreiben, ist die klassische Ursache für `SSLError: UNEXPECTED_EOF_WHILE_READING`.
- **Schlüssel können auf bestimmte Hosts abzielen.** Ein Schlüssel wie `https://api.example.com` leitet nur diesen Host durch einen bestimmten Proxy — praktisch, um eine schwierige Domain über Wohn-IP-Adressen zu senden, während alles andere direkt geht.

## Proxy-Authentifizierung: Benutzername und Passwort

Authentifizierte Proxies verwenden HTTP-Basic-Auth, eingebettet in die URL: `http://USER:PASS@host:port`. Wenn das Passwort `@`, `:` oder `/` enthält, kodieren Sie es zuerst mit `urllib.parse.quote(password, safe="")` — unkodierte Sonderzeichen teilen die URL an der falschen Stelle und führen zu Authentifizierungsfehlern, die wie tote Proxies aussehen. Eine `407 Proxy Authentication Required`-Antwort bedeutet, dass der Proxy Sie selbst abgelehnt hat: falsche Anmeldedaten oder ein IP-Whitelist-Plan, der von einer nicht registrierten Adresse aufgerufen wird. Beide Fälle werden in [unserem 407-Fehlerbehebungsleitfaden](https://quantumproxies.io/blog/fix-407-proxy-authentication-required) analysiert. Für alles, was über ein einmaliges Skript hinausgeht, hängen Sie die Proxies an eine `Session` — Sie erhalten Verbindungspooling, Cookie-Persistenz und einen Ort, um alles zu konfigurieren:

```python
import requests

session = requests.Session()
session.proxies = {
    "http": "http://USER:PASS@residentialpremium.quantumproxies.io:8080",
    "https": "http://USER:PASS@residentialpremium.quantumproxies.io:8080",
}
session.headers.update({"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"})

r = session.get("https://httpbin.org/ip", timeout=(5, 30))
print(r.status_code, r.json())
```

## Umgebungsvariablen und trust_env

Requests liest auch Proxy-Einstellungen aus der Umgebung — dieselben Variablen, die curl und die meisten Unix-Tools berücksichtigen: `HTTP_PROXY`, `HTTPS_PROXY`, `ALL_PROXY` und `NO_PROXY` (eine kommagetrennte Liste von Hosts, die ausgeschlossen werden sollen, z.B. `localhost,127.0.0.1,.internal`). Dies ist der sauberste Weg, um eine Drittanbieter-Bibliothek, die Requests unter der Haube verwendet, zu proxen, ohne ihren Code zu berühren. Die Priorität läuft explizit-schlägt-implizit: Ein `proxies=`-Argument beim Aufruf gewinnt, dann `session.proxies`, dann die Umgebung. Zwei verwandte Tools sind es wert, bekannt zu sein: `session.trust_env = False` schaltet alle Umgebungsnachschlagevorgänge ab — die Lösung, wenn eine Unternehmensproxyvariable Ihren Scraper kapert — und `urllib.request.getproxies()` gibt Betriebssystem-Ebene Proxy-Einstellungen (einschließlich macOS und Windows-Systemkonfiguration) in genau der Dictionary-Form zurück, die Requests erwartet.

![Dasselbe proxies-Dict mit zwei Schlüsseln schickt drei Schleifendurchläufe durch den CONNECT-Tunnel eines rotierenden Gateways, und httpbin.org/ip meldet jedes Mal einen anderen origin: Exit-IP A, B und C. Die Karte: Das Dict wählt die Route, der Tunnel trägt TLS zum Ziel, und das Gateway liefert bei jedem Aufruf eine neue Exit-IP.](https://res.cloudinary.com/dmqliab0t/image/upload/f_auto,q_auto,w_1200/v1785335141/blog/generated/qp-b9-001-diag1.png)
*Das Dictionary wählt die Route, das Gateway liefert die Exit-IP. Mit Rotation pro Anfrage liefern dieselben zwei Konfigurationszeilen bei jedem Aufruf eine neue IP.*

## Rotation: ein Gateway schlägt eine Proxy-Liste

Das traditionelle Rotationsrezept — eine Liste von IPs laden, `random.choice()` pro Anfrage, die toten aussortieren — ist eine Mechanik, die Sie nicht mehr bauen müssen. Ein rotierendes Gateway erledigt es serverseitig: Sie konfigurieren einen Endpunkt und der Anbieter weist bei jeder Anfrage eine frische Exit-IP aus dem Pool zu. Durch [rotierende Wohnproxies](https://quantumproxies.io/rotating-proxies) umfasst dieser Pool über 90 Millionen Haushalts-IP-Adressen in über 200 Ländern, sodass tausend Anfragen wie tausend verschiedene Besucher aussehen, ohne eine einzige Zeile Rotationslogik:

```python
import requests

proxies = {
    "http": "http://USER:PASS@residentialpremium.quantumproxies.io:8080",
    "https": "http://USER:PASS@residentialpremium.quantumproxies.io:8080",
}

for _ in range(3):
    r = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=(5, 30))
    print(r.json()["origin"])  # a different exit IP on each iteration
```

Wenn ein Fluss mehrere Anfragen umfasst — Login, in den Warenkorb legen, zur Kasse gehen — bricht die Rotation pro Anfrage die Sitzung. Sticky Sessions lösen das: Ein Sitzungsparameter im Proxy-Benutzernamen fixiert eine Exit-IP für ein festgelegtes Zeitfenster und rotiert dann. Gleicher Endpunkt, eine Zeichenkettenänderung. Wenn Sie über einfache Schleifen hinaus skalieren, multipliziert [asynchrones Python mit httpx oder aiohttp](https://quantumproxies.io/blog/python-async-scraping-httpx-aiohttp-proxies) den Durchsatz, und [Scrapys Middleware-System](https://quantumproxies.io/blog/scrapy-rotating-proxy-middleware) bietet Ihnen Rotation, Wiederholungen und Bannbehandlung als Framework-Konfiguration.

## Wiederholungen und Timeouts, die schlechte Exits überleben

Selbst Premium-Pools bieten gelegentlich langsame oder sterbende Exits, daher benötigt Produktionscode zwei Schutzmaßnahmen: ein Timeout bei jeder Anfrage (Requests wartet standardmäßig ewig) und automatische Wiederholungen mit Backoff. Das Timeout nimmt ein `(connect, read)`-Tupel — schnell scheitern bei unerreichbaren Proxies, langsamere Seitenlesungen zulassen. Wiederholungen werden auf der Transportschicht über urllib3 montiert:

```python
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

retry = Retry(
    total=4,
    backoff_factor=1,  # exponential backoff between attempts
    status_forcelist=[429, 500, 502, 503, 504],
    allowed_methods=["GET", "HEAD"],
)

session = requests.Session()
session.mount("http://", HTTPAdapter(max_retries=retry))
session.mount("https://", HTTPAdapter(max_retries=retry))
session.proxies = {
    "http": "http://USER:PASS@residentialpremium.quantumproxies.io:8080",
    "https": "http://USER:PASS@residentialpremium.quantumproxies.io:8080",
}

r = session.get("https://httpbin.org/ip", timeout=(5, 30))
```

Mit einem rotierenden Gateway ist diese Kombination stillschweigend mächtig: Jede Wiederholung reist automatisch durch eine andere Exit-IP, sodass eine unzuverlässige Adresse niemals viermal hintereinander eine Anfrage scheitern lassen kann.

## SOCKS5-Proxies mit Requests

SOCKS-Unterstützung ist ein Extra: Installieren Sie es mit `pip install requests[socks]`. Dann ist die Dictionary-Syntax identisch — nur das Schema ändert sich. Bevorzugen Sie `socks5h://` über `socks5://`: Das `h` schiebt die DNS-Auflösung zum Proxy, was DNS-Lecks aus Ihrem echten Netzwerk stoppt und geo-eingezäunte Hostnamen von der Position des Exits auflöst. Jeder QuantumProxies-Plan bietet sowohl HTTP- als auch [SOCKS5-Proxies](https://quantumproxies.io/socks5-proxies) auf demselben Gateway, sodass das Wechseln der Protokolle ein Schemawechsel ist, kein neuer Kauf:

```python
proxies = {
    "http": "socks5h://USER:PASS@residentialpremium.quantumproxies.io:1080",
    "https": "socks5h://USER:PASS@residentialpremium.quantumproxies.io:1080",
}
```

![Fünf Proxyfehler mit Python Requests und was jeder verursacht: Ein fehlendes Schema löst MissingSchema aus, https:// im https-Schlüssel führt zu einem SSLError, ein nicht kodiertes Passwort bringt einen 407, SOCKS braucht das Extra requestssocks, und ohne Timeout wird ewig gewartet. Die Karte: Drei Regeln verhindern 90 % der Einrichtungsfehler.](https://res.cloudinary.com/dmqliab0t/image/upload/f_auto,q_auto,w_1200/v1785335141/blog/generated/qp-b9-001-diag2.png)
*Fünf Fehler verursachen die meisten Ausfälle: fehlendes Schema, https:// im https-Schlüssel, unkodierte Passwörter, fehlende SOCKS-Extras und kein Timeout.*

## Häufige Python Requests Proxy-Fehler, entschlüsselt

- **MissingSchema** — Proxy-URL fehlt `http://`. Obligatorisch seit Requests 2.0.0.
- **ProxyError: Cannot connect to proxy** — falscher Host oder Port, oder ein toter Proxy. Überprüfen Sie den Endpunkt mit curl, bevor Sie Ihren Code beschuldigen.
- **SSLError / UNEXPECTED_EOF_WHILE_READING** — normalerweise `https://` im `https`-Schlüssel. Setzen Sie das Schema des Wertes auf `http://`.
- **407 Proxy Authentication Required** — falsche Anmeldedaten, unkodierte Sonderzeichen im Passwort oder eine nicht auf der Whitelist stehende Quell-IP.
- **ConnectTimeout / ReadTimeout** — langsamer Exit oder langsames Ziel. Setzen Sie `timeout=(5, 30)` und lassen Sie Wiederholungen zu einer frischen IP rotieren.
- **Proxy funktioniert in curl, schlägt in Python fehl** — eine Umgebungsvariable überschreibt Ihr Dictionary. Drucken Sie `session.proxies` und versuchen Sie `trust_env = False`.

Für einen tieferen Einblick in die Stack-Traces und ihre Ursachen siehe [Debugging von ProxyError, SSLError und ConnectTimeout in Requests](https://quantumproxies.io/blog/python-requests-proxyerror-fix).

## Häufig gestellte Fragen

### Wie verwende ich einen Proxy mit Python Requests?

Übergeben Sie ein `proxies`-Dictionary mit `http`- und `https`-Schlüsseln an jede Anfragemethode: `requests.get(url, proxies={...})`. Jeder Wert ist eine vollständige Proxy-URL einschließlich Schema, und Anmeldedaten werden als `http://user:pass@host:port` eingebettet. Hängen Sie dasselbe Dictionary an eine `Session` an, um es automatisch auf jede Anfrage anzuwenden.

### Warum funktioniert mein Python Requests Proxy nicht?

Überprüfen Sie die vier üblichen Verdächtigen in der Reihenfolge: ein fehlendes `http://`-Schema in der Proxy-URL, `https://` im `https`-Schlüssel verwendet, Sonderzeichen im Passwort, die nicht URL-kodiert wurden, und Umgebungsvariablen, die Ihren Code überschreiben. Testen Sie dieselben Anmeldedaten mit curl — wenn curl erfolgreich ist, liegt das Problem in Ihrem Dictionary.

### Unterstützt Python Requests SOCKS5-Proxies?

Ja, nach der Installation der zusätzlichen Abhängigkeit mit `pip install requests[socks]`. Verwenden Sie das `socks5h://`-Schema in Ihrem proxies-Dictionary, damit die DNS-Auflösung auf der Proxy-Seite erfolgt — das einfache `socks5://`-Schema löst Hostnamen lokal auf, was DNS-Anfragen leckt und geo-targeted Scraping brechen kann.

### Wie setze ich einen Proxy mit Umgebungsvariablen?

Exportieren Sie `HTTP_PROXY` und `HTTPS_PROXY` mit der vollständigen Proxy-URL und optional `NO_PROXY` für auszuschließende Hosts. Requests nimmt sie automatisch auf, was auch Drittanbieter-Bibliotheken, die auf Requests basieren, proxyt. Um Ihren Code die Umgebung vollständig ignorieren zu lassen, setzen Sie `session.trust_env = False`.

Das ist das gesamte Toolkit: ein Dictionary mit zwei Schlüsseln, Anmeldedaten in der URL, Wiederholungen einmal montiert und Rotation, die vom Gateway statt von Ihrem Code gehandhabt wird. Das eine, was keine Syntax behebt, ist die IP-Qualität — ein perfekt konfigurierter Rechenzentrumsproxy wird immer noch blockiert, wo ein Wohn-Exit problemlos durchkommt. Kombinieren Sie sauberen Code mit sauberen IPs und Requests wird überraschend große Arbeitslasten bewältigen.

[Holen Sie sich Wohnproxies, die beim ersten Versuch funktionieren](https://quantumproxies.io/residential-proxies)