Scrapy vs Playwright: Una comparación para Web Scraping

En esta guía aprenderás:

• Qué es Scrapy
• Qué dramaturgo es
• Las funciones que ofrecen para el web scraping y su comparación
• Introducción al web scraping con ambas herramientas
• Cómo construir un rascador con Playwright
• Cómo construir un script de web scraping con Scrapy
• ¿Qué herramienta es mejor para el web scraping?
• Sus limitaciones habituales y cómo superarlas

Sumerjámonos.

¿Qué es Scrapy?

Scrapy es un framework de scraping web de código abierto escrito en Python, desarrollado para la extracción eficiente de datos. Ofrece soporte integrado para capacidades como peticiones paralelas, seguimiento de enlaces y exportación de datos en formatos como JSON y CSV. Además, cuenta con middleware, integración de proxy y reintentos automáticos de peticiones. Scrapy funciona de forma asíncrona y en páginas HTML estáticas.

¿Qué es un dramaturgo?

Playwright es un marco de automatización de código abierto para pruebas E2E y web scraping en el navegador. Es compatible con varios navegadores, como Chrome, Firefox y WebKit, tanto en modo encabezado como sin encabezado. Además, la API de automatización del navegador está disponible en varios lenguajes de programación, como TypeScript/JavaScript, Python, Java y C#.

Scrapy frente a Playwright: características principales del raspado web

Comparemos Scrapy y Playwright en cinco aspectos diferentes que contribuyen a hacer de ellos grandes herramientas de web scraping.

Si desea consultar otras entradas del blog, lea:

• Scrapy frente a Beautiful Soup
• Scrapy vs Pyspider: ¿Cuál es mejor para Web Scraping?
• Scrapy vs. Selenium para Web Scraping
• Scrapy vs. Puppeteer para Web Scraping
• Scrapy vs. Requests: ¿Cuál es mejor para el Web Scraping?

Ahora, ¡empieza la comparación entre Scrapy y Playwright!

Facilidad de instalación y configuración

Scrapy ofrece una configuración sencilla y mínima. Puede crear rápidamente un proyecto, definir arañas y exportar datos gracias a su CLI integrada. Por el contrario, Playwright requiere más configuración, ya que implica la instalación de dependencias del navegador y la comprobación de la configuración adecuada.

Curva de aprendizaje

Scrapy tiene una curva de aprendizaje más pronunciada para los principiantes debido a su estructura modular, sus amplias funciones y sus configuraciones únicas. Entender conceptos como spiders, middlewares y pipelines puede llevar tiempo. Playwright es mucho más fácil para empezar, ya que su API es familiar para aquellos con algún conocimiento de automatización de navegadores.

Gestión dinámica de contenidos

Scrapy tiene dificultades con los sitios web que utilizan JavaScript, ya que sólo puede tratar con documentos HTML estáticos. Manejar contenido dinámico es posible, pero requiere integración con Splash o herramientas similares. Playwright destaca en el manejo de contenidos dinámicos o renderizados con JavaScript porque renderiza las páginas de forma nativa en el navegador. Esto significa que puede utilizarlo para raspar páginas que dependen de marcos de trabajo de cliente como React, Angular o Vue.

Personalización y extensibilidad

Scrapy ofrece grandes posibilidades de personalización gracias a su compatibilidad con middlewares, extensiones y pipelines. Además, dispone de varios plugins y complementos. Playwright, por otro lado, no es extensible de forma nativa. Por suerte, la comunidad ha abordado esta limitación con el proyecto Playwright Extra.

Otras funciones de raspado

Scrapy le proporciona funciones integradas como la integración de proxy, reintentos automáticos y exportación de datos configurable. También ofrece métodos integrados para la rotación de IP y otros escenarios avanzados. Playwright no soporta la integración de proxy y otras características clave de scraping. Por lo tanto, conseguir los mismos resultados requiere más esfuerzo manual en comparación con Scrapy.

Playwright vs Scrapy: Comparación de Scraping Script

En las dos secciones siguientes, aprenderá a raspar el mismo sitio utilizando Playwright y Scrapy. Empezaremos con Playwright, ya que puede llevar un poco más de tiempo porque no está optimizado específicamente para el raspado web como Scrapy.

El sitio de destino será el sandbox de raspado Books to Scrape:

El objetivo de ambos raspadores es recuperar todos los libros de Fantasía del sitio, lo que requiere manejar la paginación.

Scrapy tratará las páginas como estáticas y analizará directamente sus documentos HTML. En cambio, Playwright las renderizará en un navegador e interactuará con los elementos de las páginas, simulando las acciones del usuario.

El script de Scrapy estará escrito en Python, mientras que el script de Playwright estará en JavaScript, los dos lenguajes admitidos principalmente por ambas herramientas. Aun así, puede convertir fácilmente el script JavaScript de Playwright a Python utilizando la biblioteca playwright-python, que expone la misma API subyacente.

En ambos casos, al final de la secuencia de comandos, tendrá un CSV que contiene todos los detalles del libro Fantasy de Books to Scrape.

Pasemos ahora a la comparación entre Playwright y Scrapy.

Cómo utilizar Playwright para el Web Scraping

Siga los pasos que se indican a continuación para escribir un sencillo script de web scraping en JavaScript utilizando Playwright. Si no está familiarizado con el proceso, lea primero nuestra guía sobre web scraping en Playwright.

Paso nº 1: Configuración del proyecto

Antes de empezar, asegúrate de que tienes la última versión de Node.js instalada localmente. Si no es así, descárgala y sigue el asistente de instalación.

A continuación, cree una carpeta para su Playwright scraper y navegue hasta ella utilizando el terminal:

mkdir playwright-scraper
cd playwright-scraper

Dentro de la carpeta playwright-scraper, inicializa un proyecto npm ejecutando:

npm init -y

Ahora, abra la carpeta playwright-scraper en su IDE de JavaScript favorito. IntelliJ IDEA o Visual Studio Code son buenas opciones. Dentro de la carpeta, cree un archivo script.js, que pronto contendrá la lógica de raspado:

¡Genial! Ahora está totalmente preparado para el web scraping en Node.js con Playwright.

Paso 2: Instalar y configurar Playwright

En la carpeta del proyecto, ejecute el siguiente comando para instalar Playwright:

npm install playwright

A continuación, instala el navegador y cualquier dependencia adicional ejecutando:

npx playwright install

Ahora, abre script.js y añade el siguiente código para importar Playwright y lanzar una instancia del navegador Chromium:

const { chromium } = require("playwright");

(async () => {
  // initialize a Chromium browser
  const browser = await chromium.launch({
    headless: false, // comment out in production
  });

  // scraping logic goes here...

  // close the browser and release resources
  await browser.close();
})();

La opción headless: false lanza el navegador en modo encabezado. Esto le permite ver lo que está haciendo el script, lo que resulta útil para depurar durante el desarrollo.

Paso 3: Conectarse a la página de destino

Inicializa una nueva página en el navegador y utiliza la función goto() para navegar a la página de destino:

const page = await browser.newPage();
await page.goto("https://books.toscrape.com/catalogue/category/books/fantasy_19/index.html");

Si ejecutas el script en el depurador con breakpoint antes de la función close(), verás que el navegador se abre y navega a la página de destino:

Asombroso. Playwright controla el navegador como se esperaba.

Paso 4: Implementar la lógica de análisis de datos

Antes de escribir la lógica de raspado, debe comprender la estructura de la página. Para ello, abra el sitio de destino en una ventana de incógnito de su navegador. A continuación, haga clic con el botón derecho en un elemento del libro y seleccione la opción “Inspeccionar”.

Esto es lo que debería ver en las DevTools:

Arriba, puede observar que cada elemento del libro puede seleccionarse utilizando el selector CSS .product_pod.

Dado que la página contiene varios libros, primero inicialice una matriz para almacenar los datos raspados:

books = []

Selecciónelos todos e itere sobre ellos como se indica a continuación:

const bookElements = await page.locator(".product_pod").all();
for (const bookElement of bookElements) {
  // extract book details...
}

De cada elemento del libro, como se muestra en la imagen anterior, puede extraer:

• La URL del libro de la etiqueta <a>.
• El título del libro del nodo h3 a
• La imagen del libro del elemento .thumbnail
• La valoración del libro a partir del elemento .star-rating
• El precio del producto del elemento .product_price .price_color
• La disponibilidad del producto a partir del elemento .availability

Ahora, implemente la lógica de raspado dentro del bucle:

const urlElement = await bookElement.locator("a").first();
const url = makeAbsoluteURL(
  await urlElement.getAttribute("href"),
  "https://books.toscrape.com/catalogue/"
);

const titleElement = await bookElement.locator("h3 a");
const title = await titleElement.getAttribute("title");

const imageElement = await bookElement.locator(".thumbnail");
const image = makeAbsoluteURL(
  await imageElement.getAttribute("src"),
  "https://books.toscrape.com/"
);

const ratingElement = await bookElement.locator(".star-rating");
const ratingClass = await ratingElement.getAttribute("class");
let rating;
switch (true) {
  case ratingClass.includes("One"):
    rating = 1;
    break;
  case ratingClass.includes("Two"):
    rating = 2;
    break;
  case ratingClass.includes("Three"):
    rating = 3;
    break;
  case ratingClass.includes("Four"):
    rating = 4;
    break;
  case ratingClass.includes("Five"):
    rating = 5;
    break;
  default:
    rating = null;
}

const priceElement = await bookElement.locator(
  ".product_price .price_color"
);
const price = (await priceElement.textContent()).trim();

const availabilityElement = await bookElement.locator(".availability");
const availability = (await availabilityElement.textContent()).trim();

El fragmento anterior utiliza las funciones de Playwright getAttribute() y textContent() para extraer atributos HTML específicos y texto de nodos HTML, respectivamente. Observe la lógica personalizada para recuperar la puntuación de la calificación.

Además, dado que las URL de la página son relativas, pueden convertirse en URL absolutas utilizando la siguiente función personalizada:

function makeAbsoluteURL(url, baseURL) {
  // use a regular expression to remove any ../ or ../../ patterns
  const cleanURL = url.replace(/(\.\.\/)+/, "");

  // combine the base URL with the cleaned relative URL
  return baseURL + cleanURL;
}

A continuación, rellene un nuevo objeto con los datos obtenidos y añádalo a la matriz de libros:

const book = {
  "url": url,
  "title": title,
  "image": image,
  "rating": rating,
  "price": price,
  "availability": availability,
};
books.push(book);

Perfecto. La lógica de raspado de Playwright ya está completa.

Paso 4: Implementar la lógica de rastreo

Si echa un vistazo al sitio de destino, observará que algunas páginas tienen un botón “siguiente” en la parte inferior:

Al hacer clic, se carga la página siguiente. Tenga en cuenta que la última página de paginación no lo incluye por razones obvias.

Por lo tanto, puede implementar la lógica de rastreo web con un bucle while (true) que:

1. Extrae datos de la página actual
2. Pulsa el botón “siguiente” si está presente y espera a que se cargue la nueva página.
3. Repite el proceso hasta que el botón “siguiente” ya no se encuentra

A continuación te explicamos cómo puedes conseguirlo:

while (true) {
  // select the book elements ...

  // select the "next" button and check if it is on the page
  const nextElement = await page.locator("li.next a");
  if ((await nextElement.count()) !== 0) {
    // click the "next" button and go to the next page
    await nextElement.click();
    // wait for the page to have been loaded
    await page.waitForLoadState("domcontentloaded")
  } else {
    break;
  }
}

¡Fantástico! Lógica de rastreo implementada.

Paso 5: Exportar a CSV

El último paso es exportar los datos a un archivo CSV. Aunque puedes hacerlo con Node.js, es mucho más fácil con una librería dedicada como fast-csv.

Instale el paquete fast-csv ejecutando el siguiente comando:

npm install fast-csv

Al principio de su archivo scraping.js, importe los módulos necesarios:

const { writeToPath } = require("fast-csv");

A continuación, utilice el siguiente fragmento para escribir los datos obtenidos en un archivo CSV:

writeToPath("books.csv", books, { headers: true });

¡Et voilà! El script Playwright web scraping está listo.

Paso nº 6: Póngalo todo junto

Su archivo script.js debe contener:

const { chromium } = require("playwright");
const { writeToPath } = require("fast-csv");

(async () => {
  // initialize a Chromium browser
  const browser = await chromium.launch({
    headless: false, // comment out in production
  });

  // initialize a new page in the browser
  const page = await browser.newPage();

  // visit the target page
  await page.goto(
    "https://books.toscrape.com/catalogue/category/books/fantasy_19/index.html"
  );

  // where to store the scraped data
  books = [];

  while (true) {
    // select the book elements
    const bookElements = await page.locator(".product_pod").all();
    // iterate over them to extract data from them
    for (const bookElement of bookElements) {
      // data extraction logic
      const urlElement = await bookElement.locator("a").first();
      const url = makeAbsoluteURL(
        await urlElement.getAttribute("href"),
        "https://books.toscrape.com/catalogue/"
      );

      const titleElement = await bookElement.locator("h3 a");
      const title = await titleElement.getAttribute("title");

      const imageElement = await bookElement.locator(".thumbnail");
      const image = makeAbsoluteURL(
        await imageElement.getAttribute("src"),
        "https://books.toscrape.com/"
      );

      const ratingElement = await bookElement.locator(".star-rating");
      const ratingClass = await ratingElement.getAttribute("class");
      let rating;
      switch (true) {
        case ratingClass.includes("One"):
          rating = 1;
          break;
        case ratingClass.includes("Two"):
          rating = 2;
          break;
        case ratingClass.includes("Three"):
          rating = 3;
          break;
        case ratingClass.includes("Four"):
          rating = 4;
          break;
        case ratingClass.includes("Five"):
          rating = 5;
          break;
        default:
          rating = null;
      }

      const priceElement = await bookElement.locator(
        ".product_price .price_color"
      );
      const price = (await priceElement.textContent()).trim();

      const availabilityElement = await bookElement.locator(".availability");
      const availability = (await availabilityElement.textContent()).trim();

      // populate a new book item with the scraped data and
      // then add it to the array
      const book = {
        "url": url,
        "title": title,
        "image": image,
        "rating": rating,
        "price": price,
        "availability": availability,
      };
      books.push(book);
    }

    // select the "next" button and check if it is on the page
    const nextElement = await page.locator("li.next a");
    if ((await nextElement.count()) !== 0) {
      // click the "next" button and go to the next page
      await nextElement.click();
      // wait for the page to have been loaded
      await page.waitForLoadState("domcontentloaded");
    } else {
      break;
    }
  }

  // export the scraped data to CSV
  writeToPath("books.csv", books, { headers: true });

  // close the browser and release resources
  await browser.close();
})();

function makeAbsoluteURL(url, baseURL) {
  // use a regular expression to remove any ../ or ../../ patterns
  const cleanURL = url.replace(/(\.\.\/)+/, "");

  // combine the base URL with the cleaned relative URL
  return baseURL + cleanURL;
}

Ejecútalo con este comando Node.js:

node script.js

El resultado será el siguiente archivo books.csv:

¡Misión cumplida! Ahora, es el momento de ver cómo obtener el mismo resultado con Scrapy.

Cómo utilizar Scrapy para Web Scraping

Siga los pasos que se indican a continuación y vea cómo crear un raspador web sencillo con Scrapy. Para obtener más orientación, consulte nuestro tutorial sobre Scrapy web scraping.

Paso nº 1: Configuración del proyecto

Antes de empezar, comprueba que tienes Python 3 instalado localmente. Si no es así, descárgalo del sitio oficial e instálalo.

Crea una carpeta para tu proyecto e inicializa un entorno virtual dentro de ella:

mkdir scrapy-scraper
cd scrapy-scraper
python -m venv venv

En Windows, ejecute el siguiente comando para activar el entorno:

venv\Scripts\activate

De forma equivalente, en Unix o macOS, ejecute:

source venv/bin/activate

En un entorno activado, instale Scrapy con:

pip install scrapy

A continuación, ejecute el siguiente comando para crear un proyecto Scrapy llamado “books_scraper”:

scrapy startproject books_scraper

Genial. Ya está preparado para el web scraping con Scrapy.

Paso 2: Crear la araña Scrapy

Entre en la carpeta del proyecto Scrapy y genere una nueva araña para el sitio de destino:

cd books_scraper
scrapy genspider books books.toscrape.com

Scrapy creará automáticamente todos los archivos necesarios para usted. En concreto, el directorio books_scraper debería contener ahora la siguiente estructura de archivos:

books_scraper/
   │── __init__.py
   │── items.py
   │── middlewares.py
   │── pipelines.py
   │── settings.py
   └── spiders/
       │── __init__.py
       └── books.py

Para implementar la lógica de raspado deseada, sustituya el contenido de books_scraper/spiders/books.py por el siguiente código:

import scrapy

class BooksSpider(scrapy.Spider):
    name = "books"
    allowed_domains = ["books.toscrape.com"]
    start_urls = ["https://books.toscrape.com/catalogue/page-1.html"]

    def parse(self, response):
        # Extract book details
        for book in response.css(".product_pod"):
            yield {
                "title": book.css("h3 a::attr(title)").get(),
                "url": response.urljoin(book.css("h3 a::attr(href)").get()),
                "image": response.urljoin(book.css(".thumbnail::attr(src)").get()),
                "rating": book.css(".star-rating::attr(class)").get().split()[-1],
                "price": book.css(".product_price .price_color::text").get(),
                "availability": book.css(".availability::text").get().strip(),
            }

        # Handle pagination
        next_page = response.css("li.next a::attr(href)").get()
        if next_page:
            yield response.follow(next_page, callback=self.parse)

Paso nº 3: Lanzar la araña

En la carpeta books_scraper, en un entorno virtual activado, ejecute el siguiente comando para ejecutar su araña Scrapy y exportar los datos raspados a un archivo CSV:

scrapy crawl books -o books.csv

Esto generará un archivo books.csv que contendrá los datos raspados, igual que el producido por el script Playwright. Una vez más, ¡misión cumplida!

Scrapy vs Playwright: ¿Cuál usar?

El script de scraping de Playwright requería seis largos pasos, mientras que Scrapy sólo necesitaba tres. Esto no es sorprendente, ya que Scrapy está diseñado para el raspado web, mientras que Playwright es una herramienta general de automatización del navegador que se utiliza tanto para pruebas como para raspado.

En concreto, la diferencia clave estaba en la lógica de rastreo web. Playwright requería interacciones manuales y lógica personalizada para la paginación, mientras que Scrapy puede hacerlo con unas pocas líneas de código.

En resumen, elija Scrapy en lugar de Playwright en uno de estos escenarios:

1. Necesita extracción de datos a gran escala con soporte de rastreo integrado.
2. El rendimiento y la velocidad son prioritarios, ya que Scrapy está optimizado para peticiones rápidas y paralelas.
3. Prefiere un marco que gestione la paginación, los reintentos, la extracción de datos en muchos formatos y el scraping paralelo por usted.

Por el contrario, prefiero Playwright a Scrapy cuando:

1. Necesita extraer datos de sitios web con mucho JavaScript que requieren la renderización del navegador.
2. Se necesitan interacciones dinámicas como el desplazamiento infinito.
3. Desea un mayor control sobre las interacciones del usuario (por ejemplo, en patrones de navegación complejos de web scraping).

Como último paso en esta comparación entre Scrapy y Playwright, consulte la tabla resumen que figura a continuación:

Características	Chatarra	Dramaturgo
Desarrollado por	Zyte + la comunidad	Microsoft + la comunidad
Estrellas de GitHub	54k+	69k+
Descargas	380k+, semanal	12M+, semanal
Lenguajes de programación	Python	Python, JavaScript, TypeScript, C#
Objetivo principal	Web scraping y crawling	Automatización de navegadores, pruebas y web scraping
Representación de JavaScript	❌ (posible con algunos plugins)	✔️
Interacción con el navegador	❌ (posible con algunos plugins)	✔️
Rastreo automático	✔️	❌ (requiere manipulación manual)
Integración de proxy	Soporte	Soporte
Solicitudes paralelas	Eficaz y fácilmente configurable	Limitado, pero posible
Exportación de datos	CSV, JSON, XML, etc.	Requiere lógica personalizada

Limitaciones de Playwright y Scrapy

Tanto Scrapy como Playwright son potentes herramientas para el web scraping, pero cada una de ellas tiene ciertas limitaciones.

Scrapy, por ejemplo, tiene problemas con el scraping de contenidos dinámicos de sitios que dependen de JavaScript para el renderizado o la recuperación de datos. Dado que muchos sitios web modernos requieren JavaScript, Scrapy es más vulnerable a las medidas anti-scraping habituales. Por supuesto, Playwright puede manejar sitios con mucho JavaScript, pero se enfrenta a problemas como las prohibiciones de IP.

Cuando se realizan muchas solicitudes, pueden activarse los limitadores de velocidad, lo que puede dar lugar a denegaciones de solicitudes o incluso prohibiciones de IP. Para evitarlo, puedes integrar un servidor proxy para rotar las IP.

Si necesita servidores proxy fiables, la red proxy de Bright Data cuenta con la confianza de empresas incluidas en la lista Fortune 500 y más de 20.000 clientes en todo el mundo. Su red incluye:

• Proxies de centros de datos: Más de 770.000 IP de centros de datos.
• Proxies residenciales: Más de 72 millones de IP residenciales en más de 195 países.
• Proxies ISP: Más de 700.000 IP de ISP.
• Proxies móviles: Más de 7 millones de IP móviles.

Otro reto con Playwright son los CAPTCHAs, que están diseñados para bloquear los bots de scraping automatizados que operan en los navegadores. Para superarlos, puede explorar soluciones para eludir los CAPTCHA en Playwright.

Conclusión

En esta entrada del blog Playwright vs Scrapy, aprendiste acerca de los roles de ambas librerías en el web scraping. Exploraste sus características para la extracción de datos y comparaste su rendimiento en un escenario real de paginación.

Scrapy proporciona todo lo necesario para analizar datos y rastrear sitios web, mientras que Playwright se centra más en simular las interacciones de los usuarios.

También descubrió sus limitaciones, como las prohibiciones de IP y los CAPTCHA. Afortunadamente, estos retos pueden superarse utilizando proxies o soluciones anti-bot dedicadas como CAPTCHA Solver de Bright Data.

Cree hoy mismo una cuenta gratuita en Bright Data para explorar nuestras soluciones de proxy y scraping.