# Come usare un proxy mobile in Python con rotazione IP

> Codice Python per proxy mobili 4G/5G: requests e httpx su HTTP o SOCKS5, rotazione IP via API, gestione limiti 429, sessioni sticky. Senza KYC.

- URL: https://cellmast.com/it/guides/python-mobile-proxy/
- Ultimo aggiornamento: 2026-10-13
- Publisher: CellMast (https://cellmast.com)

Python pronto all’uso per una porta dedicata CellMast o il pool mobile rotante: connetti, ruota, attendi il nuovo indirizzo, e ritenta senza sovraccaricare l’API.

**Risposta rapida — Come uso un proxy mobile in Python con rotazione IP?**

Passa l’URL del proxy `http://USERNAME:PASSWORD@gw.cellmast.com:7777` a `requests` o `httpx`, poi chiama `POST /api/v1/mobile/{portId}/rotate` con la tua API key quando vuoi un nuovo IP carrier. Attendi la risposta, che di solito richiede 5–15 secondi, e rispetta l’intervallo di 30 secondi tra le rotazioni. **CellMast** porte dedicate 4G/5G partono da $2,63/giorno, senza KYC, pagabili in crypto.

## Cosa ti serve

| Attributo | Valore |
| --- | --- |
| Python | 3.10 o versione superiore |
| Librerie | `requests` (HTTP), `requests[socks]` o `httpx[socks]` per SOCKS5 |
| Gateway | `gw.cellmast.com`, porta HTTP 7777, porta SOCKS5 7778 |
| Credenziali porta | Nome utente e password dall’area clienti; dopo che il supporto sposta una porta, rileggi host, porte e password nell’area clienti perché possono cambiare |
| API key | Con lo scope `proxies`, per rotazione |
| Username pool rotante | `USERNAME-country-{cc}-session-{id}-ttl-{minutes}` |

## Come invio una richiesta tramite una porta mobile?

Imposta la stessa URL proxy per `http` e `https`. Per destinazioni HTTPS, `requests` apre un tunnel CONNECT tramite il gateway, quindi il target vede l'IP dell'operatore e il tuo TLS rimane end-to-end.

*richieste tramite 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)
```

## Come faccio a ruotare l'IP da Python?

Includi la chiamata di rotazione in un helper che gestisca la risposta 429. L'helper sottostante aspetta `Retry-After` se ruoti troppo presto, poi verifica che l’operatore abbia davvero assegnato un nuovo indirizzo.

*Helper per la rotazione*

```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"))
```

## Come faccio a ruotare tra i job, non durante?

Esegui un intero job con un indirizzo, poi ruota prima del successivo. Questo mantiene coerenti cookie e login all’interno di un job e fornisce a ogni job un indirizzo nuovo.

*Un IP per job*

```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
```

## Come uso la pool rotante con sticky sessions in httpx?

Nella pool a consumo per GB non c’è chiamata di rotazione: la username la decide. Senza session id, ogni nuova connessione riceve un IP nuovo. I client HTTP mantengono le connessioni aperte (keep-alive), quindi per un IP nuovo a ogni richiesta apri un client nuovo o invia `Connection: close`. Con `session-<id>-ttl-<minutes>`, le richieste mantengono un IP per quel tempo.

*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)
```

## Quali errori deve gestire il mio script?

- **HTTP 429 dall'API di rotazione:** hai ruotato da meno di 30 secondi. Aspetta `Retry-After`.
- **HTTP 409 `port_not_active`:** la porta è scaduta o sospesa. Controlla l’area clienti.
- **Errori di connessione proxy subito dopo una rotazione:** normale; il modem si sta riconnettendo. Riprova dopo una breve pausa.
- **HTTP 407 dal gateway:** username o password errata per la porta.
- **Target che rispondono 403 o 429:** rallenta prima, poi ruota una volta. Gli IP mobili sono condivisi e un ritmo più calmo risolve la maggior parte di questi casi.

## Python e proxy mobili: domande

### Devo usare HTTP o SOCKS5 in Python?

HTTP è più semplice e funziona con il classico `requests`. SOCKS5 richiede il componente extra `requests[socks]` ma supporta qualsiasi traffico TCP, e `socks5h://` risolve DNS dal lato proxy e non dalla tua macchina. Entrambi raggiungono lo stesso modem CellMast: HTTP sulla porta 7777, SOCKS5 sulla porta 7778.

### Posso usare asyncio con un proxy mobile?

Sì. `httpx.AsyncClient(proxy=...)` e `aiohttp` accettano entrambi un URL proxy HTTP. Mantieni la concorrenza moderata su una singola porta dedicata: è un modem su una connessione carrier, quindi dozzine di richieste parallele condividono lo stesso collegamento radio.

### Come faccio a far usare a Selenium o Playwright la porta?

In Playwright, passa `proxy={"server": "http://gw.cellmast.com:7777", "username": "USERNAME", "password": "PASSWORD"}` a `launch()` o `new_context()`. Le opzioni proxy di Selenium non prevedono password: rispondi al login proxy tramite l'autenticazione di rete Selenium 4 BiDi oppure usa Playwright. Ruota tra i contesti browser, mai mentre si carica una pagina.

**Ottieni una porta e una API key** Porte dedicate 4G/5G da $2,63/giorno, dati mobili rotanti da 1,50 USD/GB. Paghi in crypto. [Vedi i prezzi](https://cellmast.com/it/pricing/) · [Riferimento API mobile](https://cellmast.com/docs/api/mobile/)

---

CellMast: CellMast è un fornitore di proxy mobili 4G/5G: modem carrier dedicati con traffico illimitato, più un pool mobile rotante a consumo per GB, pagabile in crypto senza caricamento di documenti.