# Como usar proxy móvel em Python com rotação de IP

> Código Python para proxies móveis 4G/5G: requests e httpx via HTTP ou SOCKS5, rotacione o IP via API, gerencie limites 429, sessões estáticas. Sem KYC.

- URL: https://cellmast.com/pt/guides/python-mobile-proxy/
- Última atualização: 2026-10-13
- Publisher: CellMast (https://cellmast.com)

Código Python pronto para uma porta dedicada CellMast ou pool móvel rotativo: conecte, rotacione, espere o novo endereço e tente novamente sem sobrecarregar a API.

**Resposta rápida — Como usar proxy móvel em Python com rotação de IP?**

Passe a URL do proxy `http://USERNAME:PASSWORD@gw.cellmast.com:7777` para `requests` ou `httpx` e chame `POST /api/v1/mobile/{portId}/rotate` com sua chave API quando quiser um novo IP do provedor. Aguarde a resposta, que leva geralmente de 5 a 15 segundos, e respeite o intervalo de 30 segundos entre rotações. **CellMast** portas dedicadas 4G/5G a partir de $2,63/dia, sem KYC, pagar com cripto.

## O que você precisa

| Atributo | Valor |
| --- | --- |
| Python | 3.10 ou superior |
| Bibliotecas | `requests` (HTTP), `requests[socks]` ou `httpx[socks]` para SOCKS5 |
| Gateway | `gw.cellmast.com`, porta HTTP 7777, porta SOCKS5 7778 |
| Credenciais da porta | Usuário e senha na área do cliente; após suporte mover uma porta, confira host, portas e senha novamente na área do cliente, pois podem mudar |
| Chave API | Com escopo `proxies`, para rotação |
| Usuário de pool rotativo | `USERNAME-country-{cc}-session-{id}-ttl-{minutes}` |

## Como envio uma requisição por uma porta móvel?

Configure a mesma URL de proxy para `http` e `https`. Para alvos HTTPS, `requests` abre um túnel CONNECT via gateway, assim o alvo vê o IP da operadora e seu TLS fica ponta a ponta.

*requisições 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)
```

## Como faço para rotacionar o IP com Python?

Envolva a chamada de rotação em um helper que entenda a resposta 429. O helper abaixo espera `Retry-After` quando você rotacionar cedo demais, depois verifica se a operadora realmente forneceu um novo endereço.

*Helper de rotação*

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

## Como faço para rotacionar entre jobs, não dentro deles?

Execute um job inteiro em um único endereço, depois rotacione antes do próximo. Isso mantém cookies e logins consistentes dentro do job e dá a cada job um endereço novo.

*Um IP por 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
```

## Como uso o pool rotativo com sessões sticky no httpx?

No pool por GB não existe chamada de rotação: o nome de usuário decide. Sem um ID de sessão, cada nova conexão recebe um novo IP. Clientes HTTP mantêm conexões abertas (keep-alive), então para um IP novo por requisição abra um cliente novo para cada requisição, ou envie `Connection: close`. Com `session-<id>-ttl-<minutes>`, as requisições mantêm um IP para esse 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)
```

## Quais erros meu script deve tratar?

- **HTTP 429 da API de rotação:** você rotacionou há menos de 30 segundos. Espere `Retry-After`.
- **HTTP 409 `port_not_active`:** a porta expirou ou está suspensa. Confira área do cliente.
- **Erros de conexão com proxy logo após rotação:** normal; o modem está reconectando. Tente novamente após uma pausa curta.
- **HTTP 407 do gateway:** usuário ou senha errados para a porta.
- **Alvos respondendo 403 ou 429:** diminua o ritmo primeiro, depois rotacione uma vez. IPs móveis são compartilhados, e um ritmo mais calmo resolve a maioria.

## Python e proxies móveis: perguntas

### Devo usar HTTP ou SOCKS5 no Python?

HTTP é mais simples e funciona com `requests` puro. SOCKS5 precisa do extra `requests[socks]` mas carrega qualquer tráfego TCP, e `socks5h://` resolve DNS no proxy em vez da sua máquina. Ambos alcançam o mesmo modem CellMast: HTTP na porta 7777, SOCKS5 na porta 7778.

### Posso usar asyncio com proxy móvel?

Sim. `httpx.AsyncClient(proxy=...)` e `aiohttp` aceitam URL de proxy HTTP. Mantenha a concorrência moderada em uma porta dedicada: é um modem em uma conexão de operadora, então dezenas de requisições paralelas compartilham o mesmo link rádio.

### Como fazer Selenium ou Playwright usarem a porta?

No Playwright, passe `proxy={"server": "http://gw.cellmast.com:7777", "username": "USERNAME", "password": "PASSWORD"}` para `launch()` ou `new_context()`. As opções de proxy do Selenium não aceitam senha: responda login do proxy via autenticação de rede Selenium 4 BiDi ou use Playwright. Rotacione entre contextos de navegador, nunca enquanto a página está carregando.

**Adquira porta e chave API** Portas dedicadas 4G/5G da $2,63/dia, dados móveis rotativos da US$ 1,50/GB. Pague com cripto. [Veja preços](https://cellmast.com/pt/pricing/) · [Referência API móvel](https://cellmast.com/docs/api/mobile/)

---

CellMast: CellMast é um provedor de proxies móveis 4G/5G: modems dedicados das operadoras com tráfego ilimitado, mais uma pool móvel rotativa por GB, pago em cripto sem upload de documentos.