Se o CAPTCHA aparece a cada login, a causa costuma estar na sessão de proxy, não no navegador: IP rotativo onde o site espera o mesmo IP do início ao fim (ou o contrário) é o erro mais comum. Resposta direta — sessão fixa para autenticação (login, checkout, área logada); sessão rotativa para páginas independentes (scraping em lote, monitoramento de preços, busca). O modo errado não muda o preço do proxy, mas dispara a taxa de CAPTCHA.
Matriz de decisão: qual sessão usar em cada fluxo
| Fluxo | Recomendado | Por quê |
|---|---|---|
| Login / cadastro | Sessão fixa | Token vinculado ao IP |
| Checkout / pagamento | Sessão fixa | Cookies de sessão exigem o mesmo IP |
| Coleta de páginas em lote | Sessão rotativa | Distribui a carga |
| Coleta em mecanismos de busca | Sessão rotativa | Evita rate limit por IP |
| Navegação em várias páginas | Sessão fixa | Cookies rastreados por IP |
| Monitoramento de preços | Sessão rotativa | Muitas requisições independentes |
| Gerenciamento de conta | Sessão fixa | Integridade da sessão |
| Envio de formulário com CAPTCHA | Sessão fixa | Vínculo entre token e IP |
Cenário comum: uma equipe de QA em São Paulo testa checkout em staging (workers na região sa-east-1 da AWS) com sessão fixa, para não perder o token do reCAPTCHA no meio do fluxo. No mesmo pipeline, o growth monitora preços de concorrentes com sessão rotativa — e observa a LGPD ao decidir o que fica armazenado.
Como cada modo funciona, lado a lado
STICKY SESSION:
Request 1 ──▶ IP: 192.168.1.50 ──▶ site.com/login
Request 2 ──▶ IP: 192.168.1.50 ──▶ site.com/dashboard
Request 3 ──▶ IP: 192.168.1.50 ──▶ site.com/account
(Same IP for all requests in the session window)
ROTATING SESSION:
Request 1 ──▶ IP: 192.168.1.50 ──▶ site.com/page1
Request 2 ──▶ IP: 10.0.0.77 ──▶ site.com/page2
Request 3 ──▶ IP: 172.16.5.22 ──▶ site.com/page3
(Different IP per request)
| Fator | Sessão fixa | Sessão rotativa |
|---|---|---|
| IP por requisição | O mesmo por 1 a 30 minutos | Novo a cada requisição |
| Consistência da sessão | Alta | Nenhuma |
| Taxa de CAPTCHA (fluxos em várias etapas) | Baixa (5–10%) | Alta (30–50%) |
| Taxa de CAPTCHA (páginas únicas) | Média (10–20%) | Baixa (5–10%) |
| Validade do token | Maior — mesmo IP | Risco de incompatibilidade |
| Velocidade | Mais rápida (reaproveita a conexão) | Mais lenta (nova conexão a cada vez) |
| Risco de bloqueio | Maior se o IP for sinalizado | Menor — IP novo a cada vez |
| Custo | Igual ou levemente maior | Igual |
| Ideal para | Login, checkout, autenticação | Scraping em lote, buscas |
Sessão fixa na prática
O CAPTCHA valida o token contra o IP que fez a requisição original — se o IP mudar antes do envio, o token pode ser rejeitado mesmo estando correto. No exemplo abaixo, o mesmo IP cobre da carga da página até o envio do login:
import requests
import time
CAPTCHAAI_KEY = "YOUR_API_KEY"
CAPTCHAAI_URL = "https://ocr.captchaai.com"
# Sticky session: same IP for the entire login flow
STICKY_PROXY = {
"http": "http://user-session-abc123:pass@proxy.example.com:5000",
"https": "http://user-session-abc123:pass@proxy.example.com:5000",
}
session = requests.Session()
session.proxies = STICKY_PROXY
session.headers.update({
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 Chrome/126.0.0.0 Safari/537.36",
})
def login_with_captcha(url, sitekey, username, password):
"""Full login flow — MUST use same IP throughout."""
# Step 1: Load login page (IP: 192.168.1.50)
session.get(url)
# Step 2: Solve CAPTCHA (solved against IP: 192.168.1.50)
token = solve_recaptcha(sitekey, url)
# Step 3: Submit login (MUST be IP: 192.168.1.50)
resp = session.post(url, data={
"username": username,
"password": password,
"g-recaptcha-response": token,
})
return resp.status_code == 200
def solve_recaptcha(sitekey, pageurl):
resp = requests.post(f"{CAPTCHAAI_URL}/in.php", data={
"key": CAPTCHAAI_KEY,
"method": "userrecaptcha",
"googlekey": sitekey,
"pageurl": pageurl,
"json": 1,
})
task_id = resp.json()["request"]
for _ in range(60):
time.sleep(5)
result = requests.get(f"{CAPTCHAAI_URL}/res.php", params={
"key": CAPTCHAAI_KEY, "action": "get",
"id": task_id, "json": 1,
})
data = result.json()
if data["request"] != "CAPCHA_NOT_READY":
return data["request"]
raise TimeoutError("CAPTCHA solve timeout")
Com sessão fixa, o token chega ao mesmo IP que o resolveu; com rotativa, o IP pode mudar entre resolver e enviar:
Sticky session:
1. Browser loads page → IP: 5.5.5.5
2. CAPTCHA solved → Token bound to session
3. Form submitted → IP: 5.5.5.5 ✅ Token accepted
Rotating session:
1. Browser loads page → IP: 5.5.5.5
2. CAPTCHA solved → Token bound to session
3. Form submitted → IP: 9.9.9.9 ❌ Token may be rejected
Duração ideal da sessão fixa
| Duração | Ideal para | Risco |
|---|---|---|
| 1 minuto | Envio rápido de formulário | Pode expirar no meio do fluxo |
| 5 minutos | Login padrão + ações seguintes | Bom equilíbrio |
| 10 minutos | Fluxos complexos em várias páginas | Risco moderado de bloqueio |
| 30 minutos | Sessões de navegação mais longas | Risco maior de bloqueio |
Regra geral: configure a duração para o dobro do tempo esperado do fluxo.
Sessão rotativa na prática
Em páginas independentes, cada requisição não depende da anterior — distribuir o tráfego por mais IPs reduz a chance de um endereço acumular volume suficiente para ser sinalizado. O exemplo varre 500 páginas, cada requisição com IP novo:
import concurrent.futures
ROTATING_PROXY = {
"http": "http://user:pass@rotating.proxy.example.com:5000",
"https": "http://user:pass@rotating.proxy.example.com:5000",
}
def scrape_page(url):
"""Each request gets a fresh IP automatically."""
resp = requests.get(
url,
proxies=ROTATING_PROXY,
headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"},
timeout=30,
)
if resp.status_code == 200:
return url, resp.text
return url, None
urls = [f"https://example.com/products?page={i}" for i in range(1, 501)]
with concurrent.futures.ThreadPoolExecutor(max_workers=10) as pool:
results = list(pool.map(scrape_page, urls))
success = sum(1 for _, html in results if html)
print(f"Scraped: {success}/{len(urls)}")
Buscadores acompanham o volume de consultas por IP — a rotação evita o rate limit:
def scrape_search(query, pages=10):
results = []
for page in range(pages):
# Each request → new IP
resp = requests.get(
"https://search-engine.example.com/search",
params={"q": query, "start": page * 10},
proxies=ROTATING_PROXY,
timeout=20,
)
results.append(resp.text)
time.sleep(2)
return results
Combinando os dois modos: híbrido e Node.js
Pipeline híbrido em Python
Nada impede combinar sessão fixa e rotativa no mesmo projeto — a classe abaixo escolhe o modo certo conforme o tipo de requisição:
class HybridProxyManager:
"""Sticky for multi-step flows, rotating for single requests."""
def __init__(self, provider_host, username, password, port=5000):
self.host = provider_host
self.username = username
self.password = password
self.port = port
def get_rotating_proxy(self):
return {
"http": f"http://{self.username}:{self.password}@{self.host}:{self.port}",
"https": f"http://{self.username}:{self.password}@{self.host}:{self.port}",
}
def get_sticky_proxy(self, session_id, duration_min=10):
sticky_user = f"{self.username}-session-{session_id}-ttl-{duration_min}"
return {
"http": f"http://{sticky_user}:{self.password}@{self.host}:{self.port}",
"https": f"http://{sticky_user}:{self.password}@{self.host}:{self.port}",
}
proxy_mgr = HybridProxyManager("proxy.example.com", "user", "pass")
def scrape_with_auto_strategy(url, needs_login=False):
if needs_login:
# Multi-step → sticky
import uuid
session_id = uuid.uuid4().hex[:8]
proxy = proxy_mgr.get_sticky_proxy(session_id)
else:
# Single page → rotating
proxy = proxy_mgr.get_rotating_proxy()
return requests.get(url, proxies=proxy, timeout=30)
A mesma lógica em Node.js
Sessão rotativa para scraping em lote, sessão fixa para o login com CAPTCHA, com axios:
const axios = require("axios");
const CAPTCHAAI_KEY = "YOUR_API_KEY";
const PROXY_HOST = "proxy.example.com";
const PROXY_PORT = 5000;
function getProxy(mode, sessionId = null) {
const user =
mode === "sticky" ? `user-session-${sessionId}` : "user";
return {
proxy: {
host: PROXY_HOST,
port: PROXY_PORT,
auth: { username: user, password: "pass" },
},
};
}
// Rotating: bulk scrape
async function scrapePages(urls) {
const results = [];
for (const url of urls) {
const config = getProxy("rotating");
const resp = await axios.get(url, { ...config, timeout: 30000 });
results.push({ url, data: resp.data });
}
return results;
}
// Sticky: login flow
async function loginFlow(loginUrl, sitekey, credentials) {
const sessionId = Date.now().toString(36);
const config = getProxy("sticky", sessionId);
// Step 1: Load page
await axios.get(loginUrl, config);
// Step 2: Solve CAPTCHA
const submitResp = await axios.post(
"https://ocr.captchaai.com/in.php",
null,
{
params: {
key: CAPTCHAAI_KEY,
method: "userrecaptcha",
googlekey: sitekey,
pageurl: loginUrl,
json: 1,
},
}
);
const taskId = submitResp.data.request;
let token;
for (let i = 0; i < 60; i++) {
await new Promise((r) => setTimeout(r, 5000));
const res = await axios.get("https://ocr.captchaai.com/res.php", {
params: { key: CAPTCHAAI_KEY, action: "get", id: taskId, json: 1 },
});
if (res.data.request !== "CAPCHA_NOT_READY") {
token = res.data.request;
break;
}
}
// Step 3: Submit with same IP
return axios.post(
loginUrl,
{
...credentials,
"g-recaptcha-response": token,
},
config
);
}
Problemas comuns e como resolver
| Problema | Causa | Correção |
|---|---|---|
| Token do CAPTCHA rejeitado após a resolução | O IP mudou entre resolver e enviar | Trocar para sessão fixa |
| Taxa alta de CAPTCHA em páginas únicas | O mesmo IP fixo concentrando muitas páginas | Trocar para sessão rotativa |
| Cookies de sessão perdidos | A sessão fixa expirou | Aumentar o TTL |
| IP bloqueado na sessão fixa | Todas as requisições compartilham o IP sinalizado | Reduzir o TTL ou adicionar atrasos entre requisições |
Configurar a sessão fixa depende do provedor: a maioria embute um identificador no nome de usuário (user-session-abc123), com o TTL à parte — confira sempre a documentação oficial. Já cobrimos a sintaxe de três provedores em guias dedicados: Bright Data, Smartproxy e Oxylabs.
Perguntas frequentes
O IP fixo aumenta o risco de bloqueio no CAPTCHA?
Pode aumentar, sim, se o mesmo IP concentrar muitas requisições. Reduza o TTL ou troque de IP assim que o fluxo autenticado terminar.
Sessão rotativa reduz mesmo a taxa de CAPTCHA em scraping?
Em páginas independentes, sim — vários IPs evitam que um endereço acumule volume suficiente para ser sinalizado. Em login o efeito é o oposto.
Quanto tempo deve durar uma sessão fixa antes de trocar de IP?
Sem número único — use o dobro do tempo esperado do fluxo.
Posso combinar sessão fixa e rotativa no mesmo projeto?
Sim, é comum: sessão fixa nos trechos autenticados, rotativa na coleta de dados. A maioria dos provedores oferece os dois modos no mesmo plano.
A sessão fixa mantém o mesmo IP durante toda a sessão?
Na maioria dos casos, sim, dentro do TTL contratado — mas o provedor pode reatribuir o IP antes disso.
Guias relacionados
- Proxies residenciais com rotação automática
- Como a qualidade do proxy afeta a taxa de resolução
- Persistência de sessão no navegador
Escolha o modo de sessão certo para cada etapa do seu fluxo — pegue sua chave da CaptchaAI e resolva o CAPTCHA independentemente da estratégia de proxy que você usar.
