Aller au contenu
Blog
GD·5850

Meilleur proxy pour le scraping web avec Python 2026 : du vrai code

Les meilleurs proxys pour le scraping web avec Python en 2026. Des exemples de code pour requests, Scrapy et Playwright — avec des benchmarks de prestataires et des stratégies de rotation qui fonctionnent vraiment.

Guide Publié le Mis à jour le 11 min de lecture

Réponse rapide

Pour le scraping en Python, le choix du proxy est indissociable du code : rotation, réessais et backoff, réutilisation des sessions et délais d'expiration comptent autant que le pool. Testez avec votre réel schéma de requêtes et respectez les conditions de chaque cible. Si vous avez besoin de visites de site plutôt que de données extraites, Traffic Creator les fournit sans aucun code de proxy.

L'essentiel

  • Ce qui compte : la rotation, les réessais, la réutilisation des sessions et les délais d'expiration comptent autant que le pool que vous achetez.
  • Comment benchmark : benchmark avec votre réel schéma de requêtes, pas avec un échantillon de pages faciles.
  • Conditions : respectez les conditions de chaque cible ; un scraper qui fonctionne n'est pas automatiquement un scraper autorisé.
  • Besoin de visites seulement : pour des visites de site plutôt que des données, Traffic Creator n'exige aucun code de proxy.

Trouver le bon proxy pour le scraping en Python, c'est accorder le prestataire au niveau de protection de votre cible — et savoir le configurer correctement dans le code. Un proxy parfaitement adapté au scraping de prix e-commerce échouera aussitôt contre LinkedIn.

Vue d'ensemble visuelle de Meilleur proxy pour le scraping web avec Python 2026 : testé avec du vrai code
Résumé visuel de « Meilleur proxy pour le scraping web avec Python 2026 : testé avec du vrai code ».

Ce guide couvre les meilleurs prestataires de proxys pour le scraping en Python en 2026, avec des exemples de code fonctionnels pour les trois bibliothèques Python les plus courantes : requests, Scrapy et Playwright.

Configuration de proxy en Python : les bases#

Chaque bibliothèque HTTP Python accepte les proxys dans un format similaire. La structure d'URL du proxy est :

http://username:password@proxy_host:port

Pour les proxys résidentiels rotatifs (où chaque requête reçoit automatiquement une nouvelle IP), l'hôte est la passerelle rotative du prestataire. Vous ne gérez pas les IP individuelles — l'infrastructure du prestataire les fait tourner à chaque requête.

Vue d'ensemble des prestataires, par cas d'usage#

Prestataire Meilleur cas d'usage Python $/Go Palier de difficulté
DataImpulse Scraping en volume, cibles non protégées ~1 $ Palier 1
ProxyScrape Mixte, non protégé/modéré ~2–4 $ Palier 1–2
GeoNode Scraping résidentiel en production ~3–5 $ Palier 2
IPRoyal Résidentiel orienté UE ~7–10 $ Palier 2
Bright Data Cibles entreprise + API gérée ~10,89 $ Palier 3

Exemples de code par bibliothèque#

1. La bibliothèque requests de Python

requests est la bibliothèque HTTP Python la plus répandue. La configuration du proxy tient en un unique dictionnaire transmis à chaque requête.

Configuration basique d'un proxy rotatif (exemple GeoNode)

import requests

# GeoNode rotating residential proxy
# Replace with your actual username/password from the GeoNode dashboard
PROXY_HOST = "rotating.geonode.com"
PROXY_PORT = "9000"
PROXY_USER = "YOUR_GEONODE_USERNAME"
PROXY_PASS = "YOUR_GEONODE_PASSWORD"

proxies = {
    "http": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
    "https": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
}

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"
}

response = requests.get(
    "https://httpbin.org/ip",
    proxies=proxies,
    headers=headers,
    timeout=30,
)
print(response.json())  # shows the exit IP used

Rotation du User-Agent à chaque requête

Des User-Agents constants forment une empreinte détectable, même avec des IP résidentielles. Faites-les tourner :

import requests
import random

USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Gecko/20100101 Firefox/125.0",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
]

def get_headers():
    return {"User-Agent": random.choice(USER_AGENTS)}

def scrape_url(url, proxies):
    try:
        response = requests.get(
            url,
            proxies=proxies,
            headers=get_headers(),
            timeout=30,
        )
        response.raise_for_status()
        return response.text
    except requests.RequestException as e:
        print(f"Request failed: {e}")
        return None

Logique de réessai pour les requêtes échouées

import requests
import time
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

def make_session_with_retry(proxies):
    session = requests.Session()
    session.proxies = proxies

    retry_strategy = Retry(
        total=3,
        backoff_factor=1,
        status_forcelist=[429, 500, 502, 503, 504],
    )
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("http://", adapter)
    session.mount("https://", adapter)

    return session

# Usage
session = make_session_with_retry(proxies)
response = session.get("https://example.com", timeout=30)

2. Scrapy

Scrapy est le framework de référence pour le scraping Python en production. Il gère la concurrence, les réessais et les pipelines — mais la configuration du proxy exige un middleware.

Middleware de proxy Scrapy (proxy rotatif)

Ajoutez dans votre settings.py :

# settings.py
DOWNLOADER_MIDDLEWARES = {
    "scrapy.downloadermiddlewares.retry.RetryMiddleware": 90,
    "myproject.middlewares.ProxyMiddleware": 100,
    "scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware": 110,
}

RETRY_TIMES = 3
RETRY_HTTP_CODES = [500, 502, 503, 504, 429]

# GeoNode credentials (set via environment variables in production)
PROXY_HOST = "rotating.geonode.com:9000"
PROXY_USER = "YOUR_GEONODE_USERNAME"
PROXY_PASS = "YOUR_GEONODE_PASSWORD"

Créez middlewares.py :

# middlewares.py
import base64
from scrapy import signals

class ProxyMiddleware:
    def __init__(self, proxy_host, proxy_user, proxy_pass):
        self.proxy = f"http://{proxy_host}"
        credentials = f"{proxy_user}:{proxy_pass}"
        self.proxy_auth = base64.b64encode(credentials.encode()).decode()

    @classmethod
    def from_crawler(cls, crawler):
        return cls(
            proxy_host=crawler.settings.get("PROXY_HOST"),
            proxy_user=crawler.settings.get("PROXY_USER"),
            proxy_pass=crawler.settings.get("PROXY_PASS"),
        )

    def process_request(self, request, spider):
        request.meta["proxy"] = self.proxy
        request.headers["Proxy-Authorization"] = f"Basic {self.proxy_auth}"

Araignée Scrapy avec proxy

# spiders/product_spider.py
import scrapy

class ProductSpider(scrapy.Spider):
    name = "products"
    start_urls = ["https://example-shop.com/products"]

    custom_settings = {
        "DOWNLOAD_DELAY": 1,          # 1 second between requests
        "RANDOMIZE_DOWNLOAD_DELAY": True,  # actual delay: 0.5–1.5s
        "CONCURRENT_REQUESTS_PER_DOMAIN": 5,
    }

    def parse(self, response):
        for product in response.css(".product-card"):
            yield {
                "name": product.css(".product-name::text").get(),
                "price": product.css(".product-price::text").get(),
                "url": response.urljoin(product.css("a::attr(href)").get()),
            }

        next_page = response.css("a.next-page::attr(href)").get()
        if next_page:
            yield response.follow(next_page, self.parse)

3. Playwright (cibles rendues en JavaScript)

Pour les cibles qui utilisent le rendu JavaScript — applications monopages, contenus chargés à retard, prix dynamiques — il faut un navigateur headless. Playwright s'en charge en Python.

Playwright basique avec proxy (GeoNode)

from playwright.sync_api import sync_playwright

PROXY_HOST = "rotating.geonode.com"
PROXY_PORT = "9000"
PROXY_USER = "YOUR_GEONODE_USERNAME"
PROXY_PASS = "YOUR_GEONODE_PASSWORD"

proxy_config = {
    "server": f"http://{PROXY_HOST}:{PROXY_PORT}",
    "username": PROXY_USER,
    "password": PROXY_PASS,
}

with sync_playwright() as p:
    browser = p.chromium.launch(
        headless=True,
        proxy=proxy_config,
    )
    context = browser.new_context(
        user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
        viewport={"width": 1920, "height": 1080},
    )
    page = context.new_page()

    page.goto("https://example.com", wait_until="networkidle")
    content = page.content()
    print(content[:500])

    browser.close()

Playwright pour les cibles du palier 3 avec le Web Unlocker de Bright Data

Pour les cibles protégées au niveau entreprise, le Web Unlocker de Bright Data gère la résolution des CAPTCHA et la gestion des empreintes automatiquement. Vous envoyez une URL ; Bright Data renvoie le HTML rendu.

import requests

# Bright Data Web Unlocker endpoint
# Get your credentials from: https://get.brightdata.com/293896dumfgt
BRIGHTDATA_HOST = "brd.superproxy.io"
BRIGHTDATA_PORT = 22225
BRIGHTDATA_USER = "YOUR_BRIGHTDATA_USERNAME-zone-web_unlocker"
BRIGHTDATA_PASS = "YOUR_BRIGHTDATA_PASSWORD"

proxies = {
    "http": f"http://{BRIGHTDATA_USER}:{BRIGHTDATA_PASS}@{BRIGHTDATA_HOST}:{BRIGHTDATA_PORT}",
    "https": f"http://{BRIGHTDATA_USER}:{BRIGHTDATA_PASS}@{BRIGHTDATA_HOST}:{BRIGHTDATA_PORT}",
}

# Bright Data handles all anti-detection automatically
response = requests.get(
    "https://www.amazon.com/dp/B08N5WRWNW",
    proxies=proxies,
    verify=False,  # Bright Data uses custom cert
    timeout=60,
)
print(response.status_code)  # 200 on Amazon with Web Unlocker

Référence de configuration des prestataires#

GeoNode (recommandé pour le palier 2)

# GeoNode rotating residential proxy
# Get credentials at: https://geonode.com/?ref=22282

PROXY_HOST = "rotating.geonode.com"
PROXY_PORT = "9000"   # HTTP rotating
# PROXY_PORT = "9001" # SOCKS5 rotating
# PROXY_PORT = "9002" # HTTP sticky (session-based)

# Country-specific targeting (add to username):
# PROXY_USER = "username-country-US"  # US exit nodes only
# PROXY_USER = "username-country-DE"  # German exit nodes only

proxies = {
    "http": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
    "https": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
}

Spécifications de GeoNode pour le scraping Python :

  • Plus de 10 M d'IP résidentielles, plus de 195 pays
  • 3–5 $/Go, aucun engagement minimal
  • Modes de session rotative et sticky
  • Ciblage par pays et par ville

→ Découvrir le plan gratuit de GeoNode — sans carte bancaire.

IPRoyal (palier 2 orienté UE)

# IPRoyal rotating residential proxy
# Get credentials at: https://iproyal.com/?r=Traffic-Creator

PROXY_HOST = "geo.iproyal.com"
PROXY_PORT = "12321"

# Country targeting:
# PROXY_USER = "username_country-DE"  # Germany
# PROXY_USER = "username_country-GB"  # UK

proxies = {
    "http": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
    "https": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
}

Spécifications d'IPRoyal : forte densité de nœuds européens — idéal pour les cibles de scraping spécifiques à l'UE, à 7–10 $/Go.

DataImpulse (palier économique 1–2)

# DataImpulse budget residential proxy
# Get credentials at: https://dataimpulse.com/?aff=312345

PROXY_HOST = "gw.dataimpulse.com"
PROXY_PORT = "823"

proxies = {
    "http": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
    "https": f"http://{PROXY_USER}:{PROXY_PASS}@{PROXY_HOST}:{PROXY_PORT}",
}

Spécifications de DataImpulse : ~0,70–1,50 $/Go — l'option résidentielle la moins chère pour un scraping non protégé à moyennement protégé.

Bright Data Web Unlocker (palier 3)

# Bright Data Web Unlocker
# Get access at: https://get.brightdata.com/293896dumfgt

proxies = {
    "http": "http://YOUR_USER-zone-web_unlocker:[email protected]:22225",
    "https": "http://YOUR_USER-zone-web_unlocker:[email protected]:22225",
}

# For SERP scraping with structured output:
# Use Bright Data's SERP API instead — returns structured JSON
import json

serp_response = requests.get(
    "https://www.google.com/search?q=python+web+scraping",
    proxies=proxies,
    verify=False,
    timeout=60,
)

Choisir le bon prestataire pour votre scraper Python#

Arbre de décision

Que scrapez-vous ?

Unprotected sites (no bot protection)
  → DataImpulse (~$1/GB) or ProxyScrape (~$2–4/GB)
  → requests or Scrapy, rotating IPs

Moderately protected (rate limiting, IP reputation)
  → GeoNode (~$3–5/GB) for most targets
  → IPRoyal (~$7–10/GB) for EU-specific targets
  → requests/Scrapy with rotating residential IPs

Heavily protected (Google, Amazon, LinkedIn)
  → Bright Data Web Unlocker (~$10.89/GB + $3/1k requests)
  → requests with Bright Data proxy endpoint, or their SERP API
  → For browser automation on Tier 3: Bright Data's Scraping Browser

Réglages de concurrence par prestataire

Les proxys résidentiels gèrent la concurrence différemment des datacenters. Une concurrence trop agressive brûle la bande passante sans améliorer le débit.

Réglages Scrapy recommandés par prestataire :

# GeoNode (mid-market residential)
CONCURRENT_REQUESTS = 20
CONCURRENT_REQUESTS_PER_DOMAIN = 5
DOWNLOAD_DELAY = 0.5
RANDOMIZE_DOWNLOAD_DELAY = True

# DataImpulse (budget residential — lower concurrency)
CONCURRENT_REQUESTS = 10
CONCURRENT_REQUESTS_PER_DOMAIN = 3
DOWNLOAD_DELAY = 1
RANDOMIZE_DOWNLOAD_DELAY = True

# Bright Data Web Unlocker (managed anti-detection)
# Follow Bright Data's recommended concurrency per zone
CONCURRENT_REQUESTS = 10
DOWNLOAD_DELAY = 0

Erreurs de proxy Python courantes et corrections#

ConnectionError: HTTPSConnectionPool

Cause : la connexion au proxy a échoué — hôte, port ou identifiants erronés.

Correction : testez avec requests.get("https://httpbin.org/ip", proxies=proxies) avant de lancer votre scraper. Vérifiez hôte/port/identifiants depuis votre tableau de bord prestataire.

407 Proxy Authentication Required

Cause : identifiants mal transmis ou mal formés dans l'URL du proxy.

Correction : vérifiez que le nom d'utilisateur et le mot de passe ne contiennent pas de caractères spéciaux nécessitant un encodage d'URL. Encodez avec urllib.parse.quote(password, safe='') si le mot de passe comporte des symboles.

from urllib.parse import quote
encoded_pass = quote(PROXY_PASS, safe='')
proxy_url = f"http://{PROXY_USER}:{encoded_pass}@{PROXY_HOST}:{PROXY_PORT}"

503 Service Unavailable sur les cibles protégées

Cause : la cible a détecté votre requête comme un bot malgré l'usage d'IP résidentielles. Causes fréquentes : User-Agent constant, absence d'en-tête referer, en-tête accept-language manquant, rythme de requête trop rapide.

Correction :

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
    "Accept-Language": "en-US,en;q=0.5",
    "Accept-Encoding": "gzip, deflate, br",
    "Connection": "keep-alive",
    "Upgrade-Insecure-Requests": "1",
}

Si cela ne règle pas le problème sur les cibles du palier 3, passez au Web Unlocker de Bright Data.

Requêtes renvoyant des CAPTCHA au lieu du contenu

Cause : le site cible sert des défis CAPTCHA à votre IP. Se produit sur les cibles du palier 3 lorsque les IP résidentielles ne tournent pas assez vite.

Correction : soit tourner plus vite (nouvelle IP à chaque requête via le point d'accès rotatif), soit utiliser le Web Unlocker de Bright Data, qui résout les CAPTCHA automatiquement.

Tester votre configuration de proxy#

Validez toujours avant de lancer un scraping complet :

import requests

def test_proxy(proxies):
    # Test 1: Check your exit IP
    try:
        r = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=10)
        print(f"Exit IP: {r.json()['origin']}")
    except Exception as e:
        print(f"Failed: {e}")
        return False

    # Test 2: Confirm IP is residential (not datacenter)
    try:
        r = requests.get("https://ipinfo.io/json", proxies=proxies, timeout=10)
        data = r.json()
        print(f"IP type: {data.get('org', 'unknown')}")
        print(f"Country: {data.get('country', 'unknown')}")
        print(f"City: {data.get('city', 'unknown')}")
    except Exception as e:
        print(f"IPinfo check failed: {e}")

    return True

test_proxy(proxies)

Une IP résidentielle affiche une organisation d'opérateur (par exemple « AS7922 Comcast Cable Communications »), pas un ASN de datacenter (par exemple « AS14061 DigitalOcean »).

Annuaire des prestataires#

Prestataire Meilleur cas d'usage Python Lien d'inscription
GeoNode Scraping résidentiel en production S'inscrire
IPRoyal Résidentiel orienté UE S'inscrire
DataImpulse Économique, volume élevé, non protégé S'inscrire
ProxyScrape Mixte, palier 1/2 S'inscrire
Bright Data Cibles entreprise + API gérée S'inscrire

Questions fréquentes#

Quel proxy convient le mieux au scraping en Python ?

Le pool importe moins que le code qui l'entoure : stratégie de rotation, réessais et backoff, réutilisation des sessions et gestion des délais d'expiration. Benchmark avec votre réel schéma de requêtes.

Comment éviter d'être bloqué ?

Espacez les requêtes, réutilisez les sessions quand la cible attend une continuité, et respectez les conditions de chaque site. Un scraper qui fonctionne n'est pas automatiquement un scraper autorisé.

Que faire si j'ai besoin de visites plutôt que de données ?

Traffic Creator fournit des visites ciblées géographiquement et visibles dans GA4, sans code de proxy à écrire ni à maintenir.

Puis-je scraper avec un proxy gratuit ?

Les listes de proxys publics gratuits conviennent aux tests basiques mais ne se prêtent pas au scraping en production. Elles sont peu fiables, lentes et bloquées par la plupart des sites. Le palier gratuit de Webshare offre 1 Go/mois de bande passante datacenter légitime — le meilleur point de départ gratuit.

Quelle est la différence entre sessions rotatives et sessions sticky en Python ?

Une session rotative vous donne une nouvelle IP à chaque requête — idéal pour scraper le même domaine à haute fréquence. Une session sticky conserve la même IP pendant une durée configurable — idéal quand le site cible utilise des cookies de session (e-commerce avec état du panier, scraping connecté). Chez GeoNode et IPRoyal, on choisit le mode via le port du proxy ou un suffixe du nom d'utilisateur.

Faut-il Playwright ou puis-je utiliser requests ?

Utilisez requests ou Scrapy pour les cibles rendues côté serveur (le HTML se trouve dans la réponse initiale). Utilisez Playwright ou Selenium quand le contenu recherché est chargé via JavaScript après le chargement de la page — vous verrez des conteneurs vides ou des espaces réservés dans la réponse requests si le rendu JavaScript est nécessaire.

Quelle est la bibliothèque de proxy Python la plus rapide pour le scraping à haut volume ?

aiohttp avec async/await est plus rapide que requests synchrone pour le scraping à forte concurrence. Scrapy gère l'asynchrone en interne. Pour la plupart des scrapers de production, Scrapy avec le bon réglage CONCURRENT_REQUESTS l'emporte sur des implémentations personnalisées de aiohttp en termes de compromis vitesse de développement/performances.

Une question sur cet article ?

Une erreur ou une offre qui a changé ? Envoyez-nous la source, nous la vérifions et corrigeons l'article.

Nous contacter Voir les tarifs

Écrit par

Fondateur, Traffic Creator · À propos ·

Loading Traffic Creator