---
title: "Guia para Scraping de dados com SeleniumBase em 2026"
slug: web-scraping-with-seleniumbase
date: 2026-02-17T09:14:55+00:00
modified: 2026-02-17T09:14:58+00:00
permalink: https://brightdata.com.br/blog/dados-do-site/web-scraping-with-seleniumbase
type: blog
---
[ Blog ](https://brightdata.com.br/blog "Blog") / [Dados do site](https://brightdata.com.br/blog/dados-do-site)
[Dados do site](https://brightdata.com.br/blog/dados-do-site)
# Guia para Scraping de dados com SeleniumBase em 2026
Simplifique o Scraping de dados da web com o SeleniumBase usando seus recursos avançados e guia passo a passo.
24 min de leitura
[  ](https://brightdata.com/blog/authors/antonello-zanini)
[Antonello Zanini
Technical Writer
](https://brightdata.com/blog/authors/antonello-zanini)
Neste guia, você aprenderá:
- O que é o SeleniumBase e por que ele é útil para Scraping de dados
- Como ele se compara ao Selenium básico
- Os recursos e benefícios que o SeleniumBase oferece
- Como usá-lo para criar um Scraper simples
- Como utilizá-lo para casos de uso mais complexos
Vamos começar!
## O que é o SeleniumBase?
[O SeleniumBase](https://seleniumbase.com/) é uma estrutura Python para automação de navegadores. Construído sobre as APIs Selenium/WebDriver, ele fornece um kit de ferramentas de nível profissional para automação da web. Ele suporta uma ampla gama de tarefas, desde testes até scraping de dados.
O SeleniumBase é uma biblioteca completa para testar páginas da web, automatizar fluxos de trabalho e dimensionar operações baseadas na web. Ele vem equipado com recursos avançados, como bypass de CAPTCHA, prevenção de detecção de bots e ferramentas para aumentar a produtividade.
## SeleniumBase vs Selenium: comparação de recursos e APIs
Para entender melhor o *motivo* por trás do SeleniumBase, faz sentido compará-lo diretamente com a versão básica do Selenium — a ferramenta na qual ele se baseia.
Para uma comparação rápida entre Selenium e SeleniumBase, consulte a tabela resumida abaixo:
**Recurso****SeleniumBase****Selenium****Executores de teste integrados**Integra-se com `pytest`, `pynose` e `behave`Requer configuração manual para integração de testes**Gerenciamento de drivers**Baixa automaticamente o driver do navegador compatível com a versão do navegadorRequer download e configuração manual do driver**Lógica de automação da Web**Combina várias etapas em uma única chamada de métodoRequer várias linhas de código para funcionalidades semelhantes**Manipulação de seletores**Detecta automaticamente seletores CSS ou XPathRequer a definição explícita dos tipos de seletores nas chamadas de método**Manipulação de tempo limite**Aplica tempos limite padrão para evitar falhasOs métodos falham imediatamente se os tempos limite não forem definidos explicitamente**Saídas de erro**Fornece mensagens de erro claras e legíveis para facilitar a depuraçãoGera logs de erros detalhados e menos interpretáveis**Painéis e relatórios**Inclui painéis, relatórios e capturas de tela de falhas integradosSem painéis integrados ou recursos de relatórios**Aplicativos GUI para desktop**Oferece ferramentas visuais para execução de testesNão possui ferramentas GUI para desktop para execução de testes**Gravador de testes**Gravador de testes integrado para criar scripts a partir de ações manuais do navegadorRequer a escrita manual de scripts**Gerenciamento de casos de teste**Fornece CasePlans para organizar testes e documentar etapas diretamente na estruturaSem ferramentas integradas de gerenciamento de casos de teste**Suporte a aplicativos de dados**Inclui o ChartMaker para gerar JavaScript a partir do Python para criar aplicativos de dadosSem ferramentas adicionais para a criação de aplicativos de dadosÉ hora de explorar as diferenças!
### Executores de teste integrados
O SeleniumBase se integra a executores de teste populares, como `pytest`, `pynose` e `behave`. Essas ferramentas fornecem uma estrutura organizada, descoberta de testes contínua, execução, rastreamento do status dos testes (por exemplo, aprovado, reprovado ou ignorado) e opções de linha de comando para personalizar configurações, como a seleção do navegador.
Com o Selenium básico, você precisaria implementar manualmente um analisador de opções ou contar com ferramentas de terceiros para configurar testes a partir da linha de comando.
### Gerenciamento aprimorado de drivers
Por padrão, o SeleniumBase baixa uma versão de driver compatível que corresponde à versão principal do seu navegador. Você pode substituir isso usando a opção `--driver-version=VER` no seu comando `pytest`. Por exemplo:
```none
pytest my_script.py --driver-version=114
```
Em vez disso, o Selenium exige que você baixe e configure manualmente o driver apropriado. Nesse caso, você é responsável por garantir a compatibilidade com a versão do navegador.
### Métodos de múltiplas ações
O SeleniumBase combina várias etapas em métodos únicos para simplificar a automação da web. Por exemplo, o método `driver.type(selector, text)` executa o seguinte:
1. Aguarda até que o elemento fique visível
2. Aguarda até que o elemento esteja interativo
3. Limpa qualquer texto existente
4. Digita o texto fornecido
5. Envia se o texto terminar com ` “n”`
Com o Selenium bruto, replicar a mesma lógica exigiria algumas linhas de código.
### Manipulação simplificada do seletor
O SeleniumBase pode diferenciar automaticamente entre [seletores CSS e expressões XPath](/blog/web-data/xpath-vs-css-selectors). Isso elimina a necessidade de especificar explicitamente os tipos de seletor com `By.CSS_SELECTOR` ou `By.XPATH`. No entanto, você ainda pode fornecer o tipo explicitamente, se preferir.
Exemplo com SeleniumBase:
```none
driver.click("button.submit") # Detecta automaticamente como seletor CSS
driver.click("//button[@class='submit']") # Detecta automaticamente como XPath
```
O código equivalente do Selenium básico é:
```none
driver.find_element(By.CSS_SELECTOR, "button.submit").click()
driver.find_element(By.XPATH, "//button[@class='submit']").click()
```
### Valores padrão e personalizados de tempo limite
O SeleniumBase aplica automaticamente um tempo limite padrão de 10 segundos aos métodos, garantindo que os elementos tenham tempo para carregar. Isso evita falhas imediatas, que são comuns no Selenium bruto.
Você também pode definir valores de tempo limite personalizados diretamente nas chamadas de método, como no exemplo abaixo:
```none
driver.click("button", timeout=20)
```
O código Selenium equivalente seria muito mais detalhado e complexo:
```none
WebDriverWait(driver, 20).until(EC.element_to_be_clickable((By.CSS_SELECTOR, "button"))).click()
```
### Saídas de erro claras
O SeleniumBase fornece mensagens de erro claras e fáceis de ler quando os scripts falham. O Selenium bruto, por outro lado, geralmente gera logs de erros verbosos e menos interpretáveis, exigindo esforço adicional para depurar.
### Painéis, relatórios e capturas de tela
O SeleniumBase inclui recursos para gerar painéis e relatórios para execuções de teste. Ele também salva capturas de tela de falhas na pasta `./latest_logs/` para facilitar a depuração. O Selenium bruto não possui esses recursos prontos para uso.
### Recursos extras
Em comparação com o Selenium, o SeleniumBase inclui:
- Aplicativos GUI para desktop para executar testes visualmente, como [o SeleniumBase Commander](https://github.com/seleniumbase/SeleniumBase/blob/master/help_docs/commander.md) para `pytest` e [o SeleniumBase Behave GUI](https://github.com/seleniumbase/SeleniumBase/blob/master/examples/behave_bdd/ReadMe.md) para `behave`.
- Um [gravador/gerador de testes](https://github.com/seleniumbase/SeleniumBase/blob/master/help_docs/recorder_mode.md) integrado para criar scripts de teste com base em ações manuais do navegador. Isso reduz significativamente o esforço necessário para escrever testes para fluxos de trabalho complexos.
- Software de gerenciamento de casos de teste chamado [CasePlans](https://github.com/seleniumbase/SeleniumBase/blob/master/help_docs/case_plans.md) para organizar testes e documentar descrições de etapas diretamente dentro da estrutura.
- Ferramentas como [o ChartMaker](https://github.com/seleniumbase/SeleniumBase/blob/master/examples/chart_maker/ReadMe.md) para criar aplicativos de dados gerando código JavaScript a partir do Python. Isso o torna uma solução versátil além da automação de testes padrão.
## SeleniumBase: Recursos, métodos e opções de CLI
Veja o que torna o SeleniumBase especial, explorando seus recursos e API.
### Recursos
Esta é uma lista de alguns dos recursos mais relevantes do SleniumBase:
- Inclui o Modo Gravador para gerar instantaneamente testes de navegador em Python.
- Suporta vários navegadores, guias, iframes e Proxies dentro do mesmo teste.
- Possui software de gerenciamento de casos de teste com tecnologia Markdown.
- O mecanismo de espera inteligente melhora automaticamente a confiabilidade e reduz os testes instáveis.
- Compatível com `pytest`, `unittest`, `nose` e `behave` para descoberta e execução de testes.
- Inclui ferramentas avançadas de registro para painéis, relatórios e capturas de tela.
- Pode executar testes no modo Headless para ocultar a interface do navegador.
- Suporta execução de testes multithread em navegadores paralelos.
- Permite que os testes sejam executados usando o emulador de dispositivo móvel do Chromium.
- Suporta a execução de testes através de um Proxy, mesmo que seja autenticado.
- Personaliza a string do agente do usuário do navegador para testes.
- Impede a detecção por sites que bloqueiam a automação do Selenium.
- Integra-se ao selenium-wire para inspecionar solicitações de rede do navegador.
- Interface de linha de comando flexível para opções personalizadas de execução de testes.
- Arquivo de configuração global para gerenciar as configurações de teste.
- Suporta integrações com GitHub Actions, Google Cloud, Azure, S3 e Docker.
- Suporta a execução de JavaScript a partir do Python.
- Pode interagir com elementos Shadow DOM usando `::shadow` em seletores CSS.
Para[ver](https://github.com/seleniumbase/SeleniumBase/blob/master/help_docs/features_list.md) a lista completa,[consulte a documentação](https://github.com/seleniumbase/SeleniumBase/blob/master/help_docs/features_list.md). Não deixe de ler nosso blog sobre como usar [o SeleniumBase com Proxies](/blog/proxy-101/seleniumbase-with-proxies).
### Métodos
Abaixo está uma lista dos métodos mais úteis do SeleniumBase:
- `driver.open(url)`: Navegue pela janela do navegador até o URL especificado.
- `driver.go_back()`: Navegue de volta para a URL anterior.
- `driver.type(selector, text)`: Atualiza o campo identificado pelo seletor com o texto especificado.
- `driver.click(seletor)`: clica no elemento identificado pelo seletor.
- `driver.click_link(link_text)`: clica no link que contém o texto especificado.
- `driver.select_option_by_text(dropdown_selector, option)`: Seleciona uma opção de um menu suspenso pelo texto visível.
- `driver.hover_and_click(seletor de foco, seletor de clique)`: Passe o mouse sobre um elemento e clique em outro.
- `driver.drag_and_drop(seletor_arrastar, seletor_soltar)`: Arraste um elemento e solte-o em outro elemento.
- `driver.get_text(selector)`: Obtenha o texto do elemento especificado.
- `driver.get_attribute(seletor, atributo)`: Obter o atributo especificado de um elemento.
- `driver.get_current_url()`: Obter a URL da página atual.
- `driver.get_page_source()`: Obter a fonte HTML da página atual.
- `driver.get_title()`: Obter o título da página atual.
- `driver.switch_to_frame(frame)`: Muda para o contêiner iframe especificado.
- `driver.switch_to_default_content()`: Sai do contêiner iframe e retorna ao documento principal.
- `driver.open_new_window()`: Abre uma nova janela do navegador na mesma sessão.
- `driver.switch_to_window(window)`: Alterna para a janela do navegador especificada.
- `driver.switch_to_default_window()`: Retorna à janela original do navegador.
- `driver.get_new_driver(OPTIONS)`: Abre uma nova sessão do driver com as opções especificadas.
- `driver.switch_to_driver(driver)`: Alterna para o driver do navegador especificado.
- `driver.switch_to_default_driver()`: Retorna ao driver original do navegador.
- `driver.wait_for_element(seletor)`: Aguarda até que o elemento especificado fique visível.
- `driver.is_element_visible(seletor)`: Verifica se o elemento especificado está visível.
- `driver.is_text_visible(texto, seletor)`: Verifica se o texto especificado está visível dentro de um elemento.
- `driver.sleep(segundos)`: Pausa a execução pelo tempo especificado.
- `driver.save_screenshot(name)`: Salva uma captura de tela no formato `.png` com o nome fornecido.
- `driver.assert_element(seletor)`: Verifica se o elemento especificado está visível.
- `driver.assert_text(texto, seletor)`: Verifica se o texto especificado está presente no elemento.
- `driver.assert_exact_text(texto, seletor)`: Verifica se o texto especificado corresponde exatamente ao elemento.
- `driver.assert_title(title)`: Verifica se o título da página atual corresponde ao título especificado.
- `driver.assert_downloaded_file(arquivo)`: Verifica se o arquivo especificado foi baixado.
- `driver.assert_no_404_errors()`: Verifica se não há links quebrados na página.
- `driver.assert_no_js_errors()`: Verifica se não há erros de JavaScript na página.
Para obter a lista completa, [explore a documentação](https://github.com/seleniumbase/SeleniumBase/blob/master/help_docs/method_summary.md).
### Opções da CLI
O SeleniumBase estende `o pytest` com as seguintes opções de linha de comando:
- `--browser=BROWSER`: Define o navegador da web (padrão: “chrome”).
- `--chrome`: Atalho para `--browser=chrome`.
- `--edge`: atalho para `--browser=edge`.
- `--firefox`: Atalho para `--browser=firefox`.
- `--safari`: atalho para `--browser=safari`.
- `--settings-file=FILE`: Substitui as configurações padrão do SeleniumBase.
- `--env=ENV`: Define o ambiente de teste, acessível via `driver.env`.
- `--account=STR`: Define a conta, acessível via `driver.account`.
- `--data=STRING`: Dados de teste extras, acessíveis via `driver.data`.
- `--var1=STRING`: Dados de teste extras, acessíveis via `driver.var1`.
- `--var2=STRING`: Dados de teste extras, acessíveis via `driver.var2`.
- `--var3=STRING`: Dados de teste extras, acessíveis através de `driver.var3`.
- `--variáveis=DICT`: Dados de teste extras, acessíveis via `driver.variáveis`.
- `--proxy=SERVIDOR:PORTA`: Conecta-se a um servidor Proxy.
- `--proxy=USERNAME:PASSWORD@SERVER:PORT`: Usar um Proxy autenticado.
- `--proxy-bypass-list=STRING`: Hosts a serem ignorados (por exemplo, “\*.foo.com”).
- `--proxy-pac-url=URL`: Conecta-se via URL PAC.
- `--proxy-pac-url=USERNAME:PASSWORD@URL`: Proxy autenticado com URL PAC.
- `--proxy-driver`: Use Proxy para download do driver.
- `--multi-proxy`: Permita vários proxies autenticados em multithreading.
- `--agent=STRING`: Modifique a string do agente do usuário do navegador.
- `--mobile`: habilitar emulador de dispositivo móvel.
- `--metrics=STRING`: Define métricas móveis (por exemplo, “CSSWidth,CSSHeight,PixelRatio”).
- `--chromium-arg="ARG=N,ARG2"`: Define argumentos do Chromium.
- `--firefox-arg="ARG=N,ARG2"`: Define argumentos do Firefox.
- `--firefox-pref=SET`: Define as preferências do Firefox.
- `--extension-zip=ZIP`: Carregar arquivos `.``zip/.crx` da extensão do Chrome.
- `--extension-dir=DIR`: Carregar diretórios de extensões do Chrome.
- `--disable-features="F1,F2"`: Desativar recursos.
- `--binary-location=PATH`: Define o caminho binário do Chromium.
- `--driver-version=VER`: Define a versão do driver.
- `--headless`: Modo headless padrão.
- `--headless1`: Utilizar o modo headless antigo do Chrome.
- `--headless2`: usa o novo modo headless do Chrome.
- `--headed`: Ativar o modo GUI no Linux.
- `--xvfb`: Executa testes com o Xvfb no Linux.
- `--locale=LOCALE_CODE`: Define a localidade do idioma do navegador.
- `--reuse-session`: Reutiliza a sessão do navegador para todos os testes.
- `--reuse-class-session`: Reutilize a sessão para testes de classe.
- `--crumbs`: excluir cookies entre sessões reutilizadas.
- `--disable-cookies`: Desative os cookies.
- `--disable-js`: Desativa o JavaScript.
- `--disable-csp`: Desativar a Política de Segurança de Conteúdo.
- `--disable-ws`: Desativar a segurança da Web.
- `--enable-ws`: Ativar a Segurança da Web.
- `--log-cdp`: Registra eventos do Chrome DevTools Protocol (CDP).
- `--remote-debug`: Sincronizar com o Chrome Remote Debugger.
- `--visual-baseline`: Define a linha de base visual para testes de layout.
- `--timeout-multiplier=MULTIPLIER`: Multiplicar os valores padrão de tempo limite.
Veja a lista completa de definições de opções de linha de comando [na documentação](https://github.com/seleniumbase/SeleniumBase/blob/master/seleniumbase/plugins/pytest_plugin.py).
## Usando o SeleniumBase para Scraping de dados: guia passo a passo
Siga este tutorial passo a passo para aprender a criar um Scraper SeleniumBase para recuperar dados da sandbox [Quotes to Scrape](https://quotes.toscrape.com/):
Para um tutorial semelhante usando o Selenium básico, consulte nosso guia sobre [Scraping de dados com Selenium](/blog/how-tos/using-selenium-for-web-scraping).
### Etapa 1: Inicialização do projeto
Antes de começar, certifique-se de que o Python 3 esteja instalado em sua máquina. Caso contrário, [baixe-o](https://www.python.org/downloads/) e instale-o.
Abra o terminal e execute o comando abaixo para criar um diretório para o seu projeto:
```none
mkdir seleniumbase-Scraper
```
`seleniumbase-scraper` conterá seu Scraper SeleniumBase.
Navegue dentro dele e inicialize um [ambiente virtual](https://docs.python.org/3/library/venv.html) dentro dele:
```none
cd seleniumbase-Scraper
python -m venv env
```
Em seguida, carregue a pasta do projeto em seu IDE Python favorito. [O Visual Studio Code com a extensão Python](https://code.visualstudio.com/docs/languages/python) ou [o PyCharm Community Edition](https://www.jetbrains.com/pycharm/download/#section=windows) são opções adequadas.
Crie um arquivo `scraper.py` no diretório do projeto, que agora deve conter esta estrutura de arquivos:
`O Scraper.py` logo conterá sua lógica de raspagem.
Ative o ambiente virtual no terminal do IDE. No Linux ou macOS, faça isso com o comando abaixo:
```none
./env/bin/activate
```
De forma equivalente, no Windows, execute:
```none
env/Scripts/activate
```
No ambiente ativado, execute este comando para [instalar o SeleniumBase](https://pypi.org/project/seleniumbase/):
```none
pip install seleniumbase
```
Ótimo! Você tem um ambiente Python para o Scraping de dados da web com o SeleniumBase.
### Etapa 2: Configuração do teste do SeleniumBase
Embora o SeleniumBase suporte a sintaxe `pytest` para a criação de testes, um [bot de Scraping de dados](/blog/how-tos/what-is-a-scraping-bot) não é um script de teste. Você ainda pode aproveitar todas as opções de extensão de linha de comando `pytest` do SeleniumBase usando a [sintaxe`SB`](https://github.com/seleniumbase/SeleniumBase/blob/master/help_docs/syntax_formats.md#-21-seleniumbase-sb-python-context-manager):
```none
from seleniumbase import SB
with SB() as sb:
pass
# Lógica de scraping...
```
Agora você pode executar seu teste com:
```none
python3 Scraper.py
```
**Observação**: no Windows, substitua `python3` por `python`.
Para executá-lo no modo headless, execute:
```none
python3 Scraper.py --headless
```
Lembre-se de que você pode combinar várias opções de linha de comando.
### Etapa 3: Conecte-se à página de destino
Use o método `open()` para instruir o navegador controlado a visitar sua página de destino:
```none
sb.open("https://quotes.toscrape.com/")
```
Se você executar o script de teste de scraping no modo headed, isso é o que você verá por uma fração de segundo:
Observe que, em comparação com o Selenium básico, você não precisa fechar manualmente o driver. O SeleniumBase cuidará disso para você.
### Passo 4: Selecione os elementos de cotação
Abra a página de destino no modo de navegação anônima do seu navegador e inspecione um elemento de citação:
Como a página contém várias citações, crie uma matriz `de citações` para armazenar os dados extraídos:
```none
citações = []
```
Na seção DevTools acima, você pode ver que todas as citações podem ser selecionadas usando o seletor CSS `.quote`. Use `find_elements()` para selecionar todas elas:
```none
quote_elements = sb.find_elements(".quote")
```
Em seguida, prepare-se para iterar sobre os elementos e coletar dados de cada elemento de citação. Adicione os dados coletados a uma matriz:
```none
para quote_element em quote_elements:
# Lógica de extração...
```
Ótimo! A lógica de extração de alto nível agora está pronta.
### Etapa 5: extrair dados das citações
Inspecione um único elemento de citação:
Observe que você pode extrair:
- O texto da citação de `.text`
- O autor da citação de `.author`
- As tags da citação de `.tag`
Selecione cada nó e extraia os dados deles com o atributo `de texto`:
```none
text_element = quote_element.find_element(By.CSS_SELECTOR, ".text")
text = text_element.text.replace("“", "").replace("”", "")
elemento_autor = quote_element.find_element(By.CSS_SELECTOR, ".author")
autor = elemento_autor.text
tags = []
elementos_tag = quote_element.find_elements(By.CSS_SELECTOR, ".tag")
para elemento_tag em elementos_tag:
tag = elemento_tag.text
tags.append(tag)
```
Observe que `find_elements()` retorna objetos Selenium `WebElement` básicos. Portanto, para selecionar elementos dentro deles, você deve usar os métodos nativos do Selenium. É por isso que você deve especificar `By.CSS_SELECTOR` como localizador.
Certifique-se de importar `By` no início do seu script:
```none
from selenium.webdriver.common.by import By
```
Observe como a extração das tags requer um loop, pois uma única citação pode ter uma ou mais tags. Além disso, observe o uso do método `replace()` para remover as aspas duplas especiais que envolvem o texto.
### Etapa 6: Preencha a matriz de citações
Preencha um novo objeto `quotes` com os dados extraídos e adicione-o a `quotes`:
```none
quote = {
"text": text,
"author": author,
"tags": tags
}
quotes.append(quote)
```
Incrível! A lógica de extração do SelenumBase está completa.
### Etapa 7: Implemente a lógica de rastreamento
Lembre-se de que o site de destino contém várias páginas. Para navegar para a próxima página, clique no botão “Próximo →” na parte inferior:
Na última página, esse botão não estará presente.
Para implementar [o rastreamento da web](/blog/leadership/web-crawling-vs-web-scraping) e extrair todas as páginas, envolva sua lógica de extração em um loop que clica no botão “Próximo →” e para quando o botão não estiver mais disponível:
```none
while sb.is_element_present(".next"):
# Lógica de scraping...
# Visite a próxima página
sb.click(".next a")
```
Observe o uso do método especial SleniumBae `is_element_present()` para verificar se o botão está presente ou não.
Perfeito! Seu scraper SeleniumBase agora percorrerá todo o site.
### Etapa 8: Exportar os dados coletados
Exporte os dados coletados em `quotes` para um arquivo CSV da seguinte maneira:
```none
com open("quotes.csv", mode="w", newline="", encoding="utf-8") como arquivo:
writer = csv.DictWriter(arquivo, fieldnames=["texto", "autor", "tags"])
writer.writeheader()
# Achate os objetos de citação para gravação em CSV
for quote in quotes:
writer.writerow({
"text": quote["text"],
"author": quote["author"],
"tags": ";".join(quote["tags"])
})
```
Não se esqueça de importar [`csv`](https://docs.python.org/3/library/csv.html) da biblioteca padrão do Python:
```none
import csv
```
### Etapa 9: Junte tudo
Seu arquivo `script.py` agora deve conter o seguinte código:
```none
from seleniumbase import SB
from selenium.webdriver.common.by import By
import csv
with SB() as sb:
# Conecte-se à página de destino
sb.open("https://quotes.toscrape.com/")
# Onde armazenar os dados coletados
quotes = []
# Iterar sobre todas as páginas de citações
enquanto sb.is_element_present(".next"):
# Selecionar todos os elementos de citação na página
quote_elements = sb.find_elements(".quote")
# Iterar sobre eles e coletar dados para cada elemento de citação
para quote_element em quote_elements:
# Lógica de extração de dados
elemento_texto = elemento_citação.find_element(By.CSS_SELECTOR, ".text")
texto = elemento_texto.text.replace("“", "").replace("”", "")
elemento_autor = elemento_citação.find_element(By.CSS_SELECTOR, ".author")
autor = elemento_autor.text
tags = []
tag_elements = quote_element.find_elements(By.CSS_SELECTOR, ".tag")
para tag_element em tag_elements:
tag = tag_element.text
tags.append(tag)
# Preencha um novo objeto de citação com os dados coletados
quote = {
"text": text,
"author": author,
"tags": tags
}
# Adicione-o à lista de citações coletadas
quotes.append(quote)
# Visite a próxima página
sb.click(".next a")
# Exportar os dados coletados para CSV
com open("quotes.csv", modo="w", nova linha="", codificação="utf-8") como arquivo:
writer = csv.DictWriter(arquivo, nomes de campos=["texto", "autor", "tags"])
writer.writeheader()
# Achate os objetos de citação para gravação em CSV
para citação em citações:
writer.writerow({
"text": citação["text"],
"author": citação["author"],
"tags": ";".join(citação["tags"])
})
```
Execute o Scraper SeleniumBase no modo headless com:
```none
python3 script.py --headless
```
Após alguns segundos, um arquivo `quotes.csv` aparecerá na pasta do projeto.
Abra-o e você verá:
Et voilà! Seu script de Scraping de dados da web SeleniumBase funciona perfeitamente.
## Casos de uso avançados de raspagem com SeleniumBase
Agora que você já conhece os fundamentos do SeleniumBase, está pronto para explorar alguns cenários mais complexos.
### Automatizar o preenchimento e envio de formulários
**Observação: a Bright Data não faz scraping atrás do login.**
O SeleniumBase também permite que você interaja com elementos em uma página como um usuário humano faria. Por exemplo, suponha que você precise interagir com um formulário de login como mostrado abaixo:
Seu objetivo é preencher os campos “Nome de usuário” e “Senha” e, em seguida, enviar o formulário clicando no botão “Login”. Você pode fazer isso com um teste do SeleniumBase da seguinte maneira:
```none
# login.py
from seleniumbase import BaseCase
BaseCase.main(__name__, __file__)
class LoginTest(BaseCase):
def test_submit_login_form(self):
# Visite a página de destino
self.open("https://quotes.toscrape.com/login")
# Preencha o formulário
self.type("#username", "test")
self.type("#password", "test")
# Envie o formulário
self.click("input[type="submit"]")
# Verifique se você está na página certa
self.assert_text("Top Ten tags")
```
Este exemplo é ótimo para criar um teste, portanto, observe o uso da classe `BaseCase`. Isso permite que você crie testes `pytest`.
Execute o teste com este comando:
```none
pytest login.py
```
Você verá o navegador abrir, carregar a página de login, preencher o formulário, enviá-lo e, em seguida, verificar se o texto fornecido aparece na página.
A saída no terminal será semelhante a esta:
```none
login.py . [100%]
======================================== 1 aprovado em 11,20 s =========================================
```
### Contornar tecnologias simples anti-bot
Muitos sites implementam [medidas](/blog/web-data/anti-scraping-techniques) avançadas [anti-scraping](/blog/web-data/anti-scraping-techniques) para impedir que bots acessem seus dados. Essas técnicas incluem desafios CAPTCHA, limites de taxa, impressão digital do navegador e outras. Para fazer scraping de sites de forma eficaz sem ser bloqueado, você precisa contornar essas proteções.
O SeleniumBase oferece um recurso especial chamado Modo UC ([Modo Undetected-Chromedriver](https://github.com/seleniumbase/SeleniumBase/blob/master/help_docs/uc_mode.md)), que ajuda os bots de scraping a parecerem mais com usuários humanos. Isso permite que eles evitem a detecção por serviços anti-bot, que poderiam bloquear o bot de scraping diretamente ou acionar CAPTCHAs.
O Modo UC é baseado no [`undetected-chromedriver`](https://github.com/ultrafunkamsterdam/undetected-chromedriver) e vem com várias atualizações, correções e melhorias, tais como:
- Rotação automática do User-Agent para evitar a detecção.
- Configuração automática dos argumentos do Chromium conforme necessário.
- Métodos especiais `uc_*()` para contornar CAPTCHAs.
Agora, vamos ver como usar o Modo UC no SeleniumBase para contornar os desafios anti-bot.
Para esta demonstração, você verá como acessar a página anti-bot do [site Scraping Course](https://www.scrapingcourse.com/antibot-challenge):
Para contornar as medidas anti-bot e lidar com o CAPTCHA, habilite o Modo UC e use os métodos `uc_open_with_reconnect()` e `uc_gui_click_captcha()`:
```none
from seleniumbase import SB
with SB(uc=True) as sb:
# Página de destino com medidas anti-bot
url = "https://www.scrapingcourse.com/antibot-challenge"
# Abra a URL usando o Modo UC com um tempo de reconexão de 4 segundos para evitar a detecção inicial
sb.uc_open_with_reconnect(url, reconnect_time=4)
# Tentar ignorar o CAPTCHA
sb.uc_gui_click_captcha()
# Capturar uma imagem da página
sb.save_screenshot("screenshot.png")
```
Agora, inicie o script e verifique se ele funciona conforme o esperado. Como `o uc_gui_click_captcha()` requer [o PyAutoGUI](https://pyautogui.readthedocs.io/en/latest/) para funcionar, o SeleniumBase irá instalá-lo para você na primeira execução:
```none
PyAutoGUI necessário! Instalando agora...
```
Você verá o navegador clicar automaticamente na opção “Verificar que você é humano” movendo o mouse. O arquivo `screenshot.png` na pasta do seu projeto mostrará:
Uau! O Cloudflare foi contornado.
### Contornar tecnologias anti-bot complexas
As soluções anti-bot estão se tornando cada vez mais sofisticadas, e o Modo UC pode não ser sempre eficaz. É por isso que o SeleniumBase também oferece um Modo CDP especial ([Modo Chrome DevTools Protocol](https://github.com/seleniumbase/SeleniumBase/blob/master/examples/cdp_mode/ReadMe.md)).
O Modo CDP opera dentro do Modo UC e permite que os bots pareçam mais humanos, controlando o navegador por meio do CDP-Driver. Enquanto o Modo UC normal não pode executar ações do WebDriver quando o `driver` está desconectado do navegador, o CDP-Driver ainda pode interagir com o navegador, superando essa limitação.
O Modo CDP é baseado em [`python-cdp`](https://github.com/HyperionGray/python-chrome-devtools-protocol), [`trio-cdp`](https://github.com/HyperionGray/trio-chrome-devtools-protocol) e [`nodriver`](https://github.com/ultrafunkamsterdam/nodriver). Ele foi projetado para contornar soluções anti-bot avançadas de sites do mundo real, como no exemplo abaixo:
```none
from seleniumbase import SB
with SB(uc=True, test=True) as sb:
# Página de destino com medidas anti-bot avançadas
url = "https://gitlab.com/users/sign_in"
# Visite a página no Modo CDP
sb.activate_cdp_mode(url)
# Lidar com o CAPTCHA
sb.uc_gui_click_captcha()
# Aguardar 2 segundos para que a página seja recarregada e o driver retome o controle
sb.sleep(2)
# Capturar uma imagem da página
sb.save_screenshot("screenshot.png")
```
O resultado será:
Pronto! Agora você é um mestre em scraping com SeleniumBase.
## Conclusão
Neste artigo, você aprendeu sobre o SeleniumBase, os recursos e métodos que ele oferece e como usá-lo para Scraping de dados. Você começou com cenários básicos e depois explorou casos de uso mais complexos.
Embora o modo UC e o modo CDP sejam eficazes para contornar certas medidas anti-bot, eles não são infalíveis.
Os sites ainda podem bloquear seu IP se você fizer muitas solicitações ou desafiá-lo com CAPTCHAs mais complexos que exigem várias ações. Uma solução mais eficaz é usar uma ferramenta de automação de navegador da web como o Selenium em combinação com um navegador dedicado a scraping, baseado em nuvem e altamente escalável, como [o Navegador de scraping da Bright Data](/products/scraping-browser).
O Navegador de scraping é um navegador que funciona com Playwright, Puppeteer, Selenium e outros. Ele alterna automaticamente os IPs de saída a cada solicitação e pode lidar com impressões digitais do navegador, novas tentativas, [resolução de CAPTCHA](/products/web-unlocker/captcha-solver) e muito mais. Esqueça o bloqueio e otimize sua operação de scraping.
Inscreva-se agora e comece seu teste grátis!
Contate-nosTeste grátis
Índice
Dedicated Scraper APIs & No-Code Scrapers
Over 1000 scrapers for all popular domains. Simplify your web scraping.
[See pricing](/pricing/web-scraper "See pricing")
Just want data? Skip scraping.
Hundreds of ready-to-use datasets from all popular domains.
[See pricing](/pricing/datasets "See pricing")
[ ](https://news.ycombinator.com/submitlink?t=Guia+para+Scraping+de+dados+com+SeleniumBase+em+2026&u=https://brightdata.com.br/blog/dados-do-site/web-scraping-with-seleniumbase) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Guia+para+Scraping+de+dados+com+SeleniumBase+em+2026&url=https://brightdata.com.br/blog/dados-do-site/web-scraping-with-seleniumbase) [ ](http://www.reddit.com/submit?title=Guia+para+Scraping+de+dados+com+SeleniumBase+em+2026&url=https://brightdata.com.br/blog/dados-do-site/web-scraping-with-seleniumbase)
## Você também pode estar interessado em
[  ](https://brightdata.com.br/blog/ai/openhuman-with-bright-data "Acesso à Web Pronto para Produção no OpenHuman Através do Bright Data CLI")
[AI
Antonello Zanini
Technical Writer
### Acesso à Web Pronto para Produção no OpenHuman Através do Bright Data CLI
Integre o Bright Data CLI ao OpenHuman para habilitar acesso à web pronto para produção e coleta de dados para agentes de IA.
09-Sep-2026
14 min de leitura
](https://brightdata.com.br/blog/ai/openhuman-with-bright-data)
[  ](https://brightdata.com.br/blog/dados-do-site/multimodal-web-scraping-with-minimax "Scraping de Dados Multimodal com MiniMax")
[Dados do site
Antonello Zanini
Technical Writer
### Scraping de Dados Multimodal com MiniMax
Combine a API Web Unlocker da Bright Data com a visão MiniMax M3 para extrair dados estruturados de imagens e capturas de tela de páginas web.
09-Sep-2026
5 min de leitura
](https://brightdata.com.br/blog/dados-do-site/multimodal-web-scraping-with-minimax)
[  ](https://brightdata.com.br/blog/ai/best-cli-tools-for-codex "As 10 Melhores Ferramentas CLI para Codex em 2026 – Testadas & Classificadas")
[AI
Daniel Shashko
Web Data & AI Expert
### As 10 Melhores Ferramentas CLI para Codex em 2026 – Testadas & Classificadas
As 10 ferramentas CLI que tornam o Codex mais rápido e capaz, começando com o Bright Data CLI para acesso real à web de dentro do sandbox.
06-Sep-2026
24 min de leitura
](https://brightdata.com.br/blog/ai/best-cli-tools-for-codex)