# Codevoorbeelden voor datacenterproxy's: curl, Python, Node.js en Playwright

> Proxy-codevoorbeelden voor curl, Python requests en aiohttp, Node.js undici en Playwright, HTTP en SOCKS5. RackProxies: vanaf US$ 1,29 per IP, zonder KYC, crypto.

- URL: https://rackproxies.com/nl/docs/code-examples/
- Laatst bijgewerkt: 2026-10-19
- Publisher: RackProxies (https://rackproxies.com)

Kant-en-klare snippets voor de meestgebruikte clients, elk getest op syntax. Elk voorbeeld richt zich op api.ipify.org, httpbin.org/ip of example.com.

**Snel antwoord — Hoe gebruik ik een datacenterproxy in code?**

Deze proxy-codevoorbeelden geven één `http://USERNAME:PASSWORD@IP:PORT`-URL door aan je client: `-x` in curl, `proxies=` in Python requests, een `ProxyAgent` in Node.js, een `proxy`-optie in Playwright. SOCKS5 gebruikt `socks5h://`. **RackProxies**-IP's ondersteunen HTTP, HTTPS (CONNECT) en SOCKS5, vanaf US$ 1,29 per dedicated IPv4 voor 30 dagen. Zonder KYC, alleen crypto.

## Welke snippet heb ik nodig?

*Vervang in elke snippet het documentatieadres 203.0.113.24 en poort 8000 door een regel uit je account.*

| Client | HTTP-proxy | SOCKS5-proxy | Extra package |
| --- | --- | --- | --- |
| curl | `-x http://…` | `-x socks5h://…` | Geen |
| Python requests | `proxies={…}` | `socks5h://` URL | `requests[socks]` voor SOCKS5 |
| Python aiohttp | `proxy=` en `proxy_auth=` | Niet ingebouwd | `aiohttp-socks` voor SOCKS5 |
| Node.js fetch | undici `ProxyAgent` | Niet ingebouwd | `undici` |
| Node.js https | `https-proxy-agent` | `socks-proxy-agent` | Een van de twee |
| Playwright | `proxy: { server, username, password }` | Gebruik HTTP of de allowlist | `playwright` |

## Hoe gebruik ik de proxy met curl?

Geef de proxy-URL mee met `-x`. curl regelt de CONNECT-tunnel voor `https://`-doelen zelf. Alle snippets op deze pagina gebruiken het documentatieadres `203.0.113.24`; de pagina [verbindingsformaat](https://rackproxies.com/nl/docs/connection-format/) laat zien hoe je de URL opbouwt uit je regel.

*curl: HTTP, SOCKS5, aparte login, allowlist*

```bash
# HTTP proxy, HTTPS target (CONNECT tunnel)
curl -x http://USERNAME:PASSWORD@203.0.113.24:8000 https://api.ipify.org

# SOCKS5, hostname resolved by the proxy
curl -x socks5h://USERNAME:PASSWORD@203.0.113.24:8000 https://api.ipify.org

# Login passed separately (no URL-encoding needed)
curl -x http://203.0.113.24:8000 -U 'USERNAME:PASSWORD' https://httpbin.org/ip

# IP allowlist: no login
curl -x http://203.0.113.24:8000 https://api.ipify.org

# Show the proxy handshake and the timings
curl -v -s -o /dev/null -w '%{time_connect} %{time_appconnect} %{time_total}\n' \
  -x http://USERNAME:PASSWORD@203.0.113.24:8000 https://example.com
```

## Hoe gebruik ik de proxy met Python requests?

Geef requests een `proxies`-dictionary met dezelfde URL voor `http` en `https`. De `https`-key is degene die wordt gebruikt voor `https://`-doelen; de waarde begint nog steeds met `http://` omdat die de verbinding met de proxy beschrijft. requests geeft `ProxyError` wanneer de proxy de verbinding of de login weigert.

*requests via een HTTP-proxy, met foutafhandeling*

```python
import requests  # pip install requests

# From the line 203.0.113.24:8000:USERNAME:PASSWORD in your account
proxy = 'http://USERNAME:PASSWORD@203.0.113.24:8000'
proxies = {'http': proxy, 'https': proxy}

try:
    response = requests.get('https://api.ipify.org', proxies=proxies, timeout=20)
    response.raise_for_status()
    print('Exit IP:', response.text)
except requests.exceptions.ProxyError as error:
    print('Proxy problem (credentials, port or allowlist):', error)
except requests.exceptions.Timeout:
    print('No answer within 20 seconds')
```

*verzoeken via SOCKS5 (pip install "requests[socks]")*

```python
import requests  # pip install "requests[socks]"

# socks5h: the proxy resolves the hostname. Use the SOCKS5 port shown in your account.
proxy = 'socks5h://USERNAME:PASSWORD@203.0.113.24:8000'
proxies = {'http': proxy, 'https': proxy}

response = requests.get('https://httpbin.org/ip', proxies=proxies, timeout=20)
print(response.json())  # {'origin': '203.0.113.24'}
```

*Een sessie voor veel verzoeken via één IP*

```python
import requests

# A Session reuses connections: faster for many requests through the same IP.
session = requests.Session()
session.proxies.update({
    'http': 'http://USERNAME:PASSWORD@203.0.113.24:8000',
    'https': 'http://USERNAME:PASSWORD@203.0.113.24:8000',
})
session.headers['User-Agent'] = 'my-monitor/1.0 (contact: you@example.com)'

for url in ['https://example.com', 'https://httpbin.org/ip']:
    response = session.get(url, timeout=20)
    print(url, response.status_code, len(response.content), 'bytes')
```

Stel een `User-Agent` in met de naam van je tool en een contact, zoals in het sessievoorbeeld: site-eigenaren kunnen je dan bereiken in plaats van je te blokkeren. requests leest ook de omgevingsvariabelen `HTTP_PROXY` en `HTTPS_PROXY` als er geen argument voor `proxies` wordt meegegeven.

## Hoe gebruik ik de proxy met Python aiohttp?

aiohttp neemt de proxy per verzoek: `proxy=` voor het adres en `proxy_auth=` voor de login. Het ondersteunt HTTP-proxy's, inclusief CONNECT voor `https://`-doelen. Voor SOCKS5 is het aparte `aiohttp-socks`-pakket nodig.

*aiohttp via een HTTP-proxy*

```python
import asyncio

import aiohttp  # pip install aiohttp (HTTP proxies; SOCKS needs the aiohttp-socks package)

PROXY = 'http://203.0.113.24:8000'
AUTH = aiohttp.BasicAuth('USERNAME', 'PASSWORD')


async def main():
    timeout = aiohttp.ClientTimeout(total=20)
    async with aiohttp.ClientSession(timeout=timeout) as session:
        async with session.get('https://httpbin.org/ip', proxy=PROXY, proxy_auth=AUTH) as response:
            print(await response.json())


asyncio.run(main())
```

## Hoe gebruik ik de proxy met Node.js?

Node's ingebouwde `fetch` accepteert geen proxy-argument, dus gebruik het `undici`-pakket en zijn `ProxyAgent` als de `dispatcher`. Voor de klassieke `https`-module gebruik je `https-proxy-agent` voor HTTP-proxy's en `socks-proxy-agent` voor SOCKS5. Beide snippets zijn ES-modules: sla ze op als `.mjs`-bestanden.

*fetch met undici ProxyAgent*

```javascript
// npm install undici
import { ProxyAgent, fetch } from 'undici';

const dispatcher = new ProxyAgent({
  uri: 'http://203.0.113.24:8000',
  token: `Basic ${Buffer.from('USERNAME:PASSWORD').toString('base64')}`,
});

const response = await fetch('https://api.ipify.org', { dispatcher });
console.log('Exit IP:', await response.text());
```

*https met https-proxy-agent en socks-proxy-agent*

```javascript
// npm install https-proxy-agent socks-proxy-agent
import https from 'node:https';
import { HttpsProxyAgent } from 'https-proxy-agent';
import { SocksProxyAgent } from 'socks-proxy-agent';

const httpAgent = new HttpsProxyAgent('http://USERNAME:PASSWORD@203.0.113.24:8000');
// Use the SOCKS5 port shown in your account; socks5h lets the proxy resolve DNS.
const socksAgent = new SocksProxyAgent('socks5h://USERNAME:PASSWORD@203.0.113.24:8000');

for (const agent of [httpAgent, socksAgent]) {
  https.get('https://api.ipify.org', { agent }, (res) => {
    res.setEncoding('utf8');
    res.on('data', (chunk) => console.log('Exit IP:', chunk));
  }).on('error', (err) => console.error('Proxy error:', err.message));
}
```

## Hoe gebruik ik de proxy met Playwright?

Geef een `proxy`-object door aan `chromium.launch()` met de server en, apart, de gebruikersnaam en het wachtwoord. Gebruik de HTTP-vorm: Chromium's ingebouwde SOCKS5-client heeft historisch geen gebruikersnaam- en wachtwoordauthenticatie voor SOCKS5-proxy's ondersteund. Met de IP-allowlist laat je `username` en `password` weg.

*Playwright (Chromium) via een HTTP-proxy*

```javascript
// npm install playwright && npx playwright install chromium
import { chromium } from 'playwright';

const browser = await chromium.launch({
  proxy: { server: 'http://203.0.113.24:8000', username: 'USERNAME', password: 'PASSWORD' },
});
const page = await browser.newPage();
await page.goto('https://api.ipify.org');
console.log('Exit IP:', await page.textContent('body'));
await browser.close();
```

Gebruik browsers via een proxy voor QA van je eigen sites, advertentie- en localisatiechecks en vergelijkbare legitieme taken. Onthoud dat een proxy alleen het IP wijzigt: de taal en tijdzone van de browser blijven die van je machine, tenzij je ze instelt in de browsercontext.

## Hoe meet ik de latency via een proxy?

Time een paar volledige verzoeken en neem de mediaan. Het Python-snippet hieronder stuurt vijf verzoeken naar `https://example.com` via één IP. Voer het uit via IP's in verschillende datacentersteden om ze te vergelijken; de [stadsgids](https://rackproxies.com/nl/guides/choose-a-datacenter-city/) legt de fysieke ondergrens per afstand uit.

*Mediane verzoektijd via een proxy*

```python
import statistics
import time

import requests

proxy = 'http://USERNAME:PASSWORD@203.0.113.24:8000'
timings = []
for _ in range(5):
    start = time.perf_counter()
    requests.get('https://example.com', proxies={'http': proxy, 'https': proxy}, timeout=20)
    timings.append((time.perf_counter() - start) * 1000)

print(f'median {statistics.median(timings):.0f} ms over {len(timings)} requests')
```

## Hoe gebruik ik een hele lijst met IP's?

Laad je TXT-export, converteer elke regel naar een URL en kies een IP per verzoek: round-robin over sites, of hetzelfde IP voor dezelfde site. De [rotating vs static-gids](https://rackproxies.com/nl/guides/rotating-vs-static-datacenter-proxies/) bevat een compleet voorbeeld, en de pagina [verbindingsformaat](https://rackproxies.com/nl/docs/connection-format/) heeft een converter voor de hele lijst. Respecteer het tempo van elke site, ongeacht de grootte van je lijst: meer IP's verhogen de limiet van een site niet.

## Vragen over codevoorbeelden

### Waarom gebruik ik http:// voor de proxy terwijl de site https:// is?

Het schema van de proxy-URL beschrijft je verbinding met de proxy, niet met de website. Je client verbindt met de proxy via gewone TCP, vraagt hem een CONNECT-tunnel te openen en voert daarbinnen TLS uit met de website. De pagina-inhoud blijft end-to-end versleuteld; alleen de proxylogin wordt leesbaar verzonden.

### Mijn wachtwoord bevat speciale tekens. Wat verandert er?

Codeer het wachtwoord in URL-vorm met `urllib.parse.quote(password, safe='')` in Python of `encodeURIComponent(password)` in JavaScript. Clients die de login apart nemen, zoals aiohttp's `BasicAuth`, Playwright's `username` en `password`, of curl's `-U`, hebben geen codering nodig. De pagina [verbindingsformaat](https://rackproxies.com/nl/docs/connection-format/) vermeldt de tekens.

### Waarom zegt requests dat de dependencies voor SOCKS-ondersteuning ontbreken?

De SOCKS-ondersteuning van requests zit in een optionele extra. Installeer die met `pip install "requests[socks]"`, wat PySocks toevoegt, en gebruik een `socks5h://`-URL zodat de proxy hostnames resolveert. HTTP-proxy's werken zonder extra pakket, dus je kunt de URL ook omzetten naar `http://` en je dependencies ongewijzigd laten.

### Kan ik veel verzoeken parallel via één IP uitvoeren?

Ja, binnen fair use; we publiceren geen verbindingslimiet per IP. Houd de paralleliteit redelijk voor je eigen stabiliteit en respecteer het tempo van elke website: parallelle verzoeken naar dezelfde site tellen nog steeds mee voor de limieten ervan. Per IP gefactureerd voor 30 dagen, niet per GB, onder een fair-usebeleid.

### Welke test-URL moet mijn code als eerste aanroepen?

Roep `https://api.ipify.org` of `https://httpbin.org/ip` aan: elk retourneert het IP dat het ziet, zodat je kunt bevestigen dat het verkeer via je proxy vertrekt. Roep daarna je echte doel aan. Als de test-URL werkt en het doel niet, zit het probleem tussen de proxy en het doel, niet in je code.

### Heb ik een ID nodig om de proxy's voor deze voorbeelden te krijgen?

Nee. Geen KYC: geen ID, geen selfie, geen documenten om je aan te melden, op te waarderen of te kopen. Waardeer op in BTC, USDT, USDC, ETH, SOL, LTC, koop een plan via US$ 1,29 en kopieer de regels uit je account in de snippets. Zie [prijzen](https://rackproxies.com/nl/pricing/) voor elke plangrootte.

**Voer de voorbeelden uit met je eigen IP** 1 IP voor US$ 1,29, HTTP en SOCKS5 inbegrepen. Zonder KYC, betaald in crypto. [Bekijk prijzen](https://rackproxies.com/nl/pricing/) · [Snelstart](https://rackproxies.com/nl/docs/quickstart/)

## Referenties

1. [curl man-pagina](https://curl.se/docs/manpage.html) — curl project (2026-10-19)
2. [Requests: Proxy's en SOCKS](https://requests.readthedocs.io/en/latest/user/advanced/) — Requests (2026-10-19)
3. [aiohttp: proxy-ondersteuning](https://docs.aiohttp.org/en/stable/client_advanced.html) — aiohttp (2026-10-19)
4. [undici: ProxyAgent](https://undici.nodejs.org/) — Node.js (2026-10-19)
5. [proxy-agents (https-proxy-agent, socks-proxy-agent)](https://github.com/TooTallNate/proxy-agents) — GitHub (2026-10-19)
6. [Playwright: HTTP-proxy](https://playwright.dev/docs/network) — Playwright (2026-10-19)

---

RackProxies: RackProxies is een aanbieder van dedicated datacenterproxy's: IPv4-adressen gehuurd per IP voor 30 dagen, betaald in crypto zonder ID-upload. Pagina's dekken 22 landen en 34 datacentersteden met openbare netwerkgegevens.