Como Resolver Desafios de Web Scraping com Scrapy e Playwright em 2025

O que é Scrapy-Playwright?

Scrapy-Playwright é um middleware que integra o Scrapy, um framework rápido e poderoso de web scraping para Python, com o Playwright, uma biblioteca de automação de navegador. Essa combinação permite que o Scrapy manipule sites com JavaScript pesado, aproveitando a capacidade do Playwright de renderizar conteúdo dinâmico, interagir com páginas da web e gerenciar contextos de navegador perfeitamente.

Por que usar Scrapy-Playwright?

Embora o Scrapy seja excelente para raspar sites estáticos, muitos sites modernos dependem fortemente do JavaScript para renderizar conteúdo dinamicamente. Os spiders tradicionais do Scrapy podem ter dificuldades com esses sites, muitas vezes perdendo dados importantes ou falhando em navegar por estruturas de página complexas. O Scrapy-Playwright preenche essa lacuna, permitindo que o Scrapy controle um navegador sem cabeça, garantindo que todo o conteúdo dinâmico seja totalmente carregado e acessível para scraping.

Benefícios de usar Scrapy-Playwright

• Renderização de JavaScript: Raspe facilmente sites que carregam conteúdo dinamicamente usando JavaScript.
• Navegação sem Cabeça: Execute tarefas de scraping sem um navegador visível, otimizando o desempenho.
• Interações Avançadas: Manipule interações complexas, como clicar em botões, preencher formulários e navegar pelas páginas.
• Operações Assíncronas: Beneficie-se das capacidades assíncronas do Playwright para acelerar as tarefas de scraping.

Instalação

Para começar a usar o Scrapy-Playwright, você precisa instalar o Scrapy e o Playwright. Veja como configurar seu ambiente:

1. Instale o Scrapy:

   bash Copy

   pip install scrapy

2. Instale o Scrapy-Playwright:

   bash Copy

   pip install scrapy-playwright

3. Instale os navegadores Playwright:

   Após instalar o Playwright, você precisa instalar os binários do navegador necessários.

   bash Copy

   playwright install

Começando

Configurando um novo projeto Scrapy

Primeiro, crie um novo projeto Scrapy se você ainda não o fez:

scrapy startproject myproject
cd myproject

Configurando o Playwright

Em seguida, você precisa habilitar o Playwright nas configurações do seu projeto Scrapy. Abra settings.py e adicione as seguintes configurações:

# settings.py

# Habilite o middleware de download Playwright
DOWNLOADER_MIDDLEWARES = {
    'scrapy_playwright.middleware.ScrapyPlaywrightDownloadHandler': 543,
}

# Especifique o manipulador de download para HTTP e HTTPS
DOWNLOAD_HANDLERS = {
    'http': 'scrapy_playwright.handler.ScrapyPlaywrightDownloadHandler',
    'https': 'scrapy_playwright.handler.ScrapyPlaywrightDownloadHandler',
}

# Habilite as configurações do Playwright
TWISTED_REACTOR = 'twisted.internet.asyncioreactor.AsyncioSelectorReactor'

# Configurações do Playwright (opcional)
PLAYWRIGHT_BROWSER_TYPE = 'chromium'  # Pode ser 'chromium', 'firefox' ou 'webkit'
PLAYWRIGHT_LAUNCH_OPTIONS = {
    'headless': True,
}

Uso básico

Criando um Spider

Com a configuração concluída, vamos criar um spider simples que usa o Playwright para raspar um site renderizado por JavaScript. Para ilustração, vamos raspar um site hipotético que carrega conteúdo dinamicamente.

Crie um novo arquivo de spider dynamic_spider.py dentro do diretório spiders:

# spiders/dynamic_spider.py

import scrapy
from scrapy_playwright.page import PageCoroutine

class DynamicSpider(scrapy.Spider):
    name = "dynamic"
    start_urls = ["https://example.com/dynamic"]

    def start_requests(self):
        for url in self.start_urls:
            yield scrapy.Request(
                url,
                meta={
                    "playwright": True,
                    "playwright_page_coroutines": [
                        PageCoroutine("wait_for_selector", "div.content"),
                    ],
                },
            )

    async def parse(self, response):
        # Extraia dados depois que o JavaScript renderizou o conteúdo
        for item in response.css("div.content"):
            yield {
                "title": item.css("h2::text").get(),
                "description": item.css("p::text").get(),
            }

        # Lidar com paginação ou interações adicionais, se necessário

Manipulando conteúdo renderizado por JavaScript

No exemplo acima:

• playwright: True: Informa ao Scrapy para usar o Playwright para essa solicitação.
• playwright_page_coroutines: Especifica ações para executar com o Playwright. Aqui, ele espera por um seletor div.content para garantir que o conteúdo dinâmico tenha sido carregado antes de analisar.
• Método parse assíncrono: Aproveita as capacidades assíncronas para lidar com a resposta de forma eficaz.

Resolvendo captchas com CapSolver

Um dos desafios significativos no web scraping é lidar com captchas, que são projetados para evitar acesso automatizado. O CapSolver é uma solução robusta que fornece serviços de resolução de captcha, incluindo integrações com ferramentas de automação de navegador, como Playwright. Nesta seção, exploraremos como integrar o CapSolver com o Scrapy-Playwright para lidar com captchas perfeitamente.

O que é CapSolver?

O CapSolver é um serviço de resolução de captcha que automatiza o processo de resolução de vários tipos de captchas, incluindo captcha e reCAPTCHA. Ao integrar o CapSolver em seu fluxo de trabalho de scraping, você pode ignorar desafios de captcha e manter o fluxo de suas tarefas de scraping sem intervenção manual.

Integrando o CapSolver com o Scrapy-Playwright

Para integrar o CapSolver com o Scrapy-Playwright, você precisará:

1. Obter a extensão do navegador CapSolver: O CapSolver fornece uma extensão de navegador que automatiza a resolução de captcha dentro de contextos de navegador.
2. Configurar o Playwright para carregar a extensão CapSolver: Ao iniciar o navegador Playwright, carregue a extensão CapSolver para habilitar a resolução de captcha.
3. Modificar solicitações Scrapy para usar o contexto Playwright personalizado: Certifique-se de que suas solicitações Scrapy utilizem o contexto Playwright com a extensão CapSolver carregada.

Exemplo de implementação em Python

Abaixo, há um guia passo a passo para integrar o CapSolver com o Scrapy-Playwright, completo com código de exemplo.

1. Obter a extensão do navegador CapSolver

Primeiro, baixe a extensão do navegador CapSolver e coloque-a no diretório do seu projeto. Suponha que a extensão esteja localizada em CapSolver.Browser.Extension.

2. Configure a extensão:

• Localize o arquivo de configuração ./assets/config.json no diretório da extensão CapSolver.
• Defina a opção enabledForcaptcha como true e ajuste o captchaMode para token para resolução automática.

Exemplo config.json:

{
  "enabledForcaptcha": true,
  "captchaMode": "token"
  // outras configurações permanecem as mesmas
}

3. Atualize as configurações do Scrapy para carregar a extensão

Modifique seu settings.py para configurar o Playwright para carregar a extensão CapSolver. Você precisará especificar o caminho para a extensão e passar os argumentos necessários para o Playwright.

# settings.py

import os
from pathlib import Path

# Configurações existentes do Playwright
PLAYWRIGHT_BROWSER_TYPE = 'chromium'
PLAYWRIGHT_LAUNCH_OPTIONS = {
    'headless': False,  # Deve ser Falso para carregar extensões
    'args': [
        '--disable-extensions-except={}'.format(os.path.abspath('CapSolver.Browser.Extension')),
        '--load-extension={}'.format(os.path.abspath('CapSolver.Browser.Extension')),
    ],
}

# Certifique-se de que o reator Twisted esteja definido
TWISTED_REACTOR = 'twisted.internet.asyncioreactor.AsyncioSelectorReactor'

Nota: Carregar extensões de navegador requer que o navegador seja executado no modo não sem cabeça. Portanto, defina 'headless': False.

4. Crie um Spider que lida com captchas

Crie um novo spider ou modifique um existente para interagir com captchas usando a extensão CapSolver.

# spiders/captcha_spider.py

import scrapy
from scrapy_playwright.page import PageCoroutine
import asyncio

class CaptchaSpider(scrapy.Spider):
    name = "captcha_spider"
    start_urls = ["https://site.example/captcha-protected"]

    def start_requests(self):
        for url in self.start_urls:
            yield scrapy.Request(
                url,
                meta={
                    "playwright": True,
                    "playwright_page_coroutines": [
                        PageCoroutine("wait_for_selector", "iframe[src*='captcha']"),
                        PageCoroutine("wait_for_timeout", 1000),  # Aguarde a extensão para processar
                    ],
                    "playwright_context": "default",
                },
                callback=self.parse_captcha
            )

    async def parse_captcha(self, response):
        page = response.meta["playwright_page"]

        # Localize a caixa de seleção ou o frame captcha e interaja de acordo
        try:
            # Aguarde o iframe captcha estar disponível
            await page.wait_for_selector("iframe[src*='captcha']", timeout=10000)
            frames = page.frames
            captcha_frame = None
            for frame in frames:
                if 'captcha' in frame.url:
                    captcha_frame = frame
                    break

            if captcha_frame:
                # Clique na caixa de seleção captcha
                await captcha_frame.click("div#checkbox")

                # Aguarde o captcha ser resolvido pelo CapSolver
                await page.wait_for_selector("div.captcha-success", timeout=60000)  # Ajuste o seletor conforme necessário

                self.logger.info("Captcha resolvido com sucesso.")
            else:
                self.logger.warning("captcha iframe não encontrado.")
        except Exception as e:
            self.logger.error(f"Erro ao lidar com o captcha: {e}")

        # Prossiga analisando a página depois que o captcha for resolvido
        for item in response.css("div.content"):
            yield {
                "title": item.css("h2::text").get(),
                "description": item.css("p::text").get(),
            }

        # Lidar com paginação ou interações adicionais, se necessário

5. Executando o Spider

Certifique-se de que todas as dependências estejam instaladas e execute seu spider usando:

scrapy crawl captcha_spider

Recursos avançados

Quando você se sentir confortável com os fundamentos, o Scrapy-Playwright oferece vários recursos avançados para aprimorar seus projetos de scraping.

Manipulando múltiplas páginas

Raspando várias páginas ou navegando por um site pode ser simplificado usando as capacidades de navegação do Playwright.

# spiders/multi_page_spider.py

import scrapy
from scrapy_playwright.page import PageCoroutine

class MultiPageSpider(scrapy.Spider):
    name = "multipage"
    start_urls = ["https://example.com/start"]

    def start_requests(self):
        for url in self.start_urls:
            yield scrapy.Request(
                url,
                meta={
                    "playwright": True,
                    "playwright_page_coroutines": [
                        PageCoroutine("wait_for_selector", "div.list"),
                        PageCoroutine("evaluate", "window.scrollTo(0, document.body.scrollHeight)"),
                    ],
                },
            )

    async def parse(self, response):
        # Extraia dados da primeira página
        for item in response.css("div.list-item"):
            yield {
                "name": item.css("span.name::text").get(),
                "price": item.css("span.price::text").get(),
            }

        # Navegue para a próxima página
        next_page = response.css("a.next::attr(href)").get()
        if next_page:
            yield scrapy.Request(
                response.urljoin(next_page),
                callback=self.parse,
                meta={
                    "playwright": True,
                    "playwright_page_coroutines": [
                        PageCoroutine("wait_for_selector", "div.list"),
                    ],
                },
            )

Usando contextos do Playwright

O Playwright permite a criação de vários contextos de navegador, o que pode ser útil para lidar com sessões, cookies ou tarefas de scraping paralelas.

# settings.py

PLAYWRIGHT_CONTEXTS = {
    "default": {
        "viewport": {"width": 1280, "height": 800},
        "user_agent": "CustomUserAgent/1.0",
    },
    "mobile": {
        "viewport": {"width": 375, "height": 667},
        "user_agent": "MobileUserAgent/1.0",
        "is_mobile": True,
    },
}

Em seu spider, especifique o contexto:

# spiders/context_spider.py

import scrapy

class ContextSpider(scrapy.Spider):
    name = "context"
    start_urls = ["https://example.com"]

    def start_requests(self):
        yield scrapy.Request(
            self.start_urls[0],
            meta={
                "playwright": True,
                "playwright_context": "mobile",
            },
        )

    async def parse(self, response):
        # Sua lógica de análise aqui
        pass

Integrando com Middleware

O Scrapy-Playwright pode ser integrado a outros middlewares para aprimorar a funcionalidade, como lidar com novas tentativas, gerenciamento de proxy ou cabeçalhos personalizados.

# settings.py

DOWNLOADER_MIDDLEWARES.update({
    'scrapy.downloadermiddlewares.retry.RetryMiddleware': 550,
    'scrapy_playwright.middleware.ScrapyPlaywrightDownloadHandler': 543,
})

# Exemplo de definir cabeçalhos personalizados
DEFAULT_REQUEST_HEADERS = {
    'User-Agent': 'MyCustomAgent/1.0',
    'Accept-Language': 'en-US,en;q=0.9',
}

Boas práticas

Para aproveitar ao máximo o Scrapy-Playwright e o CapSolver, considere as seguintes boas práticas:

1. Otimize o uso do Playwright: Use o Playwright apenas para solicitações que exigem renderização de JavaScript para economizar recursos.
2. Gerencie contextos de navegador: Reutilize contextos de navegador sempre que possível para melhorar o desempenho e reduzir o overhead.
3. Lidar com timeouts graciosamente: Defina timeouts apropriados e tratamento de erros para gerenciar páginas de carregamento lento.
4. Respeite o Robots.txt e os termos de serviço: Sempre certifique-se de que suas atividades de scraping estejam em conformidade com as políticas do site de destino.
5. Implemente limitação e atrasos: Evite sobrecarregar o servidor de destino, implementando práticas de scraping corretas.
6. Proteja suas chaves de API CapSolver: Armazene informações confidenciais, como chaves de API, com segurança e evite codificá-las em seus scripts.
7. Monitore e registre a atividade de scraping: Mantenha o controle de suas operações de scraping para identificar e resolver problemas rapidamente.

Código bônus

Reivindique seu Código Bônus para as principais soluções de captcha no CapSolver: scrape. Após resgatá-lo, você receberá um bônus extra de 5% após cada recarga, ilimitado vezes.

Conclusão

O Scrapy-Playwright é um divisor de águas para o web scraping, fechando a lacuna entre a extração de conteúdo estático e dinâmico. Ao aproveitar o poder do framework robusto do Scrapy e da automação avançada de navegador do Playwright, você pode lidar com as tarefas de scraping mais desafiadoras com facilidade. Além disso, a integração do CapSolver permite que você supere desafios de captcha, garantindo a coleta de dados ininterrupta, mesmo dos sites mais protegidos.

Se você está raspando sites de comércio eletrônico, plataformas de mídia social ou qualquer site com JavaScript intenso, o Scrapy-Playwright combinado com o CapSolver fornece as ferramentas de que você precisa para ter sucesso. Seguindo as melhores práticas e aproveitando essas integrações poderosas, você pode construir soluções de web scraping eficientes, confiáveis e escalonáveis, adaptadas às suas necessidades específicas.

Pronto para elevar seus projetos de scraping? Mergulhe no Scrapy-Playwright e no CapSolver e desbloqueie novas possibilidades para coleta e automação de dados.