Si le parseur fonctionne sous un compte authentifié, le changement d'IP signifie presque toujours une déconnexion instantanée, un captcha ou un bannissement de session. La plateforme détecte une incohérence dans l'« empreinte » de connexion et la session expirée — et réinitialise les cookies. Dans cet article, nous allons examiner 4 schémas éprouvés qui permettent de changer d'IP tout en conservant l'authentification, ainsi qu'un code fonctionnel en Python.
Pourquoi la session expire lors du changement d'IP
Une session authentifiée n'est pas seulement un cookie avec un session_id. Les plateformes modernes (marketplaces, réseaux sociaux, comptes bancaires) lient la session à un ensemble de paramètres : adresse IP, User-Agent, empreinte TLS, géolocalisation par IP, parfois à l'empreinte Canvas/WebGL du navigateur. Dès qu'un de ces paramètres change brusquement — par exemple, si l'IP passe d'un centre de données de Moscou à une IP d'un autre pays — le système anti-fraude considère cela comme un comportement suspect et réinitialise la session, demandant une nouvelle connexion ou affichant un captcha.
Cela est particulièrement critique pour les tâches où le parsing se fait depuis un compte authentifié : collecte de prix sur Wildberries via le compte personnel du vendeur, surveillance des concurrents sur Ozon avec authentification, parsing de sections fermées d'Avito, collecte de données depuis Instagram ou VK via API avec un token. Dans chacun de ces cas, la combinaison « compte + IP + cookies » doit rester stable tout au long de la session, et ne pas changer à chaque requête, comme c'est souvent le cas lors d'un parsing normal sans authentification.
D'où découle la règle principale : la rotation d'IP lors du parsing authentifié doit être contrôlée, et non aléatoire. Ci-dessous, quatre schémas qui résolvent ce problème avec différents niveaux de complexité et de fiabilité.
Schéma 1 : Sessions collantes (liaison IP au compte)
Le schéma le plus simple et le plus fiable consiste à lier la même IP à un compte ou une session pendant toute la durée de l'opération (de quelques minutes à plusieurs heures), et à changer l'IP uniquement lorsque la session se termine naturellement (déconnexion, expiration du token, changement planifié de compte).
Techniquement, cela se réalise via un port collant chez le fournisseur de proxy : vous obtenez un endpoint qui maintient la même IP sortante pendant une période donnée (généralement de 1 à 30 minutes, parfois jusqu'à plusieurs heures), puis l'IP change automatiquement. Pour les tâches avec authentification, les proxies résidentiels sont les plus adaptés — ils fournissent de vraies IP de fournisseurs domestiques qui ne figurent pas sur les listes noires des centres de données et apparaissent comme un utilisateur ordinaire, ce qui est critique pour les comptes bancaires, les comptes personnels des marketplaces et des réseaux sociaux.
La règle est simple : un compte = une IP collante pendant tout le cycle de vie de la session. Si vous devez parser 50 comptes simultanément — vous créez 50 sessions collantes avec des IP différentes, chacune fonctionnant avec son propre ensemble de cookies et ne se chevauchant pas avec les autres. C'est le même principe que celui utilisé par les spécialistes SMM dans les navigateurs anti-détection Dolphin Anty ou AdsPower lorsqu'ils gèrent des dizaines de comptes clients : un profil de navigateur = une IP permanente = son propre ensemble de cookies, qui ne se mélange pas avec les autres.
Schéma 2 : Pool de cookies + IP comme paire unique
Si la tâche nécessite une rotation d'IP (par exemple, pour ne pas atteindre la limite de taux d'une session), mais qu'il est nécessaire de conserver plusieurs états authentifiés parallèles — le schéma « pool de paires » est appliqué. L'idée : vous vous connectez à l'avance N fois avec des identifiants différents (ou à partir de différentes IP de départ), vous conservez pour chaque session la combinaison cookies + IP + User-Agent, et à chaque requête suivante, vous utilisez exactement la paire avec laquelle la session a été initialement créée.
En pratique, cela ressemble à ceci : dans une base de données ou dans Redis, il y a un tableau du type "id de session → cookies → IP du proxy → User-Agent → temps de dernière utilisation". Avant chaque requête, le parseur prend une paire libre du pool, effectue la requête via l'IP qui lui est liée, met à jour les cookies à partir de la réponse et les remet dans la même entrée. Si la session a expiré (le serveur a renvoyé une redirection vers la page de connexion) — la paire est marquée comme invalide, supprimée du pool, et une nouvelle est créée par une nouvelle connexion.
Ce schéma se scalabilise bien horizontalement : plus il y a de paires « cookies + IP » dans le pool, plus la capacité totale du parseur est élevée sans risque de bannissements. Pour cette tâche, il est pratique d'utiliser des proxies de centres de données là où la vitesse est plus importante que l'anonymat — par exemple, lors du parsing de catalogues ouverts après authentification, lorsque la plateforme elle-même ne détecte pas agressivement l'empreinte, et que le goulot d'étranglement devient la vitesse de navigation dans le catalogue.
Schéma 3 : Liaison par empreinte digitale via anti-détection
Le troisième schéma est nécessaire lorsque la plateforme vérifie non seulement l'IP et les cookies, mais aussi l'empreinte complète du navigateur : Canvas, WebGL, polices, fuseau horaire, langue du système, résolution d'écran. Cela est typique pour les réseaux sociaux (Instagram, TikTok, VK) et certaines marketplaces avec un anti-fraude avancé. Dans ce cas, la combinaison doit être étendue à « IP + cookies + empreinte digitale » et stockée comme un tout — sinon, même avec la bonne IP et des cookies valides, la session sera tout de même réinitialisée en raison d'une incohérence de l'empreinte du navigateur.
En pratique, cela se résout via des navigateurs sans tête avec une empreinte gérée (Playwright, Puppeteer avec un plugin stealth) ou via des navigateurs anti-détection comme Dolphin Anty, Multilogin, GoLogin ou Octo Browser, où chaque profil se voit attribuer son propre ensemble de paramètres d'empreinte digitale, sa propre IP permanente via une intégration de proxy intégrée et son propre stockage de cookies. Le profil se connecte une fois, puis se relance simplement avec les mêmes paramètres — la session continue d'exister, car la plateforme voit le même « appareil » à la même IP.
Pour le parsing des réseaux sociaux et des applications mobiles via API, à ce stade, on passe souvent à des proxies mobiles — les IP opérateurs avec CGNAT suscitent moins de soupçons auprès des systèmes qui s'attendent à du trafic précisément des réseaux mobiles, et combiner l'IP avec l'empreinte digitale requise offre la meilleure stabilité de session.
Schéma 4 : Réauthentification contrôlée
Le quatrième schéma consiste à ne pas essayer de maintenir une session éternellement, mais à intégrer à l'avance dans le parseur la logique de réauthentification planifiée lors du changement d'IP. C'est l'option la plus coûteuse en termes de travail, mais aussi la plus résiliente : au lieu de transférer les anciens cookies vers la nouvelle IP (ce qui entraîne presque toujours un bannissement), le parseur initie lui-même une nouvelle connexion lors du changement d'IP — il saisit le login/mot de passe (ou utilise un refresh-token), obtient de nouveaux cookies déjà sous la nouvelle IP et continue à travailler à partir d'une page blanche.
Ce schéma est obligatoire là où l'API prend en charge OAuth2 avec des refresh-tokens (de nombreuses marketplaces et comptes publicitaires, par exemple Google Ads API, TikTok Ads API) : lors du changement d'IP, vous échangez simplement le refresh-token contre un nouveau access-token, sans avoir besoin de saisir à nouveau le mot de passe. S'il n'y a pas de refresh-token — il faut émuler un flux de connexion complet : obtenir un token CSRF depuis la page de connexion, envoyer le login/mot de passe, passer un éventuel captcha ou 2FA, et sauvegarder les nouveaux cookies.
Le inconvénient de ce schéma — le risque de connexions fréquentes peut lui-même sembler suspect et provoquer le blocage du compte, c'est pourquoi il est généralement combiné avec le schéma 1 : l'IP change rarement et uniquement de manière synchrone avec la réauthentification planifiée, et non à chaque requête.
Comparaison des 4 schémas
| Schéma | Complexité | Fiabilité | Quand appliquer |
|---|---|---|---|
| Sessions collantes | Faible | Élevée | 1 compte — 1 IP, petits volumes |
| Pool de cookies + IP | Moyenne | Moyenne-élevée | Parsing massif avec plusieurs comptes |
| Liaison par empreinte digitale | Élevée | Élevée | Réseaux sociaux, anti-fraude avancé |
| Réauthentification | Élevée | Très élevée | API avec refresh-tokens, rotation fréquente d'IP |
Code : session + proxy collant en Python
Ci-dessous, un exemple de base utilisant requests.Session,
qui conserve les cookies et fonctionne via le même proxy collant pendant toute la session.
La session conserve les cookies automatiquement, et la liaison à l'IP est réalisée grâce au port collant du fournisseur de proxy,
qui renvoie la même IP sortante pour toutes les requêtes dans la fenêtre de temps spécifiée.
import requests
# le port collant maintient la même IP tant que la session est active
PROXY = {
"http": "http://login:[email protected]:8000",
"https": "http://login:[email protected]:8000",
}
session = requests.Session()
session.proxies.update(PROXY)
session.headers.update({
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/124.0.0.0 Safari/537.36"
})
# connexion — les cookies seront automatiquement sauvegardés dans session.cookies
login_payload = {"login": "[email protected]", "password": "secret"}
resp = session.post("https://example.com/login", data=login_payload)
assert resp.status_code == 200
# les requêtes suivantes se font avec les mêmes cookies et la même IP
page = session.get("https://example.com/cabinet/orders")
print(page.status_code, len(page.text))
Pour le schéma avec le pool de paires cookies + IP, il est pratique de stocker l'état dans Redis — cela permet de scalabiliser le parseur sur plusieurs workers sans chevauchement des sessions :
import json
import redis
import requests
r = redis.Redis(host="localhost", port=6379, db=0)
def get_session_pair(account_id):
raw = r.get(f"session:{account_id}")
if raw:
data = json.loads(raw)
session = requests.Session()
session.cookies.update(data["cookies"])
session.proxies.update({"http": data["proxy"], "https": data["proxy"]})
return session
return None
def save_session_pair(account_id, session, proxy_url):
data = {
"cookies": session.cookies.get_dict(),
"proxy": proxy_url,
}
r.set(f"session:{account_id}", json.dumps(data), ex=3600)
Pour l'option avec liaison par empreinte digitale via Playwright, il suffit de se connecter une fois et de sauvegarder l'état de stockage — cela inclut non seulement les cookies, mais aussi le localStorage/sessionStorage, ce qui est critique pour les sites SPA des marketplaces et des réseaux sociaux :
from playwright.sync_api import sync_playwright
with sync_playwright() as p:
browser = p.chromium.launch(proxy={"server": "http://gate.proxycove.com:8000",
"username": "login", "password": "password"})
context = browser.new_context()
page = context.new_page()
page.goto("https://example.com/login")
page.fill("#login", "[email protected]")
page.fill("#password", "secret")
page.click("#submit")
page.wait_for_selector("#cabinet")
context.storage_state(path="session_state.json") # sauvegarde la session entière
browser.close()
# lors de la prochaine exécution — même IP + même session
with sync_playwright() as p:
browser = p.chromium.launch(proxy={"server": "http://gate.proxycove.com:8000",
"username": "login", "password": "password"})
context = browser.new_context(storage_state="session_state.json")
page = context.new_page()
page.goto("https://example.com/cabinet")
Erreurs fréquentes
1. Rotation d'IP à chaque requête au sein d'une même session authentifiée. C'est la principale raison des bannissements instantanés — le système voit qu'un session_id est utilisé avec des dizaines d'IP différentes en une minute, et le bloque comme un signe évident d'automatisation.
2. Sauvegarde uniquement du session_id sans User-Agent et autres en-têtes. Si les cookies ont été obtenus avec un User-Agent, mais utilisés avec un autre — cela déclenche également l'anti-fraude, même si l'IP n'a pas changé.
3. Ignorer la géolocalisation de l'IP. Si le compte s'est connecté depuis Moscou, mais que la requête suivante part avec une IP d'un autre pays — la session sera presque toujours réinitialisée, indépendamment de la validité des cookies.
4. Absence de traitement des sessions expirées. Le parseur doit être capable de distinguer "le serveur a renvoyé la page de connexion" de "le serveur a renvoyé les données requises" et déclencher automatiquement la réauthentification, plutôt que de tomber avec une erreur.
5. Utilisation du même pool de proxies pour différents comptes sans liaison. Si deux comptes différents reçoivent accidentellement la même IP sortante, la plateforme peut les lier entre eux — cela est particulièrement dangereux pour les agences SMM gérant des dizaines de comptes clients simultanément.
Checklist avant le lancement du parseur avec authentification
- Un schéma a été choisi, correspondant au niveau de protection de la plateforme (collant / pool / empreinte / réauthentification)
- Chaque compte a reçu une IP permanente pour toute la durée de la session
- Les cookies et le session_id sont sauvegardés avec l'IP, le User-Agent et les en-têtes, et non séparément
- Une vérification de la validité de la session a été mise en place avant chaque requête importante
- Une réauthentification automatique est configurée en cas de détection d'une session expirée
- Les proxies sont adaptés au type de plateforme : résidentiels pour les comptes bancaires et e-commerce, mobiles pour les réseaux sociaux, centres de données pour le parsing rapide des sections ouvertes
- Toutes les modifications d'IP et les moments de réauthentification sont enregistrés pour analyser les bannissements
Conclusion
La conclusion principale est simple : lors du parsing avec authentification, l'IP et la session doivent changer de manière synchrone, et non indépendamment l'une de l'autre. Le démarrage le plus fiable est le schéma des sessions collantes, où un compte est lié à une IP pendant toute la durée de l'opération. Pour le parsing massif sous plusieurs comptes, le pool de paires cookies + IP est adapté, pour les réseaux sociaux avec un anti-fraude avancé — la liaison par empreinte digitale via un navigateur anti-détection, et pour les API avec tokens — la réauthentification planifiée lors du changement d'IP.
Si vous configurez un parseur avec authentification pour des marketplaces ou des comptes personnels, commencez par des proxies résidentiels avec un port collant — ils fournissent une IP stable pour le temps nécessaire et un risque minimal de blocage de session. Pour le parsing des réseaux sociaux via des API authentifiées, il vaut mieux se tourner vers des IP mobiles, et pour un contournement à grande vitesse des catalogues ouverts après connexion — vers des proxies de centres de données, comme décrit ci-dessus.