Raspagem da Web com o Pydoll em 2025: Guia passo a passo

mkdir pydoll-scraper

cd pydoll-scraper
python -m venv venv

source venv/bin/activate

venv/Scripts/activate

pip install pydoll-python

import asyncio
from pydoll.browser.chrome import Chrome

async def main():
    async with Chrome() as browser:
        # Launch the Chrome browser and open a new page
        await browser.start()
        page = await browser.get_page()

        # scraping logic...

# Execute the async scraping function
asyncio.run(main())

await page.go_to("https://quotes.toscrape.com/js-delayed/?delay=2000")

com a classe quote. Isso significa que você pode direcioná-las usando o seletor CSS:

.quote

Agora, use o Pydoll para esperar que esses elementos apareçam antes de continuar:

await page.wait_element(By.CSS_SELECTOR, ".quote", timeout=3)

Não se esqueça de importar By:

from pydoll.constants import By

Execute o script novamente e, dessa vez, você verá que o Pydoll aguarda o carregamento dos elementos de citação antes de fechar o navegador. Bom trabalho!

Etapa 5: Prepare-se para o Web Scraping

Lembre-se de que a página de destino contém mais do que apenas uma citação. Como você deseja extrair todas elas, precisa de uma estrutura de dados para armazenar esses dados. Uma matriz simples funciona perfeitamente, portanto, inicialize uma:

quotes = []

Para localizar elementos da página, o Pydoll oferece dois métodos úteis:

• find_element(): Encontra o primeiro elemento correspondente
• find_elements(): Encontra todos os elementos correspondentes

Assim como em wait_element(), esses métodos aceitam um seletor usando o objeto By.

Portanto, selecione todos os elementos de citação na página com:

quote_elements = await page.find_elements(By.CSS_SELECTOR, ".quote")

Em seguida, percorra os elementos e prepare-se para aplicar sua lógica de raspagem:

for quote_element in quote_elements:
  # Scraping logic...

Excelente! Hora da lógica de extração de dados.

Etapa nº 6: implementar a lógica de análise de dados

Comece inspecionando um único elemento de citação:

Como você pode ver no HTML acima, um único elemento de citação contém:

• A citação de texto em um nó .text
• O autor no elemento .author
• Uma lista de tags nos elementos .tag

Implemente a lógica de raspagem para selecionar esses elementos e extrair deles os dados de interesse:

# Extract the quote text (and remove curly quotes)
text_element = await quote_element.find_element(By.CSS_SELECTOR, ".text")
text = (await text_element.get_element_text()).replace("“", "").replace("”", "")

# Extract the author name
author_element = await quote_element.find_element(By.CSS_SELECTOR, ".author")
author = await author_element.get_element_text()

# Extract all associated tags
tag_elements = await quote_element.find_elements(By.CSS_SELECTOR, ".tag")
tags = [await tag_element.get_element_text() for tag_element in tag_elements]

Observação: O método replace() remove as aspas duplas curvas desnecessárias do texto de citação extraído.

Agora, utilize os dados extraídos para preencher um novo objeto de dicionário e adicione-o à matriz de citações:

# Populate a new quote with the scraped data
quote = {
    "text": text,
    "author": author,
    "tags": tags
}
# Append the extracted quote to the list
quotes.append(quote)

Muito bem! Resta apenas exportar os dados extraídos para CSV.

Etapa nº 7: Exportar para CSV

Atualmente, os dados extraídos são armazenados em uma lista Python. Facilite o compartilhamento e a exploração com outras pessoas exportando-os para um formato legível por humanos, como CSV.

Use o Python para criar um novo arquivo chamado quotes.csv e preenchê-lo com os dados extraídos:

with open("quotes.csv", "w", newline="", encoding="utf-8") as csvfile:
            # Add the header
            fieldnames = ["text", "author", "tags"]
            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

            # Populate the output file with the scraped data
            writer.writeheader()
            for quote in quotes:
                writer.writerow(quote)

Lembre-se de importar csv da biblioteca padrão do Python:

import csv

Missão concluída! Seu raspador Pydoll está pronto para ser executado.

Etapa #8: Juntar tudo

O arquivo scraper.py agora deve conter:

import asyncio
from pydoll.browser.chrome import Chrome
from pydoll.constants import By
import csv

async def main():
    async with Chrome() as browser:
        # Launch the Chrome browser and open a new page
        await browser.start()
        page = await browser.get_page()

        # Navigate to the target page
        await page.go_to("https://quotes.toscrape.com/js-delayed/?delay=2000")

        # Wait up to 3 seconds for the quote elements to appear
        await page.wait_element(By.CSS_SELECTOR, ".quote", timeout=3)

        # Where to store the scraped data
        quotes = []

        # Select all quote elements
        quote_elements = await page.find_elements(By.CSS_SELECTOR, ".quote")

        # Iterate over them and scrape data from them
        for quote_element in quote_elements:
            # Extract the quote text (and remove curly quotes)
            text_element = await quote_element.find_element(By.CSS_SELECTOR, ".text")
            text = (await text_element.get_element_text()).replace("“", "").replace("”", "")

            # Extract the author
            author_element = await quote_element.find_element(By.CSS_SELECTOR, ".author")
            author = await author_element.get_element_text()

            # Extract all tags
            tag_elements = await quote_element.find_elements(By.CSS_SELECTOR, ".tag")
            tags = [await tag_element.get_element_text() for tag_element in tag_elements]

            # Populate a new quote with the scraped data
            quote = {
                "text": text,
                "author": author,
                "tags": tags
            }
            # Append the extracted quote to the list
            quotes.append(quote)

    # Export the scraped data to CSV
    with open("quotes.csv", "w", newline="", encoding="utf-8") as csvfile:
                # Add the header
                fieldnames = ["text", "author", "tags"]
                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

                # Populate the output file with the scraped data
                writer.writeheader()
                for quote in quotes:
                    writer.writerow(quote)

# Execute the async scraping function
asyncio.run(main())

Uau! Em menos de 60 linhas de código, você pode criar um bot de raspagem da Web com o Pydoll.

Teste o script acima executando-o:

python scraper.py

Quando a execução terminar, um arquivo quotes.csv aparecerá na pasta do projeto. Abra-o e você verá os dados extraídos organizados de forma clara:

E pronto! Seu script de raspagem da Web Pydoll funciona como esperado.

Contornando o Cloudflare com o Pydoll

Ao interagir com um site em uma ferramenta de automação de navegador, um dos maiores desafios que você enfrentará são os firewalls de aplicativos da Web (WAFs). Pense em soluções como a Cloudflare, que geralmente vêm com proteções antibot avançadas.

Quando se suspeita que suas solicitações são provenientes de um navegador automatizado, esses sistemas geralmente exibem um CAPTCHA. Em alguns casos, eles o apresentam a todos os usuários durante a primeira visita ao site.

Contornar CAPTCHAs em Python não é uma tarefa fácil. No entanto, há maneiras de fazer com que o Cloudflare pense que você é um usuário real, de modo que ele não mostre um CAPTCHA em primeiro lugar. É aqui que entra o Pydoll, que fornece uma API dedicada para essa finalidade.

Para demonstrar como ele funciona, usaremos a página de teste “Antibot Challenge” do site ScrapingCourse:

Como você pode ver, a página sempre executa o Cloudflare JavaScript Challenge. Uma vez contornado, ele exibe alguns exemplos de conteúdo para confirmar que a proteção anti-bot foi derrotada.

O Pydoll apresenta duas abordagens para lidar com o Cloudflare:

1. Abordagem do gerenciador de contexto: Lida com o desafio antibot de forma síncrona, pausando a execução do script até que o desafio seja resolvido.
2. Abordagem de processamento em segundo plano: Lida com o antibot de forma assíncrona em segundo plano.

Abordaremos os dois métodos. No entanto, conforme mencionado nos documentos oficiais, lembre-se de que o desvio do Cloudflare nem sempre funciona. Isso se deve a questões como reputação do IP ou histórico de navegação.

Para obter técnicas mais avançadas, leia nosso tutorial completo sobre raspagem de sites protegidos pela Cloudflare.

Abordagem do gerenciador de contexto

Para permitir que o Pydoll lide automaticamente com o desafio anti-bot do Cloudflare para você, use o método expect_and_bypass_cloudflare_captcha() desta forma:

import asyncio
from pydoll.browser.chrome import Chrome
from pydoll.constants import By

async def main():
    async with Chrome() as browser:
        # Launch the Chrome browser and open a new page
        await browser.start()
        page = await browser.get_page()

        # Wait for the Cloudflare challenge to be executed
        async with page.expect_and_bypass_cloudflare_captcha():
            # Connect to the Cloudflare-protected page:
            await page.go_to("https://www.scrapingcourse.com/antibot-challenge")
            print("Waiting for Cloudflare anti-bot to be handled...")

        # This code runs only after the anti-bot is successfully bypassed
        print("Cloudflare anti-bot bypassed! Continuing with automation...")

        # Print the text message on the success page
        await page.wait_element(By.CSS_SELECTOR, "#challenge-title", timeout=3)
        success_element = await page.find_element(By.CSS_SELECTOR, "#challenge-title")
        success_text = await success_element.get_element_text()
        print(success_text)

asyncio.run(main())

Quando você executar esse script, a janela do Chrome ignorará automaticamente o desafio e carregará a página de destino.

O resultado será:

Waiting for Cloudflare anti-bot to be handled...
Cloudflare anti-bot bypassed! Continuing with automation...
You bypassed the Antibot challenge! :D

Abordagem de processamento em segundo plano

Se você preferir não bloquear a execução do script enquanto o Pydoll lida com o desafio do Cloudflare, poderá usar os métodos enable_auto_solve_cloudflare_captcha() e disable_auto_solve_cloudflare_captcha() da seguinte forma:

import asyncio
from pydoll.browser import Chrome
from pydoll.constants import By

async def main():
    async with Chrome() as browser:
        # Launch the Chrome browser and open a new page
        await browser.start()
        page = await browser.get_page()

        # Enable automatic captcha solving before navigating
        await page.enable_auto_solve_cloudflare_captcha()

        # Connect to the Cloudflare-protected page:
        await page.go_to("https://www.scrapingcourse.com/antibot-challenge")
        print("Page loaded, Cloudflare anti-bot will be handled in the background...")

        # Disable anti-bot auto-solving when no longer needed
        await page.disable_auto_solve_cloudflare_captcha()

        # Print the text message on the success page
        await page.wait_element(By.CSS_SELECTOR, "#challenge-title", timeout=3)
        success_element = await page.find_element(By.CSS_SELECTOR, "#challenge-title")
        success_text = await success_element.get_element_text()
        print(success_text)

asyncio.run(main())

Essa abordagem permite que seu raspador execute outras operações enquanto o Pydoll resolve o desafio anti-bot do Cloudflare em segundo plano.

Dessa vez, o resultado será:

Page loaded, Cloudflare anti-bot will be handled in the background...
You bypassed the Antibot challenge! :D

Limitações dessa abordagem de raspagem da Web

Com o Pydoll – ou qualquer ferramenta de raspagem – sevocê enviar muitas solicitações, há uma boa chance de ser bloqueado pelo servidor de destino. Isso ocorre porque a maioria dos sites implementa limitação de taxa para evitar que os bots (como seu script de raspagem) sobrecarreguem seus servidores com solicitações.

Essa é uma técnica comum de anti-scraping e anti-DDoS. Afinal de contas, ninguém quer que seu site seja inundado com tráfego automatizado.

Mesmo que você esteja seguindo as práticas recomendadas, como respeitar o robots.txt, fazer muitas solicitações do mesmo endereço IP ainda pode levantar suspeitas. Como resultado, você ainda pode se deparar com os erros 403 Forbidden ou 429 Too Many Requests.

A melhor maneira de evitar isso é alternar seu endereço IP usando um proxy da Web.

Se você não estiver familiarizado com isso, um proxy da Web atua como um intermediário entre o seu scraper e o site de destino. Ele encaminha suas solicitações e retorna as respostas, fazendo com que o site de destino considere que o tráfego está vindo do proxy e não do seu computador real.

Essa técnica não apenas ajuda a ocultar seu IP real, mas também é útil para contornar restrições geográficas e muitos outros casos de uso.

Agora, há vários tipos de proxies no mercado. Para evitar ser bloqueado, você precisa de um provedor de alta qualidade que ofereça proxies rotativos genuínos, como a Bright Data.

Na próxima seção, você verá como integrar os proxies rotativos da Bright Data com o Pydoll para extrair páginas da Web com mais eficiência, especialmente em escala.

Integração do Pydoll com os proxies rotativos da Bright Data

A Bright Data controla uma das maiores redes de proxy do mundo, com a confiança de empresas da Fortune 500 e mais de 20.000 clientes. Sua rede de proxy inclui:

• Proxies de datacenter – Mais de 770.000 IPs de datacenter.
• Proxies residenciais – Mais de 150.000.000 de IPs residenciais em mais de 195 países.
• Proxies de ISP – Mais de 700.000 IPs de ISP.
• Proxies móveis – Mais de 7.000.000 de IPs móveis.

Siga as etapas abaixo e saiba como usar os proxies residenciais da Bright Data com o Pydoll.

Se você ainda não tiver uma conta, inscreva-se na Bright Data. Caso contrário, faça o login para acessar seu painel de controle:

No painel, clique no botão “Get proxy products” (Obter produtos proxy):

Você será redirecionado para a página “Proxies & Scraping Infrastructure”:

Na tabela, localize a linha “Residential” e clique nela:

Você chegará à página de configuração do proxy residencial:

Se esta for sua primeira vez, siga o assistente de instalação para configurar o proxy de acordo com suas necessidades. Para obter ajuda, entre em contato com o suporte 24 horas por dia, 7 dias por semana.

Vá para a guia “Overview” (Visão geral) e localize o host, a porta, o nome de usuário e a senha do seu proxy:

Use esses detalhes para criar seu URL de proxy:

proxy_url = "<brightdata_proxy_username>:<brightdata_proxy_password>@<brightdata_proxy_host>:<brightdata_proxy_port>";

Substitua os espaços reservados (, , , ) com suas credenciais reais de proxy.

Certifique-se de ativar o produto proxy alternando o interruptor de “Desligado” para “Ligado”:

Agora que você já tem seu proxy pronto, veja como integrá-lo ao Pydoll usando os recursos de configuração de proxy incorporados:

import asyncio
from pydoll.browser.chrome import Chrome
from pydoll.browser.options import Options
from pydoll.constants import By
import traceback

async def main():
    # Create browser options
    options = Options()

    # The URL of your Bright Data proxy
    proxy_url = "<brightdata_proxy_username>:<brightdata_proxy_password>@<brightdata_proxy_host>:<brightdata_proxy_port>" # Replace it with your proxy URL

    # Configure the proxy integration option
    options.add_argument(f"--proxy-server={proxy_url}")

    # To avoid potential SSL errors
    options.add_argument("--ignore-certificate-errors")

    # Start browser with proxy configuration
    async with Chrome(options=options) as browser:
        await browser.start()
        page = await browser.get_page()

        # Visit a special page that returns the IP of the caller
        await page.go_to("https://httpbin.io/ip")

        # Extract the page content containing only the IP of the incoming
        # request and print it
        body_element = await page.find_element(By.CSS_SELECTOR, "body")
        body_text = await body_element.get_element_text()
        print(f"Current IP address: {body_text}")

# Execute the async scraping function
asyncio.run(main())

Toda vez que você executar esse script, verá um endereço IP de saída diferente, graças à rotação de proxy da Bright Data.

Observação: normalmente, o sinalizador --proxy-server do Chrome não oferece suporte a proxies autenticados de imediato. No entanto, o gerenciador de proxy avançado do Pydoll substitui essa limitação, permitindo que você use servidores proxy protegidos por senha.

Com os proxies rotativos da Bright Data, a rotação de proxy do Pydoll é simples, confiável e dimensionável!

Alternativas ao Pydoll for Web Scraping

O Pydoll é, sem dúvida, uma poderosa biblioteca de raspagem da Web, especialmente para automatizar navegadores com recursos integrados de desvio anti-bot. No entanto, ela não é a única ferramenta no jogo.

Abaixo estão algumas alternativas sólidas do Pydoll que vale a pena considerar:

• SeleniumBase: Uma estrutura Python construída sobre as APIs do Selenium/WebDriver, oferecendo um kit de ferramentas de nível profissional para automação da Web. Ele suporta tudo, desde testes de ponta a ponta até fluxos de trabalho de raspagem avançados.
• ChromeDriver não detectado: Uma versão corrigida do ChromeDriver projetada para evitar a detecção por serviços anti-bot populares como Imperva, DataDome e Distil Networks. Ideal para raspagem furtiva ao usar o Selenium.

Se você estiver procurando uma solução de raspagem da Web para fins mais gerais que funcione em qualquer site e ofereça suporte a várias linguagens de programação, confira nossos serviços de raspagem:

• Navegador de raspagem: Um navegador compatível com Selenium, Playwright e Puppeteer com recursos de desbloqueio incorporados.
• APIs do Web Scraper: APIs pré-configuradas para extrair dados estruturados de mais de 100 domínios principais.
• Web Unlocker: Uma API tudo em um que lida com o desbloqueio de sites com proteções antibot.
• API SERP: Uma API especializada que desbloqueia os resultados dos mecanismos de pesquisa e extrai dados SERP completos.

Conclusão

Neste tutorial de integração de proxy, você aprendeu o que é o Pydoll e como ele funciona. Exploramos como usá-lo para raspagem da Web em um site com JavaScript e vimos como resolver sua principal
limitação por meio da integração de proxy.

Você também entendeu por que usar o Pydoll sem um mecanismo de rotação de IP pode levar a resultados não confiáveis. Para obter um desempenho estável, segurança aprimorada e escalabilidade, você deve escolher um provedor de proxy confiável. Economize tempo e esforço indo direto ao melhor provedor de proxy do mercado, a Bright Data.

Crie uma conta e comece a testar nossos proxies gratuitamente hoje mesmo!