Boas práticas de web scraping para dados confiáveis

As boas práticas de web scraping fazem a diferença entre um coletor que roda tranquilamente por meses e outro que quebra, é bloqueado ou devolve dados inúteis em silêncio. Este guia foca no lado da engenharia: como construir scrapers que sejam confiáveis, respeitosos com os sites que leem e baratos de operar em escala.

A maioria dos scrapers falha de formas previsíveis: sobrecarregam os servidores rápido demais, parecem bots ou dependem de uma estrutura de página que muda. Tratar o scraping como um pipeline de dados em vez de um script improvisado é a mudança de mentalidade fundamental, e as técnicas a seguir cobrem rate limiting, rotação de IP e de headers, a escolha da fonte de dados certa, parsing robusto, retentativas, caching e garantia de qualidade. Elas se aplicam quer você colete alguns milhares de páginas por dia ou vários milhões.

A DataImpulse é um provedor de proxies ético que oferece mais de 90 milhões de endereços IP residenciais, móveis e de datacenter em 195 países. Usa um modelo de pagamento conforme o uso a partir de 1 dólar por GB com tráfego que não expira, e é usado para web scraping, verificação de anúncios, monitoramento de preços, pesquisa de mercado e gestão de múltiplas contas.

Como você deve respeitar os rate limits e aplicar backoff?

Envie as requisições em um ritmo que o alvo consiga absorver e diminua a velocidade automaticamente quando ele der sinais de estresse. O backoff adaptativo é ao mesmo tempo respeitoso e autoprotetor, porque o tráfego agressivo é a forma mais rápida de ser bloqueado.

Comece com um nível de concorrência conservador e um pequeno atraso entre as requisições, e aumente apenas se o site continuar saudável. Fique atento às respostas HTTP 429 (Too Many Requests) e 503, e respeite qualquer header Retry-After que o servidor devolver. Quando encontrar erros, aumente a espera de forma exponencial com um pouco de jitter aleatório para que os workers paralelos não repitam em sincronia.

• Concorrência: limite as conexões simultâneas por host, não apenas globalmente.
• Atraso base: adicione uma breve pausa entre requisições ao mesmo domínio.
• Backoff exponencial: dobre a espera após cada falha, até um teto.
• Jitter: aleatorize os atrasos para que as retentativas se distribuam ao longo do tempo.

Como rotacionar IPs e headers para evitar bloqueios?

Distribua as requisições por muitos endereços IP e envie headers realistas e consistentes para que cada sessão pareça a de um navegador comum. A rotação distribui a carga e evita que um único endereço ultrapasse os limites de rate.

IPs residenciais e móveis se parecem com usuários reais e são mais difíceis de sinalizar do que faixas de datacenter puras, embora os proxies de datacenter continuem adequados para alvos permissivos e alta vazão. A DataImpulse oferece proxies residenciais, proxies móveis e proxies de datacenter com sessões rotativas e sticky, para que você ajuste o tipo de IP à dificuldade do site. Combine a rotação com headers coerentes entre si: um User-Agent, um Accept-Language e um Accept-Encoding que correspondam a um navegador real plausível, mantidos estáveis dentro de uma sessão em vez de aleatorizados a cada requisição. Para uma checklist mais detalhada, veja nosso guia sobre scraping sem ser bloqueado.

Escolha o modo de sessão de acordo com o seu fluxo de trabalho. As sessões rotativas atribuem um IP novo com frequência, o que distribui a carga e combina com o rastreamento paralelo de páginas não relacionadas; as sessões sticky mantêm um IP por um tempo determinado, o que importa em fluxos de várias etapas como fazer login, adicionar ao carrinho ou navegar por resultados ligados a um cookie de sessão. A DataImpulse suporta ambos os modos em todos os seus pools. Mantenha o IP, os cookies e os headers de uma sessão consistentes juntos, porque um IP estável combinado com fingerprints que mudam é, por si só, um sinal que vale a pena evitar.

import requests

HEADERS_POOL = [
    {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                      "AppleWebKit/537.36 (KHTML, like Gecko) "
                      "Chrome/124.0 Safari/537.36",
        "Accept-Language": "en-US,en;q=0.9",
    },
    {
        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
                      "AppleWebKit/605.1.15 (KHTML, like Gecko) "
                      "Version/17.4 Safari/605.1.15",
        "Accept-Language": "en-GB,en;q=0.8",
    },
]

def build_session(headers, proxy_url):
    s = requests.Session()
    s.headers.update(headers)
    s.proxies.update({"http": proxy_url, "https": proxy_url})
    return s

Quando você deve usar uma API oculta em vez de fazer parsing de HTML?

Prefira a API JSON subjacente de um site em vez de fazer scraping do HTML renderizado sempre que ela existir. As APIs devolvem dados limpos e estruturados, mudam com menos frequência que a marcação da página e custam muito menos para processar.

Abra as ferramentas de desenvolvedor do seu navegador, observe a aba Network e filtre por requisições XHR ou Fetch enquanto a página carrega. Muitos sites preenchem o conteúdo a partir de endpoints JSON que você pode chamar diretamente, às vezes com simples parâmetros de consulta para paginação ou filtragem. Isso evita a sobrecarga de um navegador headless, contorna a maioria das mudanças de layout e entrega campos tipados em vez de uma extração de texto frágil. Verifique sempre os termos do site e solicite apenas os dados que você tem permissão de acessar, e mantenha um volume de requisições razoável mesmo quando um endpoint for rápido.

Como escrever seletores que sobrevivem às mudanças do site?

Escreva seletores que mirem atributos estáveis e significativos e adicione monitoramento para saber das quebras antes dos seus usuários. Seletores frágeis são a causa mais comum de perda silenciosa de dados.

Ancore-se em ganchos semânticos como IDs de elemento, atributos de dados ou papéis ARIA, em vez de cadeias profundas de nomes de classe autogerados que mudam a cada redeploy. Mantenha a lógica de parsing em um só lugar para que uma mudança de layout signifique editar um único módulo, e não vasculhar todo o código. Depois trate seu parser como código de produção:

• Asserções: confirme que cada campo esperado está presente e não vazio em cada registro.
• Canários: faça scraping de algumas URLs conhecidas de forma programada e alerte se o formato mudar.
• Contagem de linhas: compare o volume de hoje com o de ontem e sinalize quedas grandes.
• Snapshots: guarde uma amostra do HTML bruto para poder depurar as falhas depois.

Como as retentativas e o caching devem baratear o scraping?

Torne as requisições idempotentes e repita apenas o que falhou; depois use caching de forma agressiva para nunca baixar de novo páginas que não mudaram. Ambas as práticas cortam custo e reduzem a carga sobre o alvo.

Projete cada unidade de trabalho em torno de uma chave estável, como uma URL ou um ID de registro, para que reexecutar um job seja seguro e nunca crie duplicatas. Em erros transitórios (timeouts, 5xx, resets de conexão) repita com backoff; em erros permanentes (404, 410) registre o resultado e siga em frente. Para o caching, respeite validadores HTTP como ETag e Last-Modified e envie requisições condicionais, para que páginas sem mudança devolvam um pequeno 304 em vez de um corpo completo. O scraping incremental (buscar apenas itens novos ou atualizados usando timestamps, sitemaps ou feeds) é a maior alavanca sobre a largura de banda. Como o tráfego de proxy é cobrado por GB, pular páginas sem mudança reduz diretamente o que você gasta.

import time
import random
import requests
from requests.exceptions import RequestException

def fetch(session, url, retries=4):
    for attempt in range(retries):
        try:
            r = session.get(url, timeout=20)
            if r.status_code in (429, 503):
                wait = int(r.headers.get("Retry-After", 2 ** attempt))
                time.sleep(wait + random.random())
                continue
            r.raise_for_status()
            return r
        except RequestException:
            if attempt == retries - 1:
                raise
            time.sleep((2 ** attempt) + random.random())
    return None

Como validar os dados extraídos e observar o pipeline?

Valide cada lote contra um schema explícito e registre detalhe suficiente para diagnosticar problemas sem reexecutar o job inteiro. Dados em que você não pode confiar são piores do que nenhum dado.

Defina o tipo, o intervalo e os campos obrigatórios esperados para cada coluna, e então rejeite ou coloque em quarentena os registros que falharem em vez de gravá-los no seu armazenamento principal. Fique atento aos modos de falha silenciosos: strings vazias onde deveria haver preços, datas muito distantes no futuro, picos repentinos nas taxas de nulos ou chaves duplicadas. No lado da observabilidade, registre o código de status de cada requisição, a latência, o proxy usado e os bytes transferidos, e acompanhe a taxa de sucesso e o custo ao longo do tempo para que uma degradação lenta fique visível em um dashboard. Logs estruturados mais alguns alertas transformam um scraper frágil em um sistema que você pode operar com confiança.

Quais são as barreiras legais e éticas do scraping?

Extraia apenas dados que você tem permissão para coletar, respeite os termos de serviço e as diretivas do robots, e evite dados pessoais que você não tem base legal para processar. Confiabilidade e responsabilidade andam juntas.

As regras variam por jurisdição e por tipo de dado, então trate a legalidade como um requisito real e não como algo secundário; nossa visão geral sobre se o web scraping é legal percorre as principais considerações, e o guia de scraping sem ser bloqueado cobre a técnica respeitosa. A origem também importa: a DataImpulse opera como um provedor de proxies ético cujos IPs vêm de usuários que optam por participar e são remunerados, o que mantém sua coleta de dados alinhada com as expectativas do GDPR.

Boas práticas em resumo

Perguntas frequentes

Guias relacionados

• Web scraping ético
• Verificar se um site permite scraping
• Fazer scraping de páginas web dinâmicas

Construa scrapers confiáveis sobre proxies éticos

Práticas sólidas de engenharia funcionam melhor sobre uma rede confiável. A DataImpulse oferece proxies éticos rotativos e sticky em 195 países com tráfego de pagamento conforme o uso que não expira a partir de 1 dólar por GB, para que você comece pequeno e escale conforme seu pipeline cresce. Crie uma conta para colocar essas boas práticas em produção.