Proxy retorna dados incorretos: causas e soluções

Você configurou seu scraper, iniciou a coleta de dados e, como resultado, obteve preços de outra região, conteúdo desatualizado ou uma página completamente diferente. Vamos analisar por que seu proxy pode estar retornando dados incorretos e como corrigir isso.

1. Cache no lado do proxy

A causa mais comum de dados desatualizados é o cache. Alguns servidores proxy armazenam respostas de sites para reduzir a carga e acelerar o processamento. Como resultado, você recebe dados de uma semana atrás em vez dos dados atuais.

Como identificar o problema

• Os dados não mudam em solicitações repetidas
• Preços ou disponibilidade de estoque não correspondem à realidade
• O cabeçalho Age na resposta mostra um valor alto

Solução

Adicione cabeçalhos que proíbem o cache:

import requests

headers = {
    'Cache-Control': 'no-cache, no-store, must-revalidate',
    'Pragma': 'no-cache',
    'Expires': '0'
}

response = requests.get(
    'https://example.com/prices',
    proxies={'http': proxy, 'https': proxy},
    headers=headers
)

Se o provedor ainda estiver em cache, adicione um parâmetro aleatório ao URL:

import time

url = f'https://example.com/prices?_nocache={int(time.time())}'

2. Incompatibilidade de geolocalização

Você solicita um proxy da Alemanha, mas recebe preços em Reais. Ou vice-versa — você precisa de dados russos, mas o site mostra conteúdo para os EUA. Isso ocorre por várias razões.

Por que a geolocalização não corresponde

Solução

Sincronize todos os parâmetros da solicitação com a geolocalização desejada:

# Para fazer scraping de um site alemão
headers = {
    'Accept-Language': 'de-DE,de;q=0.9,en;q=0.8',
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)...'
}

# Sessão limpa sem cookies
session = requests.Session()
session.cookies.clear()

response = session.get(
    'https://example.de/preise',
    proxies={'http': german_proxy, 'https': german_proxy},
    headers=headers
)

Verifique a geolocalização real do IP antes de fazer o scraping:

def check_proxy_geo(proxy):
    response = requests.get(
        'http://ip-api.com/json/',
        proxies={'http': proxy, 'https': proxy},
        timeout=10
    )
    data = response.json()
    return data.get('country'), data.get('city')

3. Problemas com a rotação de IP

Ao usar proxies residenciais com rotação automática de IP, o IP muda entre as solicitações. Isso é útil para contornar limites, mas cria problemas quando a consistência dos dados é necessária.

Sintomas típicos

• A paginação retorna duplicatas ou pula itens
• O carrinho de compras é limpo entre as solicitações
• A autenticação falha no meio da sessão
• Testes A/B do site mostram versões diferentes das páginas

Solução: sessões "sticky" (fixas)

A maioria dos provedores de proxy suporta "sessões fixas" — o IP é mantido por um determinado período. Isso geralmente é configurado por meio de um parâmetro na string de conexão:

# Exemplo de formato com ID de sessão (a sintaxe depende do provedor)
proxy = 'http://user-session-abc123:pass@gate.provider.com:7777'

# Todas as solicitações com o mesmo ID de sessão passam pelo mesmo IP
for page in range(1, 10):
    response = requests.get(
        f'https://example.com/catalog?page={page}',
        proxies={'http': proxy, 'https': proxy}
    )

Importante: A sessão fixa geralmente dura de 1 a 30 minutos. Planeje sua coleta de dados para que as solicitações relacionadas se encaixem nessa janela.

4. Violação de sessões e cookies

Sites modernos usam cookies ativamente para personalização. Se o seu scraper não os processar corretamente, você obterá dados incorretos — ou será bloqueado.

Erros comuns

1. Ignorar Set-Cookie — o site não consegue rastrear a sessão
2. Reutilizar cookies com um IP diferente — comportamento suspeito
3. Ausência de solicitação inicial — acessar uma página interna sem "entrar" pela página principal

Abordagem correta

import requests

def create_browser_session(proxy):
    session = requests.Session()
    session.proxies = {'http': proxy, 'https': proxy}
    
    # Simula a primeira visita — obtém os cookies
    session.get('https://example.com/', headers={
        'User-Agent': 'Mozilla/5.0...',
        'Accept': 'text/html,application/xhtml+xml...',
        'Accept-Language': 'en-US,en;q=0.9'
    })
    
    # Agora é possível fazer scraping com uma sessão válida
    return session

session = create_browser_session(proxy)
data = session.get('https://example.com/api/prices').json()

5. Erros de codificação e compressão

Às vezes, os dados chegam corretos, mas são exibidos incorretamente devido a problemas de codificação ou compressão. Isso é especialmente relevante ao trabalhar com cirílico e idiomas asiáticos.

Sintomas

• Caracteres estranhos em vez de texto: Цена em vez de «Preço»
• Resposta vazia com gzip ativado
• Lixo binário em vez de HTML

Solução

import requests

response = requests.get(url, proxies=proxies)

# Método 1: Detecção automática de codificação
response.encoding = response.apparent_encoding
text = response.text

# Método 2: Forçar codificação
text = response.content.decode('utf-8')

# Método 3: Desativar compressão (se o proxy quebrar o gzip)
headers = {'Accept-Encoding': 'identity'}
response = requests.get(url, proxies=proxies, headers=headers)

6. Bloqueios ocultos e CAPTCHAs

Nem todos os bloqueios são óbvios. O site pode retornar HTTP 200, mas em vez de dados reais, ele insere um placeholder, um cache desatualizado ou uma página com CAPTCHA dentro do HTML normal.

Sinais de bloqueio oculto

• O tamanho da resposta é suspeitamente pequeno ou idêntico para páginas diferentes
• O HTML contém as palavras: captcha, challenge, blocked, access denied
• Elementos esperados (preços, descrições, botões) estão ausentes
• Redirecionamento JavaScript para outra página

Validação da resposta

def is_valid_response(response, expected_markers):
    """Verifica se a resposta contém dados reais"""
    
    text = response.text.lower()
    
    # Verificação de bloqueio
    block_signals = ['captcha', 'blocked', 'access denied', 
                     'rate limit', 'try again later']
    for signal in block_signals:
        if signal in text:
            return False, f'Bloqueado: {signal}'
    
    # Verificação de conteúdo esperado
    for marker in expected_markers:
        if marker.lower() not in text:
            return False, f'Ausente: {marker}'
    
    # Verificação de tamanho (muito pequeno = placeholder)
    if len(response.content) < 5000:
        return False, 'Resposta muito pequena'
    
    return True, 'OK'

# Uso
valid, reason = is_valid_response(response, ['price', 'add to cart'])
if not valid:
    print(f'Resposta inválida: {reason}')
    # Trocar proxy, esperar, tentar novamente

Para sites com proteção anti-bot rigorosa, proxies móveis oferecem um nível de confiança melhor do que os de data center.

7. Diagnóstico passo a passo

Quando um proxy retorna dados incorretos, use este algoritmo para encontrar a causa:

Passo 1: Isole o problema

# Compare as respostas: sem proxy vs com proxy
def compare_responses(url, proxy):
    direct = requests.get(url)
    proxied = requests.get(url, proxies={'http': proxy, 'https': proxy})
    
    print(f'Direto:  {len(direct.content)} bytes, status {direct.status_code}')
    print(f'Proxy: {len(proxied.content)} bytes, status {proxied.status_code}')
    
    # Salve ambas as respostas para comparação
    with open('direct.html', 'w') as f:
        f.write(direct.text)
    with open('proxied.html', 'w') as f:
        f.write(proxied.text)

Passo 2: Verifique os cabeçalhos da resposta

response = requests.get(url, proxies=proxies)

# Cabeçalhos importantes para diagnóstico
important_headers = ['content-type', 'content-encoding', 
                     'cache-control', 'age', 'x-cache', 
                     'cf-ray', 'server']

for header in important_headers:
    value = response.headers.get(header, 'não definido')
    print(f'{header}: {value}')

Passo 3: Lista de verificação de verificações

Passo 4: Script de diagnóstico completo

import requests
import json

def diagnose_proxy(proxy, target_url):
    report = {}
    
    # 1. Verificação de funcionalidade
    try:
        r = requests.get('http://httpbin.org/ip', 
                        proxies={'http': proxy, 'https': proxy},
                        timeout=15)
        report['proxy_ip'] = r.json().get('origin')
        report['proxy_works'] = True
    except Exception as e:
        report['proxy_works'] = False
        report['error'] = str(e)
        return report
    
    # 2. Geolocalização
    r = requests.get('http://ip-api.com/json/',
                    proxies={'http': proxy, 'https': proxy})
    geo = r.json()
    report['country'] = geo.get('country')
    report['city'] = geo.get('city')
    
    # 3. Solicitação ao site de destino
    r = requests.get(target_url,
                    proxies={'http': proxy, 'https': proxy},
                    timeout=30)
    report['status_code'] = r.status_code
    report['content_length'] = len(r.content)
    report['cached'] = 'age' in r.headers or 'x-cache' in r.headers
    
    # 4. Verificação de bloqueio
    block_words = ['captcha', 'blocked', 'denied', 'cloudflare']
    report['possibly_blocked'] = any(w in r.text.lower() for w in block_words)
    
    return report

# Uso
result = diagnose_proxy('http://user:pass@proxy:port', 'https://target-site.com')
print(json.dumps(result, indent=2))

Conclusão

Dados incorretos de um proxy são quase sempre um problema solucionável. Na maioria dos casos, a causa está no cache, na incompatibilidade de geolocalização ou no manuseio incorreto de sessões. Use o script de diagnóstico deste artigo para encontrar rapidamente a fonte do problema.

Para tarefas onde a precisão da geolocalização e uma baixa taxa de bloqueio são críticas, os proxies residenciais com suporte a sessões fixas são a melhor opção — saiba mais em proxycove.com.