# Selenium avec un proxy authentifié : un forwarder local qui fonctionne

> Proxies authentifiés dans Selenium : pourquoi Chrome ignore les identifiants proxy, et un petit forwarder Python de 40 lignes qui les ajoute. Proxy résidentiel, sans KYC.

- URL: https://crawlrelay.com/fr/docs/selenium/
- Dernière mise à jour: 2026-10-13
- Publisher: CrawlRelay (https://crawlrelay.com)

Le paramètre proxy de Chrome ne prévoit pas de mot de passe. Un petit forwarder local sur 127.0.0.1 ajoute les identifiants, ainsi Selenium ne voit qu’un proxy local ouvert.

**Réponse rapide — Comment utiliser un proxy avec nom d’utilisateur et mot de passe dans Selenium ?**

Lancez un petit forwarder local qui ajoute l’en-tête `Proxy-Authorization`, et configurez Chrome pour l’utiliser avec `--proxy-server=http://127.0.0.1:8899`. Chrome ignore les identifiants dans ce paramètre, et Selenium n’a pas d’option portable pour les mots de passe proxy. Les proxies résidentiels **CrawlRelay** fonctionnent ainsi sur `gw.crawlrelay.com:7777`, depuis 0,50 $US/GB. Paiement en crypto, sans KYC.

## Installation rapide de Selenium

| Attribut | Valeur |
| --- | --- |
| Pourquoi un forwarder | Le paramètre `--proxy-server` de Chrome n’accepte ni nom d’utilisateur ni mot de passe |
| Forwarder | Écoute sur `127.0.0.1:8899`, ajoute `Proxy-Authorization`, relaie vers `gw.crawlrelay.com:7777` |
| Option Chrome | `--proxy-server=http://127.0.0.1:8899` |
| Rotation | Chaque nouveau tunnel CONNECT crée une connexion nouvelle, donc généralement une nouvelle sortie ; ajoutez un ID de session pour une IP unique |
| Alternative plus simple | [Playwright](https://crawlrelay.com/fr/docs/playwright/) prend directement le nom d'utilisateur et le mot de passe |

## Comment fonctionne le proxy local ?

Il accepte la requête proxy du navigateur, insère un en-tête avec vos identifiants, puis copie les données dans les deux sens. Pour un site HTTPS, le navigateur envoie `CONNECT host:443`, la passerelle répond `200 Connection established`, et TLS s’exécute de bout en bout entre Chrome et le site. Le proxy local ne voit jamais le contenu de la page en clair.

Cette version minimale gère les sites HTTPS, où chaque connexion porte un tunnel CONNECT. Cela couvre presque tous les sites web aujourd’hui. Gardez-le lié à `127.0.0.1` pour qu’aucune autre machine ne puisse utiliser vos identifiants.

*forwarder.py (Python 3.8+, uniquement bibliothèque standard)*

```python
import asyncio
import base64
import os

UPSTREAM = ("gw.crawlrelay.com", 7777)
USER = os.environ.get("CRAWLRELAY_USER", "USERNAME-country-us")
PASSWORD = os.environ.get("CRAWLRELAY_PASSWORD", "PASSWORD")
AUTH = b"Proxy-Authorization: Basic " + base64.b64encode(("%s:%s" % (USER, PASSWORD)).encode())


async def pipe(reader, writer):
    try:
        while True:
            data = await reader.read(65536)
            if not data:
                break
            writer.write(data)
            await writer.drain()
    except ConnectionError:
        pass
    finally:
        writer.close()


async def handle(client_reader, client_writer):
    try:
        head = await client_reader.readuntil(b"\r\n\r\n")  # request line and headers from the browser
    except asyncio.IncompleteReadError:
        client_writer.close()
        return
    lines = head.split(b"\r\n")
    lines.insert(1, AUTH)  # add the credentials right after the request line
    up_reader, up_writer = await asyncio.open_connection(*UPSTREAM)
    up_writer.write(b"\r\n".join(lines))
    await up_writer.drain()
    await asyncio.gather(pipe(client_reader, up_writer), pipe(up_reader, client_writer))


async def main():
    server = await asyncio.start_server(handle, "127.0.0.1", 8899)
    async with server:
        await server.serve_forever()


if __name__ == "__main__":
    asyncio.run(main())
```

## Comment configurer Selenium pour utiliser le proxy local ?

Démarrez `forwarder.py` dans un terminal, puis lancez votre script Selenium avec l’adresse proxy locale. Selenium Manager, intégré à Selenium 4.6 et versions supérieures, télécharge automatiquement un ChromeDriver compatible, donc rien d’autre à installer.

*selenium_example.py*

```python
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
options.add_argument("--headless=new")

driver = webdriver.Chrome(options=options)
try:
    driver.set_page_load_timeout(60)
    driver.get("https://api.ipify.org")
    print("exit IP:", driver.find_element(By.TAG_NAME, "body").text)
finally:
    driver.quit()
```

## Comment obtenir une IP par session Selenium, ou une IP nouvelle par page ?

Le proxy local envoie l’identifiant que vous lui donnez, donc le comportement de la session dépend de cet identifiant :

- **Rotation par connexion :** omettez la partie session (`USERNAME-country-us`). Chrome ouvre plusieurs connexions par page, donc une page peut charger via plusieurs sorties.
- **Une IP par session Selenium :** définissez `CRAWLRELAY_USER` à `USERNAME-country-us-session-run42-ttl-30` avant de démarrer le proxy local. Chaque connexion utilise alors la même IP pendant 30 minutes maximum ; l’IP peut changer plus tôt.
- **Plusieurs sessions en parallèle :** lancez un proxy local par session sur des ports locaux différents, par exemple 8899 et 8900, et donnez à chaque WebDriver son port dédié.

## Qu’en est-il de selenium-wire ou des extensions navigateur ?

selenium-wire, un package populaire qui ajoutait l’authentification proxy en interceptant le trafic, a été archivé par son auteur en janvier 2024 et ne reçoit plus de mises à jour. Une extension navigateur répondant à la demande d’authentification proxy fonctionne aussi, mais doit être empaquetée et chargée dans chaque profil. Le proxy local ci-dessus est sans dépendances et marche avec n’importe quel navigateur piloté par Selenium. Pour les nouveaux projets, [Playwright](https://crawlrelay.com/fr/docs/playwright/) est encore plus simple : il prend directement le nom d’utilisateur et le mot de passe du proxy.

## Selenium et proxies : questions

### Pourquoi Chrome affiche-t-il une fenêtre de connexion avec mon proxy dans Selenium ?

Parce que le proxy demande des identifiants et que Chrome n’en avait pas : son option `--proxy-server` ne prend qu’un hôte et un port. En mode headless, le même problème apparaît sous `ERR_TUNNEL_CONNECTION_FAILED`. Utilisez un proxy local qui ajoute les identifiants, ou passez à Playwright, qui accepte un nom d’utilisateur et un mot de passe.

### Le proxy local ralentit-il mon scraping ?

Pas vraiment. Il copie les données entre deux sockets locales et une distante, sans rien déchiffrer. Le temps de chargement d’une page dépend de la sortie proxy résidentiel et du site cible, pas du proxy local qui tourne sur la même machine.

### Puis-je utiliser Firefox à la place de Chrome avec Selenium ?

Oui. Configurez les préférences proxy de Firefox via `FirefoxOptions` : `network.proxy.type` à 1, et `network.proxy.http` et `network.proxy.ssl` à `127.0.0.1` avec le port 8899. Gardez le proxy local devant : Firefox demande les identifiants proxy dans une boîte de dialogue que Selenium ne peut pas remplir de façon fiable non plus.

### Mon mot de passe est-il sécurisé dans le proxy local ?

Il reste sur votre machine tant que le proxy local écoute sur `127.0.0.1`, comme dans l’exemple. Lisez-le depuis des variables d’environnement, ne le commettez jamais dans un dépôt, et utilisez un sous-utilisateur dédié avec un plafond de trafic pour chaque scraper afin qu’un mot de passe divulgué ne puisse pas épuiser tout votre forfait.

**Comment utiliser une sortie proxy résidentiel avec Selenium** 1,50 $US pour 1 GB en test, 0,50 $US/GB à partir de 50 GB. [Voir les tarifs](https://crawlrelay.com/fr/pricing/) · [Guide Playwright](https://crawlrelay.com/fr/docs/playwright/)

---

CrawlRelay: CrawlRelay est un service de proxy résidentiel rotatif et proxy mobile 4G/5G pour développeurs, adapté aux scrapers et pipelines de données IA : trafic prépayé sans expiration à partir de 0,50 $US/GB, paiement en crypto, sans téléchargement d’ID. Sans KYC — pas d’ID, pas de selfie, pas de documents. Payer en crypto.