# Comment utiliser un proxy mobile 4G en Python avec rotation d’IP

> Code Python pour proxy mobile 4G/5G : requests et httpx en HTTP ou SOCKS5, rotation d’IP via API, gestion des limites 429, sessions persistantes. Sans KYC.

- URL: https://cellmast.com/fr/guides/python-mobile-proxy/
- Dernière mise à jour: 2026-10-13
- Publisher: CellMast (https://cellmast.com)

Python prêt-à-copier pour un port dédié CellMast ou un pool mobile rotatif : connexion, rotation, attente de la nouvelle adresse, puis nouvelle tentative sans surcharger l’API.

**Réponse rapide — Comment utiliser un proxy mobile 4G en Python avec rotation d’IP ?**

Passez l’URL proxy `http://USERNAME:PASSWORD@gw.cellmast.com:7777` à `requests` ou `httpx`, puis appelez `POST /api/v1/mobile/{portId}/rotate` avec votre clé API quand vous voulez une nouvelle IP carrier. Attendez la réponse, généralement 5 à 15 secondes, et respectez un intervalle de 30 secondes entre chaque rotation. **CellMast** ports 4G/5G dédiés à partir de 2,63 $/jour, sans KYC, paiement en crypto.

## Ce qu’il vous faut

| Attribut | Valeur |
| --- | --- |
| Python | 3.10 ou supérieur |
| Bibliothèques | `requests` (HTTP), `requests[socks]` ou `httpx[socks]` pour SOCKS5 |
| Passerelle | `gw.cellmast.com`, port HTTP 7777, port SOCKS5 7778 |
| Identifiants du port | Nom d’utilisateur et mot de passe depuis l’espace client ; après modification d’un port par le support, relisez l’hôte, ports et mot de passe dans l’espace client car ils peuvent changer |
| Clé API | Avec le scope `proxies`, pour la rotation |
| Nom d’utilisateur du pool rotatif | `USERNAME-country-{cc}-session-{id}-ttl-{minutes}` |

## Comment envoyer une requête via un port mobile ?

Configurez la même URL de proxy pour `http` et `https`. Pour les cibles HTTPS, `requests` ouvre un tunnel CONNECT via la passerelle, donc la cible voit l'IP du carrier et votre TLS reste de bout en bout.

*requêtes via HTTP*

```python
import requests

PROXY = "http://USERNAME:PASSWORD@gw.cellmast.com:7777"
proxies = {"http": PROXY, "https": PROXY}

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

*SOCKS5 (pip install "requests[socks]")*

```python
import requests

# socks5h: the proxy resolves the hostname, not your machine
PROXY = "socks5h://USERNAME:PASSWORD@gw.cellmast.com:7778"
r = requests.get("https://api.ipify.org", proxies={"http": PROXY, "https": PROXY}, timeout=30)
print(r.text)
```

## Comment faire tourner l'IP depuis Python ?

Encapsulez l'appel à la rotation dans un helper qui prend en compte la réponse 429. Le helper ci-dessous attend `Retry-After` si vous effectuez une rotation trop tôt, puis vérifie que le carrier a bien fourni une nouvelle adresse.

*Helper de rotation*

```python
import time
import requests

API = "https://cellmast.com/api/v1"
KEY = "API_KEY"

def rotate(port_id: str, tries: int = 3) -> str:
    """Ask the modem for a new carrier IP and return it."""
    for _ in range(tries):
        r = requests.post(f"{API}/mobile/{port_id}/rotate",
                          headers={"Authorization": f"Bearer {KEY}"}, timeout=60)
        if r.status_code == 429:  # rotation_too_soon
            time.sleep(int(r.headers.get("Retry-After", "30")))
            continue
        r.raise_for_status()
        data = r.json()
        if data["ip"] != data.get("previousIp"):
            return data["ip"]
        time.sleep(30)  # same IP from the carrier: wait and try again
    raise RuntimeError("no new IP after several tries")

print("new IP:", rotate("PORT_ID"))
```

## Comment faire tourner entre les tâches, et non à l'intérieur ?

Exécutez une tâche complète sur une adresse, puis tournez avant la suivante. Cela maintient la cohérence des cookies et des connexions dans une tâche, et offre à chaque tâche une adresse fraîche.

*Une IP par tâche*

```python
import requests

PROXY = "http://USERNAME:PASSWORD@gw.cellmast.com:7777"

def run_job(urls):
    with requests.Session() as s:
        s.proxies = {"http": PROXY, "https": PROXY}
        for url in urls:
            resp = s.get(url, timeout=30)
            print(resp.status_code, url)

jobs = [["https://example.com/a", "https://example.com/b"],
        ["https://example.com/c"]]
for urls in jobs:
    run_job(urls)
    rotate("PORT_ID")  # helper from the previous example
```

## Comment utiliser la piscine rotative avec sessions persistantes dans httpx ?

Dans la piscine au GB il n’y a pas d’appel de rotation : c’est l’identifiant utilisateur qui décide. Sans ID de session, chaque connexion obtient une nouvelle IP. Les clients HTTP gardent les connexions ouvertes (keep-alive) donc pour une IP par requête ouvrez un nouveau client à chaque fois ou envoyez `Connection: close`. Avec `session-<id>-ttl-<minutes>`, les requêtes gardent une IP pour ce temps.

*httpx (pip install httpx)*

```python
import uuid
import httpx

def pool_client(country: str = "us", minutes: int | None = None) -> httpx.Client:
    user = f"USERNAME-country-{country}"
    if minutes:
        user += f"-session-{uuid.uuid4().hex[:8]}-ttl-{minutes}"
    proxy = f"http://{user}:PASSWORD@gw.cellmast.com:7777"
    return httpx.Client(proxy=proxy, timeout=30)

with pool_client("gb", minutes=10) as c:   # same UK mobile IP for 10 minutes
    print(c.get("https://api.ipify.org").text)
    print(c.get("https://api.ipify.org").text)
```

## Quelles erreurs mon script doit-il gérer ?

- **HTTP 429 de l'API de rotation :** vous avez tourné il y a moins de 30 secondes. Attendez `Retry-After`.
- **HTTP 409 `port_not_active` :** le port a expiré ou est suspendu. Vérifiez dans l’espace client.
- **Erreurs de connexion proxy juste après une rotation :** normal ; le modem se reconnecte. Réessayez après une courte pause.
- **HTTP 407 depuis la passerelle :** nom d’utilisateur ou mot de passe incorrect pour le port.
- **Cibles répondant 403 ou 429 :** ralentissez d’abord, puis tournez une fois. Les IP mobile sont partagées, un rythme plus calme règle la plupart des cas.

## Python et proxies mobiles : questions

### Dois-je utiliser HTTP ou SOCKS5 dans Python ?

HTTP est plus simple et marche avec les requêtes `requests` classiques. SOCKS5 nécessite le paquet `requests[socks]` supplémentaire mais transporte tout trafic TCP, et `socks5h://` résout le DNS côté proxy au lieu de votre machine. Les deux atteignent le même modem CellMast : HTTP sur le port 7777, SOCKS5 sur le port 7778.

### Puis-je utiliser asyncio avec un proxy mobile ?

Oui. `httpx.AsyncClient(proxy=...)` et `aiohttp` acceptent tous deux une URL de proxy HTTP. Gardez une concurrence modérée sur un seul port dédié : c’est un modem pour un lien transporteur, donc des dizaines de requêtes parallèles partagent la même liaison radio.

### Comment faire utiliser le port par Selenium ou Playwright ?

Dans Playwright, passez `proxy={"server": "http://gw.cellmast.com:7777", "username": "USERNAME", "password": "PASSWORD"}` à `launch()` ou `new_context()`. Les options proxy de Selenium ne prennent pas de mot de passe : utilisez l’authentification réseau BiDi de Selenium 4, ou Playwright. Faites tourner entre contextes du navigateur, jamais pendant le chargement d’une page.

**Obtenez un port et une clé API** Ports dédiés 4G/5G de 2,63 $/jour, données mobiles en rotation de 1,50 $US/GB. Payer en crypto. [Voir les tarifs](https://cellmast.com/fr/pricing/) · [Référence API mobile](https://cellmast.com/docs/api/mobile/)

---

CellMast: CellMast est un fournisseur de proxy mobile 4G/5G : modems carrier dédiés avec trafic illimité, plus une piscine mobile tournante facturée au GB, payée en crypto sans téléchargement d'identité.