Cómo rotar la IP de un proxy móvil 4G/5G (2026)

¿Cómo funciona la rotación de IP en un proxy 4G/5G?

Un proxy 4G/5G cambia la IP cuando su módem se reconecta al operador. El operador asigna entonces una nueva IP pública de su propia reserva. Los operadores móviles comparten cada IP pública entre muchos usuarios mediante carrier-grade NAT (CGNAT). Por eso los sitios web son cautelosos bloqueando IPs móviles: un bloqueo puede afectar a muchos usuarios reales.

Un puerto dedicado es un módem con una tarjeta SIM reservada para ti. Su IP se mantiene igual hasta que la rotas, ya sea llamando al enlace de rotación o con un temporizador. Durante la reconexión, que dura un momento breve, las conexiones abiertas en ese puerto se caen. Tus scripts deben esperar y reintentar, como se muestra en el código abajo.

¿Debo rotar bajo demanda o con temporizador?

Rota bajo demanda cuando tu script sabe cuándo termina una tarea; usa un temporizador cuando solo quieres una IP nueva en intervalos regulares. LatamProxies soporta ambos: Cambio de IP bajo demanda a través de un enlace API, o automáticamente cada 5 a 60 minutos.

• Bajo demanda (enlace API): tu código llama al enlace de rotación entre trabajos, por ejemplo después de cada lote de 200 páginas de productos o antes de cada verificación de anuncios. Controlas exactamente cuándo cambia la IP.
• Temporizador: configura un intervalo en el panel. El puerto se reconecta solo. Ideal para herramientas que no pueden llamar a una URL, como algunos perfiles de navegador o apps de escritorio.

No combines un temporizador corto con llamadas bajo demanda en el mismo puerto: la IP podría cambiar en medio de un trabajo.

¿Cuál es la diferencia entre proxies móviles sticky y rotativos?

Un proxy móvil sticky mantiene una IP por un período que controlas; uno rotativo te da IPs nuevas frecuentemente, sin gestionar módems.

• Puerto dedicado (sticky por defecto): desde $9/día, tráfico ilimitado (uso razonable, sin límite diario de GB). La IP cambia solo cuando la rotas. Ideal para trabajo con cuentas propias, pruebas de apps y sesiones largas en navegador.
• Rotativo 4G/5G por GB: desde 1,50 US$/GB. Se factura por tráfico y se usa vía gateway con la sintaxis de usuario del guía de configuración de proxy. Mejor para distribuir muchas solicitudes cortas entre IPs móviles.

Los puertos dedicados dependen del stock de módems activos por operador; el panel muestra los puertos libres antes de pagar. Compara productos en la página de proxies móviles y cada nivel en la página de precios.

¿Dónde encuentro mi enlace de rotación?

Tu panel muestra, para cada puerto dedicado, los detalles de conexión (host, puerto, usuario, contraseña) y su enlace de rotación. El enlace sigue este patrón:

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

Reemplaza {port} con tu número de puerto y API_KEY con la clave que aparece en el panel. Trata el enlace como una contraseña: quien lo tenga puede cambiar tu IP. Si se filtra, pide [email protected] una nueva clave.

¿Cómo rotar la IP en bash?

El script a continuación llama al enlace de rotación y luego verifica la IP de salida a través del proxy hasta que cambie. Completa los cuatro valores desde tu panel.

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

¿Cómo rotar la IP en Python?

En Python, envuelve la rotación en una función y llámala entre tareas. La función devuelve la nueva IP o lanza un error si el módem no se reconectó a tiempo.

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())

¿Cómo rotar la IP en Node.js?

En Node.js 18 o superior, usa undici para solicitudes con proxy y el fetch incorporado para el enlace de rotación, que es una llamada HTTPS normal que no pasa por el 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());

¿Cuáles son buenas prácticas para la rotación?

Rota entre tareas, no en medio de ellas. Algunas reglas para mantener la estabilidad:

• Termina la tarea y luego rota. La rotación cierra conexiones abiertas, así que una carga de página o subida en curso fallará.
• No rote en un bucle cerrado. Cada rotación requiere reconexión; llamar al enlace antes de que termine solo añade retraso.
• Mantén las cookies con la IP. Si usas un perfil de navegador, inicia un contexto nuevo tras cada rotación.
• Usa el país adecuado para el objetivo. Usa un puerto en Brasil para apps brasileñas, en México para mexicanas, y así sucesivamente.
• Cumple las reglas. La rotación es para distribuir carga legítima, como verificaciones de precios y control de anuncios, no para evadir bloqueos o crear cuentas masivas. Consulta la Política de Uso Aceptable.