Como construir um rastreador da Web em Python: Do início à escala

Na sua essência, um rastreador web em Python é um script automatizado que começa a partir de uma ou mais URLs de partida, obtém o conteúdo da página, extrai todos os links que encontra e, em seguida, repete o ciclo para cada nova URL. Pense nele como um visitante metódico que lê o diretório em cada andar de um edifício antes de decidir em que salas entrar a seguir.

A distinção entre rastreamento e scraping confunde as pessoas constantemente. O rastreamento é a fase de descoberta: encontrar páginas percorrendo o gráfico de links. O scraping é a fase de extração: extrair campos estruturados (títulos, preços, datas) de páginas que já localizou. Na prática, a maioria dos projetos precisa de ambos, mas são questões distintas com requisitos de ferramentas diferentes. Compreender esta distinção ajuda-o a escolher as ferramentas certas e a estruturar o seu projeto adequadamente.

Então, porquê construir um em Python? Algumas razões concretas:

• Auditoria de SEO e mapeamento de backlinks: rastreie o seu próprio site para encontrar links quebrados, páginas órfãs ou meta tags em falta. Também pode percorrer blogs, sites de parceiros e meios de comunicação para descobrir quem tem links para si ou para os seus concorrentes.
• Recolha de dados para ML e análise: Recolha dados de treino de centenas de páginas e encaminhe-os diretamente para DataFrames do pandas, armazenamentos de características ou pipelines de treino de LLM. A saída estruturada de um rastreador bem concebido alimenta diretamente a análise a jusante.
• Monitorização de preços e inventário: percorra as páginas de categorias de produtos todas as noites para acompanhar alterações de preços e níveis de stock em milhares de SKUs.
• Investigação e arquivo: Investigadores académicos rastreiam fóruns, bases de dados governamentais e conjuntos de dados públicos que não oferecem APIs de download em massa.
• Agregação de conteúdo: Organizações de notícias e empresas de pesquisa de mercado rastreiam sites do setor para criar feeds selecionados e painéis de inteligência competitiva.

O ecossistema do Python (requests, BeautifulSoup, Scrapy e muitos mais) permite-lhe prototipar um rastreador funcional em menos de 30 linhas e, em seguida, escalar a mesma lógica para milhões de páginas sem mudar de linguagem. Esse percurso do protótipo à produção é exatamente o que este guia aborda.

Todos os rastreadores web em Python, desde um script de dez linhas até um sistema distribuído, seguem o mesmo ciclo fundamental:

1. Começa com URLs de partida. Fornece um ou mais endereços iniciais. Estes vão para uma fila (muitas vezes chamada de «fronteira»).
2. Recupera a página. O rastreador envia um pedido HTTP GET para o URL seguinte na fila e recebe a resposta HTML.
3. Analise o HTML. Um analisador (BeautifulSoup, lxml, seletores Scrapy) lê o documento e expõe a sua estrutura como uma árvore navegável.
4. Extraia links. O analisador extrai todos os <a href="..."> da página, juntamente com quaisquer outras URLs detetáveis.
5. Filtrar e deduplicar. Nem todos os links valem a pena seguir. O rastreador verifica cada URL em relação a um conjunto de URLs já visitadas, aplica filtros de domínio ou caminho e descarta duplicados. Esta etapa também inclui a normalização de URLs: remover fragmentos, ordenar parâmetros de consulta e converter caminhos para minúsculas, de modo que example.com/Page e example.com/page não sejam tratados como URLs diferentes.
6. Enfileirar novas URLs. Os links que sobraram entram na fila de fronteira.
7. Repita até que a fila esteja vazia ou uma condição de paragem seja satisfeita (profundidade máxima, páginas máximas, limite de tempo).

Este ciclo é aparentemente simples, mas a verdadeira engenharia está nos detalhes. Como lida com páginas que devolvem um redirecionamento 301 para um URL que já visitou? O que acontece quando o servidor está lento e tem 500 URLs à espera na fila? Como evita rastrear o mesmo conteúdo sob diferentes padrões de URL (IDs de sessão, parâmetros de rastreamento, widgets de calendário)?

Uma implementação ingênua busca URLs uma de cada vez, o que é adequado para algumas dezenas de páginas. Quando você precisa rastrear milhares, é necessário ter concorrência (múltiplas solicitações em andamento), filas persistentes e lógica de repetição para falhas transitórias. Rastiladores simples que não possuem tentativas de repetição e buscam páginas sequencialmente são genuinamente inadequados para trabalho em escala de produção. Essa é exatamente a lacuna que o Scrapy foi projetado para preencher: ele oferece um motor assíncrono, um agendador integrado com deduplicação e ganchos de middleware para cada etapa do ciclo.

Compreender este ciclo não é apenas uma questão académica. Quando o seu rastreador apresenta um comportamento anómalo (falha páginas, revisita o mesmo URL ou fica tão lento que chega a parar), o bug está quase sempre relacionado com uma destas sete etapas. O diagnóstico de problemas torna-se muito mais rápido quando se consegue identificar qual a etapa que está a falhar.

Antes de escrever uma única linha de código, vale a pena escolher a biblioteca certa para a escala e complexidade do seu projeto. Aqui está uma matriz de decisão prática para construir um rastreador web em Python:

requests + BeautifulSoup é a combinação ideal quando precisa de um protótipo rápido ou de um rastreador que aceda a algumas páginas. Controla todos os detalhes, o que é ótimo para aprender e péssimo para escalar. Rastreadores básicos construídos desta forma visitam frequentemente as mesmas páginas ou ficam presos a seguir links repetidos sem uma lógica de deduplicação cuidadosa.

O Scrapy é uma estrutura completa concebida especificamente para rastreamento web em escala. Ele lida com concorrência, tentativas de repetição, deduplicação e pipelines de dados de forma nativa. A desvantagem é uma curva de aprendizagem mais íngreme e uma estrutura de projeto rígida. Mas, assim que internalizar o padrão spider/pipeline, a criação de novos rastreadores torna-se notavelmente rápida.

Os serviços de API geridos fazem sentido quando a parte difícil do seu rastreamento não é a lógica de análise, mas sim a infraestrutura: proxies rotativos, resolução de CAPTCHAs, renderização de JavaScript. Em vez de manter essa pilha por conta própria, envia um pedido e recebe HTML (ou JSON) em resposta.

Escolha a opção mais simples que satisfaça os seus requisitos. Pode sempre atualizar mais tarde, e este guia irá mostrar-lhe como avançar através de cada nível.

Um ambiente limpo evita conflitos de dependências e mantém o seu projeto reproduzível. Aqui está a configuração mínima para o seu projeto de rastreador web em Python:

# Create and activate a virtual environment
python3 -m venv crawler-env
source crawler-env/bin/activate   # macOS / Linux
crawler-env\\Scripts\\activate      # Windows

# Install core libraries
pip install requests beautifulsoup4 lxml scrapy

A pasta do seu projeto deve ter um aspeto semelhante a este:

my-crawler/
├── crawler-env/
├── simple_crawler.py      # requests + BS4 version
├── scrapy_project/        # generated by scrapy startproject
│   ├── scrapy_project/
│   │   ├── spiders/
│   │   ├── items.py
│   │   ├── pipelines.py
│   │   └── settings.py
│   └── scrapy.cfg
└── requirements.txt

Fixa as tuas dependências com pip freeze > requirements.txt para que quem clonar o repositório obtenha as mesmas versões. Se pretender usar o Scrapy com um navegador headless para páginas renderizadas em JavaScript, adicione também scrapy-playwright à lista de instalação.

lxml está incluído como backend de análise para o BeautifulSoup. É significativamente mais rápido do que o html.parser e lida com HTML malformado de forma mais elegante, o que é importante quando está a rastrear páginas cuja marcação claramente não foi escrita por humanos.

Com estes pacotes instalados, está pronto para escrever código. A próxima secção constrói um rastreador funcional completo a partir do zero.

É hora de escrever o código propriamente dito. O objetivo deste primeiro rastreador é simples: começar a partir de um URL inicial, buscar a página, encontrar todos os links nela e, em seguida, visitar cada um desses links enquanto permanece no mesmo domínio. É intencionalmente minimalista para que possa ver as partes móveis antes de adicionar complexidade.

import requests
from bs4 import BeautifulSoup
from urllib.parse import urljoin, urlparse
import time

def crawl(seed_url, max_pages=20, delay=1):
    visited = set()
    queue = [seed_url]
    allowed_domain = urlparse(seed_url).netloc

    while queue and len(visited) < max_pages:
        url = queue.pop(0)
        if url in visited:
            continue

        try:
            response = requests.get(
                url,
                headers={"User-Agent": "MyCrawler/1.0 (contact@example.com)"},
                timeout=10,
            )
            response.raise_for_status()
        except requests.RequestException as e:
            print(f"Failed to fetch {url}: {e}")
            continue

        visited.add(url)
        print(f"Crawled: {url} ({response.status_code})")

        soup = BeautifulSoup(response.text, "lxml")

        for anchor in soup.find_all("a", href=True):
            link = urljoin(url, anchor["href"])
            parsed = urlparse(link)
            # Strip fragments and stay on the same domain
            clean_link = parsed._replace(fragment="").geturl()
            if parsed.netloc == allowed_domain and clean_link not in visited:
                queue.append(clean_link)

        time.sleep(delay)  # Be polite

    print(f"Done. Visited {len(visited)} pages.")
    return visited

if __name__ == "__main__":
    crawl("https://example.com")

Vamos percorrer as decisões-chave neste rastreador web em Python:

• visited set: Este é o seu mecanismo de deduplicação. Antes de buscar qualquer URL, verifica se ela já está no conjunto. Sem isto, o rastreador ficaria num loop infinito em sites com links de navegação circulares. Mesmo sites pequenos podem ter menus de navegação que criam ciclos.
• urljoin: Converte caminhos relativos como /about em URLs absolutas como example.com/about. Isto é fundamental porque a maioria dos sites utiliza hrefs relativos na sua navegação e ligações internas.
• Filtragem de domínios: A urlparse verificação mantém o rastreador num único domínio. Sem ela, um único link externo poderia fazer com que o seu rastreador percorresse toda a Internet. Esta é a diferença entre um rastreamento focado e um rastreamento descontrolado.
• Remoção de fragmentos: A _replace(fragment="") chamada remove #section âncoras dos URLs. Estas apontam para posições diferentes na mesma página, não para páginas diferentes, pelo que tratá-las como URLs distintas causaria recuperações redundantes.
• max_pages limite: Uma rede de segurança que é especialmente importante durante o desenvolvimento. Não queres disparar acidentalmente milhares de pedidos enquanto depuras o teu analisador.
• time.sleep(delay): Uma medida básica de cortesia. Mesmo um segundo entre pedidos faz uma diferença significativa na carga do servidor de destino.
• User-Agent personalizado: Identificar o seu rastreador com um cabeçalho descritivo (incluindo informações de contacto) é tanto ético como prático. É muito menos provável que os sites bloqueiem um rastreador que se identifique honestamente.
• Tratamento de erros: O try/except bloco deteta tempos de espera de ligação, falhas de DNS e erros HTTP (através de raise_for_status). Um rastreador de produção precisa disto; um processo que falha significa progresso perdido e dados potencialmente incompletos.

Este rastreador é síncrono, o que significa que obtém uma página de cada vez. Para 20 páginas, isso é perfeitamente aceitável. Para 2.000, seria dolorosamente lento. Abordaremos essa limitação quando passarmos para o Scrapy mais adiante neste guia.

A lógica de extração de links no rastreador básico funciona, mas as páginas do mundo real são confusas. As tags âncora apontam para PDFs, endereços mailto, chamadas de JavaScript nulas, links apenas de fragmentos e variações de strings de consulta da mesma página. Um filtro mais inteligente evita que desperdice pedidos em URLs inúteis e mantém o seu rastreamento focado.

from urllib.parse import urljoin, urlparse

IGNORED_EXTENSIONS = {".pdf", ".jpg", ".png", ".gif", ".zip", ".exe", ".mp4"}

def extract_links(soup, base_url, allowed_domain):
    links = set()
    for anchor in soup.find_all("a", href=True):
        raw = anchor["href"]

        # Skip non-HTTP schemes
        if raw.startswith(("mailto:", "javascript:", "tel:", "#")):
            continue

        full_url = urljoin(base_url, raw)
        parsed = urlparse(full_url)

        # Strip fragments for deduplication
        clean = parsed._replace(fragment="").geturl()

        # Domain filter
        if parsed.netloc != allowed_domain:
            continue

        # Extension filter
        if any(clean.lower().endswith(ext) for ext in IGNORED_EXTENSIONS):
            continue

        links.add(clean)
    return links

Esta função lida com os casos extremos mais comuns quando rastreia um site com Python: resolve URLs relativas, remove identificadores de fragmentos (a #section parte que não altera a página real), ignora esquemas que não sejam HTTP e omite extensões de ficheiros binários. O resultado é um conjunto limpo de URLs do mesmo domínio, prontas para a fila de rastreamento.

Para uma deteção de URLs duplicadas ainda mais eficaz, considere normalizar os parâmetros de consulta, ordenando-os alfabeticamente. Duas URLs que diferem apenas na ordem dos parâmetros (?a=1&b=2 vs. ?b=2&a=1) normalmente apresentam o mesmo conteúdo, e tratá-las como distintas desperdiça largura de banda. Também pode aplicar o tratamento de URLs canónicas verificando as <link rel="canonical"> no HTML, que indicam a URL preferencial para um determinado conteúdo.

Outra técnica útil é a deteção de padrões de URL. Se notar que o rastreador está a gerar milhares de URLs que correspondem a um padrão como /calendar?date=2024-01-01, /calendar?date=2024-01-02, e assim por diante, pode adicionar uma lista de exclusão de expressões regulares para bloquear esses caminhos antes mesmo de entrarem na fila.

As URLs relativas são a fonte mais comum de erros num rastreador web Python de primeira viagem. Uma página em example.com/blog/ pode conter links como ../about, ./post-1, ou mesmo //cdn.example.com/image.png. O urllib.parse.urljoin lida com todos estes corretamente, razão pela qual apareceu em todos os exemplos de código até agora.

Para além dos caminhos relativos, tenha cuidado com estes casos extremos:

• Cadeias de redirecionamento: Um redirecionamento 301 ou 302 significa que o URL final difere daquele que solicitou. Use response.url (não a URL da solicitação original) ao adicionar ao seu conjunto de páginas visitadas, ou irá rastrear a mesma página duas vezes em endereços diferentes.
• 404s suaves: Alguns sites devolvem um estado 200, mas apresentam um corpo genérico de «página não encontrada». Se estiver a extrair dados, verifique se existe um marcador de conteúdo (como o título de um produto) antes de considerar a página válida.
• Caracteres codificados por URL: %20 vs. um espaço literal, %2F vs. /. Normalize-os antes da deduplicação para evitar tratar variantes codificadas e não codificadas como URLs separadas.
• Padrões de URL infinitos: Widgets de calendário, IDs de sessão no caminho ou combinações de filtros podem gerar um número ilimitado de URLs com aparência única, mas que apresentam conteúdo semelhante. Defina uma profundidade máxima de rastreamento ou utilize a deteção de padrões de URL para quebrar o ciclo.

Lidar com isto antecipadamente poupa horas de depuração mais tarde. Um rastreador que conta silenciosamente as páginas duas vezes ou perde conteúdo devido a uma barra final é mais difícil de corrigir do que um que falha de forma evidente num URL malformado.

Nem todos os sites servem os seus dados como HTML. Muitas aplicações web modernas carregam conteúdo a partir de APIs internas que devolvem JSON, em vez de incorporarem dados diretamente na marcação da página. Se inspecionar os pedidos de rede nas ferramentas de programador do seu navegador (o separador Rede, filtrado por XHR/Fetch), encontrará frequentemente pontos finais que lhe fornecem dados estruturados sem necessidade de análise de HTML.

Eis um padrão para rastrear uma API JSON paginada:

import requests
import json
import time

def crawl_json_api(base_url, max_pages=10, delay=1):
    all_items = []
    page = 1

    while page <= max_pages:
        response = requests.get(
            base_url,
            params={"page": page, "per_page": 50},
            headers={"Accept": "application/json"},
            timeout=10,
        )
        response.raise_for_status()
        data = response.json()

        items = data.get("results", [])
        if not items:
            break  # No more data

        all_items.extend(items)
        print(f"Page {page}: fetched {len(items)} items")

        # Check for explicit pagination metadata
        if not data.get("has_next", True):
            break

        page += 1
        time.sleep(delay)

    return all_items

# Example usage
items = crawl_json_api("https://api.example.com/products")
print(f"Total items collected: {len(items)}")

A abordagem é quase idêntica ao rastreamento de HTML, com duas diferenças principais. Primeiro, salta-se completamente a etapa de análise de HTML porque response.json() lhe fornece um dicionário Python nativo. Em segundo lugar, a paginação é geralmente explícita: a API devolve um next URL, um has_next flag, ou você incrementa um parâmetro de página até que a matriz de resultados volte vazia.

Quando a API exigir autenticação (uma chave de API ou um token de sessão), passe-a através de cabeçalhos em vez de parâmetros de consulta para evitar a fuga de credenciais nos registos do servidor. E verifique sempre os cabeçalhos de limite de taxa (X-RateLimit-Remaining, Retry-After). Respeitar esses cabeçalhos é tanto uma questão de boa educação como de praticidade, porque o servidor irá bloquear o acesso se os ignorar.

Esta abordagem combina bem com ferramentas como o pandas. Assim que tiver uma lista de dicionários do seu rastreamento JSON, carregá-los num DataFrame para análise ou exportação é uma única pd.DataFrame(items) chamada. Pode então usar o pandas para limpar, filtrar e analisar os dados recolhidos ou treinar modelos de aprendizagem automática diretamente com eles.

Quando as suas necessidades de rastreamento ultrapassarem um ciclo síncrono requests , o Scrapy é o próximo passo natural. Trata-se de uma estrutura Python completa, concebida especificamente para rastreamento web em escala, e lida com os problemas complexos de infraestrutura (concorrência, repetições, deduplicação e limitação de tráfego) para que se possa concentrar na lógica de análise.

A arquitetura do Scrapy tem cinco componentes principais que funcionam em conjunto:

• Motor: O coordenador central. Envia os pedidos para o Downloader e as respostas para os Spiders, orquestrando todo o ciclo de rastreamento.
• Agendador: Gerencia a fila de solicitações e desduplica URLs automaticamente usando impressão digital. Você nunca precisa criar um visited conjunto manualmente.
• Downloader: Envia pedidos HTTP de forma assíncrona utilizando o ciclo de eventos do Twisted, o que significa que centenas de pedidos podem estar em curso simultaneamente sem sobrecarga de threads.
• Spiders: O seu código. Cada classe de spider define por quais URLs começar e como analisar cada resposta. É aqui que reside a sua lógica específica do domínio.
• Pipelines de itens: Etapas de pós-processamento que limpam, validam e armazenam os dados que os seus spiders extraem. Pode encadear vários pipelines para diferentes finalidades.

O que torna esta arquitetura poderosa é que todos os componentes são plugáveis. Precisa de cabeçalhos personalizados em cada solicitação? Escreva um middleware de downloader. Quer descartar itens com campos em falta? Adicione um pipeline de validação. Precisa de canalizar os resultados para uma base de dados em vez de um ficheiro JSON? Troque o exportador padrão por um pipeline personalizado.

O Scrapy consegue processar páginas significativamente mais rápido do que um ciclo de pedidos de thread único. A estrutura lida com pedidos simultâneos em vários domínios, mantendo-se dentro dos limites de limitação que definir. Também respeita o robots.txt por predefinição (através da ROBOTSTXT_OBEY configuração), algo que muitos rastreadores criados manualmente se esquecem de implementar.

A contrapartida é a complexidade. O Scrapy tem uma estrutura de projeto bem definida, uma curva de aprendizagem e o seu próprio vocabulário (spiders, itens, pipelines, middlewares). Mas assim que internalizar o padrão, poderá construir crawlers de nível de produção com uma rapidez notável. O resto deste guia mostra-lhe como.

Vamos criar a estrutura de um projeto Scrapy real. Abra um terminal dentro do seu ambiente virtual e execute:

scrapy startproject bookstore
cd bookstore
scrapy genspider books books.toscrape.com

Isto gera a árvore de diretórios completa: settings.py, items.py, pipelines.py, e uma spiders/ pasta com o seu novo books.py spider. O genspider comando pré-preenche o spider com o allowed_domains e uma lista inicial start_urls . Abra esse ficheiro do spider e substitua o código padrão por um analisador funcional:

import scrapy

class BooksSpider(scrapy.Spider):
    name = "books"
    allowed_domains = ["books.toscrape.com"]
    start_urls = ["https://books.toscrape.com/"]

    def parse(self, response):
        for book in response.css("article.product_pod"):
            yield {
                "title": book.css("h3 a::attr(title)").get(),
                "price": book.css(".price_color::text").get(),
                "availability": book.css(
                    ".instock.availability::text"
                ).getall()[-1].strip(),
            }

        # Follow the "next" pagination link
        next_page = response.css("li.next a::attr(href)").get()
        if next_page:
            yield response.follow(next_page, callback=self.parse)

Execute o spider com:

scrapy crawl books -o books.json

Esse único comando inicia o motor, obtém todas as páginas de listagem paginadas, extrai os dados dos livros e grava os resultados num ficheiro JSON. Sem loops manuais, sem conjunto de páginas visitadas, sem código padrão de gravação de ficheiros. Este é o poder de um rastreador web em Python construído sobre uma estrutura adequada.

Algumas coisas que vale a pena notar sobre este spider:

• allowed_domains restringe o rastreador ao site de destino. Quaisquer links fora do domínio descobertos durante a análise são silenciosamente descartados, impedindo que o seu spider vagueie por sites externos.
• response.css() utiliza seletores CSS no corpo da resposta. O Scrapy analisa o HTML uma vez e armazena em cache a árvore analisada, pelo que chamar vários seletores na mesma resposta é económico.
• yield em vez de return: os spiders do Scrapy são geradores. Você gera itens (dicionários ou objetos Item) e pedidos. O motor decide quando e como agendá-los, gerindo a concorrência por si.
• response.follow() lida com URLs relativas internamente (não urljoin necessário) e deduplica automaticamente em relação a URLs vistas anteriormente através do filtro de impressão digital do agendador.

Este é um spider de rastreamento web completo e funcional em cerca de 20 linhas de código. Tudo o resto (gestão de HTTP, agendamento, downloads simultâneos, exportação) é gerido pela estrutura Scrapy. A partir daqui, pode alargar o spider com seguimento de links mais profundo, callbacks de análise adicionais e processamento em pipeline.

A paginação é um dos padrões mais comuns na construção de um rastreador web em Python. A maioria dos sites de listagem divide os resultados por páginas, e o seu spider precisa de seguir esses links «Próximo» até que se esgotem. O spider Scrapy acima já demonstra a abordagem básica, mas vamos ver uma versão mais robusta que lida com estruturas de links mais profundas usando o LinkExtractor.

import scrapy
from scrapy.linkextractors import LinkExtractor

class DeepCrawlSpider(scrapy.Spider):
    name = "deepcrawl"
    start_urls = ["https://example.com/catalog"]
    allowed_domains = ["example.com"]

    link_extractor = LinkExtractor(
        allow=r"/catalog/",
        deny=[r"/login", r"/cart", r"/account"],
    )

    def parse(self, response):
        # Extract data from the current page
        for product in response.css(".product-card"):
            yield {
                "name": product.css("h2::text").get(),
                "url": response.urljoin(product.css("a::attr(href)").get()),
                "price": product.css(".price::text").get(),
            }

        # Follow all matching links found on the page
        for link in self.link_extractor.extract_links(response):
            yield scrapy.Request(link.url, callback=self.parse)

LinkExtractor é o utilitário do Scrapy para extrair links de uma página com base em padrões de expressões regulares. O allow parâmetro mantém apenas URLs que correspondam a /catalog/, enquanto deny filtra páginas de login, carrinho e conta que desperdiçariam pedidos. Isto é muito mais fácil de manter do que codificar manualmente verificações de URL dentro do seu método de análise, especialmente à medida que o número de padrões de exclusão cresce.

Para sites que utilizam botões «Carregar Mais» em vez de links de paginação tradicionais, encontrará normalmente um endpoint de API subjacente no separador Rede. Construa o próximo pedido manualmente incrementando um parâmetro de página ou deslocamento, exatamente como o padrão de rastreamento da API JSON discutido anteriormente neste guia.

Um erro comum é esquecer-se de definir um limite de profundidade. O Scrapy DEPTH_LIMIT limita o número de saltos de link a partir da URL inicial que o rastreador seguirá. Sem isso, um spider num site grande pode enfileirar milhões de URLs antes que você perceba. Comece com um limite conservador (3-5) durante o desenvolvimento e, em seguida, aumente-o assim que o seu spider estiver estável e você tiver confiança na sua lógica de filtragem.

Outra técnica útil é combinar CrawlSpider (uma classe incorporada do Scrapy) com Rule objetos. Esta abordagem permite-lhe definir regras de seguimento de links de forma declarativa, separando a lógica de navegação da lógica de extração de dados. Torna os rastreios complexos de vários níveis mais fáceis de compreender.

O Scrapy suporta tanto seletores CSS como expressões XPath para analisar HTML, e pode misturá-los livremente no mesmo spider. Saber quando recorrer a cada um poupa tempo e mantém os seus seletores legíveis.

Use seletores CSS quando estiver a selecionar elementos por classe, ID ou hierarquia simples. São mais curtos, mais fáceis de ler e suficientes para a maioria das tarefas de extração:

# CSS: get all product titles
titles = response.css("h3.product-title::text").getall()

# CSS: get the href of every link inside a nav element
nav_links = response.css("nav a::attr(href)").getall()

Use XPath quando precisar de navegar para cima na árvore DOM, corresponder conteúdo de texto parcial ou aplicar lógica condicional que o CSS não consegue expressar:

# XPath: find links whose visible text contains "Next"
next_link = response.xpath('//a[contains(text(), "Next")]/@href').get()

# XPath: get the parent div of a specific span
parent = response.xpath('//span[@class="price"]/..').get()

# XPath: select items where the price is not empty
priced_items = response.xpath(
    '//div[@class="product"][.//span[@class="price" and text()]]'
).getall()

Na prática, a maioria dos spiders do Scrapy usa seletores CSS para cerca de 80% do seu trabalho de extração e muda para o XPath nos casos restantes em que o CSS não é suficiente. O Scrapy converte seletores CSS para XPath internamente antes de os executar, pelo que não há diferença de desempenho entre as duas abordagens. Escolha aquela que tornar a sua intenção mais clara para cada tarefa de extração específica.

Uma dica prática: ao depurar seletores, use scrapy shell "https://target-url.com" para abrir uma sessão interativa. Pode testar expressões CSS e XPath numa página ativa sem executar o seu spider completo, o que acelera significativamente o desenvolvimento.

As exportações de feed integradas do Scrapy lidam com os formatos de saída mais comuns sem qualquer código personalizado. Já viu o comando básico de exportação:

# Export to JSON
scrapy crawl books -o output.json

# Export to CSV
scrapy crawl books -o output.csv

# Export to JSON Lines (one JSON object per line, better for large datasets)
scrapy crawl books -o output.jsonl

O -o sinalizador acrescenta ao ficheiro se este já existir, o que pode produzir JSON malformado em execuções repetidas. Use -O (O maiúsculo, disponível no Scrapy 2.3+) para sobrescrever.

Para ter mais controlo sobre o seu pipeline de exportação de dados, configure as exportações em settings.py:

FEEDS = {
    "data/books.json": {
        "format": "json",
        "encoding": "utf-8",
        "indent": 2,
        "overwrite": True,
    },
    "data/books.csv": {
        "format": "csv",
        "fields": ["title", "price", "availability"],
    },
}

O FEEDS dicionário permite-lhe gerar resultados em vários formatos simultaneamente, controlar a ordem dos campos no CSV e definir a codificação. Isto é particularmente útil quando diferentes utilizadores necessitam de formatos diferentes: a sua equipa de análise pretende CSV com colunas específicas, os utilizadores da sua API pretendem JSON Lines para ingestão em streaming e o seu arquivo necessita de um instantâneo JSON com formatação legível.

O formato JSON Lines (.jsonl) merece atenção especial para rastreamentos de maior dimensão. Ao contrário do JSON padrão, que envolve tudo numa única matriz, o JSON Lines escreve um objeto JSON completo por linha. Isto significa que pode processar o ficheiro em fluxo, linha a linha, acrescentar novos registos sem voltar a analisar todo o ficheiro e recuperar resultados parciais se um rastreamento falhar a meio.

Se precisar de enviar dados para uma base de dados, uma fila de mensagens ou um bucket de armazenamento na nuvem, ignore completamente o exportador de ficheiros e crie um pipeline de itens personalizado. Essa abordagem dá-lhe controlo total sobre a validação, a transformação e a lógica de armazenamento.

Os dados brutos rastreados quase nunca estão limpos. Os preços têm espaços em branco à direita, os títulos incluem saltos de linha indesejados e algumas páginas devolvem registos incompletos. O sistema de pipelines de itens do Scrapy permite-lhe processar cada item entre a extração e a exportação, garantindo que a sua saída é consistente e válida.

Aqui está um pipeline que lida com as três tarefas de limpeza mais comuns:

from scrapy.exceptions import DropItem

class CleaningPipeline:
    def __init__(self):
        self.seen_titles = set()

    def process_item(self, item, spider):
        # 1. Strip whitespace from all string fields
        for field in item:
            if isinstance(item[field], str):
                item[field] = item[field].strip()

        # 2. Validate required fields
        if not item.get("title"):
            raise DropItem(f"Missing title: {item}")

        # 3. Drop duplicates based on title
        if item["title"] in self.seen_titles:
            raise DropItem(f"Duplicate: {item['title']}")
        self.seen_titles.add(item["title"])

        return item

Para ativar o pipeline, registe-o em settings.py:

ITEM_PIPELINES = {
    "bookstore.pipelines.CleaningPipeline": 300,
}

O número inteiro (300) representa a prioridade. Os números mais baixos são executados primeiro, pelo que pode encadear vários pipelines: um pipeline de limpeza com prioridade 300, um pipeline de validação com prioridade 400 e um pipeline de gravação na base de dados com prioridade 500. Cada pipeline recebe o item, processa-o e ou devolve o item modificado (passando-o para o pipeline seguinte) ou lança DropItem para o descartar por completo.

Lançar DropItem remove o item da saída e regista uma mensagem. Isto é mais limpo do que filtrar a posteriori, porque os itens descartados nunca chegam ao exportador ou à base de dados. Pode monitorizar a taxa de descarte do seu rastreio para identificar problemas de análise antecipadamente.

Para projetos que extraem dados de dezenas de tipos de páginas diferentes, considere definir Itens Scrapy formais (ou carregadores de itens baseados em dataclass) em vez de dicionários simples. Os itens impõem um esquema, fornecem valores padrão e funcionam com os processadores de carregadores de itens do Scrapy para transformações ao nível do campo, como MapCompose(str.strip, str.lower). Isto é especialmente valioso em projetos de equipa onde vários programadores escrevem spiders para o mesmo modelo de dados.

Um rastreador web em Python que ignore as regras de um site acabará por ser bloqueado e, em algumas jurisdições, poderá criar riscos legais. O rastreamento responsável não é apenas uma questão de boas maneiras; é um requisito prático para qualquer rastreador que precise de funcionar de forma fiável ao longo do tempo.

O ficheiro robots.txt encontra-se na raiz de todos os sites (por exemplo, https://example.com/robots.txt) e indica aos rastreadores quais os caminhos que estão fora dos limites e a que velocidade devem efetuar os pedidos. Veja aqui como analisá-lo programaticamente com a biblioteca padrão do Python:

from urllib.robotparser import RobotFileParser

rp = RobotFileParser()
rp.set_url("https://example.com/robots.txt")
rp.read()

if rp.can_fetch("*", "https://example.com/private/data"):
    print("Allowed")
else:
    print("Blocked by robots.txt")

crawl_delay = rp.crawl_delay("*")
print(f"Recommended delay: {crawl_delay} seconds")

O Scrapy verifica o robots.txt automaticamente quando ROBOTSTXT_OBEY = True (a configuração padrão). Se estiver a utilizar requests e o BeautifulSoup, terá de implementar esta verificação manualmente antes de cada recuperação.

Mesmo que o robots.txt não especifique um atraso de rastreamento, sobrecarregar um servidor com centenas de pedidos simultâneos é uma forma rápida de ter o IP bloqueado. No Scrapy, três definições controlam o ritmo do rastreamento:

# settings.py
DOWNLOAD_DELAY = 1                      # seconds between requests
CONCURRENT_REQUESTS_PER_DOMAIN = 8      # max parallel requests to one domain
AUTOTHROTTLE_ENABLED = True             # dynamically adjusts delay based on load
AUTOTHROTTLE_TARGET_CONCURRENCY = 2.0   # target number of parallel requests

O AUTOTHROTTLE é particularmente útil porque se adapta automaticamente com base nos tempos de resposta do servidor. Se o servidor responder rapidamente, o Scrapy acelera. Se os tempos de resposta dispararem (indicando sobrecarga do servidor), ele abranda. Isto equilibra o rendimento com a cortesia, sem que seja necessário adivinhar o atraso fixo certo.

Para além das configurações técnicas, siga estes princípios:

• Identifique o seu rastreador com uma string User-Agent descritiva que inclua informações de contacto.
• Não rastreie páginas protegidas por login ou acesso pago, a menos que tenha permissão explícita.
• Armazene as respostas em cache localmente durante o desenvolvimento, para não sobrecarregar os servidores ativos em cada execução de teste.
• Respeite o Protocolo de Exclusão de Robôs como referência, mesmo que não seja juridicamente vinculativo na sua jurisdição.

Quando expandir a escala, lembre-se de que os sites não são concebidos para lidar com centenas de pedidos simultâneos de bots. Sobrecarregar um servidor afeta os utilizadores reais, e um rastreamento responsável garante que poderá regressar ao mesmo site amanhã sem encontrar o seu IP numa lista de bloqueios.

Mesmo os rastreadores educados são bloqueados. Os sites implementam sistemas anti-bot que procuram padrões: pedidos repetidos a partir de um único IP, cabeçalhos User-Agent em falta ou genéricos e intervalos de tempo entre pedidos que nenhum ser humano produziria. Veja aqui como tornar o seu rastreador web em Python mais resiliente.

O User-Agent padrão da maioria das bibliotecas HTTP identifica-as como bots. Os sites que filtram este cabeçalho rejeitarão as suas solicitações imediatamente. Defina um cabeçalho realista, semelhante ao de um navegador:

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                  "AppleWebKit/537.36 (KHTML, like Gecko) "
                  "Chrome/124.0.0.0 Safari/537.36"
}
response = requests.get(url, headers=headers, timeout=10)

Para sessões de rastreamento mais longas, alterne entre uma lista de strings de User-Agent para evitar apresentar a mesma assinatura digital em cada solicitação. No Scrapy, o scrapy-fake-useragent middleware lida com esta rotação automaticamente.

Os limites de taxa baseados em IP são o mecanismo de bloqueio mais comum. Se todas as suas solicitações vierem de um único endereço, o site percebe o padrão instantaneamente. O encaminhamento do tráfego através de proxies rotativos distribui as suas solicitações por vários IPs, fazendo com que cada um pareça um visitante independente.

Os proxies residenciais são particularmente eficazes porque utilizam endereços IP atribuídos a residências reais, tornando-os praticamente indistinguíveis do tráfego normal dos utilizadores. Os IPs de centros de dados, embora mais rápidos e baratos, são mais fáceis de identificar e bloquear em massa pelos sistemas anti-bot.

Antes de investir em contramedidas, aprenda a reconhecer os sintomas:

• HTTP 403 ou 429: Resposta de recusa explícita ou de limitação de taxa.
• Redirecionamento para uma página CAPTCHA: o servidor quer prova de que é humano.
• HTML vazio ou com espaço reservado: A página carrega, mas não contém conteúdo significativo, apenas um esboço ou uma mensagem do tipo «por favor, aguarde».
• Picos repentinos no tempo de resposta: O servidor está a atrasá-lo intencionalmente (uma técnica chamada tarpitting).

Quando detetar um bloqueio, recue antes de tentar novamente. Um recuo exponencial (esperar 1 s, depois 2 s, depois 4 s, depois 8 s) é um padrão razoável. O middleware de repetição do Scrapy lida automaticamente com falhas transitórias, mas bloqueios persistentes geralmente exigem uma mudança de estratégia: IPs diferentes, taxas de solicitação mais lentas ou uma camada de renderização para sites que servem conteúdo apenas a navegadores reais.

As defesas anti-bot são uma corrida ao armamento. Quando entram em jogo desafios de JavaScript, impressão digital do navegador e CAPTCHAs, os scripts de rastreamento simples esbarram numa parede. A escolha pragmática é, muitas vezes, transferir essa complexidade para um serviço criado especificamente para o efeito, em vez de manter o seu próprio conjunto de proxies e infraestrutura de automação de navegadores.

Um número crescente de sites depende de JavaScript do lado do cliente para renderizar o seu conteúdo. Quando se obtém uma dessas páginas com requests, obtém-se um shell HTML com <div> e um pacote de JavaScript. Os dados reais carregam-se após a execução dos scripts num ambiente de navegador, o que significa que os rastreadores tradicionais baseados em HTTP não veem nada de útil.

Tem três opções principais para lidar com isto ao criar um rastreador web em Python:

1. Encontre a API subjacente. Antes de recorrer a um navegador sem interface gráfica, abra as ferramentas de programador do seu navegador e verifique o separador Rede. Muitas aplicações de página única obtêm dados de uma API JSON que pode chamar diretamente, contornando totalmente o problema da renderização. Esta é a abordagem mais rápida e eficiente em termos de recursos quando funciona.

2. Utilizar um navegador sem interface gráfica. Ferramentas como o Playwright e o Puppeteer permitem-lhe controlar uma instância real (sem interface gráfica) do Chrome ou do Firefox a partir do seu código. O navegador executa JavaScript, aguarda a renderização do conteúdo e, em seguida, extrai os dados do DOM totalmente carregado. O Scrapy integra-se com o Playwright através do scrapy-playwright plugin, que permite marcar seletivamente pedidos específicos para renderização no navegador, mantendo o resto como chamadas HTTP rápidas e leves:

# In a Scrapy spider, mark a request for Playwright rendering
yield scrapy.Request(
    url,
    meta={"playwright": True, "playwright_page_methods": [
        {"method": "wait_for_selector", "args": [".product-list"]},
    ]},
    callback=self.parse_products,
)

3. Utilize um serviço de renderização gerido. Se não quiser executar e manter uma infraestrutura de navegador sem interface gráfica (que consome uma quantidade significativa de memória e CPU), os serviços de API geridos podem tratar da renderização por si. Estes devolvem o HTML totalmente carregado para que possa analisá-lo com os seus seletores BeautifulSoup ou Scrapy existentes.

A escolha certa depende do volume e da complexidade. Para algumas centenas de páginas com muito JS, um navegador headless local é perfeitamente gerenciável. Para milhares de páginas em sites com proteções anti-bot, a sobrecarga operacional de gerenciar instâncias de navegador, lidar com fugas de memória e recuperar de falhas acumula-se rapidamente.

A certa altura, a parte mais difícil de construir um rastreador web em Python deixa de ser a lógica de análise e passa a ser tudo o resto: manter conjuntos de proxies, resolver CAPTCHAs, alternar impressões digitais do navegador e acompanhar os sistemas anti-bot que atualizam as suas defesas semanalmente. Quando a carga da infraestrutura supera o trabalho de extração, faz sentido descarregar essa camada e concentrar-se no que o seu código realmente importa: os dados.

Um serviço de API gerida situa-se entre o seu rastreador e o site de destino. Envia um pedido com o URL de destino e o serviço trata da rotação de proxies, da renderização de JavaScript, das tentativas de repetição e das contramedidas anti-bot nos bastidores. O que recebe em troca é HTML limpo (ou JSON estruturado) que analisa com o mesmo código BeautifulSoup ou Scrapy que já possui. A sua lógica de rastreamento não muda; apenas a camada de obtenção de dados é que muda.

Esta abordagem é especialmente prática quando:

• Está a rastrear sites com deteção agressiva de bots que bloqueiam IPs de centros de dados em poucos minutos.
• Precisa de renderização de JavaScript em escala, mas não quer gerir uma frota de instâncias de navegadores headless e os custos de memória e CPU associados.
• O tempo de engenharia da sua equipa é mais bem empregue na análise de dados e no desenvolvimento de pipelines do que na manutenção da infraestrutura de proxy.
• Precisa de rastrear muitos sites de destino diferentes, cada um com a sua própria pilha anti-bot, tornando impraticável uma solução local única para todos.

A contrapartida é o custo. Está a pagar por cada pedido bem-sucedido em vez de gerir a sua própria infraestrutura. Para rastreamentos de grande volume e longa duração, em que os alvos não estão fortemente protegidos, a economia pende para as configurações autogeridas. Para a maioria dos projetos que envolvem sites protegidos contra bots, no entanto, o tempo poupado pelos programadores mais do que compensa a taxa por pedido.

• Comece de forma simples e, depois, expanda de forma intencional. Um requests rastreador básico + BeautifulSoup é suficiente para tarefas pequenas e aprendizagem. Mude para o Scrapy quando precisar de concorrência, deduplicação automática e pipelines de dados estruturados.
• A deduplicação é imprescindível. Utilize um conjunto de URLs já visitadas com normalização adequada (ou deixe que o agendador do Scrapy trate disso) para evitar loops infinitos e desperdício de largura de banda.
• Faça o rastreamento de forma responsável sempre. Respeite o robots.txt, configure atrasos de rastreamento, use AUTOTHROTTLE e identifique o seu bot com um User-Agent descritivo. Isto protege tanto o site de destino como a reputação do seu próprio IP.
• Lide com JavaScript de forma intencional. Verifique primeiro as APIs subjacentes, utilize navegadores headless quando necessário e considere serviços geridos quando precisar de renderização JS em escala.
• Limpe os dados durante o rastreamento, não depois. Os pipelines de itens do Scrapy permitem-lhe validar, deduplicar e transformar registos antes mesmo de estes chegarem ao seu ficheiro de exportação ou base de dados.

O rastreamento é o processo de descoberta: um programa automatizado segue hiperligações entre páginas para mapear a estrutura de um site e encontrar URLs. A extração é a etapa de recolha: extrair campos de dados específicos (preços, títulos, datas) de páginas que já foram localizadas. A maioria dos projetos reais combina ambos, mas resolvem problemas diferentes e, muitas vezes, beneficiam de ferramentas e estratégias diferentes.

Depende da jurisdição, dos termos de serviço do site e do tipo de dados que recolhe. Nos Estados Unidos, a decisão de 2022 no caso hiQ v. LinkedIn confirmou que o acesso a dados publicamente disponíveis não constitui uma violação da Lei de Fraude e Abuso Informático. No entanto, podem ainda aplicar-se restrições dos termos de serviço, a lei de direitos de autor e regulamentos de privacidade como o RGPD. Consulte sempre um advogado antes de realizar rastreamento em grande escala, especialmente para uso comercial.

Verifique primeiro se existe uma API subjacente, inspecionando o separador Rede do navegador para ver se há pedidos XHR/Fetch. Se os dados só estiverem disponíveis após a renderização do lado do cliente, utilize um navegador headless como o Playwright ou o Puppeteer para executar JavaScript e extrair o DOM totalmente renderizado. Para rastreamento de JS de grande volume, um serviço de renderização gerido pode tratar da orquestração do navegador, para que não precise de manter essa infraestrutura por conta própria.

Alterne as cadeias de caracteres do User-Agent, utilize proxies residenciais para distribuir os pedidos por vários IPs, adicione atrasos aleatórios entre os pedidos e respeite as diretivas de atraso de rastreamento do robots.txt. Acompanhe de perto os códigos de resposta: um pico nas respostas 403 ou 429 significa que o site detetou o seu padrão de tráfego. Recuar e reduzir a simultaneidade é quase sempre mais eficaz do que tentar ultrapassar os bloqueios com força bruta.

Utilize o Scrapy quando o seu rastreio envolver mais do que algumas centenas de páginas, necessitar de pedidos simultâneos, exigir deduplicação integrada ou beneficiar de pipelines de dados estruturados e exportação. Para scripts rápidos e pontuais direcionados a um pequeno número de páginas, o requests e o BeautifulSoup são mais rápidos de configurar e mais simples de depurar. Se o seu projeto crescer para além de um único ficheiro de script, a arquitetura do Scrapy poupar-lhe-á de ter de reinventar as suas funcionalidades.

Construir um rastreador web em Python é um processo gradual, não um passo único. Começa-se com algumas linhas usando requests e o BeautifulSoup para compreender o ciclo de busca-análise-extração. A partir daí, passa para o Scrapy para obter concorrência, deduplicação automática, flexibilidade de seletores e limpeza de dados baseada em pipelines sem ter de escrever essa infraestrutura por conta própria.

Os princípios fundamentais permanecem os mesmos independentemente da escala: respeite os sites que rastreia, deduplique agressivamente, lide com erros de forma elegante e limpe os seus dados antes de os armazenar. Quando os sites alvo reagem com CAPTCHAs, bloqueios de IP ou renderização apenas em JavaScript, tem uma árvore de decisão clara: verifique primeiro se existe uma API subjacente, utilize navegadores headless para volumes moderados e recorra a serviços geridos para trabalhos pesados.

Se se vir a gastar mais tempo com rotação de proxies, resolução de CAPTCHAs e soluções alternativas anti-bot do que no processamento de dados propriamente dito, a WebScrapingAPI pode tratar dessa camada de infraestrutura por si. Esta gere proxies, renderização JavaScript e novas tentativas por trás de um único ponto de acesso, para que os seus spiders Scrapy ou scripts BeautifulSoup continuem a funcionar com alterações mínimas no código. Dessa forma, mantém-se focado no que os dados lhe dizem, e não em como os obter.