Se o parser opera sob uma conta autenticada, mudar de IP quase sempre significa logout instantâneo, captcha ou banimento da sessão. A plataforma percebe a discrepância na "impressão" da conexão e a sessão perdida — e descarta os cookies. Neste artigo, vamos analisar 4 esquemas comprovados que permitem mudar de IP e, ao mesmo tempo, não perder a autenticação, além de um código funcional em Python.
Por que a sessão é perdida ao mudar de IP
Uma sessão autenticada não é apenas um cookie com session_id. Plataformas modernas (marketplaces, redes sociais, contas bancárias) vinculam a sessão a um conjunto inteiro de parâmetros: endereço IP, User-Agent, fingerprint TLS, geolocalização por IP, às vezes até o fingerprint do Canvas/WebGL do navegador. Assim que um desses parâmetros muda abruptamente — por exemplo, o IP salta de um datacenter em Moscovo para um IP de outro país — o sistema antifraude considera isso um comportamento suspeito e zera a sessão, exigindo um novo login ou mostrando um captcha.
Isso é especialmente crítico para tarefas onde a análise é feita a partir de uma conta autenticada: coleta de preços no Wildberries através da conta do vendedor, monitoramento de concorrentes no Ozon com autenticação, análise de seções fechadas do Avito, coleta de dados do Instagram ou VK através da API com token. Em cada um desses casos, a combinação "conta + IP + cookies" deve permanecer estável durante toda a sessão, e não mudar a cada solicitação, como frequentemente acontece em análises normais sem autenticação.
Daí surge a regra principal: a rotação de IP em análises autenticadas deve ser controlada, e não aleatória. Abaixo estão quatro esquemas que resolvem essa tarefa com diferentes balanços de complexidade e confiabilidade.
Esquema 1: Sessões Sticky (vinculação de IP à conta)
O esquema mais simples e ao mesmo tempo mais confiável é vincular um mesmo IP a uma única conta ou sessão durante todo o período de operação (de alguns minutos a várias horas), e mudar o IP apenas quando a sessão já estiver se encerrando naturalmente (logout, expiração do token, troca programada de conta).
Tecnicamente, isso é realizado através de um sticky-port com o provedor de proxy: você recebe um endpoint que mantém o mesmo IP de saída durante um tempo determinado (geralmente de 1 a 30 minutos, às vezes até várias horas), e então o IP muda automaticamente. Para tarefas com autenticação, os proxies residenciais são os mais adequados — eles fornecem IPs reais de provedores domésticos, que não estão em listas negras de datacenters e se comportam como um usuário comum, o que é crítico para contas bancárias, contas de marketplaces e redes sociais.
A regra é simples: uma conta = um IP sticky durante todo o ciclo de vida da sessão. Se você precisa analisar 50 contas simultaneamente — você levanta 50 sessões sticky com diferentes IPs, cada uma trabalhando com seu próprio conjunto de cookies e não se sobrepondo a outras. Este é o mesmo princípio que os especialistas em SMM usam em navegadores anti-detect como Dolphin Anty ou AdsPower ao gerenciar dezenas de contas de clientes: um perfil de navegador = um IP constante = seu próprio conjunto de cookies, que não se mistura com os demais.
Esquema 2: Pool de cookies + IP como um único par
Se a tarefa exige especificamente a rotação de IP (por exemplo, para não atingir o limite de taxa de uma única sessão), mas ao mesmo tempo precisa manter vários estados autenticados paralelos — aplica-se o esquema "pool de pares".
A ideia: você faz login N vezes com diferentes credenciais (ou a partir de diferentes IPs iniciais), salva
para cada sessão a combinação cookies + IP + User-Agent,
e a cada nova solicitação utiliza exatamente aquele par com o qual a sessão foi criada inicialmente.
Na prática, isso se parece com isto: em um banco de dados ou no Redis, é mantida uma tabela do tipo "id da sessão → cookies → IP do proxy → User-Agent → tempo da última utilização". Antes de cada solicitação, o parser pega um par livre do pool, faz a solicitação exatamente através do IP vinculado, atualiza os cookies da resposta e os coloca de volta na mesma entrada. Se a sessão expirou (o servidor retornou um redirecionamento para o login) — o par é marcado como inválido, removido do pool, e um novo é criado através de um novo login.
Este esquema se escala bem horizontalmente: quanto mais pares "cookies + IP" no pool, maior a capacidade total do parser sem risco de bans. Para essa tarefa, é conveniente usar proxies de datacenters onde a velocidade é mais importante que a anonimidade — por exemplo, ao analisar catálogos abertos após a autenticação, quando a própria plataforma não monitora tão agressivamente a impressão digital, e o gargalo se torna a velocidade de navegação pelo catálogo.
Esquema 3: Vinculação de fingerprint através de abordagem anti-detect
O terceiro esquema é necessário quando a plataforma verifica não apenas o IP e os cookies, mas também uma impressão digital completa do navegador: Canvas, WebGL, fontes, fuso horário, idioma do sistema, resolução da tela. Isso é típico para redes sociais (Instagram, TikTok, VK) e alguns marketplaces com avançados sistemas antifraude. Nesse caso, a combinação precisa ser ampliada para "IP + cookies + fingerprint" e armazenada como um todo — caso contrário, mesmo com o IP correto e cookies válidos, a sessão ainda será perdida devido à discrepância na impressão digital do navegador.
Na prática, isso é resolvido através de navegadores headless com fingerprint controlado (Playwright, Puppeteer com plugin stealth) ou através de navegadores anti-detect como Dolphin Anty, Multilogin, GoLogin ou Octo Browser, onde cada perfil recebe seu próprio conjunto de parâmetros de fingerprint, seu IP constante através de integração embutida com proxies e seu próprio armazenamento de cookies. O perfil faz login uma vez, e depois simplesmente é reiniciado com os mesmos parâmetros — a sessão continua ativa, porque a plataforma vê o mesmo "dispositivo" no mesmo IP.
Para a análise de redes sociais e aplicativos móveis através da API, nesta etapa é comum mudar para proxies móveis — IPs operacionais com CGNAT raramente levantam suspeitas em sistemas que esperam tráfego especificamente de redes móveis, e combinar IP com a impressão digital necessária proporciona a melhor estabilidade da sessão.
Esquema 4: Reautenticação controlada
O quarto esquema é não tentar manter uma única sessão para sempre, mas embutir antecipadamente no parser a lógica de reautenticação programada ao mudar de IP. Esta é a opção mais trabalhosa, mas também a mais resistente a falhas: em vez de transferir os cookies antigos para o novo IP (o que quase sempre leva a um banimento), o parser, ao mudar de IP, inicia um novo login — insere login/senha (ou usa um refresh-token), obtém novos cookies já sob o novo IP e continua a operação do zero.
Este esquema é obrigatório onde a API suporta OAuth2 com refresh-tokens (muitos marketplaces e contas de anúncios, como Google Ads API, TikTok Ads API): ao mudar de IP, você simplesmente troca o refresh-token por um novo access-token, sem a necessidade de inserir a senha novamente. Se não houver refresh-token — é necessário emular um fluxo de login completo: obter um token CSRF da página de login, enviar login/senha, passar por um possível captcha ou 2FA, salvar novos cookies.
A desvantagem do esquema é que o risco de logins frequentes pode parecer suspeito e provocar o bloqueio da conta, por isso geralmente é combinado com o esquema 1: o IP muda raramente e apenas de forma síncrona com a reautenticação programada, e não a cada solicitação.
Comparação de 4 esquemas
| Esquema | Complexidade | Confiabilidade | Quando aplicar |
|---|---|---|---|
| Sessões Sticky | Baixa | Alta | 1 conta — 1 IP, volumes pequenos |
| Pool de cookies + IP | Média | Média-alta | Análise em massa com várias contas |
| Vinculação de fingerprint | Alta | Alta | Redes sociais, antifraude avançado |
| Reautenticação | Alta | Muito alta | API com refresh-tokens, rotação frequente de IP |
Código: sessão + proxy sticky em Python
Abaixo está um exemplo básico usando requests.Session,
que salva cookies e opera através do mesmo proxy sticky durante toda a sessão.
A sessão armazena cookies automaticamente, e a vinculação ao IP é alcançada através do sticky-port do provedor de proxy,
que retorna o mesmo IP de saída para todas as solicitações dentro de uma janela de tempo determinada.
import requests
# sticky-port mantém o mesmo IP enquanto a sessão estiver viva
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"
})
# login — os cookies serão salvos automaticamente na session.cookies
login_payload = {"login": "[email protected]", "password": "secret"}
resp = session.post("https://example.com/login", data=login_payload)
assert resp.status_code == 200
# solicitações subsequentes vão com os mesmos cookies e o mesmo IP
page = session.get("https://example.com/cabinet/orders")
print(page.status_code, len(page.text))
Para o esquema com pool de pares de cookies + IP, é conveniente armazenar o estado no Redis — isso permite escalar o parser para vários workers sem sobreposição de sessões:
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)
Para a opção com vinculação de fingerprint através do Playwright, basta fazer login uma vez e salvar o storage_state — que inclui não apenas cookies, mas também localStorage/sessionStorage, o que é crítico para sites SPA de marketplaces e redes sociais:
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") # salvando a sessão inteira
browser.close()
# na próxima execução — o mesmo IP + a mesma sessão
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")
Erros comuns
1. Rotação de IP em cada solicitação dentro de uma única sessão autenticada. Esta é a principal razão para bans instantâneos — o sistema vê que um session_id está sendo usado com dezenas de IPs diferentes em um minuto, e bloqueia-o como um sinal claro de automação.
2. Salvar apenas session_id sem User-Agent e outros cabeçalhos. Se os cookies foram obtidos com um User-Agent, mas são usados com outro — isso também é um gatilho para o antifraude, mesmo que o IP não tenha mudado.
3. Ignorar a geolocalização do IP. Se a conta fez login de Moscovo, e a próxima solicitação vem de um IP de outro país — a sessão será quase sempre zerada, independentemente da validade dos cookies.
4. Falta de tratamento de sessões expiradas. O parser deve ser capaz de distinguir "o servidor retornou a página de login" de "o servidor retornou os dados necessários" e iniciar automaticamente a reautenticação, em vez de falhar com um erro.
5. Uso do mesmo pool de proxies para diferentes contas sem vinculação. Se duas contas diferentes recebem acidentalmente o mesmo IP de saída, a plataforma pode vinculá-las entre si — isso é especialmente perigoso para agências de SMM que gerenciam dezenas de contas de clientes simultaneamente.
Checklist antes de iniciar o parser com autenticação
- Escolhida a esquema correspondente ao nível de proteção da plataforma (sticky / pool / fingerprint / reautenticação)
- Cada conta recebeu um IP constante durante toda a vida útil da sessão
- Cookies e session_id são salvos junto com IP, User-Agent e cabeçalhos, e não separadamente
- Implementada a verificação de validade da sessão antes de cada solicitação importante
- Configurada a reautenticação automática ao detectar uma sessão perdida
- Proxies escolhidos de acordo com o tipo de plataforma: residenciais para contas bancárias e e-commerce, móveis para redes sociais, datacenter para análise rápida de seções abertas
- Registradas todas as mudanças de IP e momentos de reautenticação para análise de bans
Conclusão
A principal conclusão é simples: ao analisar com autenticação, o IP e a sessão devem mudar de forma síncrona, e não independentemente um do outro. O início mais confiável é o esquema de sessões sticky, onde uma conta está vinculada a um IP durante todo o período de operação. Para análises em massa com várias contas, o pool de pares de cookies + IP é adequado, para redes sociais com antifraude avançado — a vinculação de fingerprint através de um navegador anti-detect, e para APIs com tokens — a reautenticação programada ao mudar de IP.
Se você está apenas configurando um parser com autenticação para marketplaces ou contas pessoais, comece com proxies residenciais com sticky-port — eles fornecem um IP estável pelo tempo necessário e minimizam o risco de bloqueio da sessão. Para análise de redes sociais através de APIs autenticadas, é melhor considerar IPs móveis, e para navegação de alta velocidade em catálogos abertos após login — proxies de datacenters, que foram descritos acima no texto.