# Exemples de code proxy datacenter : curl, Python, Node.js et Playwright

> Exemples de code proxy pour curl, Python requests et aiohttp, Node.js undici et Playwright, HTTP et SOCKS5. RackProxies : à partir de 1,29 $US par IP, sans KYC, paiement en crypto.

- URL: https://rackproxies.com/fr/docs/code-examples/
- Dernière mise à jour: 2026-10-19
- Publisher: RackProxies (https://rackproxies.com)

Extraits prêts à copier pour les clients les plus courants, chacun testé pour la syntaxe. Chaque exemple cible api.ipify.org, httpbin.org/ip ou example.com.

**Réponse rapide — Comment utiliser un proxy datacenter dans le code ?**

Ces exemples de code proxy transmettent une URL de proxy `http://USERNAME:PASSWORD@IP:PORT` à votre client : `-x` dans curl, `proxies=` dans Python requests, un `ProxyAgent` dans Node.js, une option `proxy` dans Playwright. SOCKS5 utilise `socks5h://`. Les IP **RackProxies** prennent en charge HTTP, HTTPS (CONNECT) et SOCKS5, à partir de 1,29 $US par IPv4 dédiée pour 30 jours. Sans KYC, paiement en crypto uniquement.

## De quel extrait ai-je besoin ?

*L'adresse de documentation 203.0.113.24 et le port 8000 dans chaque extrait : remplacez-les par une ligne de votre compte.*

| Client | Proxy HTTP | Proxy SOCKS5 | Package supplémentaire |
| --- | --- | --- | --- |
| curl | `-x http://…` | `-x socks5h://…` | Aucun |
| Python requests | `proxies={…}` | URL `socks5h://` | `requests[socks]` pour SOCKS5 |
| Python aiohttp | `proxy=` et `proxy_auth=` | Non intégré | `aiohttp-socks` pour SOCKS5 |
| Node.js fetch | undici `ProxyAgent` | Non intégré | `undici` |
| Node.js https | `https-proxy-agent` | `socks-proxy-agent` | L'un des deux |
| Playwright | `proxy: { server, username, password }` | Utiliser HTTP ou l'allowlist | `playwright` |

## Comment utiliser le proxy avec curl ?

Passez l'URL du proxy avec `-x`. curl gère lui-même le tunnel CONNECT pour les cibles `https://`. Tous les extraits de cette page utilisent l'adresse de documentation `203.0.113.24` ; la page [format de connexion](https://rackproxies.com/fr/docs/connection-format/) montre comment construire l'URL à partir de votre ligne.

*curl : HTTP, SOCKS5, identifiants séparés, 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
```

## Comment utiliser le proxy avec Python requests ?

Donnez à requests un dictionnaire `proxies` avec la même URL pour `http` et `https`. La clé `https` est celle utilisée pour les cibles `https://` ; sa valeur commence toujours par `http://` car elle décrit la connexion au proxy. requests lève `ProxyError` lorsque le proxy refuse la connexion ou l'identifiant.

*requests via un proxy HTTP, avec gestion des erreurs*

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

*requêtes 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'}
```

*Une session pour de nombreuses requêtes via une seule 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')
```

Définissez un `User-Agent` qui nomme votre outil et un contact, comme dans l'exemple Session : les propriétaires de sites peuvent alors vous joindre au lieu de vous bloquer. requests lit aussi les variables d'environnement `HTTP_PROXY` et `HTTPS_PROXY` lorsqu'aucun argument `proxies` n'est fourni.

## Comment utiliser le proxy avec Python aiohttp ?

aiohttp prend le proxy par requête : `proxy=` pour l'adresse et `proxy_auth=` pour le login. Il prend en charge les proxies HTTP, dont CONNECT pour les cibles `https://`. Pour SOCKS5, il nécessite le package `aiohttp-socks` séparé.

*aiohttp via un proxy HTTP*

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

## Comment utiliser le proxy avec Node.js ?

Le module intégré `fetch` de Node ne prend pas d'argument proxy, utilisez donc le package `undici` et son `ProxyAgent` comme `dispatcher`. Pour le module classique `https`, utilisez `https-proxy-agent` pour les proxies HTTP et `socks-proxy-agent` pour SOCKS5. Les deux extraits sont des modules ES : enregistrez-les en fichiers `.mjs`.

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

## Comment utiliser le proxy avec Playwright ?

Passez un objet `proxy` à `chromium.launch()` avec le serveur et, séparément, le nom d'utilisateur et le mot de passe. Utilisez la forme HTTP : le client SOCKS5 intégré à Chromium n'a historiquement pas pris en charge l'authentification par nom d'utilisateur et mot de passe pour les proxies SOCKS5. Avec la liste blanche d'IP, omettez `username` et `password`.

*Playwright (Chromium) via un proxy HTTP*

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

Utilisez des navigateurs via un proxy pour le QA de vos propres sites, les vérifications publicitaires et de localisation et des tâches licites similaires. Rappelez-vous qu'un proxy ne change que l'IP : la langue et le fuseau horaire du navigateur restent ceux de votre machine, sauf si vous les définissez dans le contexte du navigateur.

## Comment mesurer la latence via un proxy ?

Chronométrez quelques requêtes complètes et gardez la médiane. L'extrait Python ci-dessous envoie cinq requêtes à `https://example.com` via une seule IP. Exécutez-le via des IP dans différentes villes de datacenter pour les comparer ; le [guide des villes](https://rackproxies.com/fr/guides/choose-a-datacenter-city/) explique le plancher physique pour chaque distance.

*Temps de requête médian via un 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')
```

## Comment utiliser toute une liste d'IP ?

Chargez votre export TXT, convertissez chaque ligne en URL et choisissez une IP par requête : en round-robin entre les sites, ou la même IP pour le même site. Le [guide rotating vs static](https://rackproxies.com/fr/guides/rotating-vs-static-datacenter-proxies/) contient un exemple complet, et la page [format de connexion](https://rackproxies.com/fr/docs/connection-format/) propose un convertisseur pour toute la liste. Respectez le rythme de chaque site quelle que soit la taille de votre liste : plus d'IP n'augmente pas la limite d'un site.

## Questions sur les exemples de code

### Pourquoi utiliser http:// pour le proxy alors que le site est en https:// ?

Le schéma de l'URL du proxy décrit votre connexion au proxy, pas au site web. Votre client se connecte au proxy via TCP simple, lui demande d'ouvrir un tunnel CONNECT, puis exécute TLS avec le site web à l'intérieur. Le contenu de la page reste chiffré de bout en bout ; seul le login du proxy circule en clair.

### Mon mot de passe contient des caractères spéciaux. Qu'est-ce qui change ?

Sous forme d'URL, encodez le mot de passe avec `urllib.parse.quote(password, safe='')` en Python ou `encodeURIComponent(password)` en JavaScript. Les clients qui prennent le login séparément, comme `BasicAuth` d'aiohttp, `username` et `password` de Playwright, ou `-U` de curl, n'ont pas besoin d'encodage. La page [format de connexion](https://rackproxies.com/fr/docs/connection-format/) liste les caractères.

### Pourquoi requests indique-t-il qu'il manque des dépendances pour la prise en charge de SOCKS ?

La prise en charge de SOCKS dans requests réside dans un extra optionnel. Installez-la avec `pip install "requests[socks]"`, qui ajoute PySocks, et utilisez une URL `socks5h://` pour que le proxy résolve les noms d'hôtes. Les proxies HTTP fonctionnent sans package supplémentaire, vous pouvez donc aussi passer l'URL en `http://` et garder vos dépendances inchangées.

### Puis-je exécuter de nombreuses requêtes en parallèle via une seule IP ?

Oui, dans le cadre d'un usage équitable ; nous ne publions pas de limite de connexions par IP. Gardez un parallélisme raisonnable pour votre propre stabilité, et respectez le rythme de chaque site : les requêtes parallèles vers le même site comptent quand même dans ses limites. Facturé par IP pour 30 jours, pas par GB, selon une politique d'usage raisonnable.

### Quelle URL de test mon code doit-il appeler en premier ?

Appelez `https://api.ipify.org` ou `https://httpbin.org/ip` : chacune renvoie l'IP qu'elle voit, ce qui vous permet de confirmer que le trafic sort bien par votre proxy. Appelez ensuite votre cible réelle. Si l'URL de test fonctionne et pas la cible, le problème se situe entre le proxy et la cible, pas dans votre code.

### Ai-je besoin d'une pièce d'identité pour obtenir les proxies de ces exemples ?

Non. Sans KYC : aucune pièce d'identité, aucun selfie, aucun document pour s'inscrire, recharger ou acheter. Rechargez en BTC, USDT, USDC, ETH, SOL, LTC, achetez un plan depuis 1,29 $US, et copiez les lignes de votre compte dans les extraits. Voir [tarifs](https://rackproxies.com/fr/pricing/) pour toutes les tailles de plan.

**Exécutez les exemples avec votre propre IP** 1 IP pour 1,29 $US, HTTP et SOCKS5 inclus. Sans KYC, payer en crypto. [Voir les tarifs](https://rackproxies.com/fr/pricing/) · [Démarrage rapide](https://rackproxies.com/fr/docs/quickstart/)

## Références

1. [page man de curl](https://curl.se/docs/manpage.html) — curl project (2026-10-19)
2. [Requests : Proxies et SOCKS](https://requests.readthedocs.io/en/latest/user/advanced/) — Requests (2026-10-19)
3. [aiohttp : prise en charge des proxies](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 : proxy HTTP](https://playwright.dev/docs/network) — Playwright (2026-10-19)

---

RackProxies: RackProxies est un fournisseur de proxies datacenter dédiés : adresses IPv4 louées par IP pour 30 jours, payées en crypto sans envoi de pièce d'identité. Les pages couvrent 22 pays et 34 villes de datacenter avec des données de réseau public.