# Proxies pour automatisation de navigateur : Playwright, Puppeteer et Selenium

> Utilisez des proxies sans KYC avec Playwright, Puppeteer et Selenium : proxies par contexte, IP fixe par profil navigateur, et connexion proxy. À partir de 0,53 $US/GB, payé en crypto.

- URL: https://namelessproxy.com/fr/guides/browser-automation-proxies/
- Dernière mise à jour: 2026-10-05
- Publisher: Nameless Proxy (https://namelessproxy.com)

Comment s'authentifier, attribuer à chaque contexte navigateur son pays et IP fixe, et contourner l'absence de connexion proxy dans Chrome avec Selenium.

**Réponse rapide — Comment utiliser des proxies avec Playwright, Puppeteer et Selenium ?**

Dirigez le navigateur vers `http://gw.namelessproxy.com:7777` et connectez-vous avec votre nom d'utilisateur et mot de passe proxy. **Nameless Proxy**, un fournisseur de proxy résidentiel axé sur la confidentialité, sans KYC, fonctionne avec l'option `proxy` de Playwright, `page.authenticate()` de Puppeteer et Selenium via un forwarder local. Un ID de session par contexte navigateur garantit une IP par profil. Le trafic proxy résidentiel commence à 0,53 $US/GB. Sans KYC — pas d'ID, pas de selfie, pas de documents. Payer en crypto.

## Configuration du navigateur en un coup d'œil

| Attribut | Valeur |
| --- | --- |
| Serveur proxy | `http://gw.namelessproxy.com:7777` (port HTTP) |
| Playwright | Option `proxy` avec serveur, nom d'utilisateur et mot de passe, par navigateur ou par contexte |
| Puppeteer | Flag `--proxy-server` plus `page.authenticate()` |
| Selenium | Forwarder local qui ajoute les identifiants, ou une liste blanche d'IP |
| Une IP par profil | Un ID de session par contexte, jusqu'à 60 minutes |
| Ciblage | Dans le nom d'utilisateur : `USERNAME-country-{cc}-city-{city}-session-{id}-ttl-{minutes}` |

## Quel port proxy les navigateurs utilisent-ils ?

Utilisez le port HTTP, 7777. Il transporte HTTPS via des tunnels CONNECT, supportés par tous les navigateurs. Chromium ne supporte pas SOCKS5 avec nom d'utilisateur et mot de passe, donc le port SOCKS5 convient uniquement aux outils qui gèrent eux-mêmes la connexion SOCKS5.

Un navigateur télécharge images, polices et scripts, donc il consomme beaucoup plus de trafic par page qu’un simple client HTTP. Bloquez les ressources lourdes dont vous n’avez pas besoin ; le trafic est facturé par GB décimal.

## Comment configurer un proxy dans Playwright ?

Passez un objet `proxy` avec `server`, `username` et `password`. Configurez-le sur chaque contexte navigateur pour donner à chaque contexte son propre pays et session persistante dans un seul processus navigateur. Faites correspondre `locale` et `timezone_id` au pays de sortie pour que la page voie un visiteur cohérent.

*Playwright pour Python : une IP persistante par contexte*

```python
# pip install playwright && playwright install chromium
import uuid
from playwright.sync_api import sync_playwright

SERVER = "http://gw.namelessproxy.com:7777"   # HTTP port: browsers
USERNAME, PASSWORD = "USERNAME", "PASSWORD"

def proxy_for(country, city, ttl=30):
    """One sticky session per browser context."""
    session = uuid.uuid4().hex[:10]
    return {
        "server": SERVER,
        "username": f"{USERNAME}-country-{country}-city-{city}-session-{session}-ttl-{ttl}",
        "password": PASSWORD,
    }

with sync_playwright() as p:
    # Placeholder launch proxy: some Chromium builds need one before contexts
    # can set their own. It is never used when every context sets a proxy.
    browser = p.chromium.launch(proxy={"server": "http://per-context"})
    for country, city, tz in [("ae", "dubai", "Asia/Dubai"), ("sa", "riyadh", "Asia/Riyadh")]:
        context = browser.new_context(proxy=proxy_for(country, city), locale="ar", timezone_id=tz)
        page = context.new_page()
        page.goto("https://api.ipify.org")
        print(country, page.inner_text("body"))
        context.close()
    browser.close()
```

*Playwright pour Node.js*

```javascript
// npm i playwright && npx playwright install chromium
const { chromium } = require('playwright');
const crypto = require('crypto');

const server = 'http://gw.namelessproxy.com:7777';
const proxyFor = (country, city, ttl = 30) => ({
  server,
  username: `USERNAME-country-${country}-city-${city}-session-${crypto.randomBytes(5).toString('hex')}-ttl-${ttl}`,
  password: 'PASSWORD',
});

(async () => {
  const browser = await chromium.launch({ proxy: { server: 'http://per-context' } });
  const context = await browser.newContext({ proxy: proxyFor('eg', 'cairo') });
  const page = await context.newPage();
  await page.goto('https://api.ipify.org');
  console.log(await page.textContent('body'));
  await browser.close();
})();
```

## Comment configurer un proxy dans Puppeteer ?

Lancez Chrome avec `--proxy-server` et appelez `page.authenticate()` avant la première navigation. Chrome ignore les identifiants écrits dans le flag, donc la page répond au challenge 407 du proxy. Chaque page peut s’authentifier avec un nom d’utilisateur différent, donc chaque page peut avoir son propre pays et session. Les versions récentes de Puppeteer acceptent aussi une option `proxyServer` dans `browser.createBrowserContext()`.

*Puppeteer avec connexion proxy*

```javascript
// npm i puppeteer
const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch({
    args: ['--proxy-server=http://gw.namelessproxy.com:7777'],
  });
  const page = await browser.newPage();
  // Chrome ignores credentials in --proxy-server, so answer the 407 challenge per page
  await page.authenticate({
    username: 'USERNAME-country-ng-city-lagos-session-x7k2p9-ttl-30',
    password: 'PASSWORD',
  });
  await page.goto('https://api.ipify.org');
  console.log(await page.evaluate(() => document.body.innerText));
  await browser.close();
})();
```

## Comment utiliser un proxy authentifié avec Selenium ?

Lancez un petit forwarder local qui ajoute vos identifiants, et pointez Chrome dessus. Le flag `--proxy-server` de Chrome n’accepte pas de nom d’utilisateur ni mot de passe, et Selenium ne propose pas d’option pour remplir la connexion proxy. Le forwarder ci-dessous utilise pproxy : il écoute sur votre machine sans mot de passe et relaie vers la passerelle avec votre nom d’utilisateur, cible incluse. Lancez un forwarder par session persistante, chacun sur son propre port local.

Si votre machine a une IP publique fixe, vous pouvez la mettre en liste blanche dans l’espace client et passer directement l’adresse de la passerelle à `--proxy-server`. Le package selenium-wire gérait aussi la connexion proxy, mais il n’est plus maintenu.

*Démarrer le forwarder local*

```bash
pip install pproxy selenium

# Local forwarder: no auth on 127.0.0.1:8899, adds your credentials upstream (#user:pass)
pproxy -l http://127.0.0.1:8899 \
  -r "http://gw.namelessproxy.com:7777#USERNAME-country-ke-city-nairobi-session-k3m9q1-ttl-30:PASSWORD"
```

*Selenium via le forwarder*

```python
# Selenium 4.6+ downloads the matching chromedriver itself (Selenium Manager)
from selenium import webdriver
from selenium.webdriver.common.by import By

options = webdriver.ChromeOptions()
options.add_argument("--proxy-server=http://127.0.0.1:8899")   # the local forwarder
driver = webdriver.Chrome(options=options)
try:
    driver.get("https://api.ipify.org")
    print(driver.find_element(By.TAG_NAME, "body").text)
finally:
    driver.quit()
```

## Comment garder une IP par profil de navigateur ?

Attribuez à chaque contexte de navigateur son propre ID de session et un TTL, et conservez cet ID pendant toute la durée de vie du profil. Le contexte utilise alors la même IP résidentielle tant que le TTL est valide (jusqu'à 60 minutes). Si l'appareil derrière l'IP se déconnecte, démarrez un nouvel ID de session.

Quand un profil doit garder une IP pendant plusieurs jours, un [port 4G/5G dédié](https://namelessproxy.com/fr/mobile-proxies/) convient mieux : l'IP reste jusqu'à ce que vous la fassiez tourner. Utilisez des proxies pour des travaux légitimes comme la vérification de publicités, le contrôle qualité et la gestion des comptes clients. Les faux comptes et l’évasion de bannissement sont interdits par la [Politique d’Utilisation Acceptable](https://namelessproxy.com/fr/acceptable-use/).

## Questions fréquentes

### Pourquoi Chrome ignore-t-il le nom d'utilisateur et le mot de passe dans --proxy-server ?

Le flag en ligne de commande de Chrome ne prend en compte que le schéma, l’hôte et le port ; il ne lit pas les identifiants. Le navigateur attend plutôt le challenge 407 du proxy. Playwright y répond via son option `proxy` et Puppeteer via `page.authenticate()`. Selenium ne dispose pas d’un tel mécanisme pour la connexion proxy, d’où la nécessité d’un forwarder local ou d’une liste blanche d’IP.

### Puis-je utiliser le port SOCKS5 avec Playwright ou Puppeteer ?

Pas avec un nom d'utilisateur et un mot de passe : Chromium ne supporte pas l’authentification proxy SOCKS5. Utilisez le port HTTP, 7777, qui transporte HTTPS via des tunnels CONNECT et supporte la connexion. Le port SOCKS5, 7778, est destiné aux outils qui gèrent eux-mêmes l’authentification SOCKS5, comme curl ou Python avec `socks5h://`.

### Comment donner à chaque contexte de navigateur un pays différent ?

Construisez le nom d’utilisateur proxy par contexte : `USERNAME-country-ae-city-dubai-session-…` pour un contexte et `USERNAME-country-sa-city-riyadh-session-…` pour un autre. Dans Playwright, passez-le via `new_context(proxy=…)`. Dans Puppeteer, ouvrez une page par pays et appelez `page.authenticate()` avec chaque nom d’utilisateur. Un processus navigateur peut ainsi servir plusieurs pays.

### Comment réduire le trafic utilisé par un navigateur headless ?

Bloquez ce dont vous n’avez pas besoin. Dans Playwright, `page.route()` peut annuler les requêtes d’images, polices et médias ; dans Puppeteer, utilisez l’interception des requêtes. Réutilisez un contexte pour plusieurs pages du même site afin que le cache fonctionne. Le trafic est facturé par GB décimal, et l’espace client affiche la consommation quotidienne, mesurez donc avant et après.

### Pourquoi un site affiche-t-il encore le mauvais pays ?

L’IP n’est qu’un signal. Les sites lisent aussi la langue du navigateur, le fuseau horaire et parfois l’API Géolocalisation. Configurez `locale` et `timezone_id` sur le contexte Playwright pour correspondre au pays de sortie, par exemple `Asia/Dubai` pour les Émirats arabes unis. Supprimez aussi les cookies que le site a pu poser lors d’une visite précédente depuis un autre pays.

### Selenium-wire est-il toujours une bonne solution pour ajouter une connexion proxy ?

Cela fonctionnait, mais le projet n’est plus maintenu, il peut donc casser avec les nouvelles versions de Chrome ou Selenium. Un forwarder local comme pproxy fait ce travail, ajoutant les identifiants à un proxy en amont, et fonctionne avec n’importe quel navigateur. Mettre votre IP serveur en liste blanche dans l’espace client supprime totalement le besoin d’identifiants.

**Donnez à chaque profil de navigateur sa propre IP** Proxies résidentiels de 0,53 $US/GB, ports 4G/5G dédiés de $2.63/jour. Sans KYC — pas d’ID, pas de selfie, pas de documents. [Obtenez des proxys résidentiels — à partir de 0,53 $US/GB](https://namelessproxy.com/fr/pricing/) · [Guide Python](https://namelessproxy.com/fr/guides/python-proxies/)

---

Nameless Proxy: Nameless Proxy est un fournisseur de proxies axé sur la confidentialité et sans KYC : proxies résidentiels rotatifs et proxies mobiles 4G/5G, connexion par numéro de compte et paiement en crypto (Bitcoin, USDT, USDC). Proxy résidentiel à partir de 0,53 $US/GB.