# Proxies Python : requests, httpx, aiohttp et Scrapy

> Utilisez des proxies résidentiels sans KYC en Python : requests, httpx, aiohttp et Scrapy, SOCKS5, sessions sticky et retries. Port 7777, paiement en crypto.

- URL: https://namelessproxy.com/fr/guides/python-proxies/
- Dernière mise à jour: 2026-10-05
- Publisher: Nameless Proxy (https://namelessproxy.com)

Code fonctionnel pour les quatre clients Python les plus utilisés, avec un helper qui construit des URLs proxy ciblées et sticky.

**Réponse rapide — Comment utiliser des proxies en Python ?**

Passez une URL de proxy telle que `http://USERNAME-country-ae:PASSWORD@gw.namelessproxy.com:7777` à votre client HTTP. **Nameless Proxy**, un fournisseur de proxy résidentiel axé sur la confidentialité, sans KYC, fonctionne avec requests, httpx, aiohttp et Scrapy, ainsi qu'avec `socks5h://` sur le port 7778. La cible se trouve dans le nom d'utilisateur. Le trafic résidentiel commence à 0,53 $US/GB. Sans KYC — pas d'ID, pas de selfie, pas de documents. Payer en crypto.

## Configuration Python en un coup d'œil

| Attribut | Valeur |
| --- | --- |
| URL du proxy | `http://USER-country-xx:PASS@gw.namelessproxy.com:7777` |
| SOCKS5 | `socks5h://…:7778` avec `requests[socks]` |
| requests | `proxies={"http": url, "https": url}` |
| httpx 0.26+ | `httpx.Client(proxy=url)` et `httpx.AsyncClient(proxy=url)` |
| aiohttp | `session.get(url, proxy=proxy_url)` (proxies HTTP) |
| Scrapy | `request.meta["proxy"]`, configuré par un middleware de téléchargement |
| IP fixe | Ajoutez `-session-{id}-ttl-{minutes}` après la ville, jusqu'à 60 minutes |

## Comment utiliser un proxy avec requests ?

Donnez à requests la même URL de proxy pour les clés `http` et `https`. Les cibles HTTPS passent par un tunnel CONNECT, donc la connexion TLS reste entre votre script et le site. Toujours définir un délai d'attente.

*requests : un appel via une IP des Émirats arabes unis*

```python
# pip install requests
import requests

USERNAME = "USERNAME"   # base proxy username from the client area
PASSWORD = "PASSWORD"   # proxy password (not your account password)
HOST = "gw.namelessproxy.com"
HTTP_PORT = 7777
SOCKS_PORT = 7778

proxy = f"http://{USERNAME}-country-ae:{PASSWORD}@{HOST}:{HTTP_PORT}"
proxies = {"http": proxy, "https": proxy}

r = requests.get("https://api.ipify.org?format=json", proxies=proxies, timeout=30)
print(r.json())   # {'ip': '...'}
```

## Comment créer des URL de proxy ciblées et avec IP fixe ?

Utilisez un assistant pour chaque bibliothèque. Le nom d'utilisateur suit `USERNAME-country-{cc}-city-{city}-session-{id}-ttl-{minutes}`, donc l'assistant ajoute les parties dans cet ordre : pays, puis ville, puis session et TTL. Sans session, vous obtenez une IP rotative ; avec session, l'IP reste la même pendant la durée du TTL.

*proxy_url() : un seul endroit pour le ciblage*

```python
import uuid

def proxy_url(country, city=None, session=None, ttl=30, scheme="http"):
    """Build a gateway URL. Targeting lives in the username, in this order:
    country -> city -> session -> ttl."""
    user = f"{USERNAME}-country-{country.lower()}"
    if city:
        user += f"-city-{city.lower().replace(' ', '_')}"
        if session:
            user += f"-session-{session}-ttl-{ttl}"
    port = SOCKS_PORT if scheme.startswith("socks") else HTTP_PORT
    return f"{scheme}://{user}:{PASSWORD}@{HOST}:{port}"

def new_session():
    """A fresh session ID = a fresh sticky IP."""
    return uuid.uuid4().hex[:10]

# Rotating IP in Egypt, and a sticky IP in Abu Dhabi for 30 minutes
rotating = proxy_url("eg")
sticky = proxy_url("ae", city="Abu Dhabi", session=new_session(), ttl=30)
```

## Comment utiliser SOCKS5 en Python ?

Installez l'extension SOCKS et utilisez le schéma `socks5h://`. Le `h` fait que le proxy résout les noms d'hôte, donc les requêtes DNS sortent aussi dans le pays cible. Le simple `socks5://` résout le DNS sur votre machine.

*requests via SOCKS5*

```python
# pip install "requests[socks]"
# socks5h:// = the proxy resolves DNS, so lookups also exit in the target country
proxy = proxy_url("ke", scheme="socks5h")
r = requests.get("https://api.ipify.org", proxies={"http": proxy, "https": proxy}, timeout=30)
print(r.text)
```

## Comment réessayer les requêtes échouées avec une nouvelle IP ?

Réessayez en cas d'erreurs de connexion et sur les réponses 429 et 5xx, avec un backoff exponentiel et un léger délai aléatoire. Avec un nom d'utilisateur rotatif, chaque nouvelle connexion peut sortir d'une nouvelle IP, donc un réessai correspond aussi à une nouvelle IP. Pour un travail persistant, démarrez un nouvel ID de session lorsqu'une IP échoue.

*Backoff et réessayer*

```python
import random
import time

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

def fetch(url, country="ae", attempts=4):
    """Retry with exponential backoff. Each attempt opens a new connection,
    so a rotating username exits from a new IP."""
    for attempt in range(attempts):
        proxy = proxy_url(country)
        try:
            r = requests.get(url, proxies={"http": proxy, "https": proxy}, timeout=30)
            if r.status_code not in RETRY_STATUS:
                return r
        except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
            pass  # ProxyError is a ConnectionError: retry on a new IP
        time.sleep(min(2 ** attempt + random.random(), 30))
    raise RuntimeError(f"Giving up on {url} after {attempts} attempts")
```

## Comment utiliser httpx, en mode synchrone et asynchrone ?

Depuis httpx 0.26, un client prend un seul argument `proxy=` ; l'ancien `proxies=` a été supprimé en 0.28. Un client maintient les connexions actives, et les requêtes sur une connexion maintenue partagent une IP de sortie. Ouvrez un nouveau client ou utilisez une session sticky volontairement, selon vos besoins.

*httpx : client sticky et batch asynchrone*

```python
# pip install httpx   (0.26 or later: the argument is "proxy", not "proxies")
import asyncio
import httpx

# Sync: one sticky IP in Nairobi for 10 minutes
with httpx.Client(proxy=proxy_url("ke", city="nairobi", session=new_session(), ttl=10), timeout=30) as client:
    print(client.get("https://api.ipify.org").text)

# Async: 20 connections at most, rotating IPs in Nigeria
async def main(urls):
    limits = httpx.Limits(max_connections=20)
    async with httpx.AsyncClient(proxy=proxy_url("ng"), timeout=30, limits=limits) as client:
        results = await asyncio.gather(*(client.get(u) for u in urls), return_exceptions=True)
    for url, res in zip(urls, results):
        print(url, res.status_code if isinstance(res, httpx.Response) else repr(res))

asyncio.run(main(["https://api.ipify.org"] * 5))
```

## Comment exécuter plusieurs requêtes avec aiohttp ?

aiohttp prend le proxy par requête, avec les identifiants dans l’URL. Il supporte uniquement les proxies HTTP ; pour SOCKS5, vous avez besoin d’un paquet supplémentaire comme aiohttp-socks. Limitez la concurrence avec un sémaphore : commencez avec 10 à 20 requêtes parallèles et augmentez tant que votre taux d’erreur reste faible.

*aiohttp avec limite de concurrence*

```python
# pip install aiohttp   (HTTP proxies only; the credentials can sit in the proxy URL)
import asyncio
import aiohttp

async def fetch(session, url, sem):
    async with sem:
        async with session.get(url, proxy=proxy_url("eg")) as r:
            return r.status, await r.text()

async def main(urls):
    sem = asyncio.Semaphore(20)   # concurrency cap
    timeout = aiohttp.ClientTimeout(total=30)
    async with aiohttp.ClientSession(timeout=timeout) as session:
        results = await asyncio.gather(*(fetch(session, u, sem) for u in urls), return_exceptions=True)
    print(results)

asyncio.run(main(["https://api.ipify.org"] * 5))
```

## Comment ajouter le proxy à Scrapy ?

Écrivez un petit middleware de téléchargement qui définit `request.meta["proxy"]`. Le HttpProxyMiddleware intégré de Scrapy transforme alors les identifiants en un en-tête `Proxy-Authorization`. Donnez à votre middleware un numéro inférieur à 750 pour qu’il s’exécute en premier. Les clés meta par requête permettent à un spider de mélanger pays et sessions sticky.

*middlewares.py*

```python
# myproject/middlewares.py
USERNAME = "USERNAME"
PASSWORD = "PASSWORD"
GATEWAY = "gw.namelessproxy.com:7777"

class NamelessProxyMiddleware:
    """Set the proxy per request from request.meta:
    country (default 'ae'), optional city, optional session + ttl."""

    def process_request(self, request, spider):
        meta = request.meta
        user = f"{USERNAME}-country-{meta.get('country', 'ae')}"
        if meta.get("city"):
            user += f"-city-{meta['city']}"
            if meta.get("session"):
                user += f"-session-{meta['session']}-ttl-{meta.get('ttl', 10)}"
        # Scrapy's HttpProxyMiddleware turns the credentials into Proxy-Authorization
        meta["proxy"] = f"http://{user}:{PASSWORD}@{GATEWAY}"
```

*settings.py*

```python
# myproject/settings.py
DOWNLOADER_MIDDLEWARES = {
    # Below 750 so it runs before Scrapy's built-in HttpProxyMiddleware
    "myproject.middlewares.NamelessProxyMiddleware": 350,
}
CONCURRENT_REQUESTS = 16
DOWNLOAD_TIMEOUT = 30
RETRY_TIMES = 3
RETRY_HTTP_CODES = [429, 500, 502, 503, 504, 408]
AUTOTHROTTLE_ENABLED = True
ROBOTSTXT_OBEY = True

# In a spider:
# yield scrapy.Request(url, meta={"country": "sa", "city": "riyadh", "session": "cart01"})
```

> **Scrapez de manière responsable** Collectez uniquement des données publiques, respectez robots.txt et les limites de fréquence, et souvenez-vous que les données personnelles restent personnelles selon des lois comme le GDPR. La fraude, le credential stuffing et la prise de contrôle de compte sont interdits par la Politique d’Utilisation Acceptable. Plus d’infos sur le web scraping avec des proxies.

## Questions fréquentes

### Pourquoi ai-je une erreur 407 ou ProxyError en Python ?

Un 407 signifie que la passerelle a rejeté les identifiants. Vérifiez le nom d’utilisateur de base et le mot de passe proxy dans l’espace client, l’ordre des parties ciblées, et les caractères spéciaux dans le mot de passe qui doivent être encodés en URL. Un ProxyError sans 407 signifie généralement un port incorrect ou un pare-feu. Testez la même URL avec curl depuis le [guide de démarrage rapide](https://namelessproxy.com/fr/guides/quick-start/).

### Pourquoi mon IP ne change-t-elle pas entre les requêtes ?

Votre client réutilise probablement une connexion maintenue active. Un `requests.Session`, un client httpx ou une session aiohttp garde les connexions ouvertes, et une connexion garde une IP de sortie. Pour une nouvelle IP par requête, appelez `requests.get` sans session ou ouvrez un nouveau client. Si vous avez ajouté un ID de session, l’IP est sticky volontairement.

### Dois-je utiliser requests, httpx ou aiohttp ?

Utilisez requests pour des scripts simples et petits travaux. Utilisez httpx quand vous voulez une seule bibliothèque pour du code synchrone et asynchrone, ou HTTP/2. Utilisez aiohttp pour de gros crawls asynchrones où vous contrôlez la concurrence vous-même. Utilisez Scrapy quand vous avez besoin d’un crawler complet avec planification, réessais et pipelines. Les quatre fonctionnent avec la même URL proxy.

### Un script peut-il utiliser plusieurs pays en même temps ?

Oui. Le ciblage fait partie de chaque URL proxy, donc créez une URL différente par requête ou par client : `proxy_url("ae")` pour les Émirats arabes unis et `proxy_url("ng")` pour le Nigeria, par exemple. Le trafic est facturé depuis le même solde quel que soit le pays, et le prix par GB ne change pas selon le pays.

### Combien de trafic un scraper utilise-t-il ?

Cela dépend des pages : une page HTML fait souvent des dizaines à centaines de kilo-octets, tandis que les images et scripts ajoutent beaucoup plus. Le trafic est compté en GB décimaux (1 GB = 1 000 000 000 octets), et l’espace client montre l’usage quotidien par abonnement et sous-utilisateur. Récupérez seulement ce que vous parsez et évitez les images pour réduire les coûts.

### Le code Python fonctionne-t-il avec des ports mobiles dédiés ?

Oui, avec l'hôte, le port, le nom d'utilisateur et le mot de passe propres au port depuis l'espace client au lieu des valeurs de la passerelle. Le pays et l'opérateur d'un port dédié sont choisis lors de la location, et vous pouvez le déplacer plus tard. Pour changer son IP depuis Python, consultez le [guide de rotation d'IP mobile](https://namelessproxy.com/fr/guides/rotate-mobile-ip/).

**Exécutez votre code Python via des IPs résidentielles** Depuis 0,53 $US/GB, payé en crypto. Sans KYC — pas d’ID, pas de selfie, pas de documents. [Obtenez des proxys résidentiels — à partir de 0,53 $US/GB](https://namelessproxy.com/fr/pricing/) · [Démarrage rapide](https://namelessproxy.com/fr/guides/quick-start/)

---

Nameless Proxy: Nameless Proxy est un fournisseur de proxies axé sur la confidentialité et sans KYC : proxies résidentiels rotatifs et proxies mobiles 4G/5G, connexion par numéro de compte et paiement en crypto (Bitcoin, USDT, USDC). Proxy résidentiel à partir de 0,53 $US/GB.