Web scraping em Python em 2026: automação eficiente da coleta de dados

Web scraping é um método de coleta de dados de sites. Ele permite extrair informações necessárias para análise, monitoramento de preços, acompanhamento de notícias e outros diversos objetivos. Web scrapers ou parsers são ferramentas usadas para realizar web scraping. A linguagem mais conveniente e popular para escrever web scrapers é Python, embora praticamente qualquer linguagem possa ser usada para essa finalidade. Os usuários escolhem Python por várias razões: sintaxe simples, muitas bibliotecas úteis para parsing, suporte contínuo e atualizações. 

Neste guia, vamos analisar as principais ferramentas para web scraping e fornecer um exemplo de implementação em Python. Com instruções passo a passo, você poderá entender os fundamentos de web scraping e parsing, escrever um script simples para coleta de dados, além de aprender métodos para contornar diferentes obstáculos durante o processo. 

Ferramentas para trabalho, suas características

Escolha do ambiente de desenvolvimento

Para o trabalho é necessário um ambiente de desenvolvimento. A escolha do ambiente adequado para web scraping depende de vários fatores, como facilidade de uso, suporte às ferramentas necessárias, preferências pessoais e requisitos do projeto. Entre as ferramentas mais populares para esse tipo de trabalho, que são bem adequadas para web scraping em Python, podemos destacar PyCharm e Visual Studio Code. 

PyCharm

Prós: 

• IDE completa com muitas funcionalidades.

• Suporte a depuração, autocompletar de código e gerenciamento de projetos.

• Suporte a ambientes virtuais e integração com Git.

Contras:

• Pode ser pesada para projetos pequenos.

• Exige mais recursos em comparação com editores de texto.

Visual Studio Code (VS Code)

Prós:

• Ambiente leve e personalizável.

• Ampla variedade de extensões para Python e web scraping.

• Suporte a depuração, Git e terminal.

Contras:

• Pode exigir configuração para uso completo com Python.

• Possíveis problemas de desempenho com muitas extensões instaladas.

Instalação do Python 

Também é necessário ter o Python instalado no seu computador. Instruções de instalação para o seu sistema operacional: 

macOS

Para instalar a versão mais recente do Python, acesse o link , baixe o instalador e siga as instruções: 

python --version 

sudo apt-get update && sudo apt-get install python3 

Windows

Acesse a página do Python e baixe a versão adequada. Marque a opção "Add python.exe to PATH". Isso adicionará o Python ao PATH do sistema, facilitando seu uso pela linha de comando. 

Bibliotecas e ferramentas para web scraping em Python

Agora podemos dar atenção às bibliotecas e ferramentas que tornam a escrita de scripts para o seu parser mais conveniente. Vamos destacar as melhores delas e analisar suas características para ajudar você a fazer a escolha certa para suas tarefas.

Exemplos de web scrapers para sites estáticos e dinâmicos

O que é HTML

Antes de começar a escrever qualquer scraper, é necessário entender os fundamentos de HTML e saber analisar a estrutura dos sites sem se perder ao procurar elementos. Ou seja, HTML (HyperText Markup Language) é a linguagem de marcação padrão usada para criar e estruturar páginas web. Ele descreve a estrutura do documento, incluindo texto, imagens, links e outros elementos exibidos no navegador. 

Elementos básicos de HTML 

Escolha do site 

 

Antes de escolher as ferramentas adequadas para escrever um scraper, é necessário estudar o site alvo e entender se ele contém conteúdo dinâmico. Para isso, você deve carregar a página, abrir a aba Network nas Ferramentas do Desenvolvedor e verificar se existem requisições Fetch/XHR (tecnologias que permitem que páginas web atualizem dinamicamente seu conteúdo com base em dados recebidos do servidor):

Requisições Fetch/XHR não são executadas

 

Carregamento dinâmico de dados via JavaScript

 

Se o site não contém conteúdo dinâmico, você pode usar as bibliotecas BeautifulSoup e requests. Caso contrário, deve-se utilizar o carregamento de páginas web com Selenium ou Playwright.

Como página estática de teste para extração de alguns dados, vamos escolher https://quotes.toscrape.com/ . Vamos escrever um scraper simples para extrair as três primeiras citações e seus autores.

Seleção de ferramentas para escrever o scraper, instalação

Para o nosso objetivo, as bibliotecas BeautifulSoup e requests são perfeitamente adequadas. Vamos criar um novo arquivo no editor/IDE e adicionar as bibliotecas ao projeto com o comando: 

pip install beautifulsoup4 requests

BeautifulSoup realiza a busca e extração de dados: 

Por tags:

title_tag = soup.title
print(title_tag)  # <title>Page Title</title>

Por texto. Para extrair texto de uma tag, use o método .get_text():

header_text = soup.h1.get_text()
print(header_text)  # Header

Por classes, identificadores e atributos:

elements = soup.find_all(class_='my-class')
element = soup.find(id='my-id')
links = soup.find_all('a', href=True)

Para consultas mais complexas, você pode usar seletores CSS com o método .select():

headers = soup.select('h1')

Busca de elementos na página, escrita do scraper

Voltamos à página alvo, encontramos os elementos necessários e começamos a escrever o código. 

1. Abrimos o novo arquivo criado e importamos as bibliotecas previamente instaladas:  

import requests
from bs4 import BeautifulSoup

1. Definimos a URL da página desejada, configuramos o cabeçalho User-Agent para simular um navegador e enviamos uma requisição GET para a página: 

url = 'https://quotes.toscrape.com/'
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36'
}
response = requests.get(url, headers=headers)

3. Verificamos se a requisição foi bem-sucedida: 

if response.status_code == 200:
    # Criamos um objeto BeautifulSoup para analisar o HTML
    soup = BeautifulSoup(response.text, 'html.parser')

4. No navegador aberto na página desejada, procuramos os blocos de citações, percorremos os três primeiros blocos e extraímos o texto das citações no nosso código: 

    quotes = soup.select('.quote')
    
    for quote in quotes[:3]:
        text = quote.select_one('.text').get_text(strip=True)

5. Extraímos o nome do autor e imprimimos no console: 

        author = quote.select_one('.author').get_text(strip=True)
 
        print(f'Citação: {text}\nAutor: {author}\n')
else:
    print(f'Não foi possível obter a página. Código de status: {response.status_code}')

Código final com explicações: 

import requests
from bs4 import BeautifulSoup

url = 'https://quotes.toscrape.com/'
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36'
}

response = requests.get(url, headers=headers)

if response.status_code == 200:
    soup = BeautifulSoup(response.text, 'html.parser')
    
    quotes = soup.select('.quote')
    
    for quote in quotes[:3]:
        text = quote.select_one('.text').get_text(strip=True)
        
        author = quote.select_one('.author').get_text(strip=True)
        
        print(f'Citação: {text}\nAutor: {author}\n')
else:
    print(f'Não foi possível obter a página. Código de status: {response.status_code}')

6. Ao executar o código, o scraper exibirá as informações necessárias — as três primeiras citações e os nomes de seus autores: 

Exemplo de scraper para site dinâmico

Como exemplo de site dinâmico, vamos usar o https://parsemachine.com. Em particular, escolhemos a página de teste https://parsemachine.com/sandbox/catalog/, onde há cartões com 12 produtos. Vamos tentar extrair o nome de cada produto e o link para ele. Como o site é dinâmico, usaremos o Playwright. Esta ferramenta de automação de navegador encontra e extrai elementos em páginas web usando seletores CSS e XPath, seletores de texto e ARIA, além de suportar a combinação de seletores para uma escolha precisa.

1. Criamos um novo projeto, instalamos o Playwright e o navegador Chromium com os comandos:

pip install playwright
playwright install chromium

2. Encontramos os elementos desejados usando as Ferramentas de desenvolvedor:

3. Importamos o Playwright, iniciamos o navegador e acessamos a página desejada:

from playwright.sync_api import sync_playwright
url = 'https://parsemachine.com/sandbox/catalog/'
def scrape_with_playwright():
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()
        
        page.goto(url)

4. Procuramos todos os cartões de produtos, percorremos cada cartão e extraímos o link do produto:

        product_cards = page.query_selector_all('.card.product-card')
            
            for card in product_cards:
                title_tag = card.query_selector('.card-title .title')
                title = title_tag.inner_text() if title_tag else 'Sem nome'

5. Link para a página do produto:

 product_link = title_tag.get_attribute('href') if title_tag else 'Sem link'

6. Se o link for relativo, adicionamos o URL base:

  if product_link and not product_link.startswith('http'):
             product_link = f'https://parsemachine.com{product_link}'

7. Fechamos o navegador e chamamos a função de execução:

        browser.close()
    scrape_with_playwright()

Código completo:

from playwright.sync_api import sync_playwright

# URL da página alvo
url = 'https://parsemachine.com/sandbox/catalog/'
def scrape_with_playwright():
    with sync_playwright() as p:
        # Iniciar o navegador Chromium
        browser = p.chromium.launch(headless=False) # Mude para True se quiser modo headless
        # Abrir nova aba
        page = browser.new_page()
        
        # Acessar a página alvo
        page.goto(url)
        
        # Buscar todos os cartões de produtos
        product_cards = page.query_selector_all('.card.product-card')
        
        for card in product_cards:
            # Extrair o link do produto
            title_tag = card.query_selector('.card-title .title')
            title = title_tag.inner_text() if title_tag else 'Sem nome'
            
            # Link do produto
            product_link = title_tag.get_attribute('href') if title_tag else 'Sem link'
            
            # Se o link for relativo, adiciona o URL base
            if product_link and not product_link.startswith('http'):
                product_link = f'https://parsemachine.com{product_link}'
            
            # Exibir informação do produto
            print(f'Nome: {title}, Link: {product_link}')
        
        browser.close()
scrape_with_playwright()

8. Ao executar o script, ele exibirá todas as informações necessárias com os nomes de cada produto e seus links:

Como salvar as informações extraídas? 

Para salvar as informações extraídas, é necessário conhecer um pouco sobre os formatos de armazenamento de resultados: 

CSV – um dos formatos mais populares para armazenar dados tabulares. Ele é um arquivo de texto em que cada linha corresponde a um registro e os valores são separados por vírgulas. Vantagens: suportado pela maioria dos programas de análise de dados, incluindo Excel, fácil de ler e editar em editores de texto. Desvantagens: capacidades limitadas para armazenar estruturas complexas de dados (por exemplo, dados aninhados). Problemas com escape de vírgulas e caracteres especiais.

JSON – é um formato de troca de dados em texto, útil para representar dados estruturados. É amplamente usado no desenvolvimento web. Vantagens: suporta estruturas aninhadas e hierárquicas; amplamente suportado por várias linguagens de programação; fácil de ler tanto por humanos quanto por máquinas. JSON é adequado para dados que podem ser transmitidos via API. Desvantagens: JSON pode gerar arquivos maiores que CSV; é mais lento para processar devido à estrutura mais complexa.

XLS – destinado a tabelas do Excel, onde são armazenados dados de células, formatação e fórmulas. É frequentemente usado para armazenar bancos de dados. Para trabalhar com XLS em Python, são necessárias bibliotecas externas, como pandas. Esse formato permite armazenar dados de forma legível e apresentável. A principal desvantagem é a necessidade de bibliotecas adicionais, o que aumenta a carga no servidor e o tempo de processamento dos dados.

XML – é uma linguagem de marcação usada para armazenar e transmitir dados. Suporta estruturas aninhadas e atributos. Vantagens: estruturado, permite armazenar dados complexos, bem suportado por diversos padrões e sistemas. Desvantagens: XML pode ser pesado e complexo de processar; a análise pode ser lenta devido à sua estrutura.

Bancos de dados são usados para armazenar grandes volumes de dados estruturados. Exemplos incluem MySQL, PostgreSQL, MongoDB, SQLite. Vantagens: suporte a grandes volumes de dados e acesso rápido; facilidade para organizar e relacionar dados; suporte a transações e recuperação de dados. Desvantagem: exige esforço adicional de configuração e manutenção. 

Para nossos scrapers, escolheremos o formato CSV, porque os dados extraídos são tabulares (texto da citação e autor, nomes de produtos e seus links) e o volume de dados é relativamente pequeno, sem estruturas aninhadas. Mais informações sobre como ler e escrever nesse formato podem ser encontradas aqui. Vamos adicionar ao nosso código de citações a importação do CSV, criar um objeto writer e gravar os dados das citações (texto e autores):

    with open('quotes.csv', 'w', newline='', encoding='utf-8') as csvfile:
        csvwriter = csv.writer(csvfile)

        csvwriter.writerow(['Citação', 'Autor'])

        for quote in quotes[:3]:
            text = quote.select_one('.text').get_text(strip=True)

            author = quote.select_one('.author').get_text(strip=True)

            csvwriter.writerow([text, author])

Também adicionaremos saídas no console e tratamento de possíveis erros: 

    print("Dados gravados com sucesso em quotes.csv")

except requests.RequestException as e:
    print(f'Erro ao requisitar a página: {e}')
except Exception as e:
    print(f'Ocorreu um erro: {e}')

Código completo: 

import requests
from bs4 import BeautifulSoup
import csv

url = 'https://quotes.toscrape.com/'
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36'
}

try:
    response = requests.get(url, headers=headers)
    response.raise_for_status()

    soup = BeautifulSoup(response.text, 'html.parser')

    quotes = soup.select('.quote')

    with open('quotes.csv', 'w', newline='', encoding='utf-8') as csvfile:
        csvwriter = csv.writer(csvfile)

        csvwriter.writerow(['Citação', 'Autor'])

        for quote in quotes[:3]:
            text = quote.select_one('.text').get_text(strip=True)
            author = quote.select_one('.author').get_text(strip=True)

            csvwriter.writerow([text, author])

    print("Dados gravados com sucesso em quotes.csv")

except requests.RequestException as e:
    print(f'Erro ao requisitar a página: {e}')
except Exception as e:
    print(f'Ocorreu um erro: {e}')

Faremos o mesmo com o segundo scraper: 

from playwright.sync_api import sync_playwright
import csv

url = 'https://parsemachine.com/sandbox/catalog/'

def scrape_with_playwright():
    try:
        with sync_playwright() as p:
            browser = p.chromium.launch(headless=False)

            try:
                page = browser.new_page()

                page.goto(url)

                product_cards = page.query_selector_all('.card.product-card')

                with open('products.csv', 'w', newline='', encoding='utf-8') as csvfile:
                    csvwriter = csv.writer(csvfile)

                    csvwriter.writerow(['Nome', 'Link'])

                    for card in product_cards:
                        title_tag = card.query_selector('.card-title .title')
                        title = title_tag.inner_text() if title_tag else 'Sem nome'

                        product_link = title_tag.get_attribute('href') if title_tag else 'Sem link'

                        if product_link and not product_link.startswith('http'):
                            product_link = f'https://parsemachine.com{product_link}'

                        csvwriter.writerow([title, product_link])

                        print(f'Nome: {title}, Link: {product_link}')

                print("Dados gravados com sucesso em products.csv")

            except Exception as e:
                print(f'Erro ao trabalhar com Playwright: {e}')

            finally:
                browser.close()
                print("Navegador fechado.")

    except Exception as e:
        print(f'Erro ao iniciar Playwright: {e}')

scrape_with_playwright()

Obstáculos no web scraping 

• Estrutura do site em mudança e mais complexa: um dos obstáculos mais comuns no web scraping é a alteração da estrutura de um site e a ofuscação do código. Mesmo pequenas mudanças na marcação HTML ou na estrutura das páginas podem fazer com que os scripts de scraping deixem de funcionar. Isso pode exigir atualizações frequentes no código para se adaptar às novas mudanças.

• Limitação de requisições: muitos sites impõem limites no número de requisições que podem ser enviadas em um determinado período de tempo. Se suas requisições excederem os limites definidos, seu endereço IP pode ser bloqueado temporariamente.

• Bloqueio de IP: os sites podem bloquear endereços IP que considerem suspeitos ou excessivamente ativos, o que pode ser um grande obstáculo para o scraping. Nesse caso, pode ser necessário o uso de servidores proxy de qualidade para contornar essas restrições.

• CAPTCHA: muitos recursos web implementam medidas de proteção como CAPTCHA para evitar ações automatizadas. O CAPTCHA exige inserção manual ou o uso de serviços especializados para sua resolução.

Um dos melhores serviços atualmente é o CapMonster Cloud – a disponibilidade de API permite uma integração fácil no código para contornar CAPTCHAs e continuar o funcionamento do scraper. Ele é fácil de conectar, oferece resolução rápida de diferentes tipos de CAPTCHA com erros mínimos – suporta reCAPTCHA, DataDome, Amazon CAPTCHA e outros. CapMonster Cloud pode ser considerado uma escolha ideal como ferramenta auxiliar e uma parte importante do processo de web scraping. 

Experimentar CapMonster Cloud

Biblioteca pronta para integração rápida em código Python 

Recomendações para um scraping bem-sucedido 

• Use rotação de proxies e User-Agent para evitar bloqueios de IP e contornar limitações de requisições, isso ajuda a simular acessos de diferentes dispositivos e navegadores. 

• Adicione tratamento de erros e tentativas automáticas: uma página pode ficar temporariamente indisponível ou uma requisição pode falhar. Um mecanismo de retry e tratamento de erros ajuda a manter a estabilidade do script e evita interrupções no processo de scraping.

• Antes de iniciar o scraping, sempre consulte o arquivo robots.txt do site. Esse arquivo contém recomendações para bots sobre quais partes do site podem ou não ser rastreadas. Seguir essas regras ajuda a evitar problemas legais e conflitos com os proprietários dos sites.

• Adicione atrasos aleatórios entre requisições para evitar atividades suspeitas e reduzir a chance de bloqueio. 

Essas recomendações ajudam seu script a simular o comportamento de um usuário real, reduzindo assim a probabilidade de detecção.

Conclusão 

Assim, o web scraping em Python é uma das formas mais populares de coleta eficiente de dados de diferentes sites. Discutimos como escolher ferramentas adequadas para scraping, analisamos o processo de instalação do Python e das bibliotecas necessárias, além da escrita de código para extração de dados e salvamento dos resultados em formatos convenientes. Com uma abordagem passo a passo, qualquer desenvolvedor iniciante pode aprender as técnicas básicas de web scraping e criar seus primeiros scripts de coleta de dados. O web scraping abre grandes possibilidades para análise de dados, coleta de informações, monitoramento de mercado e muitas outras tarefas. É importante continuar estudando novas ferramentas e metodologias para se manter atualizado nessa área em constante evolução. 

Usando bibliotecas e ferramentas como BeautifulSoup, requests, Selenium, Playwright e outras mencionadas neste guia, é possível extrair informações tanto de sites estáticos quanto dinâmicos. Ao trabalhar com web scraping, é importante considerar aspectos legais e éticos, além de estar preparado para lidar com obstáculos como CAPTCHA ou carregamento dinâmico de conteúdo.

Cada uma das ferramentas e abordagens apresentadas possui suas próprias vantagens e limitações. A escolha da ferramenta adequada depende da especificidade da tarefa, da complexidade das páginas web e do volume de dados. Para um scraping eficiente, é essencial entender as características das páginas com as quais você está trabalhando.

Esperamos que as instruções acima ajudem você a entender melhor o processo de web scraping e forneçam os conhecimentos básicos necessários para criar seus próprios scrapers. Boa sorte nos seus projetos de automação de coleta e análise de dados!

NB: Por favor, observe que o produto é destinado exclusivamente à automação de testes em seus próprios sites e recursos aos quais você possui direito legal de acesso.