# Python Requests Proxy Gids: Syntax, Auth, Rotatie, Retries

De proxies dict is drie regels code, maar proxyfouten in Requests vullen een decennium aan Stack Overflow. Hier is de volledige setup — syntax, auth, omgevingsvariabelen, rotatie, retries en SOCKS5 — met de scherpe randen gemarkeerd.

Python Requests is nog steeds de standaard HTTP-client voor scraping en automatisering, en het richten ervan op een proxy is een klus van drie regels: geef een proxies dictionary door en elke request verlaat het IP van de proxy in plaats van dat van jou. Toch is 'python requests proxy werkt niet' al meer dan een decennium een topzoekopdracht — de oorspronkelijke Stack Overflow-vraag over de proxies dict dateert uit 2011, het topantwoord heeft 480+ stemmen, en het werd nog steeds bewerkt in januari 2026. De syntax heeft scherpe randen: een ontbrekend schema veroorzaakt een uitzondering, het verkeerde schema binnen de https-sleutel veroorzaakt SSL-fouten, en omgevingsvariabelen overschrijven stilletjes de code. Deze Python Requests proxy gids behandelt alles: syntax, authenticatie, omgevingsvariabelen, rotatie, retries, SOCKS5 en de fouten die je daadwerkelijk tegenkomt.

## De proxies dict: Python Requests proxy syntax

Het `proxies` argument koppelt een protocol aan een proxy-URL. Twee sleutels dekken normaal scrapen — één voor gewone HTTP-doelen, één voor HTTPS-doelen — en beide wijzen meestal naar dezelfde 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>'}
```

Drie regels voorkomen 90% van de setup-fouten:

- **Het schema is verplicht.** Sinds Requests 2.0.0 geeft een proxy-URL zonder `http://` een `MissingSchema`. Kale `ip:port` strings werkten in 1.x en braken overal toen 2.0 arriveerde.
- **Gebruik `http://` binnen de `https` sleutel.** De sleutel benoemt het doelprotocol; de waarde benoemt hoe je de proxy bereikt. Proxies accepteren gewone HTTP en tunnelen TLS via een CONNECT-verzoek. Het schrijven van `https://` daar is de klassieke oorzaak van `SSLError: UNEXPECTED_EOF_WHILE_READING`.
- **Sleutels kunnen specifieke hosts targeten.** Een sleutel zoals `https://api.example.com` routeert alleen die host via een gegeven proxy — handig om één moeilijk domein via residentiële IP's te sturen terwijl de rest direct gaat.

## Proxy authenticatie: gebruikersnaam en wachtwoord

Geauthenticeerde proxies gebruiken HTTP Basic auth ingebed in de URL: `http://USER:PASS@host:port`. Als het wachtwoord `@`, `:` of `/` bevat, codeer het dan eerst met `urllib.parse.quote(password, safe="")` — ongecodeerde speciale tekens splitsen de URL op de verkeerde plaats en veroorzaken auth-fouten die lijken op dode proxies. Een `407 Proxy Authentication Required` respons betekent dat de proxy zelf je heeft afgewezen: verkeerde inloggegevens, of een IP-whitelist plan aangeroepen vanaf een niet-geregistreerd adres. Beide gevallen worden uiteengezet in [onze 407 probleemoplossingsgids](https://quantumproxies.io/blog/fix-407-proxy-authentication-required). Voor alles wat verder gaat dan een eenmalig script, koppel de proxies aan een `Session` — je krijgt verbinding pooling, cookie persistentie en één plek om alles te configureren:

```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())
```

## Omgevingsvariabelen en trust_env

Requests leest ook proxy-instellingen uit de omgeving — dezelfde variabelen die curl en de meeste Unix-tools respecteren: `HTTP_PROXY`, `HTTPS_PROXY`, `ALL_PROXY` en `NO_PROXY` (een kommagescheiden lijst van hosts om uit te sluiten, bijv. `localhost,127.0.0.1,.internal`). Dit is de schoonste manier om een derde-partij bibliotheek die Requests onder de motorkap gebruikt te proxyen zonder de code aan te raken. Voorrang loopt expliciet-boven-impliciet: een `proxies=` argument bij de oproep wint, dan `session.proxies`, dan de omgeving. Twee gerelateerde tools zijn de moeite waard om te kennen: `session.trust_env = False` schakelt alle omgevingsopzoekingen uit — de oplossing wanneer een bedrijfsproxyvariabele je scraper kaapt — en `urllib.request.getproxies()` retourneert proxy-instellingen op OS-niveau (inclusief macOS en Windows systeemconfiguratie) in precies de dict-vorm die Requests verwacht.

![Dezelfde proxies-dict met twee sleutels stuurt drie lusiteraties door de CONNECT-tunnel van een roterende gateway, en httpbin.org/ip meldt elke keer een andere origin: exit-IP A, B en C. De kaart: de dict kiest de route, de tunnel draagt TLS naar het doel, en de gateway levert bij elke call een nieuw exit-IP.](https://res.cloudinary.com/dmqliab0t/image/upload/f_auto,q_auto,w_1200/v1785335141/blog/generated/qp-b9-001-diag1.png)
*De dict kiest de route, de gateway levert het exit-IP. Met rotatie per request leveren dezelfde twee regels config elke oproep een nieuw IP op.*

## Rotatie: één gateway verslaat een proxylijst

Het traditionele rotatierecept — laad een lijst met IP's, `random.choice()` per request, snoei de dode — is een mechanisme dat je niet meer hoeft te bouwen. Een roterende gateway doet het server-side: je configureert één endpoint en de provider wijst bij elke request een nieuw exit-IP uit de pool toe. Via [roterende residentiële proxies](https://quantumproxies.io/rotating-proxies) bestaat die pool uit 90M+ huishoudelijke IP's in 200+ landen, zodat duizend requests eruitzien als duizend verschillende bezoekers zonder een enkele regel rotatielogica:

```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
```

Wanneer een flow meerdere requests beslaat — inloggen, toevoegen aan winkelwagen, afrekenen — breekt rotatie per request de sessie. Sticky sessions lossen dat op: een sessieparameter in de proxy gebruikersnaam verankert één exit-IP voor een ingestelde periode, en roteert dan. Zelfde endpoint, één stringwijziging. Als je verder gaat dan eenvoudige loops, vermenigvuldigt [async Python met httpx of aiohttp](https://quantumproxies.io/blog/python-async-scraping-httpx-aiohttp-proxies) de doorvoer, en [Scrapy's middleware systeem](https://quantumproxies.io/blog/scrapy-rotating-proxy-middleware) biedt rotatie, retries en banhandling als frameworkconfiguratie.

## Retries en timeouts die slechte exits overleven

Zelfs premium pools bieden af en toe een trage of stervende exit, dus productcode heeft twee beschermingen nodig: een timeout op elke request (Requests wacht standaard voor altijd) en automatische retries met backoff. De timeout neemt een `(connect, read)` tuple — snel falen op onbereikbare proxies, langzamere paginalezen toestaan. Retries worden op transportlaagniveau gemonteerd via urllib3:

```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))
```

Met een roterende gateway is deze combinatie stilletjes krachtig: elke retry reist automatisch door een ander exit-IP, zodat één wankel adres nooit vier keer op rij een request kan laten falen.

## SOCKS5 proxies met Requests

SOCKS-ondersteuning is een extra: installeer het met `pip install requests[socks]`. Dan is de dict-syntax identiek — alleen het schema verandert. Geef de voorkeur aan `socks5h://` boven `socks5://`: de `h` duwt DNS-resolutie naar de proxy, wat DNS-lekken van je echte netwerk stopt en geo-afgeschermde hostnamen vanuit de exit-locatie oplost. Elk QuantumProxies-plan biedt zowel HTTP als [SOCKS5 proxies](https://quantumproxies.io/socks5-proxies) op dezelfde gateway, dus het wisselen van protocollen is een schema-wissel, geen nieuwe aankoop:

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

![Vijf proxyfouten in Python Requests en wat elk veroorzaakt: een ontbrekend scheme geeft MissingSchema, https:// in de https-sleutel geeft een SSLError, een niet-gecodeerd wachtwoord krijgt een 407, SOCKS vereist de extra requestssocks, en zonder timeout wacht het eindeloos. De kaart: drie regels voorkomen 90% van de configuratiefouten.](https://res.cloudinary.com/dmqliab0t/image/upload/f_auto,q_auto,w_1200/v1785335141/blog/generated/qp-b9-001-diag2.png)
*Vijf fouten veroorzaken de meeste mislukkingen: ontbrekend schema, https:// in de https-sleutel, ongecodeerde wachtwoorden, ontbrekende SOCKS-extra's en geen timeout.*

## Veelvoorkomende Python Requests proxyfouten, gedecodeerd

- **MissingSchema** — proxy-URL mist `http://`. Verplicht sinds Requests 2.0.0.
- **ProxyError: Cannot connect to proxy** — verkeerde host of poort, of een dode proxy. Verifieer het endpoint met curl voordat je je code de schuld geeft.
- **SSLError / UNEXPECTED_EOF_WHILE_READING** — meestal `https://` binnen de `https` sleutel. Stel het schema van de waarde in op `http://`.
- **407 Proxy Authentication Required** — verkeerde inloggegevens, ongecodeerde speciale tekens in het wachtwoord, of een niet-gelijst bron-IP.
- **ConnectTimeout / ReadTimeout** — trage exit of traag doel. Stel `timeout=(5, 30)` in en laat retries roteren naar een nieuw IP.
- **Proxy werkt in curl, faalt in Python** — een omgevingsvariabele overschrijft je dict. Print `session.proxies` en probeer `trust_env = False`.

Voor een diepere wandeling door de stacktraces en hun oorzaken, zie [debuggen van ProxyError, SSLError en ConnectTimeout in Requests](https://quantumproxies.io/blog/python-requests-proxyerror-fix).

## Veelgestelde vragen

### Hoe gebruik ik een proxy met Python Requests?

Geef een `proxies` dictionary met `http` en `https` sleutels door aan elke request-methode: `requests.get(url, proxies={...})`. Elke waarde is een volledige proxy-URL inclusief schema, en inloggegevens worden ingebed als `http://user:pass@host:port`. Koppel dezelfde dict aan een `Session` om het automatisch op elke request toe te passen.

### Waarom werkt mijn Python Requests proxy niet?

Controleer de vier gebruikelijke verdachten in volgorde: een ontbrekend `http://` schema in de proxy-URL, `https://` gebruikt binnen de `https` sleutel, speciale tekens in het wachtwoord die niet URL-gecodeerd zijn, en omgevingsvariabelen die je code overschrijven. Test dezelfde inloggegevens met curl — als curl slaagt, ligt het probleem in je dict.

### Ondersteunt Python Requests SOCKS5 proxies?

Ja, na het installeren van de extra afhankelijkheid met `pip install requests[socks]`. Gebruik het `socks5h://` schema in je proxies dict zodat DNS-resolutie aan de proxyzijde plaatsvindt — het gewone `socks5://` schema lost hostnamen lokaal op, wat DNS-queries lekt en geo-gerichte scraping kan breken.

### Hoe stel ik een proxy in met omgevingsvariabelen?

Exporteer `HTTP_PROXY` en `HTTPS_PROXY` met de volledige proxy-URL, en optioneel `NO_PROXY` voor hosts om uit te sluiten. Requests pikt ze automatisch op, wat ook derde-partij bibliotheken die op Requests zijn gebouwd, proxyert. Om je code de omgeving volledig te laten negeren, stel je `session.trust_env = False` in.

Dat is de hele toolkit: een tweesleutels dict, inloggegevens in de URL, retries eenmaal gemonteerd, en rotatie afgehandeld door de gateway in plaats van je code. Het enige dat geen syntax oplost, is IP-kwaliteit — een perfect geconfigureerde datacenterproxy wordt nog steeds geblokkeerd waar een residentiële exit doorheen zeilt. Combineer schone code met schone IP's en Requests zal verrassend grote workloads aankunnen.

[Krijg residentiële proxies die in één keer werken](https://quantumproxies.io/residential-proxies)