Come ruotare l'IP di un proxy mobile 4G/5G (2026)

Come funziona la rotazione IP su un proxy 4G/5G?

Un proxy 4G/5G cambia IP quando il suo modem si ricollega all'operatore. L'operatore assegna quindi un nuovo IP pubblico dal proprio pool. Gli operatori mobili condividono ogni IP pubblico tra molti utenti tramite carrier-grade NAT (CGNAT). Per questo i siti web sono cauti nel bloccare IP mobili: un blocco può colpire molti utenti reali.

Una porta dedicata è un modem con una SIM riservata a te. Il suo IP rimane lo stesso finché non lo ruoti, chiamando il link di rotazione o con un timer. Durante la riconnessione, che dura poco, le connessioni aperte su quella porta vengono chiuse. I tuoi script devono attendere e riprovare, come mostrato nel codice sotto.

Conviene ruotare su richiesta o con timer?

Ruota su richiesta quando il tuo script sa quando finisce un compito; usa un timer se vuoi un IP nuovo a intervalli regolari. LatamProxies supporta entrambi: Cambio IP su richiesta tramite link API, oppure automatico ogni 5-60 minuti.

• Su richiesta (link API): il tuo codice chiama il link di rotazione tra un lavoro e l'altro, per esempio dopo ogni batch di 200 pagine prodotto o prima di ogni verifica pubblicitaria. Controlli esattamente quando cambia l'IP.
• Timer: imposta un intervallo nel pannello di controllo. La porta si ricollega da sola. Utile per strumenti che non possono chiamare un URL, come alcuni profili browser o app desktop.

Non combinare un timer breve con chiamate su richiesta sulla stessa porta: l'IP potrebbe cambiare a metà lavoro.

Qual è la differenza tra proxy mobili sticky e rotanti?

Un proxy mobile sticky mantiene un IP per un periodo che controlli; uno rotante ti dà IP nuovi spesso, senza gestire i modem.

• Porta dedicata (sticky di default): da $9/giorno, traffico illimitato (fair use, nessun limite giornaliero di GB). L'IP cambia solo quando lo ruoti. Ideale per lavoro con account autenticati, test app e sessioni browser lunghe.
• Rotazione 4G/5G a consumo per GB: da 1,50 USD/GB. Fatturato in base al traffico e usato tramite gateway con sintassi username dalla guida di configurazione proxy. Perfetto per distribuire molte richieste brevi su IP mobili.

Le porte dedicate dipendono dalla disponibilità live di modem per operatore; la dashboard mostra le porte libere prima del pagamento. Confronta i prodotti nella pagina proxy mobili e ogni livello nella pagina prezzi.

Dove trovo il mio link di rotazione?

La tua dashboard mostra, per ogni porta dedicata, i dettagli di connessione (host, porta, nome utente, password) e il link di rotazione. Il link segue questo schema:

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

Sostituisci {port} con il numero della porta e API_KEY con la chiave mostrata nella dashboard. Tratta il link come una password: chiunque lo possieda può cambiare il tuo IP. Se viene compromesso, chiedi a [email protected] una nuova chiave.

Come ruoto l'IP in bash?

Lo script qui sotto chiama il link di rotazione, poi verifica l'IP di uscita attraverso il proxy finché non cambia. Inserisci i quattro valori dalla tua dashboard.

#!/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

Come ruoto l'IP in Python?

In Python, incapsula la rotazione in una funzione e chiamala tra i job. La funzione restituisce il nuovo IP, o genera un errore se il modem non si è riconnesso in 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())

Come ruoto l'IP in Node.js?

In Node.js 18 o versioni successive, usa undici per le richieste proxate e il built-in fetch per il link di rotazione, che è una normale chiamata HTTPS che non passa dal 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());

Quali sono le buone abitudini per la rotazione?

Ruota tra i task, non nel mezzo. Alcune regole per mantenere i job stabili:

• Completa il job, poi ruota. Una rotazione interrompe le connessioni aperte, quindi un caricamento pagina o un upload in corso falliranno.
• Non ruotare in un loop stretto. Ogni rotazione richiede una riconnessione; chiamare il link di nuovo prima che finisca aggiunge solo ritardo.
• Mantieni i cookie con l'IP. Se il tuo job usa un profilo browser, avvia un nuovo contesto dopo ogni rotazione.
• Abbina il paese all'obiettivo. Usa una porta in Brazil per app brasiliane, in Mexico per quelle messicane, e così via.
• Rimani entro le regole. La rotazione serve per distribuire carichi legittimi, come controlli prezzi e verifica annunci, non per eludere ban o creare account in massa. Vedi la Acceptable Use Policy.