Bright Data Scraping Browser para scraping web a escala

El scraping web a menudo requiere sortear mecanismos anti-bot, cargar contenidos dinámicos mediante herramientas de automatización del navegador como Puppeteer, utilizar rotación de proxy para evitar bloqueos de IP y resolver CAPTCHAs. Incluso con estas estrategias, escalar y mantener sesiones estables sigue siendo un reto.

Este artículo le enseña cómo pasar del scraping tradicional basado en proxy al Bright Data Scraping Browser. Aprenda a automatizar la gestión y el escalado de proxy para reducir los costes de desarrollo y mantenimiento. Se compararán ambos métodos, cubriendo la configuración, el rendimiento, la escalabilidad y la complejidad.

Nota: Los ejemplos de este artículo tienen fines educativos. Consulta siempre las condiciones de servicio del sitio web de destino y cumple las leyes y normativas pertinentes antes de realizar el scraping de datos.

Requisitos previos

Antes de empezar el tutorial, asegúrese de que dispone de los siguientes requisitos previos:

Node.js
Código de Visual Studio
Una cuenta gratuita de Bright Data para poder utilizar su Scraping Browser

Comienza creando una nueva carpeta de proyecto Node.js donde puedas almacenar tu código.

A continuación, abre tu terminal o shell y crea un nuevo directorio utilizando los siguientes comandos:

  mkdir scraping-tutorialrncd scraping-tutorial

Inicializa un nuevo proyecto Node.js:

  npm init -y

La bandera -y responde automáticamente sí a todas las preguntas, creando un archivo package.json con la configuración por defecto.

Web Scraping basado en proxy

En un enfoque típico basado en proxy, se utiliza una herramienta de automatización del navegador como Puppeteer para interactuar con el dominio de destino, cargar contenido dinámico y extraer datos. Mientras lo hace, integra proxies para evitar las prohibiciones de IP y mantener el anonimato.

Vamos a crear rápidamente un script de web scraping usando Puppeteer que scrapea datos de un sitio web de comercio electrónico usando proxies.

Crear un script de Web Scraping usando Puppeteer

Comience instalando Puppeteer:

  npm install puppeteer

A continuación, crea un archivo llamado proxy-scraper.js (puedes ponerle el nombre que quieras) en la carpeta scraping-tutorial y añade el siguiente código:

  const puppeteer = require("puppeteer");

(async () => {
  // Launch a headless browser
  const browser = await puppeteer.launch({
    headless: true,
  });
  const page = await browser.newPage();

  const baseUrl = "https://books.toscrape.com/catalogue/page-";
  const books = [];

  for (let i = 1; i  {
      let books = [];
      document.querySelectorAll(".product_pod").forEach((item) => {
        let title = item.querySelector("h3 a")?.getAttribute("title") || "";
        let price = item.querySelector(".price_color")?.innerText || "";
        books.push({ title, price });
      });
      return books;
    });

    books.push(...pageBooks); // Append books from this page to the main list
  }

  console.log(books); // Print the collected data

  await browser.close();
})();

Este script utiliza Puppeteer para extraer los títulos y precios de los libros de las cinco primeras páginas del sitio web Books to Scrape. Inicia un navegador sin cabeza, abre una nueva página y navega por cada página del catálogo.

Para cada página, el script utiliza selectores DOM dentro de page.evaluate() para extraer los títulos y precios de los libros, almacenando los datos en un array. Una vez procesadas todas las páginas, los datos se imprimen en la consola y se cierra el navegador. Este método extrae eficazmente los datos de un sitio web paginado.

Pruebe y ejecute el código utilizando el siguiente comando:

node proxy-scraper.js

El resultado debería ser el siguiente:

  Navigating to: https://books.toscrape.com/catalogue/page-1.htmlrnNavigating to: https://books.toscrape.com/catalogue/page-2.htmlrnNavigating to: https://books.toscrape.com/catalogue/page-3.htmlrnNavigating to: https://books.toscrape.com/catalogue/page-4.htmlrnNavigating to: https://books.toscrape.com/catalogue/page-5.htmlrn[rn  { title: 'A Light in the Attic', price: '£51.77' },rn  { title: 'Tipping the Velvet', price: '£53.74' },rn  { title: 'Soumission', price: '£50.10' },rn  { title: 'Sharp Objects', price: '£47.82' },rn  { title: 'Sapiens: A Brief History of Humankind', price: '£54.23' },rn  { title: 'The Requiem Red', price: '£22.65' },rn…output omitted…rn  {rn    title: 'In the Country We Love: My Family Divided',rn    price: '£22.00'rn  }rn]

Configurar proxies

Los proxies se emplean habitualmente en las configuraciones de scraping para dividir las peticiones y hacerlas imposibles de rastrear. Un enfoque común es mantener un grupo de proxies y rotarlos dinámicamente.

Coloque sus proxies en una matriz o almacénelos en un archivo separado si lo desea:

  const proxies = [
  "proxy1.example.com:port", 
  "proxy2.example.com:port"
  // Add more proxies here
];

Utilizar la lógica de rotación de proxy

Vamos a mejorar el código con la lógica que gira a través de la matriz de proxy cada vez que se inicia el navegador. Actualiza proxy-scraper.js para incluir el siguiente código:

  const puppeteer = require("puppeteer");

const proxies = [
  "proxy1.example.com:port", 
  "proxy2.example.com:port"
  // Add more proxies here
];

(async () => {
  // Choose a random proxy
  const randomProxy =
    proxies[Math.floor(Math.random() * proxies.length)];

  // Launch Puppeteer with proxy
  const browser = await puppeteer.launch({
    headless: true,
    args: [
      `--proxy-server=http=${randomProxy}`,
      "--no-sandbox",
      "--disable-setuid-sandbox",
      "--ignore-certificate-errors",
    ],
  });

  const page = await browser.newPage();

  const baseUrl = "https://books.toscrape.com/catalogue/page-";
  const books = [];

  for (let i = 1; i  {
      let books = [];
      document.querySelectorAll(".product_pod").forEach((item) => {
        let title = item.querySelector("h3 a")?.getAttribute("title") || "";
        let price = item.querySelector(".price_color")?.innerText || "";
        books.push({ title, price });
      });
      return books;
    });

    books.push(...pageBooks); // Append books from this page to the main list
  }

  console.log(`Using proxy: ${randomProxy}`);
  console.log(books); // Print the collected data

  await browser.close();
})();

Nota : En lugar de hacer la rotación de los proxies manualmente, puedes utilizar una librería como luminati-proxy para automatizar el proceso.

En este codigo, un proxy aleatorio es seleccionado de la lista de proxies y aplicado a Puppeteer usando la opcion --proxy-server=${randomProxy}. Para evitar la deteccion, tambien se asigna una cadena de agente de usuario aleatoria. La logica de scraping es repetida, y el proxy usado para scrapear los datos del producto es registrado.

Cuando ejecutes el código de nuevo, deberías ver una salida como antes pero con un añadido al proxy que se utilizó:

  Navigating to: https://books.toscrape.com/catalogue/page-1.htmlrnNavigating to: https://books.toscrape.com/catalogue/page-2.htmlrnNavigating to: https://books.toscrape.com/catalogue/page-3.htmlrnNavigating to: https://books.toscrape.com/catalogue/page-4.htmlrnNavigating to: https://books.toscrape.com/catalogue/page-5.htmlrnUsing proxy: 115.147.63.59:8081rn…output omitted…

Desafíos del scraping basado en proxy

Aunque un enfoque basado en proxy puede funcionar para muchos casos de uso, puede enfrentarse a algunos de los siguientes retos:

Bloqueos frecuentes: los proxies pueden bloquearse si el sitio tiene una detección anti-bot estricta.
Sobrecarga de rendimiento: la rotación de proxies y el reintento de solicitudes ralentizan el proceso de recopilación de datos.
Escalabilidad compleja: gestionar y rotar un gran grupo de proxies para obtener un rendimiento y una disponibilidad óptimos es complejo. Requiere equilibrar la carga, evitar el uso excesivo de proxies, periodos de enfriamiento y gestionar los fallos en tiempo real. El reto aumenta con las solicitudes simultáneas, ya que el sistema debe eludir la detección mientras supervisa y sustituye continuamente las IP incluidas en listas negras o de bajo rendimiento.
Mantenimiento del navegador: El mantenimiento del navegador puede ser un reto técnico y consumir muchos recursos. Es necesario actualizar y manipular continuamente la huella digital del navegador (cookies, cabeceras y otros atributos identificativos) para imitar el comportamiento real del usuario y eludir los controles anti-bot avanzados.
Sobrecarga del navegador en la nube: Los navegadores basados en la nube generan una sobrecarga operativa adicional a través de mayores requisitos de recursos y un complejo control de la infraestructura, lo que se traduce en elevados gastos operativos. El escalado de las instancias del navegador para obtener un rendimiento constante complica aún más el proceso.

DynamicScraping con Bright Data Scraping Browser

Para superar estos retos, puede utilizar una solución de API única como Bright Data Scraping Browser. Simplifica las operaciones, elimina la necesidad de rotar manualmente el proxy y las complejas configuraciones del navegador y, a menudo, aumenta la tasa de éxito en la recuperación de datos.

Configure su cuenta de Bright Data

Para empezar, inicie sesión en su cuenta de Bright Data y vaya a Proxies & Scraping, desplácese hasta Scraping Browser y haga clic en Empezar:

Mantenga la configuración predeterminada y haga clic en Añadir para crear una nueva instancia de Scraping Browser:

Después de haber creado una instancia de Scraping Browser, toma nota de la URL de Puppeteer ya que la necesitarás pronto:

Ajuste el código para utilizar el navegador de raspado de datos Bright

Ahora, vamos a ajustar el código para que en lugar de utilizar proxies rotatorios, se conecte directamente al endpoint de Bright Data Scraping Browser.

Crea un nuevo archivo llamado brightdata-scraper.js y añade el siguiente código:

  const puppeteer = require("puppeteer");

(async () => {
  // Choose a random proxy
  const SBR_WS_ENDPOINT = "YOUR_BRIGHT_DATA_WS_ENDPOINT"

  // Launch Puppeteer with proxy
  const browser = await puppeteer.connect({
    browserWSEndpoint: SBR_WS_ENDPOINT,
  });

  const page = await browser.newPage();

  const baseUrl = "https://books.toscrape.com/catalogue/page-";
  const books = [];

  for (let i = 1; i  {
      let books = [];
      document.querySelectorAll(".product_pod").forEach((item) => {
        let title = item.querySelector("h3 a")?.getAttribute("title") || "";
        let price = item.querySelector(".price_color")?.innerText || "";
        books.push({ title, price });
      });
      return books;
    });

    books.push(...pageBooks); // Append books from this page to the main list
  }

  console.log(books); // Print the collected data

  await browser.close();
})();

Asegúrese de sustituir YOUR_BRIGHT_DATA_WS_ENDPOINT por la URL que recuperó en el paso anterior.

Este código es similar al anterior, pero en lugar de tener una lista de proxies y hacer malabarismos entre los diferentes proxies, se conecta directamente al endpoint de Bright Data.

Ejecute el siguiente código:

  node brightdata-scraper.js

El resultado debería ser el mismo que antes, pero ahora no tendrá que rotar proxies manualmente ni configurar agentes de usuario. Bright Data Scraping Browser se encarga de todo, desde la rotación de proxies hasta la omisión de CAPTCHA, lo que garantiza un raspado de datos ininterrumpido.

Convierta el código en un punto final Express

Si desea integrar Bright Data Scraping Browser en una aplicación más amplia, considere la posibilidad de exponerlo como un punto final Express.

Empieza por instalar Express:

  npm install express

Crea un archivo llamado server.js y añade el siguiente código:

  const express = require("express");
const puppeteer = require("puppeteer");

const app = express();
const PORT = 3000;

// Needed to parse JSON bodies:
app.use(express.json());

// Your Bright Data Scraping Browser WebSocket endpoint
const SBR_WS_ENDPOINT =
 "wss://brd-customer-hl_264b448a-zone-scraping_browser2:[email protected]:9222";

/**
 POST /scraper
 Body example:
 {
    "baseUrl": "https://books.toscrape.com/catalogue/page-"
 }
*/
app.post("/scrape", async (req, res) => {
  const { baseUrl } = req.body;

  if (!baseUrl) {
    return res.status(400).json({
      success: false,
      error: 'Missing "baseUrl" in request body.',
    });
  }

  try {
    // Connect to the existing Bright Data (Luminati) Scraping Browser
    const browser = await puppeteer.connect({
      browserWSEndpoint: SBR_WS_ENDPOINT,
    });

    const page = await browser.newPage();
    const books = [];

    // Example scraping 5 pages of the base URL
    for (let i = 1; i  {
        const data = [];
        document.querySelectorAll(".product_pod").forEach((item) => {
          const title = item.querySelector("h3 a")?.getAttribute("title") || "";
          const price = item.querySelector(".price_color")?.innerText || "";
          data.push({ title, price });
        });
        return data;
      });

      books.push(...pageBooks);
    }

    // Close the browser connection
    await browser.close();

    // Return JSON with the scraped data
    return res.json({
      success: true,
      books,
    });
  } catch (error) {
    console.error("Scraping error:", error);
    return res.status(500).json({
      success: false,
      error: error.message,
    });
  }
});

// Start the Express server
app.listen(PORT, () => {
  console.log(`Server is listening on http://localhost:${PORT}`);
});

En este código, se inicializa una aplicación Express, se aceptan cargas JSON y se define una ruta POST /scrape. Los clientes envían un cuerpo JSON que contiene la baseUrl, que se reenvía al endpoint Bright Data Scraping Browser con la URL objetivo.

Ejecute su nuevo servidor Express:

  node server.js

Para probar el punto final, puede utilizar una herramienta como Postman (o cualquier otro cliente REST de su elección), o puede utilizar curl desde su terminal o shell de esta manera:

  curl -X POST http://localhost/scrape 
n-H 'Content-Type: application/json' 
n-d '{u0022baseUrlu0022: u0022https://books.toscrape.com/catalogue/page-u0022}'rn

El resultado debería ser el siguiente:

  {
  "success": true,
  "books": [
    {
      "title": "A Light in the Attic",
      "price": "£51.77"
    },
    {
      "title": "Tipping the Velvet",
      "price": "£53.74"
    },
    {
      "title": "Soumission",
      "price": "£50.10"
    },
    {
      "title": "Sharp Objects",
      "price": "£47.82"
    },
    {
      "title": "Sapiens: A Brief History of Humankind",
      "price": "£54.23"
    },
    {
      "title": "The Requiem Red",
      "price": "£22.65"
    },
    {
      "title": "The Dirty Little Secrets of Getting Your Dream Job",
      "price": "£33.34"
    },
    {
      "title": "The Coming Woman: A Novel Based on the Life of the Infamous Feminist, Victoria Woodhull",
      "price": "£17.93"
    },
    
    ... output omitted...
    
    {
      "title": "Judo: Seven Steps to Black Belt (an Introductory Guide for Beginners)",
      "price": "£53.90"
    },
    {
      "title": "Join",
      "price": "£35.67"
    },
    {
      "title": "In the Country We Love: My Family Divided",
      "price": "£22.00"
    }
  ]
}

A continuación se muestra un diagrama que muestra el contraste entre la configuración manual (proxy giratorio) y el enfoque del Navegador de Bright Data Scraping:

Configuración manual frente a Bright Data Scraping Browser

Gestionar proxies que rotan manualmente requiere una atención y un ajuste constantes, lo que provoca bloqueos frecuentes y una escalabilidad limitada.

El uso de Bright Data Scraping Browser agiliza el proceso al eliminar la necesidad de gestionar proxies o cabeceras, al tiempo que ofrece tiempos de respuesta más rápidos gracias a una infraestructura optimizada. Sus estrategias anti-bot integradas aumentan las tasas de éxito, por lo que es menos probable que seas bloqueado o marcado.

Todo el código de este tutorial está disponible en este repositorio de GitHub.

Calcular el ROI

Pasar de una configuración de raspado manual basada en proxy al Navegador de raspado de datos de Bright puede reducir significativamente el tiempo y los costes de desarrollo.

Configuración tradicional

El raspado diario de sitios web de noticias requiere lo siguiente:

Desarrollo inicial: ~50 horas (5.000 USD a 100 USD/hora)
Mantenimiento continuo: ~10 horas/mes (1.000 USD) para actualizaciones de código, infraestructura, escalado y gestión de proxy.
Costes de proxy/IP: ~250 USD/mes (varía en función de las necesidades de IP)

Coste mensual total estimado: ~1.250 USD

Configuración del navegador de Bright Data Scraping

Tiempo de desarrollo: 5-10 horas (1.000 USD)
Mantenimiento: ~2-4 horas/mes (200 USD)
No se necesitaproxy ni gestión de infraestructuras
Costes del servicio Bright Data:
- Uso del tráfico: 8,40 USD/GB(por ejemplo, 30GB/mes = 252 USD)

Coste mensual total estimado: ~450 USD

La automatización de la gestión de proxies y el escalado de Bright Data Scraping Browser reducen tanto los costes iniciales de desarrollo como el mantenimiento continuo, lo que hace que el scraping de datos a gran escala sea más eficiente y rentable.

Conclusión

La transición de una configuración de raspado web tradicional basada en proxy a Bright Data Scraping Browser elimina la molestia de la rotación de proxy y la gestión manual anti-bot.

Además de la obtención de HTML, Bright Data también ofrece herramientas adicionales para agilizar la extracción de datos:

Web Scrapers para facilitar la extracción de datos
API de Web Unlocker para raspar sitios más difíciles
Conjuntos de datos para que pueda acceder a datos estructurados recopilados previamente

Estas soluciones pueden simplificar el proceso de scraping, reducir la carga de trabajo y mejorar la escalabilidad.

Prueba gratuita

Inicia sesión con Google

No se requiere tarjeta de crédito

Mejore el raspado por proxy con el navegador de raspado de Bright Data