Raspagem da Web com Selenium: Um Guia Prático para Python

TL;DR:

• O Selenium controla um Chrome real através do protocolo WebDriver, então ele vê o DOM que uma página constrói com JavaScript — o conteúdo que uma simples solicitação HTTP nunca recebe.
• Uma execução ao vivo abaixo lê todas as dez citações de uma página de demonstração que envia um contêiner vazio e o preenche no lado do cliente; a mesma página retorna zero linhas para um requests.get simples.
• O Selenium moderno resolve seu próprio driver: o Selenium Manager combina o ChromeDriver com o seu Chrome instalado, então webdriver.Chrome(options=...) funciona sem um download manual.
• O verdadeiro custo do Selenium é operacional — cada trabalhador é um navegador completo saindo do seu próprio IP, o que é pesado para escalar e simples para sistemas anti-bot limitarem.
• O pivô de limites honestos envia a mesma URL para a API de Raspagem Universal Scrapeless, que renderiza a página no lado do servidor e retorna HTML finalizado, sem navegador para você executar ou escalar.
• Obtenha uma chave de API Scrapeless no plano gratuito e execute ambas as partes você mesmo.

O que o Selenium faz para raspagem

O Selenium automatiza um navegador real. Seu código Python fala o protocolo WebDriver para o ChromeDriver, o ChromeDriver controla o Chrome, e o Chrome faz o que um navegador faz: solicita a página, executa os scripts e constrói o DOM. Essa última parte é a razão pela qual os raspadores recorrem a ele. Uma página que monta seu conteúdo no cliente — uma grade de produtos renderizada por um framework, um feed que chega através de uma solicitação em segundo plano — está vazia no HTML bruto e completa somente após a execução dos scripts. O Selenium espera essa execução e lhe entrega a página finalizada.

O conflito é o peso. O Selenium executa um Chrome real por sessão, o que consome memória e tempo de inicialização, e a solicitação sai do IP da sua máquina. Para um punhado de páginas, isso é aceitável. Este guia constrói primeiro o raspador Selenium funcional, depois mostra o ponto onde executar seus próprios navegadores deixa de compensar e o que fazer a respeito. Cada caminho de código aqui foi executado contra a página ao vivo.

Instalação

Instale as bindings do Selenium para Python:

pip install selenium

Você não instala o ChromeDriver manualmente. Desde a versão 4.6, o Selenium inclui as ferramentas Selenium WebDriver com o Selenium Manager, que detecta seu Chrome e resolve o driver correspondente na primeira utilização. Você precisa de uma versão recente do Google Chrome instalada; as bindings cuidam do resto.

Configuração

Para o pivô mais adiante neste guia, coloque sua chave da API Scrapeless no ambiente para que ela nunca fique no código fonte:

export SCRAPELESS_API_KEY="sua_chave_api_scrapeless"

Implementação básica: renderizando uma página JavaScript

Aponte o Selenium para uma página que constrói suas linhas no cliente, e os elementos estão lá assim que a navegação retorna. A demonstração abaixo envia um contêiner vazio e o popula com JavaScript; a marcação bruta não contém nós .quote, enquanto o DOM renderizado pelo navegador contém dez porque o Chrome executou os scripts primeiro, seguindo o modelo de análise e execução de scripts HTML.

import tempfile
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By

opts = Options()
opts.add_argument("--headless=new")
opts.add_argument("--no-sandbox")
opts.add_argument("--disable-dev-shm-usage")
opts.add_argument(f"--user-data-dir={tempfile.mkdtemp()}")

driver = webdriver.Chrome(options=opts)   # O Selenium Manager resolve o driver
try:
    driver.get("https://quotes.toscrape.com/js/")
    quotes = driver.find_elements(By.CSS_SELECTOR, ".quote")
    print("blocos de citações na página JS:", len(quotes))
    print("primeiro autor:", quotes[0].find_element(By.CSS_SELECTOR, ".author").text)
finally:
    driver.quit()

A execução imprime a contagem e o primeiro registro:

blocos de citações na página JS: 10
primeiro autor: Albert Einstein

A flag --headless=new executa o Chrome sem uma janela visível, que é o que você quer em um servidor. --no-sandbox e --disable-dev-shm-usage mantêm o Chrome estável dentro de contêineres e ambientes restritos, e o --user-data-dir descartável dá a cada execução seu próprio perfil para que sessões paralelas não colidam.

Padrões avançados: esperando e selecionando

driver.get retorna quando o documento carrega, mas um elemento construído por script pode aparecer um momento depois. Em vez de esperar um intervalo fixo, aguarde pela condição específica. WebDriverWait combinado com expected_conditions bloqueia até que o elemento que você nomeou esteja presente, assim a raspagem começa no instante em que os dados existem e não antes:

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.CSS_SELECTOR, ".quote"))
)

Prefira seletores estáveis em vez de classes CSS hasheadas: um id, um atributo data-* ou uma tag semântica sobrevive a um redesign que renomeia classes de estilo. Para uma página que você pagina, leia o href do link "próximo" e siga-o em vez de adivinhar números de páginas.

Obtenha sua chave de API no plano gratuito: app.scrapeless.com

O limite honesto e a mudança de direção

Selenium renderiza JavaScript bem; o que ele não faz é tornar a execução de navegadores barata ou impedir que seu tráfego se destaque. Cada trabalhador Selenium é um Chrome completo, então escalar para muitas páginas significa escalar navegadores e a memória que eles precisam, e cada requisição sai do seu próprio IP, que um site movimentado pode limitar ou desafiar. O Selenium não tem uma resposta embutida para um desafio de anti-bot gerenciado — ele renderiza a página que lhe é dada, e uma página que nunca alcança se renderiza como nada.

A Scrapeless Universal Scraping API remove essa parte operacional da sua máquina. Você envia a URL com js_render habilitado; ela renderiza a página do lado do servidor por trás de um gerenciamento de anti-bot e uma saída residencial rotativa, e retorna o HTML final em seu campo data. Não há navegador para você lançar, e a requisição não vem do seu IP. Você analisa o HTML retornado exatamente como você analisaria a fonte de página do Selenium:

import os, re, json, requests

resp = requests.post(
    "https://api.scrapeless.com/api/v2/unlocker/request",
    headers={"x-api-token": os.environ["SCRAPELESS_API_KEY"], "Content-Type": "application/json"},
    json={"actor": "unlocker.webunlocker", "input": {"url": "https://quotes.toscrape.com/js/", "js_render": True}},
    timeout=120,
)
resp.raise_for_status()
html = resp.json()["data"]

authors = re.findall(r'<small class="author">(.*?)</small>', html)
print("blocos de citação renderizados via Universal Scraping API:", html.count('class="quote"'))
print("autores extraídos:", len(authors))
print("primeiro autor:", authors[0])

A única requisição retorna a mesma página renderizada, do lado do servidor:

blocos de citação renderizados via Universal Scraping API: 10
autores extraídos: 10
primeiro autor: Albert Einstein

A regra prática: mantenha o Selenium enquanto você controla o alvo e o volume é pequeno, e mova a busca para a API quando o trabalho é as operações — muitas páginas, IPs bloqueados ou um desafio que o Selenium não consegue superar. O código de análise não muda; apenas a fonte do HTML muda.

Solução de problemas

Um erro de versão do driver quase sempre significa que o Chrome foi atualizado e um driver antigo permaneceu; no Selenium 4.6 e versões mais novas, o Selenium Manager resolve o driver atual para você, então remover um ChromeDriver fixo do seu PATH geralmente resolve. Um resultado vazio em uma página que você pode ver em um navegador normal significa que o conteúdo chegou depois que driver.get retornou — adicione o WebDriverWait acima para o seletor que você precisa. Uma execução que trava em uma página que nunca fica silenciosa em rede significa que você esperou pela condição errada; espere pelo elemento, não pela rede.

Mantenha o trabalho dentro dos limites declarados de um site. Leia seus termos e seu arquivo o Protocolo de Exclusão de Robôs, solicite apenas páginas públicas e mantenha a concorrência modesta — a mesma disciplina coberta no guia sobre o Modelo de Objeto do Documento que o Selenium lê. Para um tour mais amplo de descoberta e extração, o walkthrough sobre construir um web scraper do zero combina bem com este.

Conclusão

O Selenium ganha seu lugar quando uma página precisa de um navegador real para existir: ele controla o Chrome através do protocolo WebDriver, executa os scripts e lhe entrega o DOM renderizado — dez citações de uma página que não fornece nenhuma em sua marcação. Onde ele para de compensar são as operações em torno desse navegador: a memória de escalar sessões, a exposição do seu próprio IP e os desafios que ele não consegue superar. Nesse ponto, a mesma URL através da Scrapeless Universal Scraping API retorna o HTML renderizado sem navegador para executar, e sua análise permanece a mesma. Verifique o volume de requisições que você precisa em relação à página de preços antes de escalar.
Junte-se à nossa comunidade para reivindicar um plano gratuito e compartilhar anotações com outros desenvolvedores que estão criando scrapers: Discord · Telegram.

FAQ

Q: Preciso baixar o ChromeDriver para usar o Selenium?

Não. O Selenium 4.6 e versões mais novas vêm com o Selenium Manager, que detecta o Chrome instalado e resolve o ChromeDriver correspondente na primeira utilização, então webdriver.Chrome(options=...) funciona sem um download manual do driver.

Q: Por que o Selenium encontra elementos que o requests não consegue?

O Selenium roda um navegador real que executa o JavaScript da página e constrói o DOM, então elementos gerados por scripts existem no momento em que você os consulta. Um cliente HTTP simples recebe apenas a marcação inicial do servidor, que em uma página renderizada pelo cliente não contém nenhum desse conteúdo.

Q: Quando devo mudar do Selenium para a API Universal de Scraping?

Mude quando a dificuldade for operacional em vez de renderização — muitas páginas para buscar, seu IP sendo limitado, ou um desafio anti-bot gerenciado que o Selenium não consegue superar. A API renderiza do lado do servidor e retorna HTML finalizado, então você mantém seu parsing e abandona a frota de navegadores.

Q: Como faço para esperar por conteúdo que carrega após a página?

Use WebDriverWait com expected_conditions para bloquear até que um seletor específico esteja presente, em vez de um time.sleep fixo. A coleta então começa no momento em que o elemento existe, o que é mais rápido e mais confiável do que uma pausa adivinhada.

Q: É legal fazer scraping com Selenium?

Fazer scraping de dados públicos é geralmente permitido, mas a responsabilidade é sua: respeite os termos do site e suas diretrizes para robôs, colete apenas páginas públicas, evite dados pessoais que você não tem base para processar e mantenha as taxas de solicitação moderadas.