Saltar al contenido
Empezar gratis
Volver al blog

Extracción de datos web con JavaScript y Node.js: una guía práctica

Robert SfichiÚltima actualización el 26 min read
Extracción de datos web con JavaScript y Node.js: una guía práctica
En resumen: El web scraping con JavaScript y Node.js requiere Node.js 22.12 o posterior, el fetch integrado para las solicitudes y Cheerio para analizar HTML. Usa Cheerio cuando los datos están en el HTML que recibe tu solicitud, y Playwright cuando JavaScript construye la página o esta necesita clics y esperas. Esta guía crea un único scraper, desde la paginación y el JSON oculto hasta las pruebas sin conexión y una API de scraping como alternativa.

El web scraping con JavaScript empieza con una tarea sencilla: los datos están en una página web, escribes código JavaScript y quieres obtener esos datos en formato JSON limpio, sin tener que lidiar con bloques ni matrices vacías. Si este concepto te resulta nuevo, lee primero qué es el web scraping.

Esta guía utiliza books.toscrape.com, una librería de prácticas creada para extractores de datos, como ejemplo práctico. Recogerás y analizarás una página con fetch y Cheerio, rastrearás un catálogo paginado de forma respetuosa, comprobarás si JavaScript genera una página, renderizarás y navegarás por las páginas con Playwright, probarás tu analizador sin conexión y transferirás las páginas bloqueadas a una API de extracción de datos sin modificar el analizador.

Inicio rápido

  • Utiliza Node.js 22.12 o posterior (se recomienda la versión 24 o 26 LTS)
  • npm install cheerio para páginas cuyos datos se encuentren en el HTML
  • npm install playwright para páginas que requieran un navegador real
  • Comprueba el archivo robots.txt y las condiciones de uso del sitio antes de realizar el rastreo

¿Qué necesitas para empezar a extraer datos de la web con JavaScript?

Necesitas Node.js 22.12 o posterior, un editor de código y dos paquetes: Cheerio para analizar el HTML y Playwright para renderizar las páginas que necesitan un navegador. La función «fetch» integrada en Node se encarga de las solicitudes, por lo que no necesitas Axios. Familiarízate también con las DevTools de tu navegador, ya que encontrar el selector adecuado y la fuente de datos de la página supone la mitad del trabajo.

Node.js se adapta muy bien a los rastreadores. Habla el mismo lenguaje que los propios scripts de la página, por lo que leer el JavaScript de un sitio resulta familiar. Su modelo de E/S asíncrono gestiona numerosas solicitudes de red sin necesidad de subprocesos. Además, las principales herramientas de automatización de navegadores, Playwright y Puppeteer, están diseñadas principalmente para JavaScript.

La tabla siguiente recoge las herramientas que utiliza esta guía. Para un resumen más amplio, consulta la comparación de seis bibliotecas de scraping para Node.js.

Herramienta

Tarea

Úsala cuando

Última versión en npm (octubre de 2026)

Node.js

fetch (integrado)

Solicitudes HTTP

Siempre; no requiere instalación

Parte de Node

Estable desde Node 21

Cheerio

Analiza HTML con selectores CSS

Los datos están en el HTML

1.2.0

20.18.1

jsdom

Un DOM similar al de un navegador en Node

Necesitas API del DOM, no solo selectores

30.1.3

22.22.2, 24.15 o 26

Playwright

Ejecuta Chromium, Firefox y WebKit

Las páginas requieren clics, tiempos de espera o renderizado

1.64.1

20

Puppeteer

Controlar Chrome o Firefox

Código existente de Puppeteer, herramientas de Chrome

25.16.0

22.12.0

p-limit

Límite de promesas simultáneas

Muchas URL en sitios web que permiten solicitudes paralelas

7.3.3

20

Axios / Got

Clientes HTTP con funciones adicionales

Ya los utilizas

1.21.0 / 16.1.0

— / 22

jsdom crea un DOM más completo que Cheerio, pero es más lento y ejecuta los scripts de la página solo con una opción que su propia documentación califica de insegura, por lo que Cheerio es la mejor opción por defecto. Axios está bien si tu proyecto ya lo utiliza. Las secciones sobre Node explican las recomendaciones de versión: Puppeteer necesita la versión 22.12, y Node 20 ya ha superado su fin de vida útil según el calendario de lanzamientos de Node.js.

¿Cómo se configura un proyecto de scraping con Node.js?

Crea una carpeta, cambia el proyecto a módulos ES para que import y el código de nivel superior await funcionen, e instala los dos paquetes principales. Playwright descarga su propia compilación de Chromium con un comando adicional.

mkdir node-scraper && cd node-scraper
npm init -y
npm pkg set type=module
npm install cheerio playwright
npx playwright install chromium
mkdir fixtures out
# Optional, for the Puppeteer example:
npm install puppeteer

La fixtures/ carpeta contiene las páginas guardadas para las pruebas sin conexión, y out/ contiene los resultados. Puppeteer descarga Chrome durante la instalación, y es posible que npm 11 muestre una advertencia sobre los scripts de instalación. Puedes revisar esos scripts con npm install-scripts ls. Si escribes en TypeScript, el mismo código se ejecuta en .ts archivos gracias a la eliminación de tipos integrada en Node o a un ejecutor como tsx.

¿Se puede extraer información de un sitio web con JavaScript en el navegador?

Solo en páginas del mismo sitio web. Los navegadores impiden que el JavaScript de un sitio web lea las respuestas de otro, a menos que ese servidor lo permita mediante encabezados CORS, y la mayoría no lo hace. Por eso los rastreadores se ejecutan en Node.js, que no tiene esa restricción. Utiliza el JavaScript del navegador para probar selectores en la consola de DevTools, no para recopilar datos.

La norma que subyace a esto es la política de mismo origen. Un script cargado desde un origen puede enviar una solicitud a otro, pero el navegador oculta la respuesta a menos que el otro servidor lo permita mediante Access-Control-Allow-Origin encabezados. La guía de CORS de MDN explica los detalles.

Node.js no es un navegador, por lo que lee cualquier respuesta que reciba. Eso lo convierte en el lugar adecuado para un rastreador y mantiene las credenciales, como las claves API, fuera de los equipos de los visitantes. Las extensiones de navegador y los bookmarklets son la única excepción: pueden leer la página que ya estás viendo, lo que sirve para copias puntuales, pero no para la recopilación programada.

¿Cómo se extrae el contenido de una página web con `fetch` de Node.js y Cheerio?

Recupera el HTML de la página con `fetch()`, comprueba que la respuesta sea correcta y carga el texto en Cheerio con `cheerio.load()`. Selecciona cada tarjeta o fila repetitiva con un selector CSS, lee el texto o los atributos de la misma y convierte los números sobre la marcha. Devuelve objetos simples y resuelve los enlaces relativos con `new URL(href, pageUrl)`.

books.toscrape.com muestra una lista de 1.000 libros repartidos en 50 páginas de catálogo, con 20 por página, incluyendo precios, valoraciones con estrellas y estado de existencias. Un banner en la página indica que se trata de una demostración para practicar el scraping y que los precios y las valoraciones son aleatorios, por lo que es un lugar seguro para aprender.

Empieza con un ayudante de recuperación que volverás a utilizar en todas partes. Envía un agente de usuario descriptivo, abandona el intento tras 15 segundos con AbortSignal.timeout(), comprueba res.oky vuelve a intentarlo ante límites de frecuencia y errores del servidor. Cuando el servidor envía el encabezado «Retry-After», espera ese tiempo. De lo contrario, reduce el intervalo de forma exponencial.

// fetch-html.js: one polite GET with a timeout, a status check, and retries
const HEADERS = {
  'User-Agent': 'node-scraper-tutorial/1.0 (+https://example.com/contact)',
  'Accept': 'text/html,application/xhtml+xml',
  'Accept-Language': 'en-US,en;q=0.9',
};
const RETRY = new Set([429, 500, 502, 503, 504]);
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

export async function fetchHtml(url, { retries = 3, timeoutMs = 15_000 } = {}) {
  for (let attempt = 0; ; attempt++) {
    let res;
    try {
      res = await fetch(url, { headers: HEADERS, signal: AbortSignal.timeout(timeoutMs) });
    } catch (err) {                                   // DNS, reset, or timeout
      if (attempt >= retries) throw err;
      await sleep(1000 * 2 ** attempt);
      continue;
    }
    if (res.ok) return res.text();
    if (!RETRY.has(res.status) || attempt >= retries) {
      throw new Error(`GET ${url} failed: HTTP ${res.status}`);
    }
    const retryAfter = Number(res.headers.get('retry-after'));  // seconds, if the server says so
    await sleep(retryAfter > 0 ? retryAfter * 1000 : 1000 * 2 ** attempt);
  }
}

Sustituye la URL de contacto por la tuya propia, para que el propietario del sitio pueda ponerse en contacto contigo en lugar de bloquearte. fetch está integrado en Node, y la API de Fetch funciona igual que en el navegador. Si estás barajando utilizar una biblioteca, consulta la comparación entre fetch nativo, Axios, Got y Ky.

El analizador toma el HTML y la URL de la página y devuelve registros tipados. Al mantenerlo libre de código de red, resulta fácil de probar y de reutilizar cuando cambias la forma de realizar la consulta.

// parse-books.js: turn one books.toscrape.com listing page into typed records
import * as cheerio from 'cheerio';

const RATINGS = { One: 1, Two: 2, Three: 3, Four: 4, Five: 5 };

export function parseBooks(html, pageUrl) {
  const $ = cheerio.load(html);

  const books = $('article.product_pod').map((_, card) => {
    const $card = $(card);
    const link = $card.find('h3 a');
    const priceText = $card.find('.price_color').text();          // "£51.77"
    const ratingWord = ($card.find('.star-rating').attr('class') ?? '')
      .replace('star-rating', '').trim();                          // "Three"

    return {
      title: link.attr('title'),                    // full title; the link text is cut off
      price: priceText ? Number(priceText.replace(/[^0-9.]/g, '')) : null,
      currency: priceText.includes('£') ? 'GBP' : null,
      rating: RATINGS[ratingWord] ?? null,
      inStock: $card.find('.instock.availability').length > 0,
      url: new URL(link.attr('href'), pageUrl).href, // hrefs are relative, and differ by page
    };
  }).get();

  const nextHref = $('li.next a').attr('href');
  const nextUrl = nextHref ? new URL(nextHref, pageUrl).href : null;
  return { books, nextUrl };
}

La salida no necesita una segunda pasada de limpieza. El precio se convierte en un número, no en una cadena "£51.77". La valoración por estrellas se encuentra en el nombre de una clase (star-rating Three), por lo que un pequeño mapa la convierte en un valor del 1 al 5, y cualquier valor inesperado se convierte null en lugar de una suposición errónea. Además, todos los enlaces pasan por new URL(), ya que los enlaces «href» del sitio son relativos.

Guarda una copia de la primera página del catálogo y ejecuta el analizador en ella sin necesidad de conexión a Internet:

curl -o fixtures/books-page-1.html "https://books.toscrape.com/catalogue/page-1.html"
// static-fixture.js: parse a saved page, no network
import { readFile } from 'node:fs/promises';
import { parseBooks } from './parse-books.js';

const html = await readFile('fixtures/books-page-1.html', 'utf8');
const { books, nextUrl } = parseBooks(html, 'https://books.toscrape.com/catalogue/page-1.html');
console.log(books.length, 'books');
console.log(books[0]);
console.log('next:', nextUrl);

Resultado:

20 books
{
  title: 'A Light in the Attic',
  price: 51.77,
  currency: 'GBP',
  rating: 3,
  inStock: true,
  url: 'https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html'
}
next: https://books.toscrape.com/catalogue/page-2.html

Guarda cada tipo de página que tengas pensado rastrear de la misma manera, una curl -o por página, con un segundo de diferencia entre ellas. Esos archivos se convertirán más adelante en tus casos de prueba. Cheerio ofrece mucho más que esto, incluyendo extract() y la lectura de JSON desde etiquetas de script. Ambos temas se tratan en nuestra guía completa de Cheerio, y la documentación de Cheerio recoge la API completa.

¿Cómo se encuentran los selectores CSS adecuados?

Abre la página en tu navegador, haz clic con el botón derecho sobre los datos que desees y selecciona «Inspeccionar». Busca el elemento que se repite una vez por registro, como una ficha de producto con una clase, y prueba tu selector en la consola de DevTools con document.querySelectorAll(). Es preferible utilizar selectores cortos basados en clases en lugar de rutas largas copiadas de DevTools, ya que estas últimas dejan de funcionar cuando cambia el diseño.

En books.toscrape.com, haz clic con el botón derecho en cualquier título de libro y selecciona «Inspeccionar». Cada libro se encuentra dentro de un <article class="product_pod">, por lo que ese es el elemento que se repite. Pruébalo en la pestaña «Consola»:

document.querySelectorAll('article.product_pod').length   // 20
document.querySelector('article.product_pod h3 a').textContent   // "A Light in the ..."
document.querySelector('article.product_pod h3 a').title         // "A Light in the Attic"

La segunda línea muestra una trampa que es fácil pasar por alto. Los títulos largos se acortan en el texto visible del enlace, pero el título completo se encuentra en el atributo title . Compara siempre lo que extraes con lo que la página realmente indica, no solo con lo que muestra. La valoración funciona de la misma manera: no hay ningún «3» en ninguna parte de la ficha, solo la clase star-rating Three.

Conoce también la diferencia entre «Ver código fuente» e «Inspeccionar». «Ver código fuente» muestra el HTML que envió el servidor, que es exactamente lo que fetch se recibe. «Inspeccionar» muestra el DOM en tiempo real después de que se hayan ejecutado los scripts. Cuando un selector funciona en «Inspeccionar» pero no devuelve nada en Node.js, significa que JavaScript ha generado ese contenido, y las secciones siguientes muestran qué hacer.

Ancla los selectores a clases y atributos en lugar de a la posición (li.next a, no ul > li:nth-child(2) > a). Además, los ID de CSS no pueden empezar por un dígito a menos que se escape, por lo que un elemento con id="2015" necesita [id="2015"] en lugar de #2015. Para todo lo demás, ten a mano una referencia completa de selectores.

¿Cómo se rastrean varias páginas de forma respetuosa?

Comprueba primero el archivo robots.txt y, a continuación, sigue el enlace «Siguiente» de cada página en lugar de adivinar patrones de URL. Mantén un conjunto de URL visitadas para que un enlace erróneo no provoque un bucle, elimina registros duplicados mediante una clave estable y espera entre solicitudes. Respeta las propias reglas de frecuencia del sitio y los encabezados «Retry-After», y limita el número total de páginas mientras desarrollas.

Empieza por el archivo robots.txt. Este lector minimalista recopila las Disallow reglas para el User-agent: * grupo. Gestiona reglas de prefijo sencillas, mientras que el estándar robots.txt (RFC 9309) define los comodines y la Allow la precedencia, así que utiliza un analizador completo en los sitios que dependan de ellos. Según ese estándar, una respuesta 4xx significa que no se aplica ninguna regla, y una 5xx significa que debes tratar todo el sitio como fuera de los límites.

// robots.js: a minimal robots.txt check for the "User-agent: *" group.
// Good enough for simple prefix rules; use a full RFC 9309 parser for wildcards or Allow precedence.
export async function disallowedPaths(origin) {
  const res = await fetch(new URL('/robots.txt', origin), { signal: AbortSignal.timeout(10_000) });
  if (res.status >= 500) throw new Error(`robots.txt HTTP ${res.status}: treat the site as off-limits`);
  if (!res.ok) return [];                       // 4xx: no robots.txt, so nothing is disallowed
  let inStar = false;
  const rules = [];
  for (const raw of (await res.text()).split('\n')) {
    const line = raw.split('#')[0].trim();
    const [key, ...rest] = line.split(':');
    const value = rest.join(':').trim();
    if (/^user-agent$/i.test(key)) inStar = value === '*';
    else if (inStar && /^disallow$/i.test(key) && value) rules.push(value);
  }
  return rules;
}

export const isAllowed = (url, rules) => !rules.some((p) => new URL(url).pathname.startsWith(p));

El rastreador comienza en la primera página del catálogo, sigue el siguiente enlace hasta que no haya ninguno más, espera un segundo entre solicitudes y guarda los datos en formato JSON y CSV.

// crawl-books.js: follow "next" links politely and save JSON + CSV
import { writeFile } from 'node:fs/promises';
import { fetchHtml } from './fetch-html.js';
import { parseBooks } from './parse-books.js';
import { disallowedPaths, isAllowed } from './robots.js';

const START = 'https://books.toscrape.com/catalogue/page-1.html';
const MAX_PAGES = Number(process.env.MAX_PAGES ?? 5);
const DELAY_MS = 1000;                           // no published limit, so stay at one request per second

const rules = await disallowedPaths(START);
const seen = new Set();                          // stops loops if a "next" link points backward
const byUrl = new Map();                         // dedupe records, not just pages

for (let url = START, page = 1; url && page <= MAX_PAGES && !seen.has(url); page++) {
  if (!isAllowed(url, rules)) { console.log('robots.txt disallows', url); break; }
  seen.add(url);
  const { books, nextUrl } = parseBooks(await fetchHtml(url), url);
  for (const b of books) byUrl.set(b.url, b);
  console.log(`page ${page}: ${books.length} books (${url})`);
  url = nextUrl;
  if (url) await new Promise((r) => setTimeout(r, DELAY_MS));
}

const books = [...byUrl.values()];
await writeFile('out/books.json', JSON.stringify(books, null, 2));
const cols = Object.keys(books[0]);
const cell = (v) => `"${String(v ?? '').replaceAll('"', '""')}"`;
await writeFile('out/books.csv',
  [cols.join(','), ...books.map((b) => cols.map((c) => cell(b[c])).join(','))].join('\n') + '\n');
console.log(`saved ${books.length} unique books; robots.txt disallows: ${rules.join(', ') || 'nothing'}`);

Resultado con el límite predeterminado de cinco páginas:

page 1: 20 books (https://books.toscrape.com/catalogue/page-1.html)
page 2: 20 books (https://books.toscrape.com/catalogue/page-2.html)
page 3: 20 books (https://books.toscrape.com/catalogue/page-3.html)
page 4: 20 books (https://books.toscrape.com/catalogue/page-4.html)
page 5: 20 books (https://books.toscrape.com/catalogue/page-5.html)
saved 100 unique books; robots.txt disallows: nothing

Ejecútalo con MAX_PAGES=100 node crawl-books.js y se detiene por sí solo tras la página 50, ya que la última página no tiene enlace siguiente:

page 49: 20 books (https://books.toscrape.com/catalogue/page-49.html)
page 50: 20 books (https://books.toscrape.com/catalogue/page-50.html)
saved 1000 unique books; robots.txt disallows: nothing

Este sitio web muestra por qué existe cada medida de seguridad. El enlace «Siguiente» de la página de inicio es catalogue/page-2.html, pero en la página 2 es simplemente page-3.html. Al pegarlo en la raíz del sitio se obtiene https://books.toscrape.com/page-3.html, lo que devuelve un 404. new URL(href, pageUrl) resuelve cada enlace en función de la página de la que procede, por lo que siempre es correcto.

La página de inicio y catalogue/page-1.html también muestran los mismos 20 libros bajo dos URL, y ambas dirigen su siguiente enlace a la página 2. Un rastreador que comience desde ambas, o que siga un enlace «anterior» de vuelta a la página 1, se ahorraría 40 filas para 20 libros. El conjunto de páginas visitadas evita la repetición de páginas, y la indexación de los registros por URL del libro evita la repetición de filas. Para conocer más prácticas como estas, lee nuestra guía sobre las mejores prácticas de scraping a lo largo del ciclo de vida del proyecto.

¿Cuántas solicitudes puedes ejecutar a la vez?

La concurrencia es una decisión que depende de cada sitio web. Cuando un sitio publique un límite de frecuencia, respétalo, aunque eso signifique una solicitud cada vez. Cuando no lo haga, limita las solicitudes paralelas por host a un valor bajo, mantén una pausa y retrocede ante un error 429. Aumentar la velocidad rara vez ayuda si eso te lleva a que te bloqueen.

books.toscrape.com no publica ningún límite, por lo que este script recupera páginas de detalles de libros de dos en dos con p-limit (npm install p-limit) para añadir el UPC y el recuento exacto de existencias de cada libro:

// details.js: enrich books from their detail pages, at most 2 requests at a time
import { readFile, writeFile } from 'node:fs/promises';
import * as cheerio from 'cheerio';
import pLimit from 'p-limit';
import { fetchHtml } from './fetch-html.js';

const books = JSON.parse(await readFile('out/books.json', 'utf8')).slice(0, 10);
const limit = pLimit(2);
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

const results = await Promise.allSettled(books.map((book) => limit(async () => {
  const $ = cheerio.load(await fetchHtml(book.url));
  await sleep(500);                               // keep a pause even with two workers
  return {
    ...book,
    upc: $('th:contains("UPC")').next('td').text(),
    stockCount: Number($('p.instock.availability').text().match(/\d+/)?.[0] ?? 0),
  };
})));

const ok = results.filter((r) => r.status === 'fulfilled').map((r) => r.value);
console.log(`${ok.length} enriched, ${results.length - ok.length} failed`);
console.log(ok[0]);
await writeFile('out/books-details.jsonl', ok.map((b) => JSON.stringify(b)).join('\n') + '\n');

Resultado:

10 enriched, 0 failed
{
  title: 'A Light in the Attic',
  price: 51.77,
  currency: 'GBP',
  rating: 3,
  inStock: true,
  url: 'https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html',
  upc: 'a897fe39b1053632',
  stockCount: 22
}

Promise.allSettled() evita que una página fallida eche por la borda los otros nueve resultados.

¿Cómo se guardan los datos extraídos en formato JSON y CSV?

JSON conserva los tipos de datos: los números siguen siendo números y null permanecen null. El formato CSV es el que utilizan las hojas de cálculo, pero requiere comillas, por lo que el rastreador envuelve cada celda entre comillas y duplica cualquier comilla que haya dentro de un valor. Los valores vacíos se convierten en celdas vacías.

title,price,currency,rating,inStock,url
"A Light in the Attic","51.77","GBP","3","true","https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html"
"Tipping the Velvet","53.74","GBP","1","true","https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html"

Para trabajos más grandes, escribe un objeto JSON por línea (JSON Lines), tal y como details.js hace, para que un fallo a mitad del proceso no te haga perder todo el archivo. Si tu fuente es una tabla en lugar de fichas, consulta nuestra guía para exportar tablas HTML a CSV limpio.

¿Cómo sabes si una página necesita renderización con JavaScript?

Carga la página con la función fetch() sin más y ejecuta tu selector. Si no encuentra nada pero el navegador muestra los datos, significa que JavaScript genera ese contenido tras la carga. A continuación, abre DevTools, selecciona la pestaña «Red», filtra por «Fetch/XHR» y vuelve a cargar la página o haz clic: la solicitud que devuelve tus datos suele ser más fácil de utilizar que el propio navegador.

Puedes automatizar esa comprobación. Este script cuenta las coincidencias de tu selector en el HTML sin procesar y en una página renderizada, y enumera todas las solicitudes fetch o XHR que realiza la página mientras se carga:

// check-js.js: does the selector match in the raw HTML and in the rendered page?
import * as cheerio from 'cheerio';
import { chromium } from 'playwright';
import { fetchHtml } from './fetch-html.js';

const url = process.argv[2] ?? 'https://books.toscrape.com/catalogue/page-1.html';
const selector = process.argv[3] ?? 'article.product_pod';

const $ = cheerio.load(await fetchHtml(url));
const inHtml = $(selector).length;

const browser = await chromium.launch();
try {
  const page = await browser.newPage();
  const dataRequests = [];
  page.on('request', (req) => {
    if (['xhr', 'fetch'].includes(req.resourceType())) dataRequests.push(req.url());
  });
  await page.goto(url, { waitUntil: 'networkidle' });
  const rendered = await page.locator(selector).count();

  console.log(`raw HTML: ${inHtml} | rendered: ${rendered} | fetch/XHR requests: ${dataRequests.length}`);
  dataRequests.forEach((u) => console.log('  ', u));
  console.log(inHtml > 0 ? 'The data is in the HTML: use fetch + Cheerio.'
    : dataRequests.length ? 'JavaScript loads the data: try calling the request above.'
    : 'JavaScript builds the data: render the page or look for JSON in a <script>.');
} finally {
  await browser.close();
}

Resultado para el catálogo de libros:

raw HTML: 20 | rendered: 20 | fetch/XHR requests: 0
The data is in the HTML: use fetch + Cheerio.

Esa es la respuesta que esperabas: el servidor envía todos los libros en el HTML, por lo que un navegador solo añadiría tiempo. Ejecuta el mismo script con otra URL y otro selector (node check-js.js <url> "<selector>") antes de escribir un rastreador para una nueva web.

Cuando el recuento sin procesar es 0, los datos se ocultan en uno de estos otros dos lugares. Puede tratarse de JSON dentro de una <script> , que Cheerio puede leer y JSON.parse() decodificar. O bien, JavaScript lo solicita tras la carga, y la solicitud aparece en la lista del script y en la pestaña «Red». En cualquier caso, a menudo puedes prescindir del navegador. Para conocer más a fondo qué hace un navegador de renderizado, consulta cómo funcionan los navegadores sin interfaz gráfica.

¿Cómo se extraen datos de JavaScript sin un navegador?

Busca la solicitud que realiza la página para obtener sus datos en la pestaña «Red» de DevTools, copia su URL y sus parámetros, y llámala tú mismo con fetch(). Obtendrás JSON sin necesidad de analizar HTML ni de ejecutar un navegador. Mantén el mismo límite de frecuencia y el mismo agente de usuario, y solo llama a los puntos finales que la propia página utiliza para los datos públicos.

Los pasos son los mismos en cualquier sitio web:

  1. Abre DevTools, selecciona la pestaña «Red» y filtra por «Fetch/XHR».
  2. Actualiza la página o haz clic en el botón, la pestaña o el enlace «cargar más» que carga los datos.
  3. Haz clic en cada solicitud y comprueba su pestaña «Respuesta» hasta que encuentres la que contiene tus registros.
  4. Anota la URL y los parámetros de consulta que cambian (a menudo page, offset, o cursor), y cualquier campo que te indique cuándo detenerte, como has_next o un array vacío.
  5. Reconstruye la URL en Node.js con URLSearchParams y recupérala en un bucle.

Un punto final JSON paginado suele tener este aspecto. Sustituye el punto final y los campos que hayas encontrado:

// fetch-json-pages.js: call a paged JSON endpoint you found in the Network tab
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

export async function fetchAllPages(endpoint, { maxPages = 50, delayMs = 1000 } = {}) {
  const items = [];
  for (let page = 1; page <= maxPages; page++) {
    const url = `${endpoint}?${new URLSearchParams({ page })}`;
    const res = await fetch(url, {
      headers: { 'User-Agent': 'node-scraper-tutorial/1.0 (+https://example.com/contact)' },
      signal: AbortSignal.timeout(15_000),
    });
    if (!res.ok) throw new Error(`HTTP ${res.status} for ${url}`);
    const data = await res.json();
    items.push(...data.items);           // the array that holds the records
    if (!data.has_next) break;           // or: if (data.items.length === 0) break;
    await sleep(delayMs);
  }
  return items;
}

Cuando existe, esta es la forma más rápida y estable: los campos JSON rara vez cambian cuando un sitio rediseña su HTML. Normaliza sobre la marcha, del mismo modo que lo hace el analizador Cheerio: recorta cadenas, convierte números y transforma las claves que faltan en null o false a propósito.

Saber también cuándo parar. Un punto final que requiera un inicio de sesión, un token de sesión o parámetros firmados no es dato público, y sortear esas comprobaciones ya no es «scraping». Trátalo como una señal de stop, no como un rompecabezas.

¿Cómo se extraen páginas renderizadas con JavaScript con Playwright?

Inicia Chromium con Playwright, abre la página y haz lo que haría un usuario, como hacer clic en un enlace. Espera a que aparezcan los datos en lugar de poner el programa en espera: waitForURL() detecta la navegación que inicia un clic, y el método waitFor() de un localizador espera hasta que haya filas. A continuación, lee las filas de la página con evaluateAll() y cierra el navegador en un bloque finally.

Utiliza un navegador cuando los datos solo aparezcan tras hacer clic, desplazarse, escribir u otros pasos controlados por scripts. Este script navega por books.toscrape.com como lo haría un lector: abre la página de inicio, hace clic en la categoría «Misterio», lee cada ficha y hace clic en «Siguiente» hasta que se agota la categoría.

// playwright-books.js: open a category like a user, read every page of results
import { chromium } from 'playwright';

const browser = await chromium.launch();               // headless by default
try {
  const page = await browser.newPage({ userAgent: 'node-scraper-tutorial/1.0 (+https://example.com/contact)' });
  await page.route('**/*.{jpg,jpeg,png}', (route) => route.abort());   // skip images you won't use
  await page.goto('https://books.toscrape.com/');

  await page.getByRole('link', { name: 'Mystery', exact: true }).click();
  await page.waitForURL('**/category/books/mystery_3/**');

  const books = [];
  for (;;) {
    const cards = page.locator('article.product_pod');
    await cards.first().waitFor();                     // wait for the data, not a fixed sleep
    books.push(...await cards.evaluateAll((els) => els.map((el) => ({
      title: el.querySelector('h3 a').getAttribute('title'),
      price: Number(el.querySelector('.price_color').textContent.replace(/[^0-9.]/g, '')),
      url: el.querySelector('h3 a').href,               // the browser resolves it for you
    }))));

    const next = page.locator('li.next a');
    if (await next.count() === 0) break;
    const current = page.url();
    await next.click();
    await page.waitForURL((u) => u.href !== current);  // the click navigates to the next page
    await page.waitForTimeout(1000);                   // politeness delay between pages
  }
  console.log(books.length, 'mystery books; last page:', page.url());
  console.log(books[0]);
} finally {
  await browser.close();
}

Resultado:

32 mystery books; last page: https://books.toscrape.com/catalogue/category/books/mystery_3/page-2.html
{
  title: 'Sharp Objects',
  price: 47.82,
  url: 'https://books.toscrape.com/catalogue/sharp-objects_997/index.html'
}

Hay algunas decisiones importantes que hay que tomar en cualquier sitio web. getByRole('link', { name: 'Mystery', exact: true }) encuentra el enlace tal y como lo ve el usuario, por lo que no se ve afectado por los cambios en el nombre de la clase. waitForURL() «after each click» garantiza que se lea la página nueva, no la antigua. cards.first().waitFor() espera hasta que haya datos disponibles, lo que es mejor que un tiempo de espera fijo que resulta demasiado corto en un día lento o una pérdida de tiempo en uno rápido. La espera automática de Playwright también comprueba que un elemento esté visible y estable antes de hacer clic.

Dentro de evaluateAll(), el código se ejecuta en la página, por lo que a.href ya es absoluto. Bloquear las imágenes con page.route() ahorra ancho de banda tanto para ti como para el sitio web. La única espera fija que queda es un retraso de cortesía deliberado, no una estimación del tiempo de carga.

Cuando un clic desencadena una solicitud de datos en lugar de una navegación, envuelve el clic y page.waitForResponse() en un Promise.all() para que la respuesta no pueda llegar antes de que empieces a escuchar. Para obtener información sobre proxies, desplazamiento infinito e interceptación de solicitudes, consulta nuestra guía detallada de Playwright.

¿Cómo se ve el mismo scraper en Puppeteer?

Puppeteer cubre el mismo flujo con llamadas ligeramente diferentes: page.click() junto con page.waitForNavigation(), y luego page.waitForSelector() y page.$$eval() para leer las tarjetas. Puppeteer 25 requiere Node.js 22.12 o posterior.

// puppeteer-books.js: the same category in Puppeteer
import puppeteer from 'puppeteer';

const browser = await puppeteer.launch();
try {
  const page = await browser.newPage();
  await page.setUserAgent('node-scraper-tutorial/1.0 (+https://example.com/contact)');
  await page.goto('https://books.toscrape.com/');

  await Promise.all([
    page.waitForNavigation(),
    page.click('a[href*="category/books/mystery_3"]'),
  ]);
  await page.waitForSelector('article.product_pod');

  const books = await page.$$eval('article.product_pod h3 a', (links) => links.map((a) => ({
    title: a.getAttribute('title'),
    url: a.href,
  })));
  console.log(books.length, 'books on page 1;', 'first:', books[0].title);
} finally {
  await browser.close();
}

Resultado:

20 books on page 1; first: Sharp Objects

Fíjate en Promise.all() alrededor del clic: empieza a esperar a la navegación antes de hacer clic, ya que una página que se carga rápido puede terminar de cargarse antes de que Puppeteer empiece a escuchar. Para capturas de pantalla, archivos PDF y más patrones de Puppeteer, consulta nuestra guía de Puppeteer y Node.js.

¿Deberías usar Playwright o Puppeteer para el web scraping?

Utiliza Playwright para nuevos rastreadores: espera los elementos automáticamente, controla Chromium, Firefox y WebKit desde una única API y gestiona bien múltiples sesiones aisladas. Utiliza Puppeteer cuando tu equipo ya disponga de código de Puppeteer o desee herramientas específicas para Chrome. Para el scraping, ambos representan las mismas páginas, así que elige en función de la facilidad de uso de la API, no de las promesas de velocidad.


Playwright

Puppeteer

Navegadores

Chromium, Firefox, WebKit

Chrome, Firefox

En espera

Los localizadores esperan automáticamente a que los elementos estén listos

Explícito waitForSelector() y similares

Sesiones aisladas

Contextos de navegador, integrados

Contextos de navegador, integrados

Captura la solicitud de datos

page.waitForResponse()

page.waitForResponse()

Lenguajes

JavaScript/TypeScript, Python, Java, .NET

JavaScript/TypeScript

Última versión en npm (octubre de 2026)

1.64.1

25.16.0

Elígelo cuando

Proyectos nuevos, comprobaciones de compatibilidad entre navegadores

Código existente de Puppeteer, trabajo con el protocolo Chrome DevTools

Ambos proyectos son de código abierto y se mantienen activamente, y ambos descargan el navegador adecuado por ti. La diferencia práctica se nota en el código diario: los localizadores de Playwright esperan y vuelven a intentarlo por sí mismos, por lo que los scripts necesitan menos esperas explícitas. Si ya utilizas Puppeteer en producción, no hay ninguna razón relacionada con el scraping para reescribirlo.

¿Cómo se extraen páginas bloqueadas desde Node.js con una API de scraping?

Mantén tu analizador y cambia solo la llamada de recuperación. Envía la URL de destino a la API de scraping de WebScrapingAPI con tu clave desde una variable de entorno, añade render_js=1 cuando la página necesite JavaScript y añade el país para contenido específico de la ubicación. Obtendrás el código HTML de la página y lo pasarás a la misma función de Cheerio que ya has escrito.

No necesitas esto para un sitio de prácticas. Lo necesitarás cuando un destino real empiece a responder con errores 403 o páginas de autenticación que los reintentos no resuelven, cuando el contenido varíe según el país o cuando prefieras no ejecutar una flota de navegadores para renderizar páginas a gran escala. Prueba primero otras formas de reducir los bloqueos si solo observas errores ocasionales.

La API de Scraper toma una URL y devuelve la página, mientras que WebScrapingAPI se encarga de los proxies, los reintentos y la renderización opcional de JavaScript. wsaFetch() es un equivalente directo de fetchHtml():

// wsa-fetch.js: same job as fetchHtml(), but WebScrapingAPI's Scraper API does the fetching
const ENDPOINT = 'https://api.webscrapingapi.com/v2';
const RETRY = new Set([429, 500, 503]);          // documented as "retry later"
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

export function buildWsaUrl(url, { renderJs = false, country } = {}) {
  const apiKey = process.env.WSA_API_KEY;
  if (!apiKey) throw new Error('Set WSA_API_KEY in your environment first.');
  const params = new URLSearchParams({ api_key: apiKey, url });   // encodes the target URL
  if (renderJs) params.set('render_js', '1');
  if (country) params.set('country', country);                     // two-letter code, e.g. "us"
  return `${ENDPOINT}?${params}`;
}

export async function wsaFetch(url, { renderJs = false, country, retries = 2 } = {}) {
  for (let attempt = 0; ; attempt++) {
    const res = await fetch(buildWsaUrl(url, { renderJs, country }), {
      signal: AbortSignal.timeout(130_000),   // the API's own timeout tops out at 120 s
    });
    if (res.ok) return res.text();
    if (res.status === 422 && !renderJs) {    // scrape not completed: try once with rendering
      renderJs = true;
      continue;
    }
    if (!RETRY.has(res.status) || attempt >= retries) {
      throw new Error(`WebScrapingAPI HTTP ${res.status}: ${await res.text()}`);
    }
    await sleep(2000 * 2 ** attempt);
  }
}

La clave proviene de process.env.WSA_API_KEY y nunca aparece en el código. URLSearchParams codifica la URL de destino, lo cual es importante: si una URL de destino incluyera su propia cadena de consulta, un ? o & se interpretaría como un parámetro de la API. El tiempo de espera del cliente se sitúa justo por encima del máximo de 120 segundos de la API, y solo se vuelven a intentar los estados que la API documenta como temporales. La representación en JavaScript y la geolocalización no suponen ningún coste adicional, pero la representación es más lenta, así que actívala solo cuando el HTML carezca de tus datos.

Cambia la capa de recuperación y mantén parseBooks() exactamente como estaba:

// crawl-books-wsa.js: swap the fetch layer, keep parseBooks() unchanged
import { wsaFetch, buildWsaUrl } from './wsa-fetch.js';
import { parseBooks } from './parse-books.js';

const url = 'https://books.toscrape.com/catalogue/page-1.html';
const opts = { country: 'us' };                    // add renderJs: true only if the HTML lacks the data

if (process.argv.includes('--dry-run')) {
  const redact = (u) => u.replace(/api_key=[^&]+/, 'api_key=REDACTED');
  console.log(redact(buildWsaUrl(url, opts)));
  console.log(redact(buildWsaUrl(url, { ...opts, renderJs: true })));
} else {
  const { books, nextUrl } = parseBooks(await wsaFetch(url, opts), url);
  console.log(books.length, 'books; first:', books[0]?.title, '; next:', nextUrl);
}

Coloca la clave en un .env archivo que contenga WSA_API_KEY=your_key_here, añade .env a .gitignore, y cárgalo con la bandera integrada de Node --env-file , para que no necesites el paquete dotenv:

node --env-file=.env crawl-books-wsa.js --dry-run
node --env-file=.env crawl-books-wsa.js

La ejecución de prueba muestra las URL de las solicitudes con la clave ocultada, para que puedas ver la codificación:

https://api.webscrapingapi.com/v2?api_key=REDACTED&url=https%3A%2F%2Fbooks.toscrape.com%2Fcatalogue%2Fpage-1.html&country=us
https://api.webscrapingapi.com/v2?api_key=REDACTED&url=https%3A%2F%2Fbooks.toscrape.com%2Fcatalogue%2Fpage-1.html&render_js=1&country=us

La ejecución real pasa el HTML devuelto al mismo analizador:

20 books; first: A Light in the Attic ; next: https://books.toscrape.com/catalogue/page-2.html

Los errores se muestran de forma explícita. Sin la variable de entorno, el script se detiene con Error: Set WSA_API_KEY in your environment first. antes de enviar nada, y una clave incorrecta devuelve WebScrapingAPI HTTP 401: {"error":"Invalid API key"} en lugar de un resultado vacío. Para conocer todos los parámetros y códigos de error, consulta nuestra guía completa de la API de Scraper. Las páginas que requieren clics o introducir texto se adaptan mejor a un navegador alojado que a una llamada `fetch`, tema que se trata en la siguiente sección.

¿Qué método de scraping con JavaScript deberías utilizar?

Utiliza `fetch` y Cheerio cuando los datos estén en el HTML. Llama al punto final JSON cuando JavaScript cargue datos desde uno. Utiliza Playwright cuando tengas que hacer clic, desplazarte o esperar en la página. Utiliza una API de scraping cuando los bloqueos, la ubicación o la renderización a gran escala hagan que la recuperación local no sea fiable. La mayoría de los proyectos combinan dos de estas opciones.

Situación

Uso

Por qué

Los datos están en «Ver código fuente»

fetch + Cheerio

El más rápido, con menos componentes móviles

Muchas páginas

fetch + Cheerio con robots.txt, retardo, reintentos y deduplicación

Cortés y reiniciable

JavaScript carga datos desde una solicitud XHR que puedes llamar

fetch en el punto final JSON

Sin análisis sintáctico, sin navegador

Los datos están en formato JSON dentro de un <script>

Cheerio + JSON.parse

Sin navegador

Clics, desplazamiento o esperas en la página

Playwright (o Puppeteer)

Navegador real, eventos reales

Errores 403, páginas de autenticación, contenido específico por país o renderización a gran escala

API de scraping de fetch

Proxies gestionados, reintentos y renderización; analizador sin cambios

Sesiones de navegador alojadas con acciones

API del navegador

Sesiones sin necesidad de ejecutar Chrome tú mismo

Realiza estas comprobaciones en orden para cada sitio web nuevo:

  1. ¿Aparecen los datos en «Ver código fuente»? Utiliza fetch y Cheerio.
  2. ¿Llegan a través de una solicitud Fetch/XHR? Realiza esa solicitud.
  3. ¿Necesitas clics, desplazamiento o tiempos de espera? Usa Playwright.
  4. ¿Estás bloqueado o el contenido depende de la ubicación? Dirige la recuperación a través de la API de Scraper.
  5. ¿Necesitas sesiones de navegador alojadas que hagan clics y escriban? Usa la API de navegador.

¿Cómo se prueba un scraper de Node.js para que no falle de forma silenciosa?

Guarda una copia de cada tipo de página como archivo HTML y prueba tu analizador con ella utilizando el ejecutor de pruebas integrado de Node. Verifica el recuento de filas, los tipos de campos clave y el enlace a la página siguiente. Cuando el sitio cambie su diseño, la prueba fallará de forma evidente, en lugar de que tu scraper guarde silenciosamente datos vacíos o erróneos.

Los rastreadores rara vez se bloquean cuando cambia un sitio web. Siguen ejecutándose y guardan cadenas vacías, ceros o nada en absoluto. Las pruebas con fixtures detectan eso antes de que los datos erróneos lleguen a tu base de datos. Guarda la última página del catálogo y una página de categoría junto a la primera página que guardaste anteriormente:

curl -o fixtures/books-page-50.html "https://books.toscrape.com/catalogue/page-50.html"
sleep 1
curl -o fixtures/mystery-page-1.html "https://books.toscrape.com/catalogue/category/books/mystery_3/index.html"

A continuación, escribe las pruebas con node:test y node:assert/strict. No se necesitan paquetes adicionales:

// parse-books.test.js: run with `node --test`; uses saved pages, no network
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { readFile } from 'node:fs/promises';
import { parseBooks } from './parse-books.js';

const BASE = 'https://books.toscrape.com/catalogue/';
const load = (name) => readFile(`fixtures/${name}`, 'utf8');

test('parses 20 typed records and the next link', async () => {
  const { books, nextUrl } = parseBooks(await load('books-page-1.html'), `${BASE}page-1.html`);
  assert.equal(books.length, 20);
  for (const b of books) {
    assert.ok(b.title.length > 0);
    assert.ok(Number.isFinite(b.price) && b.price > 0, b.title);
    assert.ok(b.rating >= 1 && b.rating <= 5, b.title);
  }
  assert.equal(nextUrl, `${BASE}page-2.html`);
});

test('resolves ../../../ links on category pages', async () => {
  const url = `${BASE}category/books/mystery_3/index.html`;
  const { books } = parseBooks(await load('mystery-page-1.html'), url);
  assert.equal(books[0].url, `${BASE}sharp-objects_997/index.html`);
});

test('the last page has no next link', async () => {
  const { books, nextUrl } = parseBooks(await load('books-page-50.html'), `${BASE}page-50.html`);
  assert.equal(books.length, 20);
  assert.equal(nextUrl, null);
});

Ejecuta node --test:

✔ parses 20 typed records and the next link
✔ resolves ../../../ links on category pages
✔ the last page has no next link
ℹ tests 3
ℹ pass 3
ℹ fail 0

La segunda prueba detecta el problema de los enlaces relativos: las páginas de categorías enlazan los libros como ../../../sharp-objects_997/index.html, y un analizador que no lo gestione correctamente seguiría devolviendo 20 registros, solo que con URL rotas. Vuelve a guardar tus fixtures periódicamente y compara la salida analizada, para que detectes los cambios de diseño antes que tus usuarios. El ejecutor de pruebas integrado de Node también admite el modo de vigilancia, la cobertura y las instantáneas.

¿Qué es mejor para el web scraping, JavaScript o Python?

Ambos funcionan bien. Elige JavaScript si tu equipo ya lo utiliza, si vas a automatizar navegadores o si el rastreador se ejecuta dentro de un servicio de Node.js. Elige Python si los datos se utilizan con pandas, notebooks o aprendizaje automático, o si quieres el marco de rastreo de Scrapy. Las defensas del sitio web importan mucho más que el lenguaje que elijas.

Los componentes básicos se corresponden casi uno a uno. Los fetch se corresponde con los clientes HTTP de Python, Cheerio desempeña el papel de un rápido analizador de HTML y Playwright existe en ambos lenguajes con una API prácticamente idéntica. La ventaja de JavaScript es la automatización del navegador y el uso de un único lenguaje desde los scripts de la página hasta tu backend. La ventaja de Python es la pila de análisis posterior y un marco de rastreo maduro para trabajos de gran envergadura. Si tu equipo trabaja con Python, lee nuestra guía sobre el scraping web con Python. Las recomendaciones de esta guía se aplican sin cambios.

¿Cómo se realiza el scraping de forma responsable con JavaScript?

Lee los términos y condiciones del sitio y el archivo robots.txt antes de realizar el rastreo, mantén bajas las tasas de solicitud, identifica tu rastreador con un agente de usuario honesto y recopila solo los campos que necesites. Evita los datos personales a menos que tengas una base legal, nunca rastrees tras un inicio de sesión sin permiso y utiliza la API oficial del sitio cuando exista.

La mayor parte de esto ya está en tu código. robots.js comprueba las reglas antes de la primera página. El retraso de un segundo y el límite de dos trabajadores mantienen baja la carga. El User-Agent encabezado identifica a tu rastreador y proporciona al sitio una forma de ponerse en contacto contigo. Y el analizador solo conserva los campos que necesitas, tipificados y limpios, en lugar de almacenar páginas completas.

El resto es cuestión de criterio. Las páginas públicas no son un «todo vale»: siguen aplicándose las condiciones de uso, los derechos de autor y la legislación sobre privacidad, especialmente en lo que respecta a los datos personales. Lee nuestros principios sobre el uso responsable de los datos web y nuestra guía sobre la legalidad del scraping web, y busca asesoramiento jurídico antes de realizar un scraping para un proyecto comercial.

Preguntas frecuentes

¿Es Node.js adecuado para el web scraping?

Sí. Node.js gestiona muchas solicitudes de red a la vez sin hilos, incluye la función fetch integrada y ejecuta las principales herramientas de automatización de navegadores, Playwright y Puppeteer. Cheerio analiza el HTML rápidamente con selectores CSS familiares. Es una opción ideal cuando tu equipo ya programa en JavaScript o cuando el extractor se ejecuta dentro de un servicio de Node.js.

¿Por qué Cheerio devuelve un array vacío?

Normalmente, porque los datos no están en el HTML que ha recibido tu solicitud. JavaScript los añade en el navegador después de que se cargue la página, por lo que Cheerio nunca los ve. Comprueba «Ver fuente» en tu navegador: si los datos no aparecen allí, busca la solicitud JSON en la pestaña «Red» o renderiza la página con Playwright.

¿Cuál es la diferencia entre Cheerio y Playwright?

Cheerio analiza el HTML que ya has obtenido. Es rápido y ligero, pero no puede ejecutar JavaScript ni hacer clic en nada. Playwright controla un navegador real, por lo que ve la página después de que se ejecuten los scripts y puede hacer clic, desplazarse y esperar. Utiliza Cheerio por defecto y recurre a Playwright solo cuando la página necesite un navegador.

¿Puede JavaScript extraer datos de sitios web dinámicos?

Sí. Para las páginas que cargan datos con JavaScript, busca primero la solicitud JSON que realiza la página y llámala con `fetch()`, que es más rápido y estable. Cuando necesites hacer clics, desplazarte o esperar en la página, utiliza Playwright o Puppeteer para cargar la página en un navegador sin interfaz gráfica y leer los elementos renderizados.

¿Cómo evito que me bloqueen al extraer datos con Node.js?

Reduce la velocidad, envía un agente de usuario legítimo, vuelve a intentar las respuestas 429 y 503 tras el retraso especificado en «Retry-After» y almacena las páginas en caché para no tener que recuperarlas dos veces. Si un sitio sigue devolviendo errores 403 o páginas de autenticación, redirige las solicitudes a través de una API de scraping que gestione los proxies y la representación, y mantén tu analizador Cheerio sin cambios.

¿Sigo necesitando Axios o node-fetch para el scraping web?

No. Node.js 18 y versiones posteriores incluyen `fetch`, y es estable en todas las versiones compatibles, por lo que un nuevo rastreador no necesita ninguna biblioteca HTTP. Axios y Got siguen funcionando y aportan comodidades como interceptores y reintentos integrados. Consérvalos si tu proyecto ya los utiliza. De lo contrario, basta con el `fetch` nativo y una pequeña herramienta de reintentos.

¿Cómo debo almacenar una clave de API en un rastreador de Node.js?

Guarda la clave en una variable de entorno, como WSA_API_KEY, y léela con `process.env`. Para trabajar localmente, colócala en un archivo `.env`, ejecuta `node --env-file=.env` y añade `.env` a `.gitignore`. Nunca pegues claves en el código, en las URL que compartas ni en el JavaScript del front-end, donde cualquier visitante pudiera leerlas.

¿Puedo extraer datos de sitios web con TypeScript?

Sí. Todos los ejemplos de esta guía funcionan en TypeScript, ya que Cheerio, Playwright y Puppeteer incluyen sus propias definiciones de tipos. Las versiones recientes de Node.js pueden ejecutar archivos .ts directamente eliminando los tipos, o bien puedes utilizar un ejecutor como tsx. Definir los tipos de tus registros también permite detectar errores de análisis antes de guardar datos incorrectos.

¿Cómo puedo extraer datos de una página con desplazamiento infinito?

Abre DevTools, desplázate por la página y observa en la pestaña «Red» la solicitud que carga cada nuevo lote. Suele tomar un número de página o la posición del cursor, por lo que puedes llamarla con `fetch()` en un bucle hasta que indique que no hay más resultados. Si no hay ninguna solicitud útil, desplázate con Playwright y lee las filas.

El lenguaje no altera el panorama legal. El scraping de datos públicos suele ser lícito, pero depende de las condiciones del sitio web, del tipo de datos y de la legislación local, especialmente en lo que respecta a los datos personales y al contenido protegido por derechos de autor. Respeta el archivo robots.txt, evita recopilar datos personales sin una base legal y busca asesoramiento jurídico para proyectos comerciales.

Mantén tu analizador de Node.js y delega las páginas difíciles

Tu analizador Cheerio no tiene por qué cambiar cuando un sitio web empiece a bloquearte o requiera JavaScript. Dirige tu solicitud a la API de WebScrapingAPI y sigue analizando en Node.js. La renderización en JavaScript y la geolocalización no suponen ningún coste adicional, y las solicitudes fallidas no se facturan. Compara los planes de la API Scraper, empezando por una prueba gratuita de 5.000 solicitudes.

Acerca del autor

Robert Sfichi, Desarrollador full-stack @ WebScrapingAPI

Robert Sfichi

Desarrollador full-stack

Robert Sfichi forma parte del equipo de WebScrapingAPI, donde contribuye al desarrollo del producto y ayuda a crear soluciones fiables que dan soporte a la plataforma y a sus usuarios.

Extracción de datos web con AWS Lambda: guía para Python y Java 2026
Guías

Extracción de datos web con AWS Lambda: guía para Python y Java 2026

TL;DR: En resumen: el web scraping con AWS Lambda funciona mejor cuando cada invocación es breve, está delimitada y se puede reintentar de forma independiente. Empieza con HTTP directo, AWS SAM y S3, y añade SQS, contenedores, renderización en navegador, proxies o una capa de recuperación gestionada solo cuando la carga de trabajo demuestre que los necesita.

Suciu Dan33 min read
Leer artículo
Cómo utilizar GoSpider: rastrear, depurar URL y extraer datos
Guías

Cómo utilizar GoSpider: rastrear, depurar URL y extraer datos

TL;DR: En resumen: GoSpider es un rastreador de línea de comandos diseñado para descubrir URL, no un extractor completo de datos estructurados. Esta guía sobre cómo utilizar GoSpider muestra cómo realizar un rastreo limitado, gestionar correctamente los resultados, pasar los datos de Colly a CSV y seguir una ruta de diagnóstico para respuestas 403 o páginas que requieren renderización con JavaScript.

Suciu Dan24 min read
Leer artículo
Cómo raspar Redfin: Guía Python de Datos Inmobiliarios
Guías

Cómo raspar Redfin: Guía Python de Datos Inmobiliarios

TL;DR: Redfin expone puntos finales de API ocultos que devuelven JSON estructurado para los listados de propiedades, lo que permite omitir por completo el frágil análisis HTML. Esta guía te guía a través de la construcción de un raspador de Python que extrae datos de alquiler y venta, busca por ubicación, supervisa los nuevos listados a través de mapas de sitio XML y exporta resultados limpios a CSV o JSON.

Suciu Dan14 min read
Leer artículo

Empieza a crear

¿Estás listo para ampliar tu recopilación de datos?

Únete a más de 2000 empresas que utilizan WebScrapingAPI para extraer datos de la web a escala empresarial sin ningún gasto de infraestructura.