Comment faire tourner l’IP d’un proxy mobile 4G/5G (2026)

Comment fonctionne la rotation d’IP sur un proxy 4G/5G ?

Un proxy 4G/5G change d’IP lorsque son modem se reconnecte à l’opérateur. L’opérateur attribue alors une nouvelle IP publique issue de son propre pool. Les opérateurs mobiles partagent chaque IP publique entre plusieurs abonnés via le NAT opérateur (CGNAT). C’est pourquoi les sites web sont prudents à bloquer les IP mobiles : un blocage peut affecter de nombreux utilisateurs réels.

Un port dédié est un modem avec une carte SIM réservée pour vous. Son IP reste la même jusqu’à ce que vous la fassiez tourner, soit en appelant le lien de rotation, soit via un minuteur. Pendant la reconnexion, qui prend un court instant, les connexions ouvertes sur ce port sont coupées. Vos scripts doivent attendre et réessayer, comme montré dans le code ci-dessous.

Dois-je faire une rotation à la demande ou selon un minuteur ?

Faites une rotation à la demande lorsque votre script sait quand une tâche se termine ; utilisez un minuteur lorsque vous souhaitez simplement une IP fraîche à intervalles réguliers. LatamProxies prend en charge les deux : Changement d'IP à la demande via un lien API, ou automatiquement toutes les 5 à 60 minutes.

• À la demande (lien API) : votre code appelle le lien de rotation entre les tâches, par exemple après chaque lot de 200 pages produit ou avant chaque nouvelle vérification de publicité. Vous contrôlez exactement quand l’IP change.
• Minuteur : définissez un intervalle dans le tableau de bord. Le port se reconnecte automatiquement. Cela convient aux outils qui ne peuvent pas appeler une URL, comme certains profils de navigateur ou applications de bureau.

Ne combinez pas un minuteur court avec des appels à la demande sur le même port : l’IP pourrait changer en plein milieu d’une tâche.

Quelle est la différence entre proxy mobile 4G sticky et rotatif ?

Un proxy mobile sticky conserve une IP pendant une période que vous contrôlez ; un proxy rotatif vous donne souvent de nouvelles IP, sans gérer les modems.

• Port dédié (sticky par défaut) : depuis $9/jour, trafic illimité (usage raisonnable, sans plafond quotidien de GB). L’IP change uniquement quand vous la faites tourner. Idéal pour travailler connecté sur des comptes que vous possédez, tester des applications et les longues sessions de navigation.
• Rotation 4G/5G au GB : depuis 1,50 $US/GB. Facturé selon le trafic et utilisé via la passerelle avec la syntaxe utilisateur du guide d’installation proxy. Parfait pour répartir de nombreuses requêtes courtes sur des IP mobiles.

Les ports dédiés dépendent du stock de modems en direct par opérateur ; le tableau de bord affiche les ports libres avant de payer. Comparez les produits sur la page proxies mobiles et chaque offre sur la page tarifs.

Où trouver mon lien de rotation ?

Votre tableau de bord affiche, pour chaque port dédié, ses détails de connexion (hôte, port, nom d’utilisateur, mot de passe) et son lien de rotation. Le lien suit ce modèle :

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

Remplacez {port} par votre numéro de port et API_KEY par la clé affichée dans le tableau de bord. Traitez ce lien comme un mot de passe : toute personne qui le possède peut changer votre IP. En cas de fuite, demandez une nouvelle clé à [email protected].

Comment faire une rotation d’IP en bash ?

Le script ci-dessous appelle le lien de rotation, puis vérifie l’IP de sortie via le proxy jusqu’à ce qu’elle change. Remplissez les quatre valeurs depuis votre tableau de bord.

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

Comment faire une rotation d’IP en Python ?

En Python, encapsulez la rotation dans une fonction et appelez-la entre les tâches. La fonction retourne la nouvelle IP, ou génère une erreur si le modem ne s’est pas reconnecté à temps.

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

Comment faire une rotation d’IP en Node.js ?

Dans Node.js 18 ou version ultérieure, utilisez undici pour les requêtes via proxy et le fetch intégré pour le lien de rotation, qui est un appel HTTPS normal ne passant pas par le 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());

Quelles sont les bonnes pratiques de rotation ?

Faites la rotation entre les tâches, pas en plein milieu. Quelques règles pour garder les jobs stables :

• Terminez le job, puis faites la rotation. Une rotation coupe les connexions ouvertes, donc un chargement de page ou un upload en cours échouera.
• Ne faites pas de rotation en boucle serrée. Chaque rotation nécessite une reconnexion ; appeler le lien avant la fin ajoute seulement du délai.
• Gardez les cookies avec l’IP. Si votre job utilise un profil navigateur, démarrez un nouveau contexte après chaque rotation.
• Adaptez le pays à la cible. Utilisez un port au Brésil pour les applis brésiliennes, au Mexique pour les mexicaines, etc.
• Respectez les règles. La rotation sert à répartir une charge légitime, comme les vérifications de prix ou la validation de pubs, pas à contourner des bans ou créer des comptes en masse. Voir la Politique d’Utilisation Acceptable.