# Codebeispiele für Datacenter-Proxys: curl, Python, Node.js und Playwright

> Proxy-Codebeispiele für curl, Python requests und aiohttp, Node.js undici und Playwright, HTTP und SOCKS5. RackProxies: ab 1,29 $ pro IP, ohne KYC, mit Krypto bezahlen.

- URL: https://rackproxies.com/de/docs/code-examples/
- Zuletzt aktualisiert: 2026-10-19
- Publisher: RackProxies (https://rackproxies.com)

Kopierfertige Snippets für die gängigsten Clients, jedes auf Syntax geprüft. Alle Beispiele zielen auf api.ipify.org, httpbin.org/ip oder example.com.

**Kurze Antwort — Wie verwende ich einen Datacenter-Proxy im Code?**

Diese Proxy-Codebeispiele übergeben eine `http://USERNAME:PASSWORD@IP:PORT`-URL an deinen Client: `-x` in curl, `proxies=` in Python requests, eine `ProxyAgent` in Node.js, eine `proxy`-Option in Playwright. SOCKS5 nutzt `socks5h://`. **RackProxies**-IPs unterstützen HTTP, HTTPS (CONNECT) und SOCKS5, ab 1,29 $ pro dedizierter IPv4 für 30 Tage. Ohne KYC, nur mit Krypto bezahlen.

## Welches Snippet brauche ich?

*Ersetze in jedem Snippet die Dokumentationsadresse 203.0.113.24 und den Port 8000 durch eine Zeile aus deinem Account.*

| Client | HTTP-Proxy | SOCKS5-Proxy | Zusätzliches Paket |
| --- | --- | --- | --- |
| curl | `-x http://…` | `-x socks5h://…` | Keine |
| Python requests | `proxies={…}` | `socks5h://`-URL | `requests[socks]` für SOCKS5 |
| Python aiohttp | `proxy=` und `proxy_auth=` | Nicht integriert | `aiohttp-socks` für SOCKS5 |
| Node.js fetch | undici `ProxyAgent` | Nicht integriert | `undici` |
| Node.js https | `https-proxy-agent` | `socks-proxy-agent` | Eines von beiden |
| Playwright | `proxy: { server, username, password }` | HTTP verwenden oder die Allowlist | `playwright` |

## Wie verwende ich den Proxy mit curl?

Übergib die Proxy-URL mit `-x`. curl übernimmt den CONNECT-Tunnel für `https://`-Ziele selbst. Alle Snippets auf dieser Seite verwenden die Dokumentationsadresse `203.0.113.24`; die Seite [Verbindungsformat](https://rackproxies.com/de/docs/connection-format/) zeigt, wie du die URL aus deiner Zeile aufbaust.

*curl: HTTP, SOCKS5, separate Anmeldung, 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
```

## Wie verwende ich den Proxy mit Python requests?

Gib requests ein `proxies`-Dictionary mit derselben URL für `http` und `https`. Der `https`-Schlüssel wird für `https://`-Ziele verwendet; sein Wert beginnt weiterhin mit `http://`, weil er die Verbindung zum Proxy beschreibt. requests wirft `ProxyError`, wenn der Proxy die Verbindung oder die Anmeldung ablehnt.

*requests über einen HTTP-Proxy, mit Fehlerbehandlung*

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

*Anfragen über 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'}
```

*Eine Session für viele Anfragen über eine 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')
```

Lege einen `User-Agent` fest, der dein Tool und einen Kontakt nennt, wie im Session-Beispiel: Site-Betreiber können dich dann erreichen statt dich zu blockieren. requests liest außerdem die Umgebungsvariablen `HTTP_PROXY` und `HTTPS_PROXY`, wenn kein Argument `proxies` angegeben ist.

## Wie verwende ich den Proxy mit Python aiohttp?

aiohttp nimmt den Proxy pro Anfrage: `proxy=` für die Adresse und `proxy_auth=` für den Login. Es unterstützt HTTP-Proxys, inklusive CONNECT für `https://`-Ziele. Für SOCKS5 braucht es das separate Paket `aiohttp-socks`.

*aiohttp über einen 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())
```

## Wie verwende ich den Proxy mit Node.js?

Nodes eingebautes `fetch` nimmt kein Proxy-Argument, also nutze das Paket `undici` und dessen `ProxyAgent` als `dispatcher`. Für das klassische Modul `https` nutze `https-proxy-agent` für HTTP-Proxys und `socks-proxy-agent` für SOCKS5. Beide Snippets sind ES-Module: Speichere sie als `.mjs`-Dateien.

*fetch mit 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 mit https-proxy-agent und 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));
}
```

## Wie verwende ich den Proxy mit Playwright?

Übergib ein `proxy`-Objekt an `chromium.launch()` mit dem Server und separat Benutzername und Passwort. Nutze die HTTP-Form: Chromiums eingebauter SOCKS5-Client hat historisch keine Benutzername-Passwort-Authentifizierung für SOCKS5-Proxys unterstützt. Bei der IP-Allowlist lässt du `username` und `password` weg.

*Playwright (Chromium) über einen 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();
```

Nutze Browser über einen Proxy für QA deiner eigenen Sites, Anzeigen- und Lokalisierungsprüfungen und ähnliche rechtmäßige Aufgaben. Denk daran, dass ein Proxy nur die IP ändert: Sprache und Zeitzone des Browsers bleiben die deiner Maschine, außer du setzt sie im Browser-Kontext.

## Wie messe ich die Latenz über einen Proxy?

Messe die Zeit für einige vollständige Anfragen und nimm den Median. Das Python-Snippet unten sendet fünf Anfragen an `https://example.com` über eine IP. Führe es über IPs in verschiedenen Datacenter-Städten aus, um sie zu vergleichen; die [Städte-Anleitung](https://rackproxies.com/de/guides/choose-a-datacenter-city/) erklärt die physische Untergrenze für jede Entfernung.

*Median-Anfragezeit über einen 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')
```

## Wie verwende ich eine ganze Liste von IPs?

Lade deinen TXT-Export, wandle jede Zeile in eine URL um und wähle eine IP pro Anfrage: Round-Robin über Sites oder dieselbe IP für dieselbe Site. Die [Anleitung zu rotierend vs. statisch](https://rackproxies.com/de/guides/rotating-vs-static-datacenter-proxies/) hat ein vollständiges Beispiel, und die Seite [Verbindungsformat](https://rackproxies.com/de/docs/connection-format/) hat einen Konverter für die ganze Liste. Respektiere das Tempo jeder Site, egal wie groß deine Liste ist: mehr IPs erhöhen nicht das Limit einer Site.

## Fragen zu Codebeispielen

### Warum verwende ich http:// für den Proxy, wenn die Site https:// ist?

Das Schema der Proxy-URL beschreibt deine Verbindung zum Proxy, nicht zur Website. Dein Client verbindet sich über einfaches TCP zum Proxy, bittet ihn, einen CONNECT-Tunnel zu öffnen, und führt dann TLS mit der Website darin aus. Der Seiteninhalt bleibt durchgehend verschlüsselt; nur der Proxy-Login wird im lesbaren Format übertragen.

### Mein Passwort enthält Sonderzeichen. Was ändert sich?

In URL-Form kodiere das Passwort mit `urllib.parse.quote(password, safe='')` in Python oder `encodeURIComponent(password)` in JavaScript. Clients, die den Login separat annehmen, wie aiohttp's `BasicAuth`, Playwright's `username` und `password` oder curl's `-U`, brauchen keine Kodierung. Die Seite [Verbindungsformat](https://rackproxies.com/de/docs/connection-format/) listet die Zeichen auf.

### Warum meldet requests fehlende Abhängigkeiten für SOCKS-Unterstützung?

Die SOCKS-Unterstützung von requests steckt in einem optionalen Extra. Installiere es mit `pip install "requests[socks]"`, was PySocks hinzufügt, und verwende eine `socks5h://`-URL, damit der Proxy Hostnamen auflöst. HTTP-Proxys funktionieren ohne zusätzliches Paket, du kannst die URL also auch auf `http://` umstellen und deine Abhängigkeiten unverändert lassen.

### Kann ich viele Anfragen parallel über eine IP ausführen?

Ja, im Rahmen der Fair Use; wir veröffentlichen kein Verbindungslimit pro IP. Halte die Parallelität für deine eigene Stabilität vernünftig und beachte das Tempo jeder Website: parallele Anfragen an dieselbe Site zählen weiterhin gegen deren Limits. Abrechnung pro IP für 30 Tage, nicht pro GB, unter einer Fair-Use-Policy.

### Welche Test-URL sollte mein Code zuerst aufrufen?

Rufe `https://api.ipify.org` oder `https://httpbin.org/ip` auf: Beide geben die IP zurück, die sie sehen, sodass du bestätigen kannst, dass der Traffic von deinem Proxy ausgeht. Rufe dann dein eigentliches Ziel auf. Wenn die Test-URL funktioniert und das Ziel nicht, liegt das Problem zwischen Proxy und Ziel, nicht in deinem Code.

### Brauche ich einen Ausweis, um die Proxys für diese Beispiele zu bekommen?

Nein. Ohne KYC: keine ID, kein Selfie, keine Dokumente zum Registrieren, Einzahlen oder Kaufen. Lade in BTC, USDT, USDC, ETH, SOL, LTC auf, kaufe einen Plan über 1,29 $ und kopiere die Zeilen aus deinem Konto in die Snippets. Siehe [Preise](https://rackproxies.com/de/pricing/) für jede Plangröße.

**Führe die Beispiele mit deiner eigenen IP aus** 1 IP für 1,29 $, HTTP und SOCKS5 inklusive. Kein KYC, mit Krypto bezahlt. [Preise ansehen](https://rackproxies.com/de/pricing/) · [Schnellstart](https://rackproxies.com/de/docs/quickstart/)

## Referenzen

1. [curl man page](https://curl.se/docs/manpage.html) — curl project (2026-10-19)
2. [Requests: Proxies and SOCKS](https://requests.readthedocs.io/en/latest/user/advanced/) — Requests (2026-10-19)
3. [aiohttp: Proxy support](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 ist ein Anbieter dedizierter Datacenter-Proxys: IPv4-Adressen, gemietet pro IP für 30 Tage, bezahlt mit Krypto ohne ID-Upload. Die Seiten decken 22 Länder und 34 Datacenter-Städte mit öffentlichen Netzwerkdaten ab.