Cómo resolver los desafíos del scraping web con Scrapy y Playwright en 2025

¿Qué es Scrapy-Playwright?

Scrapy-Playwright es un middleware que integra Scrapy, un framework de scraping web rápido y potente para Python, con Playwright, una biblioteca de automatización de navegadores. Esta combinación permite a Scrapy manejar sitios web con JavaScript intensivo al aprovechar la capacidad de Playwright para renderizar contenido dinámico, interactuar con páginas web y administrar contextos de navegador sin problemas.

¿Por qué usar Scrapy-Playwright?

Si bien Scrapy es excelente para raspar sitios web estáticos, muchos sitios web modernos dependen en gran medida de JavaScript para renderizar contenido dinámicamente. Los arañas tradicionales de Scrapy pueden tener dificultades con estos sitios, a menudo perdiendo datos críticos o sin poder navegar por estructuras de página complejas. Scrapy-Playwright cierra esta brecha al permitir que Scrapy controle un navegador sin cabeza, asegurando que todo el contenido dinámico esté completamente cargado y accesible para el raspado.

Beneficios de usar Scrapy-Playwright

• Renderizado de JavaScript: Raspe fácilmente sitios web que cargan contenido dinámicamente usando JavaScript.
• Navegación sin cabeza: Realice tareas de raspado sin un navegador visible, optimizando el rendimiento.
• Interacciones avanzadas: Maneje interacciones complejas como hacer clic en botones, rellenar formularios y navegar por las páginas.
• Operaciones asíncronas: Benefíciese de las capacidades asíncronas de Playwright para acelerar las tareas de raspado.

Instalación

Para comenzar con Scrapy-Playwright, deberá instalar tanto Scrapy como Playwright. Así es como puede configurar su entorno:

1. Instalar Scrapy:

   bash Copy

   pip install scrapy

2. Instalar Scrapy-Playwright:

   bash Copy

   pip install scrapy-playwright

3. Instalar navegadores Playwright:

   Después de instalar Playwright, necesita instalar los binarios de navegador necesarios.

   bash Copy

   playwright install

Empezando

Configurar un nuevo proyecto Scrapy

Primero, cree un nuevo proyecto Scrapy si aún no lo ha hecho:

scrapy startproject myproject
cd myproject

Configurar Playwright

A continuación, deberá habilitar Playwright en la configuración de su proyecto Scrapy. Abra settings.py y agregue las siguientes configuraciones:

# settings.py

# Habilitar el middleware de descargador Playwright
DOWNLOADER_MIDDLEWARES = {
    'scrapy_playwright.middleware.ScrapyPlaywrightDownloadHandler': 543,
}

# Especificar el controlador de descarga para HTTP y HTTPS
DOWNLOAD_HANDLERS = {
    'http': 'scrapy_playwright.handler.ScrapyPlaywrightDownloadHandler',
    'https': 'scrapy_playwright.handler.ScrapyPlaywrightDownloadHandler',
}

# Habilitar la configuración de Playwright
TWISTED_REACTOR = 'twisted.internet.asyncioreactor.AsyncioSelectorReactor'

# Configuración de Playwright (opcional)
PLAYWRIGHT_BROWSER_TYPE = 'chromium'  # Puede ser 'chromium', 'firefox' o 'webkit'
PLAYWRIGHT_LAUNCH_OPTIONS = {
    'headless': True,
}

Uso básico

Crear una araña

Con la configuración completa, creemos una araña simple que use Playwright para raspar un sitio web renderizado con JavaScript. Para ilustrar, rasparemos un sitio hipotético que carga contenido dinámicamente.

Cree un nuevo archivo de araña dynamic_spider.py dentro del directorio 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):
        # Extraer datos después de que JavaScript haya renderizado el contenido
        for item in response.css("div.content"):
            yield {
                "title": item.css("h2::text").get(),
                "description": item.css("p::text").get(),
            }

        # Manejar la paginación o las interacciones adicionales si es necesario

Manejar contenido renderizado con JavaScript

En el ejemplo anterior:

• playwright: True: Informa a Scrapy que use Playwright para esta solicitud.
• playwright_page_coroutines: Especifica acciones para realizar con Playwright. Aquí, espera un selector div.content para asegurarse de que el contenido dinámico se haya cargado antes del análisis.
• Método parse asíncrono: Aprovecha las capacidades asíncronas para manejar la respuesta de manera efectiva.

Resolver captchas con CapSolver

Uno de los desafíos importantes en el raspado web es lidiar con los captchas, que están diseñados para evitar el acceso automatizado. CapSolver es una solución robusta que proporciona servicios de resolución de captchas, incluidas integraciones con herramientas de automatización de navegadores como Playwright. En esta sección, exploraremos cómo integrar CapSolver con Scrapy-Playwright para manejar los captchas sin problemas.

¿Qué es CapSolver?

CapSolver es un servicio de resolución de captchas que automatiza el proceso de resolución de varios tipos de captchas, incluidos captcha y reCAPTCHA. Al integrar CapSolver con su flujo de trabajo de raspado, puede omitir los desafíos de captcha y mantener el flujo de sus tareas de raspado sin intervención manual.

Integrar CapSolver con Scrapy-Playwright

Para integrar CapSolver con Scrapy-Playwright, deberá:

1. Obtener la extensión del navegador CapSolver: CapSolver proporciona una extensión del navegador que automatiza la resolución de captchas dentro de los contextos del navegador.
2. Configurar Playwright para cargar la extensión CapSolver: Al iniciar el navegador Playwright, cargue la extensión CapSolver para habilitar la resolución de captchas.
3. Modificar las solicitudes de Scrapy para usar el contexto de Playwright personalizado: Asegúrese de que sus solicitudes de Scrapy utilicen el contexto de Playwright con la extensión CapSolver cargada.

Implementación de ejemplo en Python

A continuación, se muestra una guía paso a paso para integrar CapSolver con Scrapy-Playwright, con código de ejemplo.

1. Obtener la extensión del navegador CapSolver

Primero, descargue la extensión del navegador CapSolver y colóquela en el directorio de su proyecto. Suponga que la extensión está ubicada en CapSolver.Browser.Extension.

2. Configurar la extensión:

• Busque el archivo de configuración ./assets/config.json en el directorio de la extensión CapSolver.
• Establezca la opción enabledForcaptcha en true y ajuste el captchaMode a token para la resolución automática.

Ejemplo config.json:

{
  "enabledForcaptcha": true,
  "captchaMode": "token"
  // otras configuraciones permanecen iguales
}

3. Actualizar la configuración de Scrapy para cargar la extensión

Modifique su settings.py para configurar Playwright para que cargue la extensión CapSolver. Deberá especificar la ruta a la extensión y pasar los argumentos necesarios a Playwright.

# settings.py

import os
from pathlib import Path

# Configuración de Playwright existente
PLAYWRIGHT_BROWSER_TYPE = 'chromium'
PLAYWRIGHT_LAUNCH_OPTIONS = {
    'headless': False,  # Debe ser False para cargar extensiones
    'args': [
        '--disable-extensions-except={}'.format(os.path.abspath('CapSolver.Browser.Extension')),
        '--load-extension={}'.format(os.path.abspath('CapSolver.Browser.Extension')),
    ],
}

# Asegúrese de que el reactor Twisted esté configurado
TWISTED_REACTOR = 'twisted.internet.asyncioreactor.AsyncioSelectorReactor'

Nota: Cargar extensiones del navegador requiere que el navegador se ejecute en modo no sin cabeza. Por lo tanto, configure 'headless': False.

3. Crear una araña que maneje los captchas

Cree una nueva araña o modifique una existente para interactuar con los captchas usando la extensión 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),  # Esperar a que la extensión procese
                    ],
                    "playwright_context": "default",
                },
                callback=self.parse_captcha
            )

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

        # Localice la casilla de verificación o el cuadro captcha e interactúe en consecuencia
        try:
            # Espere a que el iframe captcha esté disponible
            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:
                # Haga clic en la casilla de verificación captcha
                await captcha_frame.click("div#checkbox")

                # Espere a que CapSolver resuelva el captcha
                await page.wait_for_selector("div.captcha-success", timeout=60000)  # Ajuste el selector según sea necesario

                self.logger.info("Captcha resuelto con éxito.")
            else:
                self.logger.warning("No se encontró el iframe captcha.")
        except Exception as e:
            self.logger.error(f"Error al manejar el captcha: {e}")

        # Continúe analizando la página después de que se resuelva el captcha
        for item in response.css("div.content"):
            yield {
                "title": item.css("h2::text").get(),
                "description": item.css("p::text").get(),
            }

        # Manejar la paginación o las interacciones adicionales si es necesario

4. Ejecutar la araña

Asegúrese de que todas las dependencias estén instaladas y ejecute su araña usando:

scrapy crawl captcha_spider

Funciones avanzadas

Una vez que se sienta cómodo con los conceptos básicos, Scrapy-Playwright ofrece varias funciones avanzadas para mejorar sus proyectos de raspado.

Manejar múltiples páginas

El raspado de múltiples páginas o la navegación por un sitio web se puede optimizar utilizando las capacidades de navegación de 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):
        # Extraer datos de la primera 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(),
            }

        # Navegar a la siguiente 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"),
                    ],
                },
            )

Usar contextos de Playwright

Playwright permite la creación de múltiples contextos de navegador, lo que puede ser útil para manejar sesiones, cookies o tareas de raspado en paralelo.

# 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,
    },
}

En su araña, especifique el 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):
        # Su lógica de análisis aquí
        pass

Integrar con middleware

Scrapy-Playwright se puede integrar con otros middlewares para mejorar la funcionalidad, como manejar reintentos, administración de proxy o encabezados personalizados.

# settings.py

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

# Ejemplo de configurar encabezados personalizados
DEFAULT_REQUEST_HEADERS = {
    'User-Agent': 'MyCustomAgent/1.0',
    'Accept-Language': 'en-US,en;q=0.9',
}

Mejores prácticas

Para aprovechar al máximo Scrapy-Playwright y CapSolver, considere las siguientes mejores prácticas:

1. Optimizar el uso de Playwright: Use Playwright solo para solicitudes que requieren renderizado de JavaScript para ahorrar recursos.
2. Administrar contextos de navegador: Reutilice los contextos de navegador siempre que sea posible para mejorar el rendimiento y reducir la sobrecarga.
3. Manejar los tiempos de espera con gracia: Establezca tiempos de espera apropiados y el manejo de errores para administrar páginas de carga lenta.
4. Respetar robots.txt y los términos de servicio: Asegúrese siempre de que sus actividades de raspado cumplan con las políticas del sitio web de destino.
5. Implementar el estrangulamiento y las demoras: Evite sobrecargar el servidor de destino mediante la implementación de prácticas de raspado educadas.
6. Asegurar sus claves API de CapSolver: Almacene información confidencial como claves API de forma segura y evite codificarlas en sus scripts.
7. Supervisar y registrar la actividad de raspado: Lleve un registro de sus operaciones de raspado para identificar y resolver problemas rápidamente.

Código de bonificación

Reclame su Código de bonificación para las mejores soluciones de captcha en CapSolver: scrape. Después de canjearlo, obtendrá un bono adicional del 5% después de cada recarga, sin límite de veces.

Conclusión

Scrapy-Playwright es un cambio de juego para el raspado web, cerrando la brecha entre la extracción de contenido estático y dinámico. Al aprovechar el poder del sólido marco de Scrapy y la automatización avanzada del navegador de Playwright, puede abordar incluso las tareas de raspado más desafiantes con facilidad. Además, la integración de CapSolver le permite superar los desafíos de captcha, asegurando la recolección ininterrumpida de datos incluso de los sitios web más protegidos.

Ya sea que esté raspando sitios de comercio electrónico, plataformas de redes sociales o cualquier sitio web con JavaScript intensivo, Scrapy-Playwright combinado con CapSolver le proporciona las herramientas que necesita para tener éxito. Siguiendo las mejores prácticas y aprovechando estas poderosas integraciones, puede crear soluciones de raspado web eficientes, confiables y escalables adaptadas a sus necesidades específicas.

¿Listo para elevar sus proyectos de raspado? Sumérjase en Scrapy-Playwright y CapSolver, y desbloquee nuevas posibilidades para la recolección de datos y la automatización.