Scraping de sites com Selenium: guia detalhado

O Selenium é uma ferramenta de automação de navegadores criada originalmente para testar aplicações web. Mas, graças ao fato de controlar um navegador real, é usado há muito tempo e de forma intensiva para o scraping de sites, sobretudo aqueles que servem o conteúdo por meio de JavaScript e não se abrem com uma simples requisição HTTP.

Neste artigo veremos como o Selenium funciona por dentro, como trabalhar com ele em diferentes linguagens, quais são seus pontos fortes e fracos e por que os sistemas de proteção anti-bot o detectam com facilidade.

Se você ainda está escolhendo uma abordagem de scraping, comece pelos nossos panoramas «Em que linguagem escrever um scraper? Panorama de soluções» e «Bibliotecas para web scraping» — lá comparamos as ferramentas em alto nível. Este artigo é uma análise em profundidade de uma delas.

O que é o Selenium e como ele funciona

O Selenium não controla o navegador «por dentro», e sim através de um driver à parte, pelo protocolo WebDriver (um padrão do W3C). O esquema é sempre o mesmo:

Seu script  ──▶  Binding do Selenium  ──▶  Driver (chromedriver / geckodriver / …)  ──▶  Navegador

• O binding é a biblioteca na sua linguagem (Python, Java etc.) que traduz chamadas como driver.get(url) em comandos do WebDriver.
• O driver é um executável intermediário para um navegador específico: chromedriver para o Chrome, geckodriver para o Firefox, msedgedriver para o Edge.
• O navegador é um Chrome/Firefox/Edge real que renderiza a página exatamente como para um usuário comum.

Antes era preciso baixar os drivers e colocá-los no PATH à mão, vigiando a compatibilidade entre as versões do driver e do navegador. Desde a versão 4.6, o Selenium incorpora o Selenium Manager — que localiza o navegador e escolhe e baixa sozinho o driver adequado. No momento em que este texto é escrito, a versão atual é o Selenium 4.45 (junho de 2026). Na prática, isso significa que hoje o script mínimo funcional cabe literalmente em três linhas, sem o vaivém manual com os drivers.

A diferença principal em relação aos scrapers HTTP

As bibliotecas habituais (requests + BeautifulSoup, Scrapy etc.) se limitam a baixar o HTML que o servidor devolveu para a requisição. Se o conteúdo é carregado com JavaScript já no navegador, ele não estará nesse HTML.

O Selenium, ao contrário, inicia um navegador completo: o JS é executado, as requisições XHR/fetch se resolvem e o DOM final é construído. O scraper vê exatamente o mesmo que uma pessoa. Essa é a principal razão para escolher o Selenium — mas se paga em recursos e velocidade (mais sobre isso abaixo).

Selenium em diferentes linguagens

Uma das grandes vantagens do Selenium são seus bindings oficiais para várias linguagens ao mesmo tempo. A API é quase idêntica em todas; só muda a sintaxe. Isso é confortável: a equipe pode escrever o scraper na mesma linguagem que o restante do projeto.

Oficialmente têm suporte Python, Java, JavaScript (Node.js), C# (.NET) e Ruby. Para PHP, Go, Rust e outras linguagens há bindings ou wrappers comunitários, mas eles são mantidos pela comunidade, não pela equipe principal do Selenium.

Python

A linguagem mais popular para o scraping e para o Selenium em particular: barreira de entrada baixa, um ecossistema enorme (pandas, lxml, BeautifulSoup para o pós-processamento) e uma infinidade de exemplos prontos.

from selenium import webdriver
from selenium.webdriver.common.by import By

driver = webdriver.Chrome()
driver.get("https://example.com")

title = driver.find_element(By.TAG_NAME, "h1").text
print(title)

driver.quit()

Vantagens: a maior comunidade, complementos anti-detecção prontos (undetected-chromedriver, selenium-stealth, SeleniumBase) e desenvolvimento rápido. Desvantagens: o GIL limita o paralelismo real — para escalar, costuma-se disparar vários processos ou usar o Selenium Grid.

Java

Java é a linguagem «nativa» do Selenium (o projeto cresceu historicamente em torno dela) e um padrão nas grandes equipes corporativas de QA.

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class Scraper {
    public static void main(String[] args) {
        WebDriver driver = new ChromeDriver();
        driver.get("https://example.com");

        String title = driver.findElement(By.tagName("h1")).getText();
        System.out.println(title);

        driver.quit();
    }
}

Vantagens: multithreading de verdade, alto desempenho, ferramentas de build maduras (Maven/Gradle) e conforto para sistemas grandes e de vida longa. Desvantagens: sintaxe verbosa; escrever e prototipar demora mais que em Python.

JavaScript (Node.js)

Uma escolha lógica se o backend já está em Node. O modelo assíncrono (async/await) combina bem com a espera do carregamento dos elementos.

const { Builder, By } = require("selenium-webdriver");

(async () => {
  const driver = await new Builder().forBrowser("chrome").build();
  await driver.get("https://example.com");

  const title = await driver.findElement(By.css("h1")).getText();
  console.log(title);

  await driver.quit();
})();

Vantagens: uma mesma linguagem para o front e o back, e assincronia nativa. Desvantagens: no nicho da automação de navegadores sobre Node, o Selenium tem rivais mais fortes — Puppeteer e Playwright, que muitos preferem justamente no ecossistema JS.

C# (.NET)

Popular em ambientes corporativos com stack Microsoft.

using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;

var driver = new ChromeDriver();
driver.Navigate().GoToUrl("https://example.com");

var title = driver.FindElement(By.TagName("h1")).Text;
Console.WriteLine(title);

driver.Quit();

Vantagens: tipagem estrita, bom desempenho e uma integração excelente com o ecossistema .NET. Desvantagens: menos exemplos voltados ao scraping e menos bibliotecas anti-detecção de terceiros do que em Python.

Ruby

require "selenium-webdriver"

driver = Selenium::WebDriver.for :chrome
driver.get "https://example.com"

title = driver.find_element(tag_name: "h1").text
puts title

driver.quit

Vantagens: sintaxe concisa e expressiva. Desvantagens: uma comunidade relativamente pequena em tarefas de scraping e menos soluções prontas.

PHP, Go, Rust e outras

Para PHP existe o php-webdriver/php-webdriver; para Go e Rust, wrappers comunitários. Eles funcionam, mas: são mantidos pela comunidade, ficam atrás dos bindings oficiais nas novidades e são pior documentados no contexto específico do scraping. Se a linguagem do seu projeto é uma dessas, muitas vezes compensa considerar uma alternativa (por exemplo, um navegador headless via CDP ou um scraper HTTP) antes de arrastar o Selenium.

Vantagens do Selenium

• Funciona com sites dinâmicos. Executa JavaScript e vê o DOM final — algo que os scrapers HTTP não conseguem obter sem emular um navegador.
• Imitação de um usuário real. Cliques, digitação de texto, rolagem, hover, troca de abas, manejo de cookies — tudo como uma pessoa de carne e osso.
• Multilinguagem. A mesma abordagem em Python, Java, JS, C# e Ruby — permite ficar no stack do projeto.
• Vários navegadores. Chrome, Firefox, Edge e Safari por meio de uma única API.
• Maturidade e documentação. O projeto tem mais de 15 anos, uma comunidade gigantesca, e a resposta para quase qualquer dúvida já está no Stack Overflow.
• Controle total do navegador. Capturas de tela, execução de JS arbitrário, acesso ao Chrome DevTools Protocol e interceptação de rede.

Desvantagens do Selenium

• Lento e pesado. Iniciar um navegador completo a cada sessão consome muita CPU e RAM. Em grande escala, sai dezenas — e às vezes centenas — de vezes mais caro em recursos do que uma requisição HTTP.
• Escala mal «na marra». Para processar milhares de páginas em paralelo são necessários o Selenium Grid, um pool de contêineres ou a nuvem — toda uma infraestrutura à parte.
• Fragilidade. O scraper depende da estrutura da página e dos tempos de carregamento. Se o layout muda ou os atrasos se desajustam, são necessárias esperas explícitas (WebDriverWait); caso contrário, tudo quebra.
• Mais difícil de operar. As versões do navegador e do driver precisam coincidir (o Selenium Manager alivia parte do problema, mas não todo) e executar o navegador no Docker exige uma configuração cuidadosa.
• E, sobretudo, é detectado com facilidade. A isso dedicamos a próxima seção.

Por que ele é detectado com facilidade

Este é, talvez, o problema prático mais importante. Os sistemas anti-bot modernos (Cloudflare, DataDome, Imperva/Incapsula, PerimeterX e outros) sabem reconhecer um navegador automatizado por uma infinidade de indícios. E, «de fábrica», o Selenium deixa dezenas dessas marcas.

Os principais indícios que denunciam o Selenium

1. A flag navigator.webdriver. O marcador mais conhecido. Ao iniciar via WebDriver, o navegador define navigator.webdriver = true. Em um usuário comum essa propriedade é false ou undefined. Basta uma linha de JavaScript do lado do site para marcar a visita como de bot.

2. As variáveis $cdc_ e $wdc_. O ChromeDriver injeta no documento variáveis internas (por exemplo, as que começam com $cdc_). O detector simplesmente procura sua presença no objeto document/window — e as encontra.

3. Rastros do Chrome DevTools Protocol (CDP). O Selenium se comunica com o Chrome via CDP. A ativação do domínio Runtime (Runtime.Enable) é detectada separadamente — é a chamada «detecção de segunda geração», e a maioria das bibliotecas anti-detecção simples não a encobre.

4. Incoerências no navigator. Se o User-Agent é falsificado para simular um iPhone, mas navigator.platform continua sendo Win32, o número de núcleos (hardwareConcurrency) é atípico para o dispositivo declarado e a lista de plugins e idiomas parece «estéril», o antifraude detecta a incoerência lógica no ato.

5. Assinaturas dos próprios comandos do WebDriver. As chamadas execute_script/execute_async_script deixam rastros reconhecíveis na pilha de chamadas do JS, pelos quais também é possível identificar a automação.

6. Indícios comportamentais e de rede. Uma velocidade perfeitamente uniforme, a ausência de movimentos do mouse, um histórico e cookies zerados, além de uma impressão digital TLS (JA3/JA4) e uma ordem de cabeçalhos diferentes das de um navegador real. É a «terceira geração» de detecção.

As «gerações» de detecção: para saber o que você enfrenta

Convém ter em mente esta gradação:

• Geração 1 — verificações no nível da API. navigator.webdriver, as variáveis $cdc_ e similares. São encobertas com bibliotecas anti-detecção.
• Geração 2 — detecção no nível do protocolo CDP. Por exemplo, a vigilância do Runtime.Enable. A maioria dos patches populares já não resolve isso.
• Geração 3 — fingerprinting TLS, análise de comportamento e modelos de ML sob medida para cada cliente. Não se resolve com patches do lado do cliente — aqui são necessários proxies, rotação, imitação de comportamento e impressões digitais de qualidade.

Ferramentas para «esconder» o Selenium

Eliminar a detecção por completo é impossível, mas dá para reduzir a probabilidade de bloqueio. O mais habitual é usar:

• undetected-chromedriver (Python) — aplica patch no binário do driver (remove a string cdc_), oculta o navigator.webdriver e ajusta as opções. Por muito tempo foi considerado o «padrão-ouro», mas cobre sobretudo os problemas de primeira geração.
• selenium-stealth (Python) — um conjunto de patches JS: falsifica navigator.webdriver, plugins, languages, o fornecedor de WebGL etc. Tem uma manutenção mais fraca que o UC.
• SeleniumBase UC Mode — acrescenta a técnica de disconnect/reconnect: nas ações sensíveis desconecta temporariamente o ChromeDriver do navegador e contorna parte da detecção por CDP.
• nodriver — o sucessor do undetected-chromedriver, do mesmo autor. Funciona diretamente via CDP, sem chromedriver nem a camada do WebDriver, o que elimina uma série de marcadores. Já não é bem «Selenium», e sim uma abordagem à parte.
• Técnicas manuais — a flag --disable-blink-features=AutomationControlled, desativar enable-automation, falsificar navigator.webdriver via Page.addScriptToEvaluateOnNewDocument e fazer o User-Agent condizer com as propriedades reais do navigator.

Você pode verificar até que ponto o seu navegador está bem «escondido» em bancadas de teste públicas como bot.sannysoft.com ou em serviços de fingerprinting.

Um aviso importante

Todas essas bibliotecas não são bala de prata. As empresas anti-bot estudam as evasões de código aberto: quais patches exatamente o undetected-chromedriver aplica se vê diretamente no repositório dele. O que hoje contorna uma proteção pode parar de funcionar após a próxima atualização — sem aviso prévio. Por isso, para o scraping sério quase sempre se acrescentam ao Selenium proxies de qualidade com rotação, atrasos razoáveis, perfis «aquecidos» com cookies e imitação do comportamento humano. E, mesmo assim, diante da proteção de terceira geração, o Selenium sozinho costuma ficar devendo.

Quando convém usar o Selenium e quando não

O Selenium se justifica quando:

• o site é construído inteiramente com JavaScript e sem navegador não há como obter o conteúdo;
• é preciso imitar um fluxo de usuário complexo (login, formulários de várias etapas, rolagem infinita);
• os volumes são moderados, e não de milhões de páginas por hora;
• você já conta com um stack em Java/C#/Python e prefere permanecer nele.

Convém procurar uma alternativa quando:

• os dados estão disponíveis via HTTP/API normal — nesse caso, requests/Scrapy/httpx serão várias vezes mais rápidos e baratos;
• é necessário o máximo de escala e velocidade;
• o objetivo é contornar uma proteção anti-bot séria: aqui costumam ganhar o Playwright ou o Puppeteer (mais modernos, com melhor controle do navegador e plugins stealth práticos) e, às vezes, o nodriver ou APIs especializadas.

Conclusão

O Selenium é uma ferramenta poderosa e versátil: funciona com sites dinâmicos, suporta uma infinidade de linguagens e navegadores e conta com uma comunidade enorme e uma documentação excelente. Tudo isso o torna uma boa opção para o scraping de páginas JS complexas e de fluxos que imitam um usuário real.

Mas ele cobra dois pedágios sérios: o consumo de recursos (e, com ele, os problemas de velocidade e escala) e a facilidade com que é detectado. «De fábrica», o Selenium deixa dezenas de marcas de automação e, embora seja possível camuflá-las em parte, diante da proteção anti-bot moderna isso muitas vezes não basta.

A conclusão prática é simples: se os dados podem ser obtidos com uma requisição HTTP, use um scraper HTTP. Se não há como sem navegador, o Selenium cairá como uma luva, mas preveja no projeto proxies, rotação, comportamento humano e anti-detecção; e, para os alvos mais protegidos, compare-o com honestidade com o Playwright, o Puppeteer e as soluções mais novas.