Faire tourner des proxies en Python : requests, httpx et aiohttp (Guide 2026)

Si vous faites du scraping, du crawling ou automatisez quoi que ce soit à grande échelle en Python, tôt ou tard le site cible remarque que toutes les requêtes proviennent d'une seule IP et vous coupe l'accès. Faire tourner des proxies en Python répartit votre trafic sur de nombreuses adresses IP pour qu'aucune à elle seule ne déclenche une limitation de débit ni ne récolte un bannissement. Ce guide montre le code exact pour requests, httpx et aiohttp, ainsi que comment choisir entre une passerelle rotative et un pool d'IP géré.

Deux décisions transversales façonnent tout ce qui suit. Première : sessions rotatives vs sticky — une nouvelle IP par requête, ou une seule IP conservée pour un flux multi-étapes. Deuxième : IP résidentielles vs centre de données — consultez la matrice de décision par type de proxy. Réussissez ces deux-là et le code devient la partie facile.

Deux façons de faire tourner les IP

1. Rotation par passerelle (recommandée). Vous vous connectez à un seul endpoint et le fournisseur vous remet une IP de sortie fraîche à chaque nouvelle connexion. Aucune liste à gérer, aucune IP morte à élaguer. Le pool résidentiel dynamique de JIBAO fonctionne ainsi : même hôte et même port, une nouvelle IP à chaque requête.

2. Liste d'IP auto-gérée. Vous tenez une liste d'entrées host:port et en choisissez une par requête. Plus de contrôle, mais c'est vous qui assumez la vérification de santé, les réessais et le suivi des bannissements. Utile avec des IP dédiées de centre de données quand vous avez besoin d'adresses connues et stables.

Rotation avec requests

Le cas le plus simple — router une requête à travers une passerelle qui fait tourner les IP pour vous. Utilisez socks5h:// (le h final signifie que le DNS est résolu côté proxy, ce qui évite de laisser fuiter les résolutions) :

import requests

# JIBAO rotating residential gateway: a new exit IP per connection
PROXY = "socks5h://USERNAME:[email protected]:10001"

proxies = {"http": PROXY, "https": PROXY}

for _ in range(5):
    r = requests.get("https://httpbin.org/ip", proxies=proxies, timeout=30)
    print(r.json()["origin"])   # a different IP each loop

Besoin que requests parle SOCKS5 ? Installez l'extra : pip install "requests[socks]". Si vous préférez un endpoint de proxy HTTP, remplacez le schéma par http:// — le reste est identique.

Rotation depuis votre propre liste d'IP

import random
import requests

PROXY_POOL = [
    "socks5h://USERNAME-country-us:[email protected]:10001",
    "socks5h://USERNAME-country-uk:[email protected]:10001",
    "socks5h://USERNAME-country-de:[email protected]:10001",
]

def fetch(url):
    proxy = random.choice(PROXY_POOL)
    return requests.get(url, proxies={"http": proxy, "https": proxy}, timeout=30)

resp = fetch("https://example.com")
print(resp.status_code)

Sessions sticky quand vous devez conserver une seule IP

Les flux de connexion, les paniers et les résultats paginés se brisent si l'IP change en milieu de tâche. Épinglez une IP en ajoutant un jeton de session à l'identifiant ; réutilisez le même jeton pour conserver la même IP de sortie pendant toute sa durée de vie :

import requests

SESSION_ID = "task-0001"
PROXY = f"socks5h://USERNAME-session-{SESSION_ID}:[email protected]:10001"

s = requests.Session()
s.proxies = {"http": PROXY, "https": PROXY}

s.post("https://example.com/login", data={"u": "me", "p": "secret"})
s.get("https://example.com/dashboard")   # same IP, session intact

Rotation avec httpx

httpx vous offre un client moderne avec HTTP/2 et async natif. Notez que les versions plus récentes acceptent un seul argument proxy= :

import httpx

PROXY = "socks5h://USERNAME:[email protected]:10001"

with httpx.Client(proxy=PROXY, timeout=30) as client:
    for _ in range(5):
        print(client.get("https://httpbin.org/ip").json()["origin"])

Le support de SOCKS dans httpx nécessite pip install "httpx[socks]". Pour HTTP/2, ajoutez http2=True au client — cela fait ressembler votre trafic davantage à celui d'un vrai navigateur, ce qui se marie bien avec la correspondance d'empreinte TLS.

Rotation concurrente avec aiohttp

Pour un débit élevé, lancez de nombreuses requêtes à la fois. Chaque connexion à travers la passerelle obtient sa propre IP de sortie, donc la concurrence et la rotation vont de pair :

import asyncio
import aiohttp
from aiohttp_socks import ProxyConnector

PROXY = "socks5://USERNAME:[email protected]:10001"

async def fetch(url):
    connector = ProxyConnector.from_url(PROXY)
    async with aiohttp.ClientSession(connector=connector) as session:
        async with session.get(url, timeout=aiohttp.ClientTimeout(total=30)) as r:
            return await r.text()

async def main():
    urls = ["https://httpbin.org/ip"] * 20
    results = await asyncio.gather(*(fetch(u) for u in urls))
    print(f"fetched {len(results)} pages")

asyncio.run(main())

Installez le connecteur SOCKS avec pip install aiohttp_socks. Construisez un connecteur frais par tâche pour que chaque requête ouvre une nouvelle connexion proxifiée.

Une logique de réessai qui aide vraiment

La rotation ne porte ses fruits que si vous réessayez les échecs sur une IP fraîche. Appliquez un repli exponentiel et faites tourner le jeton de session à chaque tentative :

import requests
from time import sleep

def fetch_with_retry(url, max_retries=4):
    for attempt in range(max_retries):
        proxy = f"socks5h://USERNAME-session-r{attempt}:[email protected]:10001"
        try:
            r = requests.get(url, proxies={"http": proxy, "https": proxy}, timeout=30)
            if r.status_code in (403, 429):
                raise requests.HTTPError(f"blocked: {r.status_code}")
            r.raise_for_status()
            return r.text
        except requests.RequestException:
            sleep(2 ** attempt)        # 1s, 2s, 4s, 8s
    raise RuntimeError(f"failed after {max_retries} tries: {url}")

Vérifiez que votre rotation fonctionne

Avant une grande exécution, confirmez que l'IP change réellement. Interrogez un endpoint d'écho quelques fois et vérifiez que les IP diffèrent. Pour confirmer en plus que votre empreinte TLS ne vous trahit pas, lancez la requête contre le vérificateur gratuit d'empreinte JA3/TLS de JIBAO — une IP rotative avec une empreinte Python qui vous trahit au premier coup d'œil finit quand même bloquée.

Bonnes pratiques

• Faites tourner par tâche, pas par étape. Utilisez une session sticky pour tout workflow à plusieurs requêtes ; faites tourner entre les tâches indépendantes.
• Adaptez le type d'IP à la cible. Centre de données ($0.8/GB) pour les API permissives, résidentiel ($2/GB) pour les sites derrière Cloudflare ou Akamai.
• Mettez des timeouts sur chaque requête. Une connexion proxifiée bloquée sans timeout arrêtera tout votre crawl.
• Surveillez la bande passante. Le résidentiel facture au GB — une boucle de redirection sur une page lourde brûle du crédit à toute vitesse.
• Respectez robots.txt et les limites de débit. Marteler une cible fait signaler des plages d'IP entières et nuit à tout le monde sur le pool.

Une fois la rotation solide, le mur suivant que vous heurtez est généralement le fingerprinting, pas les IP. Si des IP résidentielles propres reçoivent encore des 403, lisez comment contourner le fingerprinting TLS avec curl_cffi et la recette complète de contournement de Cloudflare.