Configuration de proxy dans Selenium WebDriver : guide complet avec exemples de code pour Python et Java

Selenium WebDriver est l'un des outils les plus populaires pour l'automatisation des navigateurs et le scraping de données. Lorsqu'il s'agit de traiter de grands volumes de requêtes ou de contourner des restrictions géographiques, il est crucial de configurer correctement les proxies. Dans ce guide, nous examinerons toutes les méthodes d'intégration des proxies dans Selenium pour différents navigateurs et langages de programmation, ainsi que les problèmes courants auxquels les développeurs sont confrontés.

Pourquoi utiliser des proxies dans Selenium

Lors de l'automatisation du web scraping ou des tests via Selenium, plusieurs tâches ne peuvent être résolues sans proxies :

• Contourner le rate limiting — de nombreux sites limitent le nombre de requêtes provenant d'une seule adresse IP. Sans proxy, votre script sera rapidement bloqué après 50-100 requêtes.
• Restrictions géographiques — si vous devez scraper du contenu accessible uniquement depuis un pays spécifique, un proxy avec une IP de la géolocalisation requise résout ce problème.
• Répartition de la charge — lors du scraping massif de données, la rotation des adresses IP via des proxies permet de répartir les requêtes et d'éviter la détection des bots.
• Tests de localisation — pour vérifier comment un site s'affiche aux utilisateurs de différents pays, des proxies des régions correspondantes sont nécessaires.
• Contourner les systèmes anti-bots — les protections modernes (Cloudflare, DataDome) analysent la réputation des IP. Des proxies de qualité aident à se comporter comme un utilisateur normal.

Sans une configuration correcte des proxies, votre script Selenium fonctionnera de manière instable : il recevra des captchas, des bans temporaires ou un blocage total d'accès. Cela est particulièrement critique lors du scraping de sites e-commerce, de réseaux sociaux ou de sites avec une protection agressive contre les bots.

Quels types de proxies utiliser

Le choix du type de proxy dépend de la tâche. Pour l'automatisation Selenium, trois types principaux de proxies sont utilisés, chacun avec ses avantages :

Recommandations pour le choix :

• Pour le scraping de sites d'actualités, d'API ouvertes, de catalogues simples — les proxies de centre de données conviennent. Ils sont moins chers et plus rapides.
• Pour travailler avec Amazon, eBay, Google, réseaux sociaux — uniquement des proxies résidentiels. Ces plateformes bloquent activement les IP des centres de données.
• Pour émuler des utilisateurs mobiles ou travailler avec Instagram, TikTok — les proxies mobiles sont indispensables.
• Pour tester la géolocalisation — choisissez des proxies avec la possibilité de sélectionner un pays et une ville spécifiques.

Configuration des proxies pour Chrome dans Selenium

Chrome WebDriver est le choix le plus populaire pour l'automatisation Selenium. La configuration des proxies se fait via l'objet ChromeOptions. Examinons plusieurs méthodes.

Méthode 1 : Proxies HTTP/HTTPS sans authentification (Python)

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

# Configuration du proxy
PROXY = "123.45.67.89:8080"  # Remplacez par votre serveur proxy

chrome_options = Options()
chrome_options.add_argument(f'--proxy-server=http://{PROXY}')

# Options supplémentaires pour la stabilité
chrome_options.add_argument('--no-sandbox')
chrome_options.add_argument('--disable-dev-shm-usage')

# Lancement du driver
driver = webdriver.Chrome(options=chrome_options)

# Vérification de l'IP
driver.get('https://httpbin.org/ip')
print(driver.page_source)

driver.quit()

Méthode 2 : Proxies SOCKS5 (Python)

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

PROXY = "123.45.67.89:1080"

chrome_options = Options()
# Pour SOCKS5, spécifiez le protocole explicitement
chrome_options.add_argument(f'--proxy-server=socks5://{PROXY}')

driver = webdriver.Chrome(options=chrome_options)
driver.get('https://httpbin.org/ip')
print(driver.page_source)
driver.quit()

Important : Chrome prend en charge les proxies HTTP, HTTPS et SOCKS5. Pour SOCKS4, des configurations supplémentaires ou l'utilisation d'extensions sont nécessaires.

Configuration des proxies pour Chrome en Java

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.Proxy;

public class ChromeProxyExample {
    public static void main(String[] args) {
        // Configuration du proxy
        Proxy proxy = new Proxy();
        proxy.setHttpProxy("123.45.67.89:8080");
        proxy.setSslProxy("123.45.67.89:8080");
        
        ChromeOptions options = new ChromeOptions();
        options.setProxy(proxy);
        options.addArguments("--no-sandbox");
        
        WebDriver driver = new ChromeDriver(options);
        driver.get("https://httpbin.org/ip");
        
        System.out.println(driver.getPageSource());
        driver.quit();
    }
}

Configuration des proxies pour Firefox dans Selenium

Firefox WebDriver utilise une approche différente pour configurer les proxies via le profil du navigateur. Cela offre plus de flexibilité, mais nécessite une compréhension des paramètres de configuration.

Proxies HTTP/HTTPS pour Firefox (Python)

from selenium import webdriver
from selenium.webdriver.firefox.options import Options

PROXY_HOST = "123.45.67.89"
PROXY_PORT = 8080

firefox_options = Options()

# Configuration du proxy via preferences
firefox_options.set_preference("network.proxy.type", 1)
firefox_options.set_preference("network.proxy.http", PROXY_HOST)
firefox_options.set_preference("network.proxy.http_port", PROXY_PORT)
firefox_options.set_preference("network.proxy.ssl", PROXY_HOST)
firefox_options.set_preference("network.proxy.ssl_port", PROXY_PORT)

# Désactiver le proxy pour les adresses locales
firefox_options.set_preference("network.proxy.no_proxies_on", "localhost,127.0.0.1")

driver = webdriver.Firefox(options=firefox_options)
driver.get('https://httpbin.org/ip')
print(driver.page_source)
driver.quit()

Proxies SOCKS5 pour Firefox (Python)

from selenium import webdriver
from selenium.webdriver.firefox.options import Options

PROXY_HOST = "123.45.67.89"
PROXY_PORT = 1080

firefox_options = Options()

firefox_options.set_preference("network.proxy.type", 1)
firefox_options.set_preference("network.proxy.socks", PROXY_HOST)
firefox_options.set_preference("network.proxy.socks_port", PROXY_PORT)
firefox_options.set_preference("network.proxy.socks_version", 5)

# Pour SOCKS5 avec DNS via proxy
firefox_options.set_preference("network.proxy.socks_remote_dns", True)

driver = webdriver.Firefox(options=firefox_options)
driver.get('https://httpbin.org/ip')
print(driver.page_source)
driver.quit()

Avantage de Firefox : le paramètre network.proxy.socks_remote_dns permet d'effectuer des requêtes DNS via le proxy, ce qui augmente l'anonymat et aide à contourner les blocages au niveau DNS.

Travailler avec des proxies nécessitant une authentification

La plupart des services de proxy de qualité utilisent une authentification par nom d'utilisateur et mot de passe. Selenium ne prend pas en charge la transmission des identifiants directement dans l'URL du proxy pour Chrome, donc des solutions de contournement sont nécessaires.

Méthode 1 : Extension Chrome pour l'authentification (recommandée)

Créons une extension Chrome temporaire qui insère automatiquement le nom d'utilisateur et le mot de passe lors de la connexion au proxy :

import os
import zipfile
from selenium import webdriver
from selenium.webdriver.chrome.options import Options

PROXY_HOST = "123.45.67.89"
PROXY_PORT = 8080
PROXY_USER = "username"
PROXY_PASS = "password"

# Création du manifeste de l'extension
manifest_json = """
{
    "version": "1.0.0",
    "manifest_version": 2,
    "name": "Chrome Proxy",
    "permissions": [
        "proxy",
        "tabs",
        "unlimitedStorage",
        "storage",
        "webRequest",
        "webRequestBlocking"
    ],
    "background": {
        "scripts": ["background.js"]
    }
}
"""

# Script pour l'authentification
background_js = """
var config = {
    mode: "fixed_servers",
    rules: {
        singleProxy: {
            scheme: "http",
            host: "%s",
            port: parseInt(%s)
        },
        bypassList: ["localhost"]
    }
};

chrome.proxy.settings.set({value: config, scope: "regular"}, function() {});

function callbackFn(details) {
    return {
        authCredentials: {
            username: "%s",
            password: "%s"
        }
    };
}

chrome.webRequest.onAuthRequired.addListener(
    callbackFn,
    {urls: [""]},
    ['blocking']
);
""" % (PROXY_HOST, PROXY_PORT, PROXY_USER, PROXY_PASS)

# Création de l'extension
plugin_path = 'proxy_auth_plugin.zip'
with zipfile.ZipFile(plugin_path, 'w') as zp:
    zp.writestr("manifest.json", manifest_json)
    zp.writestr("background.js", background_js)

# Lancement de Chrome avec l'extension
chrome_options = Options()
chrome_options.add_extension(plugin_path)

driver = webdriver.Chrome(options=chrome_options)
driver.get('https://httpbin.org/ip')
print(driver.page_source)

driver.quit()
os.remove(plugin_path)  # Suppression du fichier temporaire

Méthode 2 : Firefox avec authentification (plus simple)

Firefox permet de transmettre les identifiants via les paramètres du profil :

from selenium import webdriver
from selenium.webdriver.firefox.options import Options

PROXY_HOST = "123.45.67.89"
PROXY_PORT = 8080
PROXY_USER = "username"
PROXY_PASS = "password"

firefox_options = Options()

firefox_options.set_preference("network.proxy.type", 1)
firefox_options.set_preference("network.proxy.http", PROXY_HOST)
firefox_options.set_preference("network.proxy.http_port", PROXY_PORT)
firefox_options.set_preference("network.proxy.ssl", PROXY_HOST)
firefox_options.set_preference("network.proxy.ssl_port", PROXY_PORT)

# Authentification (ne fonctionne pas toujours, dépend de la version de Firefox)
firefox_options.set_preference("network.proxy.username", PROXY_USER)
firefox_options.set_preference("network.proxy.password", PROXY_PASS)

# Désactiver la demande d'authentification
firefox_options.set_preference("network.automatic-ntlm-auth.trusted-uris", PROXY_HOST)

driver = webdriver.Firefox(options=firefox_options)
driver.get('https://httpbin.org/ip')
print(driver.page_source)
driver.quit()

Remarque : Si votre fournisseur de proxy prend en charge la liste blanche des IP, il est plus simple d'ajouter l'IP de votre serveur à la liste blanche et d'utiliser le proxy sans authentification.

Rotation des proxies dans Selenium

Lors du scraping de grandes quantités de données, il est crucial de changer de proxy pour éviter les blocages. Il existe deux approches : la rotation au niveau du code et l'utilisation de proxies rotatifs.

Rotation au niveau du code (création d'un nouveau driver)

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import random

# Liste des proxies
PROXY_LIST = [
    "123.45.67.89:8080",
    "98.76.54.32:8080",
    "11.22.33.44:8080",
]

def create_driver_with_proxy(proxy):
    """Création d'un driver avec le proxy spécifié"""
    chrome_options = Options()
    chrome_options.add_argument(f'--proxy-server=http://{proxy}')
    chrome_options.add_argument('--no-sandbox')
    return webdriver.Chrome(options=chrome_options)

# Scraping avec rotation
urls_to_parse = [
    'https://example.com/page1',
    'https://example.com/page2',
    'https://example.com/page3',
]

for url in urls_to_parse:
    # Choisir un proxy aléatoire
    current_proxy = random.choice(PROXY_LIST)
    
    # Créer un nouveau driver avec le proxy
    driver = create_driver_with_proxy(current_proxy)
    
    try:
        driver.get(url)
        # Votre logique de scraping
        print(f"Scrapé {url} via {current_proxy}")
        print(driver.title)
    except Exception as e:
        print(f"Erreur avec {current_proxy} : {e}")
    finally:
        driver.quit()  # Il est important de fermer le driver

Utilisation de proxies rotatifs (plus simple)

De nombreux fournisseurs de proxies proposent un point de terminaison rotatif — une URL qui change automatiquement d'IP à chaque requête ou à intervalles réguliers. Cela simplifie le code :

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

# Point de terminaison de proxy rotatif (l'IP change automatiquement)
ROTATING_PROXY = "rotating.proxycove.com:8080"

chrome_options = Options()
chrome_options.add_argument(f'--proxy-server=http://{ROTATING_PROXY}')

driver = webdriver.Chrome(options=chrome_options)

# Chaque requête sera avec une nouvelle IP
urls = ['https://httpbin.org/ip'] * 5

for url in urls:
    driver.get(url)
    print(driver.find_element("tag name", "body").text)
    # Chaque sortie montrera une IP différente

driver.quit()

Recommandation : Pour de grands projets, utilisez des proxies rotatifs — cela économise des ressources (pas besoin de recréer le driver) et simplifie le code. Les proxies résidentiels prennent généralement en charge la rotation par défaut.

Erreurs courantes et leur résolution

Erreur : "ERR_PROXY_CONNECTION_FAILED"

Cause : Selenium ne peut pas se connecter au serveur proxy.

Solution :

• Vérifiez l'exactitude de l'IP et du port du proxy
• Assurez-vous que le proxy est actif (vérifiez via curl : curl -x http://123.45.67.89:8080 https://httpbin.org/ip)
• Vérifiez le pare-feu — il se peut que les connexions sortantes vers le proxy soient bloquées
• Si vous utilisez une authentification, vérifiez l'exactitude du nom d'utilisateur/mot de passe

Erreur : "ERR_TUNNEL_CONNECTION_FAILED"

Cause : Problème de connexion HTTPS via le proxy.

Solution :

• Assurez-vous que le proxy prend en charge HTTPS (méthode CONNECT)
• Pour les sites HTTPS, utilisez des proxies HTTPS ou SOCKS5
• Ajoutez l'option d'ignorance des erreurs SSL : chrome_options.add_argument('--ignore-certificate-errors')

Erreur : Le proxy fonctionne, mais le site détecte le bot

Cause : Le site utilise des méthodes avancées de détection (fingerprinting, analyse du comportement).

Solution :

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

chrome_options = Options()
chrome_options.add_argument(f'--proxy-server=http://{PROXY}')

# Désactiver le drapeau webdriver (caractéristique principale de l'automatisation)
chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"])
chrome_options.add_experimental_option('useAutomationExtension', False)

driver = webdriver.Chrome(options=chrome_options)

# Suppression de navigator.webdriver
driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
    'source': '''
        Object.defineProperty(navigator, 'webdriver', {
            get: () => undefined
        })
    '''
})

driver.get('https://bot.sannysoft.com/')  # Site pour vérifier la détection

Il est également recommandé d'utiliser la bibliothèque undetected-chromedriver, qui applique automatiquement de nombreuses techniques anti-détection.

Problème : Chargement lent des pages via le proxy

Cause : Le proxy est surchargé ou géographiquement éloigné.

Solution :

• Choisissez un proxy plus proche du serveur cible (par exemple, pour scraper des sites US, utilisez des proxies US)
• Utilisez des proxies de centre de données pour les tâches où la vitesse est plus importante que l'anonymat
• Configurez les délais d'attente dans Selenium pour éviter les blocages :

from selenium.webdriver.support.ui import WebDriverWait

driver.set_page_load_timeout(30)  # Maximum 30 secondes pour le chargement
driver.implicitly_wait(10)  # Attente implicite des éléments

Meilleures pratiques lors de l'utilisation de proxies

import time
import random

for url in urls:
    driver.get(url)
    # Scraping...
    time.sleep(random.uniform(2, 5))  # Délai aléatoire de 2 à 5 sec

import requests

def check_proxy(proxy):
    """Vérification de la fonctionnalité du proxy"""
    try:
        response = requests.get(
            'https://httpbin.org/ip',
            proxies={'http': f'http://{proxy}', 'https': f'http://{proxy}'},
            timeout=10
        )
        return response.status_code == 200
    except:
        return False

# Filtrage des proxies fonctionnels
working_proxies = [p for p in PROXY_LIST if check_proxy(p)]
print(f"Proxies fonctionnels : {len(working_proxies)}/{len(PROXY_LIST)}")

Conclusion

La configuration correcte des proxies dans Selenium WebDriver est la base d'un scraping et d'une automatisation stables. Nous avons examiné toutes les principales méthodes d'intégration des proxies pour Chrome et Firefox, le travail avec l'authentification, la rotation des adresses IP et la résolution des problèmes courants. L'essentiel est de choisir le type de proxy adapté à votre tâche : pour un scraping simple, des proxies de centre de données suffisent, tandis que pour travailler avec des plateformes protégées, des proxies résidentiels ou mobiles sont nécessaires.

N'oubliez pas les meilleures pratiques : utilisez des pools de proxies, ajoutez des délais aléatoires, surveillez la qualité des connexions et appliquez des techniques anti-détection. Cela augmentera la stabilité de vos scripts et réduira le risque de blocages de plusieurs fois.

Si vous envisagez d'automatiser le scraping avec des exigences élevées en matière d'anonymat et de contournement des systèmes anti-bots, nous vous recommandons d'essayer des proxies résidentiels — ils assurent une stabilité maximale lors de l'utilisation de n'importe quel site, y compris les réseaux sociaux, les plateformes e-commerce et les services avec une protection avancée. Pour les tâches où la vitesse de traitement de grandes quantités de données est critique, les proxies de centre de données seront le choix optimal en termes de rapport qualité-prix.