Utiliser des proxies US en Python : requests, httpx, Scrapy et Playwright

Comment utiliser un proxy US avec Python requests ?

Passez une URL de proxy unique pour http et https dans l'argument proxies. Gardez le schéma http:// dans l'URL du proxy même pour les cibles HTTPS : la passerelle ouvre un tunnel HTTPS avec CONNECT. Pour SOCKS5, installez requests[socks] et utilisez socks5h://, ainsi les requêtes DNS se font aussi côté US.

import requests

HOST = "gw.statesideip.com"
USER = "USERNAME-country-us-state-ny"  # rotating New York State IP
PASSWORD = "PASSWORD"

proxy = f"http://{USER}:{PASSWORD}@{HOST}:7777"
r = requests.get("https://api.ipify.org?format=json",
                 proxies={"http": proxy, "https": proxy}, timeout=30)
print(r.json())

# SOCKS5 (pip install "requests[socks]"); socks5h resolves DNS through the proxy
socks = f"socks5h://{USER}:{PASSWORD}@{HOST}:7778"
r = requests.get("https://api.ipify.org?format=json",
                 proxies={"http": socks, "https": socks}, timeout=30)
print(r.json())

Dois-je faire tourner les IP à chaque requête ou garder une session sticky ?

Faites tourner à chaque requête pour des récupérations de pages indépendantes, et utilisez une session sticky pour toute tâche nécessitant de garder une IP unique. Un nom d'utilisateur sans segment session obtient une nouvelle IP à chaque requête. Ajouter session-{id} et ttl-{minutes} garde une IP unique pour 1 à 120 minutes, défini par session avec le paramètre ttl.

• Tournant : vérifications de résultats de recherche ou contrôle de prix dans un catalogue répartis sur plusieurs IP US.
• Sticky : un parcours multi-pages sur votre propre site, comme un test QA du panier jusqu'au paiement.

Les passerelles tournantes assignent généralement l'IP de sortie par connexion. Si plusieurs requêtes partagent une IP, votre client réutilise une connexion ; un nouvel appel requests.get() sans Session ouvre une connexion neuve.

import uuid

def proxy_url(state=None, city=None, zip_code=None, session=None, ttl=10):
    parts = ["USERNAME", "country-us"]
    if state:
        parts.append(f"state-{state}")
    if city:
        parts.append(f"city-{city}")
    if zip_code:
        parts.append(f"zip-{zip_code}")
    if session:
        parts += [f"session-{session}", f"ttl-{ttl}"]
    user = "-".join(parts)
    return f"http://{user}:[email protected]:7777"

rotating = proxy_url(state="tx", city="houston")  # new IP per request
sticky = proxy_url(zip_code="10001", session=uuid.uuid4().hex[:8], ttl=30)  # one IP, 30 min

Comment envoyer plusieurs requêtes simultanément avec httpx async ?

Utilisez un seul httpx.AsyncClient avec l'argument proxy, et limitez les requêtes en cours avec un asyncio.Semaphore. Commencez avec environ 5 requêtes simultanées par site cible. Augmentez la limite seulement si le taux d'erreur reste faible.

L'exemple ci-dessous désactive le keep-alive, chaque requête ouvre donc une nouvelle connexion et peut obtenir une nouvelle IP. Supprimez cette ligne pour une session sticky. Les versions récentes de httpx prennent proxy= ; l'ancien argument proxies= a été supprimé dans httpx 0.28.

import asyncio
import httpx

PROXY = "http://USERNAME-country-us-state-ca:[email protected]:7777"
URLS = ["https://api.ipify.org?format=json"] * 20

async def fetch(client, sem, url):
    async with sem:  # caps requests in flight
        r = await client.get(url)
        r.raise_for_status()
        return r.json()

async def main():
    sem = asyncio.Semaphore(5)
    limits = httpx.Limits(max_keepalive_connections=0)  # new connection, new IP
    async with httpx.AsyncClient(proxy=PROXY, limits=limits, timeout=30) as client:
        results = await asyncio.gather(*(fetch(client, sem, u) for u in URLS),
                                       return_exceptions=True)
    for res in results:
        print(res)

asyncio.run(main())

Comment gérer les retries, backoff et limites de débit ?

Relancez uniquement les erreurs temporaires, attendez plus longtemps après chaque tentative, et ajoutez un jitter aléatoire. Relancez sur timeouts, erreurs de connexion et codes 429, 500, 502, 503 et 504. Respectez un en-tête Retry-After si le site en envoie un. Ne relancez jamais un 407 : cela signifie que le nom d'utilisateur ou le mot de passe est incorrect.

Respectez le robots.txt et les conditions d'utilisation de chaque site, et maintenez un rythme de requêtes proche d'une navigation normale. StatesideIP bloque les portails bancaires, gouvernementaux et de paiement, ainsi que les ports SMTP, selon sa politique d'utilisation acceptable.

import random
import time
import requests

RETRY_STATUS = {429, 500, 502, 503, 504}

def get_with_retries(url, proxies, attempts=5):
    for attempt in range(attempts):
        try:
            r = requests.get(url, proxies=proxies, timeout=30)
            if r.status_code == 407:
                raise RuntimeError("407: check USERNAME and PASSWORD")  # do not retry
            if r.status_code not in RETRY_STATUS:
                return r
            ra = r.headers.get("Retry-After", "")
            wait = int(ra) if ra.isdigit() else 2 ** attempt
        except (requests.ConnectionError, requests.Timeout):
            wait = 2 ** attempt
        time.sleep(wait + random.uniform(0, 1))  # backoff plus jitter
    raise RuntimeError(f"gave up on {url}")

Comment utiliser des proxies US dans Scrapy ?

Définissez le proxy par requête dans meta["proxy"], avec le nom d'utilisateur et le mot de passe dans l'URL. Le middleware proxy intégré de Scrapy les transforme en un en-tête Proxy-Authorization. Gardez ROBOTSTXT_OBEY = True, et laissez AutoThrottle ralentir le crawl si un site répond lentement.

# settings.py
ROBOTSTXT_OBEY = True
CONCURRENT_REQUESTS_PER_DOMAIN = 4
AUTOTHROTTLE_ENABLED = True
RETRY_TIMES = 3
RETRY_HTTP_CODES = [429, 500, 502, 503, 504]

# spiders/ip_check.py
import scrapy

PROXY = "http://USERNAME-country-us-state-fl-city-miami:[email protected]:7777"

class IpCheckSpider(scrapy.Spider):
    name = "ip_check"
    start_urls = ["https://api.ipify.org?format=json"]

    def start_requests(self):
        for url in self.start_urls:
            yield scrapy.Request(url, meta={"proxy": PROXY}, dont_filter=True)

    def parse(self, response):
        yield {"ip": response.json()["ip"]}

Comment utiliser des proxies US avec Playwright ?

Passez un dictionnaire proxy avec serveur, nom d'utilisateur et mot de passe au lancement du navigateur. Un navigateur charge de nombreux fichiers par page, utilisez donc une session sticky : une vue de page conserve une IP US unique. Utilisez un nouvel ID de session pour chaque nouvelle tâche.

import asyncio
from playwright.async_api import async_playwright

async def main():
    async with async_playwright() as p:
        browser = await p.chromium.launch(proxy={
            "server": "http://gw.statesideip.com:7777",
            "username": "USERNAME-country-us-state-il-city-chicago-session-pw1-ttl-15",
            "password": "PASSWORD",
        })
        page = await browser.new_page()
        await page.goto("https://api.ipify.org?format=json")
        print(await page.text_content("body"))
        await browser.close()

asyncio.run(main())

Pourquoi ma requête proxy Python échoue-t-elle ?

La plupart des échecs proviennent des identifiants, d'une cible trop restreinte, ou d'un client qui réutilise les connexions.

• 407 Proxy Authentication Required : le nom d'utilisateur ou le mot de passe est incorrect, ou un segment est mal orthographié. Comparez-le avec USERNAME-country-{cc}-state-{state}-city-{city}-zip-{zip}-asn-{asn}-session-{id}-ttl-{minutes}.
• Timeouts sur les cibles ZIP ou ASN : un filtre trop précis utilise moins d'IP. Élargissez à la ville ou à l'état, ou augmentez le délai d'attente.
• La même IP à chaque requête : votre client maintient la connexion ouverte. Désactivez le keep-alive, ou supprimez le segment session.
• Erreurs SSL : utilisez http:// pour l'URL du proxy, pas https://.

Le guide de démarrage couvre curl et Node.