Como rotacionar o IP de um proxy móvel 4G/5G (2026)

Como funciona a rotação de IP em um proxy 4G/5G?

Um proxy 4G/5G troca o IP quando seu modem reconecta à operadora. A operadora então atribui um novo IP público de seu próprio pool. Operadoras móveis compartilham cada IP público entre muitos assinantes via carrier-grade NAT (CGNAT). Por isso, sites são cautelosos ao bloquear IPs móveis: um bloqueio pode afetar muitos usuários reais.

Uma porta dedicada é um modem com um SIM card reservado para você. Seu IP permanece o mesmo até você rotacionar, seja chamando o link de rotação ou por timer. Durante a reconexão, que dura um curto momento, conexões abertas nessa porta são encerradas. Seus scripts devem esperar e tentar novamente, como mostrado no código abaixo.

Devo rotacionar sob demanda ou por timer?

Rotacione sob demanda quando seu script sabe quando uma tarefa termina; use um timer quando quiser um IP novo em intervalos regulares. LatamProxies suporta ambos: Troca de IP sob demanda por link de API, ou automaticamente a cada 5 a 60 minutos.

• Sob demanda (link da API): seu código chama o link de rotação entre trabalhos, por exemplo, após cada lote de 200 páginas de produtos ou antes de cada nova verificação de anúncios. Você controla exatamente quando o IP muda.
• Timer: defina um intervalo no painel. A porta reconecta sozinha. Isso é ideal para ferramentas que não conseguem chamar uma URL, como alguns perfis de navegador ou apps para desktop.

Não combine um timer curto com chamadas sob demanda na mesma porta: o IP pode mudar no meio de um trabalho.

Qual a diferença entre proxies móveis sticky e rotativos?

Um proxy móvel sticky mantém um IP por um período que você controla; um rotativo fornece IPs novos frequentemente, sem gerenciar modems.

• Porta dedicada (sticky por padrão): de $9/dia, tráfego ilimitado (uso justo, sem limite diário de GB). O IP só muda quando você rotaciona. Ideal para trabalho logado em contas próprias, testes de apps e sessões longas de navegador.
• Rotativo 4G por GB: de US$ 1,50/GB. Cobrado pelo tráfego e usado via gateway com a sintaxe de usuário do guia de configuração do proxy. Melhor para distribuir muitas requisições curtas entre IPs móveis.

Portas dedicadas dependem do estoque de modems ativos por operadora; o painel mostra portas livres antes de você pagar. Compare os produtos na página de proxies móveis e cada plano na página de preços.

Onde encontro meu link de rotação?

Seu painel mostra, para cada porta dedicada, os detalhes de conexão (host, porta, usuário, senha) e o link de rotação. O link segue este padrão:

https://latamproxies.com/api/v1/mobile/{port}/rotate?key=API_KEY

Substitua {port} pelo número da sua porta e API_KEY pela chave mostrada no painel. Trate o link como uma senha: quem o tiver pode mudar seu IP. Se vazar, peça [email protected] uma nova chave.

Como rotacionar o IP em bash?

O script abaixo chama o link de rotação e depois verifica o IP de saída pelo proxy até que ele mude. Preencha os quatro valores do seu painel.

#!/usr/bin/env bash
# Values from your dashboard
PROXY="http://USERNAME:PASSWORD@HOST:PORT"
ROTATE_URL="https://latamproxies.com/api/v1/mobile/{port}/rotate?key=API_KEY"   # replace {port} and API_KEY
CHECK="https://api.ipify.org"

old_ip=$(curl -s -x "$PROXY" "$CHECK")
echo "Current IP: $old_ip"

curl -s "$ROTATE_URL" > /dev/null

for i in $(seq 1 20); do
  sleep 3
  new_ip=$(curl -s --max-time 10 -x "$PROXY" "$CHECK")
  if [ -n "$new_ip" ] && [ "$new_ip" != "$old_ip" ]; then
    echo "New IP: $new_ip"
    exit 0
  fi
done
echo "IP did not change yet, try again later" >&2
exit 1

Como rotacionar o IP em Python?

Em Python, coloque a rotação em uma função e a chame entre trabalhos. A função retorna o novo IP ou gera erro se o modem não reconectar a tempo.

import time
import requests

PROXY = "http://USERNAME:PASSWORD@HOST:PORT"          # from your dashboard
ROTATE_URL = "https://latamproxies.com/api/v1/mobile/{port}/rotate?key=API_KEY"  # replace {port} and API_KEY
CHECK = "https://api.ipify.org"
proxies = {"http": PROXY, "https": PROXY}

def current_ip():
    return requests.get(CHECK, proxies=proxies, timeout=10).text.strip()

def rotate(max_wait=60):
    old = current_ip()
    requests.get(ROTATE_URL, timeout=30).raise_for_status()
    deadline = time.time() + max_wait
    while time.time() < deadline:
        time.sleep(3)
        try:
            new = current_ip()
            if new and new != old:
                return new
        except requests.RequestException:
            pass  # modem is reconnecting
    raise RuntimeError("IP did not change in time")

for batch in range(3):
    # ... run one batch of requests through `proxies` here ...
    print("Rotated to", rotate())

Como rotacionar o IP em Node.js?

No Node.js 18 ou posterior, use undici para requisições com proxy e o fetch embutido para o link de rotação, que é uma chamada HTTPS normal que não passa pelo proxy.

// npm install undici
import { fetch as pfetch, ProxyAgent } from 'undici';

// Values from your dashboard
const dispatcher = new ProxyAgent({
  uri: 'http://HOST:PORT',
  token: 'Basic ' + Buffer.from('USERNAME:PASSWORD').toString('base64'),
});
const ROTATE_URL = 'https://latamproxies.com/api/v1/mobile/{port}/rotate?key=API_KEY'; // replace {port} and API_KEY
const CHECK = 'https://api.ipify.org';
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

async function currentIp() {
  const res = await pfetch(CHECK, { dispatcher, signal: AbortSignal.timeout(10_000) });
  return (await res.text()).trim();
}

export async function rotate(maxWaitMs = 60_000) {
  const old = await currentIp();
  const r = await fetch(ROTATE_URL);
  if (!r.ok) throw new Error(`rotate failed: ${r.status}`);
  const deadline = Date.now() + maxWaitMs;
  while (Date.now() < deadline) {
    await sleep(3000);
    try {
      const ip = await currentIp();
      if (ip && ip !== old) return ip;
    } catch { /* modem is reconnecting */ }
  }
  throw new Error('IP did not change in time');
}

console.log('New IP:', await rotate());

Quais são bons hábitos de rotação?

Rotacione entre tarefas, não no meio delas. Algumas regras que mantêm os trabalhos estáveis:

• Finalize o trabalho antes de rotacionar. Uma rotação encerra conexões abertas, então um carregamento de página ou upload em andamento falhará.
• Não rotacione em loop apertado. Cada rotação precisa de uma reconexão; chamar o link novamente antes de terminar só atrasa.
• Mantenha os cookies com o IP. Se seu trabalho usa perfil de navegador, inicie um contexto novo após cada rotação.
• Combine o país com o alvo. Use uma porta no Brasil para apps brasileiros, no México para mexicanos, e assim por diante.
• Siga as regras. A rotação é para distribuir carga legítima, como checagem de preços e verificação de anúncios, não para burlar banimento ou criar contas em massa. Veja a Política de Uso Aceitável.