---
title: "Tutorial de Scraping de Dados em HTML"
slug: html-web-scraping
date: 2026-02-22T07:24:25+00:00
modified: 2026-08-26T19:48:01+00:00
permalink: https://brightdata.com.br/blog/procedimentos/html-web-scraping
type: blog
---
[ Blog ](https://brightdata.com.br/blog "Blog") / [procedimentos](https://brightdata.com.br/blog/procedimentos)
[procedimentos](https://brightdata.com.br/blog/procedimentos)
# Tutorial de Scraping de Dados em HTML
Descubra como dominar o scraping de dados em HTML para coletar dados de sites de forma eficiente, ideal para aprimorar seus projetos e estratégias.
17 min de leitura
[  ](https://brightdata.com/blog/authors/naman-bansal)
[Naman Bansal
](https://brightdata.com/blog/authors/naman-bansal)
Se você tem interesse em scraping de dados, entender HTML é fundamental porque todos os sites são construídos com ele. O scraping de dados pode ser usado em diversos cenários e pode ajudar a coletar dados de sites sem APIs, monitorar preços de produtos, criar listas de leads, realizar pesquisas acadêmicas e muito mais.
Neste artigo, você aprenderá os fundamentos do HTML e como extrair, fazer parsing e processar dados usando Python.
Interessado em um guia aprofundado de scraping de dados com Python? [Clique aqui](/blog/how-tos/web-scraping-with-python).
## Como Fazer Scraping de Sites e Extrair HTML
Antes de começar este tutorial, vamos revisar os componentes essenciais do HTML.
### Introdução ao HTML
HTML é uma coleção de tags que informam ao navegador sobre a estrutura e os elementos de um site. Por exemplo, `
Text
` indica ao navegador que o trecho de texto após a tag é um título, e ` link ` identifica um hiperlink.
Um atributo HTML fornece informações adicionais sobre uma tag. Por exemplo, o atributo `href` da tag `` fornece informações sobre a URL da página para a qual o atributo aponta.
[Classes e IDs](https://www.scaler.com/topics/html/class-and-id-in-html/) são atributos essenciais para identificar com precisão elementos em uma página. As classes agrupam elementos semelhantes para estilizá-los de forma consistente com CSS ou manipulá-los uniformemente com JavaScript. As classes são selecionadas usando `.class-name`.
No site W3Schools, os grupos de classes têm esta aparência:
```none
London
London is the capital of England.
Paris
Paris is the capital of France.
Tokyo
Tokyo is the capital of Japan.
```
Você pode ver como cada título e bloco de cidade está envolto por um `div` que tem a mesma classe `city`.
Em contraste, os IDs são únicos para cada elemento (ou seja, dois elementos não podem ter o mesmo ID). Por exemplo, os seguintes H1s têm IDs únicos e podem ser estilizados/manipulados de forma exclusiva:
```none
Hello World!
Lorem Ipsum Dolor
```
A sintaxe para selecionar elementos com IDs é `#id-name`.
Agora que você conhece os fundamentos do HTML, vamos começar o scraping de dados.
## Configure Seu Ambiente de Scraping
Este tutorial utiliza Python, pois oferece diversas bibliotecas de scraping HTML e a linguagem é fácil de aprender. Para verificar se o Python está instalado no seu computador, execute o seguinte comando no PowerShell (Windows) ou no terminal (macOS):
```none
python3
```
Se o Python estiver instalado, você verá o número da versão; caso contrário, receberá um erro. Vá em frente e [instale o Python](https://www.python.org/downloads/) se ainda não o tiver.
Em seguida, crie uma pasta chamada `WebScraper` e crie um arquivo dentro dela chamado `scraper.py`. Depois, abra-o no ambiente de desenvolvimento integrado (IDE) de sua preferência. [Visual Studio Code](https://code.visualstudio.com/) é utilizado aqui:
Um IDE é uma aplicação multifuncional que permite aos programadores escrever código, depurá-lo, testar programas, criar automações e muito mais. Você o usará aqui para codificar seu scraper HTML.
Em seguida, você precisa separar sua instalação global do Python do seu projeto de scraping criando um ambiente virtual. Isso ajuda a evitar conflitos de dependências e mantém toda a aplicação organizada.
Para isso, instale a biblioteca `virtualenv` usando o seguinte comando:
```none
pip3 install virtualenv
```
Navegue até a pasta do seu projeto:
```none
cd WebScraper
```
Em seguida, crie um ambiente virtual:
```none
python -m venv
```
Este comando cria uma pasta para todos os pacotes e scripts dentro da pasta do seu projeto:
Agora, você precisa ativar o ambiente virtual usando um dos seguintes comandos (de acordo com sua plataforma):
```none
source /bin/activate #In MacOS and Linux
/Scripts/activate.bat #In CMD
/Scripts/Activate.ps1 #In Powershell
```
Após a ativação bem-sucedida, você verá o nome do seu ambiente virtual no lado esquerdo da tela:
Agora que seu ambiente virtual está ativado, você precisa instalar uma biblioteca de scraping de dados. Existem diversas opções, incluindo [Playwright](https://playwright.dev/), [Selenium](https://www.selenium.dev/), [Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/) e [Scrapy](https://scrapy.org/). Aqui, utilizamos o [Playwright](https://playwright.dev/python/docs/intro) por ser fácil de usar, suportar múltiplos navegadores, lidar com conteúdo dinâmico e oferecer um modo headless (scraping sem interface gráfica do usuário (GUI)).
Execute `pip install pytest-playwright` para instalar o Playwright; em seguida, instale os navegadores necessários com `playwright install`.
Após instalar o Playwright, você está pronto para começar o scraping de dados.
## Extrair HTML de um Site
O primeiro passo de qualquer projeto de scraping de dados é identificar o site que você deseja raspar. Aqui, utilizamos [este site de teste](https://webscraper.io/test-sites/e-commerce/static).
Em seguida, você precisa identificar as informações que deseja extrair da página. Neste caso, é o conteúdo HTML completo da página.
Depois de identificar as informações que deseja extrair, você pode começar a codificar o scraper. Em Python, o primeiro passo é [importar as bibliotecas necessárias para o Playwright](https://playwright.dev/python/docs/library). O Playwright permite importar dois tipos de APIs: [sync e async](https://stackoverflow.com/questions/65439214/what-are-the-differences-between-python-playwright-sync-vs-async-apis). A biblioteca async é usada apenas ao escrever código assíncrono, portanto, importe a biblioteca sync com o seguinte comando:
```none
from playwright.sync_api import sync_playwright
```
Após importar a biblioteca sync, você precisa declarar uma função Python usando o seguinte trecho de código:
```none
def main():
#Rest of the code will be inside this function
```
Como você pode ver na nota anterior, você escreve seu código de scraping de dados dentro desta função.
Normalmente, para obter informações de um site, você abriria um navegador, criaria uma nova aba e visitaria esse site. Para fazer o scraping do site, você precisa traduzir essas ações em código, e é para isso que você usará o Playwright. A [documentação](https://playwright.dev/python/docs/library) mostra que você pode chamar a `sync_api` importada anteriormente e abrir um navegador com este trecho:
```none
with sync_playwright() as p:
browser = p.chromium.launch(headless=False)
```
Ao adicionar `headless=False` dentro dos parênteses, você consegue visualizar o conteúdo do site.
Após abrir o navegador, abra uma nova aba e visite a URL de destino:
```none
page = browser.new_page()
try:
page.goto("https://webscraper.io/test-sites/e-commerce/static")
except:
print("Error")
```
> **Nota:** As linhas anteriores precisam ser adicionadas após as linhas que inicializaram o navegador. Todo esse código vai dentro da função main e dentro de um único arquivo.
Este trecho de código envolve a função `goto()` dentro de um [bloco try-except](https://www.w3schools.com/python/python_try_except.asp) para um melhor tratamento de erros.
Quando você insere a URL de um site na barra de pesquisa, precisa aguardar o carregamento. Para simular isso no código, você pode usar o seguinte:
```none
page.wait_for_timeout(7000) #millisecond value in brackets
```
> **Nota:** Essas linhas precisam ser adicionadas após as linhas anteriores.
Por fim, é hora de extrair todo o conteúdo HTML da página usando esta linha de código:
```none
print(page.content())
```
O código completo para extrair o HTML de uma página tem esta aparência:
```none
from playwright.sync_api import sync_playwright
def main():
with sync_playwright() as p:
browser = p.chromium.launch(headless=False)
page = browser.new_page()
try:
page.goto("https://webscraper.io/test-sites/e-commerce/static")
except:
print("Error")
page.wait_for_timeout(7000)
print(page.content())
main()
```
No Visual Studio Code, o HTML extraído tem esta aparência:
## Extrair HTML Usando Atributos Específicos
Anteriormente, você extraiu todos os elementos da página do Web Scraper; no entanto, o scraping de dados só é útil quando você se limita a extrair apenas as informações necessárias. Nesta seção, você extrai apenas os títulos de todos os laptops na primeira página do site:
Para extrair elementos específicos, você precisa entender a estrutura do site de destino. Você pode fazer isso clicando com o botão direito e selecionando a opção **Inspecionar** desta forma:
Alternativamente, você pode usar estes atalhos de teclado:
- Para macOS, use **Cmd + Option + I**
- Para Windows, use **Control + Shift + C**
Aqui está a estrutura da página de destino:
Você pode visualizar o código de um item específico em uma página usando a ferramenta de seleção no canto superior esquerdo da janela **Inspecionar**:
Selecione um dos títulos de laptops na janela **Inspecionar**:
Você pode ver que o título está dentro de uma tag ``, que está envolta por uma tag `h4`, e o link tem a classe `title`. Isso significa que você está procurando por tags `` (URLs) dentro de tags `
`) e tem o texto interno `2`:
Isso significa que você pode usar o seletor `get_by_role()` para encontrar um item de lista e um seletor `get_by_text()` para encontrar um elemento com `2` como texto.
Veja como codificá-lo no seu arquivo:
```none
page.get_by_role("listitem").get_by_text("2", exact=True)
```
Isso encontra um elemento que corresponde a duas condições: primeiro, deve ser um item de lista e, segundo, deve ter `2` como texto.
`exact=True` é um argumento de função para encontrar o elemento com o texto fornecido.
Para clicar no botão, altere o código anterior para que fique assim:
```none
page.get_by_role("listitem").get_by_text("2", exact=True).click()
```
Neste código, a função `click()` clica no elemento fornecido.
Aguarde o carregamento da página e extraia todos os títulos novamente:
```none
page.wait_for_timeout(5000)
titles = page.get_by_role("heading").all()
for title in titles:
laptop = title.locator("a.title").all_inner_texts()
if len(laptop) == 1:
print(laptop[0])
```
Seu bloco de código completo deve ter esta aparência:
```none
from playwright.sync_api import sync_playwright
def main():
with sync_playwright() as p:
browser = p.chromium.launch(headless=False)
page = browser.new_page()
try:
page.goto("https://webscraper.io/test-sites/e-commerce/static/computers/laptops")
except:
print("Error")
page.wait_for_timeout(7000)
titles = page.get_by_role("heading").all()
for title in titles:
laptop = title.locator("a.title").all_inner_texts()
if len(laptop) == 1:
print(laptop[0])
page.get_by_role("listitem").get_by_text("2", exact=True).click()
page.wait_for_timeout(5000)
titles = page.get_by_role("heading").all()
for title in titles:
laptop = title.locator("a.title").all_inner_texts()
if len(laptop) == 1:
print(laptop[0])
main()
```
## Extrair HTML e Gravá-lo em um CSV
Se você não armazenar e analisar os dados que extrai, eles serão inúteis. Nesta seção, você criará um programa avançado que recebe a entrada do usuário para o número de páginas de laptops a serem extraídas, extrai os títulos e os armazena em um arquivo CSV na pasta do seu projeto.
Para este programa, você precisa de uma biblioteca CSV pré-instalada, que pode ser importada usando o seguinte comando:
```none
import csv
```
Após instalar a biblioteca CSV, você precisa descobrir como visitar um número variável de páginas dependendo da entrada do usuário.
Se você observar a estrutura de URL do site, notará que cada página de laptops é indicada usando um parâmetro de URL. Por exemplo, a URL da segunda página no diretório de laptops é https://webscraper.io/test-sites/e-commerce/static/computers/laptops?page=2.
Você pode visitar diferentes páginas alterando o parâmetro de URL `?page=2` com diferentes valores numéricos. Isso significa que você precisa solicitar ao usuário que insira o número de páginas a serem extraídas com o seguinte comando:
```none
pages = int(input("enter the number of pages to scrape: "))
```
Para visitar cada página de 1 até o número de páginas inserido pelo usuário, você usa um loop `for` desta forma:
```none
for i in range(1, pages+1):
```
Dentro desta função `range`, você usa `1` e `pages+1` como argumentos para representar os valores em que o loop começa e termina. O segundo argumento da função é excluído do loop. Por exemplo, se a função range for `range(1,5)`, o programa percorreria apenas de 1 a 4.
Em seguida, você precisa visitar cada página inserindo o valor `i` como parâmetro de URL na iteração. Você pode adicionar variáveis a uma string usando [f-strings do Python](https://www.geeksforgeeks.org/formatted-string-literals-f-strings-python/).
Ao gerar uma string, você adiciona o prefixo `f` antes das aspas para indicar que é uma f-string. Dentro das aspas, você pode usar chaves para indicar variáveis.
Aqui está um exemplo de como você pode usar f-strings para imprimir variáveis junto com strings:
```none
print(f"The value of the variable is {variable_name_goes_here}")
```
Voltando ao scraper, você pode utilizar f-strings escrevendo este bloco de código no arquivo:
```none
try:
page.goto(f"https://webscraper.io/test-sites/e-commerce/static/computers/laptops?page={i}")
except:
print("Error")
```
Aguarde o carregamento da página com uma função de timeout e extraia os títulos usando o seguinte:
```none
page.wait_for_timeout(7000)
titles = page.get_by_role("heading").all()
```
Depois de ter todos os elementos de título, você precisa abrir seu arquivo CSV, percorrer cada título, extrair o texto necessário e gravá-lo no arquivo.
Para abrir um arquivo CSV, use a seguinte sintaxe:
```none
with open("laptops.csv", "a") as csvfile:
```
Aqui, você está abrindo o arquivo `laptops.csv` no modo de anexação (`a`). Você usa o modo de anexação aqui porque não quer perder dados antigos toda vez que o arquivo é aberto. Se o arquivo não existir, a biblioteca cria um na pasta do projeto. [O CSV oferece vários modos](https://www.learnbyexample.org/reading-and-writing-csv-files-in-python/) para abrir um arquivo, incluindo os seguintes:
- **r** é a opção padrão usada se nada for especificado. Abre o arquivo somente para leitura.
- **w** abre um arquivo somente para escrita. Toda vez que um arquivo é aberto, os dados anteriores são sobrescritos.
- **a** abre um arquivo para anexar dados. Os dados anteriores não são sobrescritos.
- **r+** abre um arquivo para leitura e escrita.
- **x** cria um novo arquivo.
Abaixo do código anterior, você precisa [declarar um objeto `writer`](https://docs.python.org/3/library/csv.html#csv.writer) que permite manipular o arquivo CSV:
```none
writer = csv.writer(csvfile)
```
Em seguida, percorra cada elemento de título e extraia o texto com o seguinte:
```none
for title in titles:
laptop = title.locator("a.title").all_inner_texts()
```
Isso fornece vários arrays, cada um contendo o título de laptops individuais. Para rejeitar arrays vazios, escreva o seguinte código condicional para o arquivo CSV:
```none
if len(laptop) == 1:
writer.writerow([laptop[0]])
```
A função `writerow` permite escrever novas linhas em um arquivo CSV.
Aqui está o código completo do programa:
```none
from playwright.sync_api import sync_playwright
import csv
def main():
with sync_playwright() as p:
browser = p.chromium.launch(headless=False)
page = browser.new_page()
pages = int(input("enter the number of pages to scrape: "))
for i in range(1, pages+1):
try:
page.goto(f"https://webscraper.io/test-sites/e-commerce/static/computers/laptops?page={i}")
except:
print("Error")
page.wait_for_timeout(7000)
titles = page.get_by_role("heading").all()
with open("laptops.csv", "a") as csvfile:
writer = csv.writer(csvfile)
for title in titles:
laptop = title.locator("a.title").all_inner_texts()
if len(laptop) == 1:
writer.writerow([laptop[0]])
browser.close()
main()
```
Após executar este código, seu arquivo CSV deve ter esta aparência:
## Conclusão
Neste artigo, você aprendeu como extrair, fazer parsing e armazenar HTML usando Python.
Embora este tutorial tenha sido relativamente simples, em um cenário do mundo real, você provavelmente enfrentaria vários obstáculos durante o scraping, incluindo CAPTCHAs, limites de taxa, mudanças no layout do site ou requisitos regulatórios. Felizmente, [Bright Data](/) pode ajudar. A Bright Data oferece ferramentas como [proxies residenciais avançados](/proxy-types/residential-proxies) para melhorar seu scraping, um [Web Scraper IDE](/products/web-scraper) para construir scrapers em escala, e um [Web Unlocker](/products/web-unlocker) para desbloquear sites públicos, incluindo a [resolução de CAPTCHAs](/products/web-unlocker/captcha-solver). Essas ferramentas podem ajudá-lo a coletar dados precisos em escala e superar obstáculos. Além disso, o compromisso da Bright Data com o scraping ético garante que você permaneça dentro dos termos de serviço dos sites e das regulamentações legais.
Com a infraestrutura repleta de recursos da Bright Data, você pode se concentrar em extrair os dados valiosos de que precisa, deixando para trás as complexidades do scraping de dados. Comece seu teste grátis hoje!
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=Tutorial+de+Scraping+de+Dados+em+HTML&u=https://brightdata.com.br/blog/procedimentos/html-web-scraping) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Tutorial+de+Scraping+de+Dados+em+HTML&url=https://brightdata.com.br/blog/procedimentos/html-web-scraping) [ ](http://www.reddit.com/submit?title=Tutorial+de+Scraping+de+Dados+em+HTML&url=https://brightdata.com.br/blog/procedimentos/html-web-scraping)
## Você também pode estar interessado em
[  ](https://brightdata.com.br/blog/proxies-101/how-to-bypass-an-ip-ban "Como Contornar um Banimento de IP: 7 Métodos Comprovados (Guia 2026)")
[Proxy 101
Aviv Besinsky
### Como Contornar um Banimento de IP: 7 Métodos Comprovados (Guia 2026)
Aprenda 7 métodos comprovados para contornar banimentos de IP, desde proxies residenciais (95-99% de sucesso) até VPNs e rotação de IP.
13-May-2025
28 min de leitura
](https://brightdata.com.br/blog/proxies-101/how-to-bypass-an-ip-ban)
[  ](https://brightdata.com.br/blog/dados-do-site/best-html-parsers "Melhores bibliotecas de Parsing HTML para Scraping de dados")
[Dados do site
Antonello Zanini
Technical Writer
### Melhores bibliotecas de Parsing HTML para Scraping de dados
Descubra os melhores analisadores HTML para Scraping de dados e extração de dados, incluindo httpx, AIOHTTP e urllib.
24-Mar-2024
8 min de leitura
](https://brightdata.com.br/blog/dados-do-site/best-html-parsers)
[  ](https://brightdata.com.br/blog/dados-do-site/cheerio-vs-puppeteer "Cheerio vs. Puppeteer para raspagem da web")
[Dados do site
Gints Dreimanis
### Cheerio vs. Puppeteer para raspagem da web
Um olhar sobre as diferenças entre o “Puppeteer” e o “Cheerio”, através da construção de um raspador da web com ambos.
09-Feb-2023
12 min de leitura
](https://brightdata.com.br/blog/dados-do-site/cheerio-vs-puppeteer)