# Utiliser des proxies US en Python : requests, httpx, Scrapy et Playwright > Guide Python proxies US : code fonctionnel pour requests, httpx, Scrapy et Playwright via la passerelle port 7777, de 0,52 $US/GB. Sans KYC, payer en crypto. - URL: https://statesideip.com/fr/guides/python-us-proxies/ - Dernière mise à jour: 2026-10-05 - Publisher: StatesideIP (https://statesideip.com) Code fonctionnel pour les quatre outils Python les plus utilisés par les scrapers, avec ciblage par état US, ville et code postal, rotation, sessions persistantes, retries et limites de débit. **Réponse rapide — Comment utiliser des proxies US en Python ?** **StatesideIP**, fournisseur de proxy résidentiel et proxy mobile 4G US sans KYC, propose des proxies Python US via une seule passerelle : `gw.statesideip.com`, port 7777 pour HTTP/HTTPS ou 7778 pour SOCKS5. La localisation s’insère dans le nom d’utilisateur, par exemple `USERNAME-country-us-state-ny`. Le trafic résidentiel commence à 0,52 $US/GB, à partir d’octobre 2026. Sans KYC — pas d’ID, pas de selfie, pas de documents. Payer en crypto. ## Détails de connexion pour Python | Attribut | Valeur | | --- | --- | | Hôte de la passerelle | `gw.statesideip.com` | | Port HTTP/HTTPS | 7777 | | Port SOCKS5 | 7778 | | Format du nom d'utilisateur | `USERNAME-country-{cc}-state-{state}-city-{city}-zip-{zip}-asn-{asn}-session-{id}-ttl-{minutes}` | | Protocoles | HTTP, HTTPS (CONNECT) et SOCKS5 | | Rotation | Une nouvelle IP à chaque requête, ou une session sticky qui conserve la même IP | | Sessions persistantes | 1 à 120 minutes, défini par session avec le paramètre ttl | | Point de terminaison de test utilisé ici | `https://api.ipify.org?format=json` | | Prix | Depuis 0,52 $US/GB ; 1,50 $US pour 1 GB | | KYC et paiement | Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto. | ## Que faut-il avant d’utiliser des proxies US en Python ? Vous avez besoin de Python 3, pip, et d’un nom d’utilisateur et mot de passe StatesideIP. La configuration se fait en cinq étapes. 1. **Achetez un petit forfait** — Le plan 1 GB coûte 1,50 $US sur la page des tarifs, payé en BTC, USDT, USDC, ETH, LTC ou SOL. 2. **Copiez vos identifiants** — Les identifiants apparaissent dans votre tableau de bord dès que vous achetez un forfait à partir de votre solde crypto confirmé. Le code ci-dessous les écrit en tant que USERNAME et PASSWORD. 3. **Installez les bibliothèques** — Exécutez pip install requests httpx scrapy playwright, puis playwright install chromium pour l'exemple navigateur. 4. **Construire le nom d'utilisateur** — Ajoutez uniquement les segments de ciblage dont vous avez besoin, par exemple USERNAME-country-us-state-tx-city-houston. Les valeurs sont en minuscules, avec des underscores pour les espaces. 5. **Vérifiez l'IP de sortie** — Faites une requête https://api.ipify.org?format=json via le proxy. L'IP retournée est l'IP US que voient les sites ciblés. ## 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. *requests : une IP tournante de New York, puis SOCKS5* ```python 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. *Construire des URLs de proxy tournantes et sticky* ```python 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}:PASSWORD@gw.statesideip.com: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. *httpx : 20 requêtes, maximum 5 simultanées, IP de Californie* ```python import asyncio import httpx PROXY = "http://USERNAME-country-us-state-ca:PASSWORD@gw.statesideip.com: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](https://statesideip.com/fr/acceptable-use/). *Backoff exponentiel avec jitter pour les requêtes* ```python 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. *Scrapy : paramètres et spider avec IP de Miami* ```python # 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:PASSWORD@gw.statesideip.com: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. *Playwright : une IP sticky de Chicago pendant 15 minutes* ```python 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](https://statesideip.com/fr/guides/getting-started/) couvre curl et Node. ## FAQ proxies US Python ### Quelle bibliothèque Python utiliser avec des proxies US ? Utilisez requests pour des scripts simples, httpx pour plusieurs requêtes simultanées, Scrapy pour des crawls complets, et Playwright pour les pages nécessitant JavaScript. Les quatre fonctionnent avec la passerelle StatesideIP à `gw.statesideip.com` sur le port 7777. Le même format de nom d'utilisateur permet de définir l'état, la ville ou le code postal US dans chacun. ### Comment obtenir une nouvelle IP US à chaque requête en Python ? Laissez de côté le segment `session` dans le nom d'utilisateur, par exemple `USERNAME-country-us-state-ga`. StatesideIP fournit alors une nouvelle IP à chaque requête. Assurez-vous que votre client ouvre une nouvelle connexion à chaque fois : appelez `requests.get()` sans Session, ou désactivez le keep-alive dans httpx. Sinon, plusieurs requêtes peuvent partager une même IP. ### Comment garder la même IP US pour toute une tâche ? Ajoutez `session-{id}` et `ttl-{minutes}` au nom d'utilisateur, par exemple `USERNAME-country-us-zip-10001-session-job42-ttl-30`. Toutes les requêtes avec cet ID de session conservent une IP unique jusqu'au ttl que vous définissez. Les sessions sticky StatesideIP durent 1 à 120 minutes, défini par session avec le paramètre ttl. Une connexion domestique peut tomber prématurément, donc prévoyez des tentatives dans votre code. ### Puis-je utiliser des proxies SOCKS5 en Python ? Oui. Installez `requests[socks]`, ou `httpx[socks]` pour httpx, et utilisez une URL `socks5h://` sur le port 7778. Le `h` force les résolutions DNS via le proxy, ainsi un site US se résout comme pour un visiteur US. HTTP et HTTPS fonctionnent sur le port 7777 sans package supplémentaire. ### Combien de requêtes puis-je envoyer simultanément via StatesideIP ? Commencez avec environ 5 requêtes en cours par site cible, puis augmentez la limite tant que les erreurs restent faibles. La plupart des limites viennent du site cible, surveillez le statut 429 et ralentissez. Les IP résidentielles utilisent des connexions domestiques, attendez-vous à des réponses plus lentes qu'en datacenter. Réduisez la concurrence sur les cibles ZIP ou ASN. ### Ai-je besoin de KYC pour obtenir des identifiants pour mes scripts Python ? Non. Les identifiants sont liés au compte, pas à une vérification d'identité : Connexion par numéro de compte ; l'e-mail est facultatif. Payez en crypto (BTC, USDT, USDC, ETH, LTC ou SOL). Puis collez le nom d'utilisateur et le mot de passe dans les espaces réservés `USERNAME` et `PASSWORD` dans le code ci-dessus. Pas d'essai gratuit — testez avec le forfait 1 GB, payé à partir de la recharge minimale ; le reste reste sur votre solde (n'expire jamais, non remboursable). **Obtenez des identifiants proxy US pour votre code Python** Trafic résidentiel de 0,52 $US/GB, avec ciblage par état, ville, code postal et ASN. Sans KYC — pas d’ID, pas de selfie, pas de documents. Payez en crypto. [Obtenez des proxys résidentiels américains — chez 0,52 $US/GB](https://statesideip.com/fr/pricing/) · [Proxys résidentiels des États-Unis](https://statesideip.com/fr/residential-proxies/united-states/) --- StatesideIP: StatesideIP est un fournisseur de proxys pour les États-Unis et le Canada : IP résidentielles avec ciblage par État, ville, code postal et ASN, plus des ports mobiles 4G/5G dédiés T-Mobile, AT&T et Verizon. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payer en crypto.