Cómo manejar la paginación en la web scraping: Cada tipo explicado

TL;DR:

• Existen cuatro tipos de paginación y cada uno tiene su propia condición de detención. Botón de siguiente, páginas numeradas, cargar más e infinite scroll — si te equivocas con la condición de detención, ya sea que pierdas páginas o entres en un bucle eterno.
• Sigue el enlace "siguiente" del sitio; no adivines URLs. Leer li.next a y seguirlo página por página sobrevive a los huecos y la numeración irregular que un bucle ?page=N saltaría silenciosamente.
• El infinite scroll termina cuando la página deja de crecer. Desplázate, espera y compara scrollHeight — cuando deja de aumentar, has llegado al final; esa es la única señal confiable.
• La paginación es donde te limitan la tasa. Caminar por docenas de páginas desde una IP es exactamente el patrón que observan los sistemas anti-bot; un acceso residencial y un navegador real mantienen la ejecución limpia.
• Todo se ejecuta en Scrapeless Scraping Browser con Puppeteer simple. Crea una sesión, navega, extrae, avanza — el navegador en la nube maneja la representación y la anti-detección, así que las páginas siguen cargando.
• Gratis para empezar. Nuevas cuentas de Scrapeless incluyen tiempo de ejecución gratuito de Scraping Browser — regístrate en app.scrapeless.com.

Introducción: la paginación es la parte que rompe los raspadores

Raspar una página es fácil. Raspar todas ellas es donde la mayoría de los raspadores fallan silenciosamente — agarran la página uno y se detienen, o recorren el final buscando páginas vacías, o son limitados por las defensas anti-bot a mitad de camino. La razón es que "paginación" no es una sola cosa. Un sitio utiliza uno de cuatro mecanismos, y cada uno necesita una forma diferente de avanzar y una forma diferente de saber cuándo ha terminado.

Si obtienes el tipo correcto, el resto es mecánico: extrae la página actual, encuentra el camino a seguir, repite hasta la condición de detención. Si te equivocas — asumiendo ?page=N cuando el sitio utiliza un botón de "Cargar más", o durmiendo un tiempo fijo en lugar de esperar contenido nuevo — perderás datos sin un error que te lo indique.

Esta guía cubre los cuatro tipos y los ejecuta en Scrapeless Scraping Browser, un navegador en la nube de anti-detección conectado a Puppeteer. El recorrido por el botón siguiente a continuación se llevó a cabo contra un sitio paginado en vivo; los otros patrones comparten la misma forma de bucle.

Los cuatro tipos de paginación

El error más común es tratar un sitio de botón siguiente o cargar más como si tuviera URLs numeradas limpias. Sigue los propios controles del sitio en lugar de construir URLs y permaneces correcto incluso cuando la numeración tiene huecos.

Por qué Scrapeless Scraping Browser

Scrapeless Scraping Browser es un navegador en la nube personalizable y anti-detección diseñado para rastreadores web y agentes de IA. Para rastreos de múltiples páginas específicamente, trae:

• Una conexión estándar de Puppeteer — Puppeteer.connect() devuelve un Browser normal, por lo que tu código de navegación y extracción no cambia.
• Proxies residenciales en más de 195 países — recorre muchas páginas sin el golpe a la reputación de IP que activa la limitación de tasa.
• Huella de anti-detección — rastreos largos se presentan como un navegador real, por lo que las páginas posteriores siguen representándose.
• Renderizado de JS del lado de la nube — el contenido de cargar más e infinite-scroll (construido por JavaScript) realmente aparece.
• Persistencia de sesión — manten las cookies activas durante todo el rastreo.

Obtén tu clave API en el plan gratuito en app.scrapeless.com.

Requisitos previos

• Node.js 18 o más reciente
• Una cuenta de Scrapeless y clave API — regístrate en app.scrapeless.com
• Familiaridad básica con Puppeteer y el DOM de página y selectores

Instalar

npm install @scrapeless-ai/sdk puppeteer-core

export SCRAPELESS_API_KEY="tu_token_api_aqui"

Conectar

import { Puppeteer } from '@scrapeless-ai/sdk';

const browser = await Puppeteer.connect({
  apiKey: process.env.SCRAPELESS_API_KEY,
  sessionName: 'paginación',
  proxyCountry: 'US',
  sessionTTL: 300,
});

const page = await browser.newPage();

Tipo 1 — Botón siguiente (el más robusto)

Sigue el propio enlace "siguiente" del sitio hasta que desaparezca. Esto sobrevive a los huecos en la numeración porque nunca construyes una URL — lees la que el sitio te da:

const BASE = 'https://quotes.toscrape.com';
let url = `${BASE}/page/1/`;
const items = [];
let pages = 0;

while (url) {
  await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
  pages++;

  const pageItems = await page.evaluate(() =>
Looping a través de elementos de una página web es un proceso común en la recolección de datos. A continuación se proporciona un resumen sobre cómo manejar la paginación en diferentes tipos de sitios web para la extracción de información.

---

## Tipo 1 — Páginas con botón "siguiente"

Cuando un sitio web tiene un botón de "siguiente" claro, simplemente hay que seguir este botón hasta que ya no exista. El código es el siguiente:

```javascript
await page.goto(BASE, { waitUntil: 'domcontentloaded' });
const items = [];

while (url) {
  await page.goto(url, { waitUntil: 'domcontentloaded' });
  const pageItems = await page.evaluate(() => 
    [...document.querySelectorAll('.quote .text')].map((q) => q.textContent),
  );
  items.push(...pageItems);

  const next = await page.evaluate(() => {
    const a = document.querySelector('li.next a');
    return a ? a.getAttribute('href') : null;
  });
  url = next ? new URL(next, BASE).href : null;
}

console.log(pages, 'páginas,', items.length, 'elementos');
// 10 páginas, 100 elementos

El bucle termina de manera natural cuando li.next a ya no existe: no hay suposiciones sobre el número de páginas, y se evita el error de fuera de rango.

Tipo 2 — Páginas numeradas

Cuando el sitio expone URLs numeradas limpias y tiene una última página visible, lee el número de la última página una vez, y luego itera desde allí. Se prefiere leer el enlace de la última página en lugar de asumirlo:

await page.goto(`${BASE}/page/1/`, { waitUntil: 'domcontentloaded' });
for (let n = 1; ; n++) {
  await page.goto(`${BASE}/page/${n}/`, { waitUntil: 'domcontentloaded' });
  const count = await page.evaluate(() => document.querySelectorAll('.quote').length);
  if (count === 0) break;   // página vacía = más allá del final
  // ...extraer
}

La comprobación de la página vacía es la red de seguridad: incluso si se juzga mal el número de la última página, se detiene en el momento en que una página devuelve cero elementos.

Tipo 3 — Botón "cargar más"

El contenido está en una sola página; un botón agrega más elementos. Haz clic en él hasta que desaparezca, esperando nuevos elementos entre clics:

await page.goto(TARGET, { waitUntil: 'domcontentloaded' });
while (true) {
  const before = await page.evaluate(() => document.querySelectorAll('.item').length);
  const btn = await page.$('button.load-more');
  if (!btn) break;                       // no más botón = terminado
  await btn.click();
  await page.waitForFunction(
    (n) => document.querySelectorAll('.item').length > n,
    {},
    before,
  );                                      // esperar nuevos elementos, no un retraso fijo
}

Esperar que el conteo de elementos aumente — en lugar de un retraso fijo — es lo que hace que esto sea confiable incluso con respuestas lentas.

Tipo 4 — Desplazamiento infinito

Nuevos elementos se cargan a medida que se desplaza. Desplázate, espera y detente cuando la altura de la página deje de aumentar:

await page.goto(TARGET, { waitUntil: 'domcontentloaded' });
let prevHeight = 0;
while (true) {
  const height = await page.evaluate(() => document.body.scrollHeight);
  if (height === prevHeight) break;       // la altura dejó de crecer = fin
  prevHeight = height;
  await page.evaluate(() => window.scrollTo(0, document.body.scrollHeight));
  await new Promise((r) => setTimeout(r, 1500)); // dejar que se cargue el siguiente lote
}
const items = await page.evaluate(() =>
  [...document.querySelectorAll('.item')].map((el) => el.textContent),
);

Lo que obtienes de vuelta

Cualquiera que sea el tipo, terminas con una lista plana ensamblada a través de páginas: para la ejecución verificada con botón "siguiente", 100 elementos a lo largo de 10 páginas. Algunas observaciones honestas:

• Desduplicar defensivamente. Cargar más y el desplazamiento infinito pueden volver a emitir elementos; usa una id estable.
• Limitar el bucle. Agrega una guardia de páginas máximas para que un sitio problemático no se quede en un ciclo eterno.
• Presta atención a un selector estable. Si li.next o el botón "cargar más" cambian de clase, el bucle termina temprano: vuelve a chequear selectores cuando los conteos parecen bajos.
• Ritmo del rastreo. Un breve retraso entre páginas y una moderada concurrencia mantienen limpio el signo de reputación de IP.

Conclusión: elige el tipo y luego el bucle es mecánico

Cada rastreo paginado tiene la misma estructura: extraer, avanzar, verificar la condición de parada — una vez que hayas identificado cuál de los cuatro tipos usa el sitio. Sigue los controles de "siguiente/cargar más" del sitio en lugar de adivinar URLs, y detente en la señal real (sin enlace siguiente, página vacía, botón que falta, altura estable). Ejecutar en Scrapeless Scraping Browser mantiene los rastreos largos funcionando y desbloqueados con salida de proxy residencial. Para recolectar las URLs de las páginas a rastrear en primer lugar, consulta la guía de scraper de Etsy; la página de productos de Scraping Browser y documentación cubren toda la superficie del SDK. Lee los controles del sitio, espera el contenido y no el reloj, y protege el bucle.

¿Listo para construir tu pipeline de datos potenciado por IA?

Únete a nuestra comunidad para reclamar un plan gratuito y conectarte con desarrolladores que construyen rastreadores de múltiples páginas: Discord · Telegram.
Regístrate en app.scrapeless.com para obtener de forma gratuita el tiempo de ejecución del Scraping Browser y adapta los patrones anteriores a los sitios paginados que tu flujo de trabajo necesita. Consulta precios para escalar.

Preguntas Frecuentes

P: ¿Cómo sé qué tipo de paginación utiliza un sitio?
Mira la página: un enlace de "Siguiente" es un botón-siguiente; los enlaces numerados son páginas numeradas; un botón de "Cargar más" es cargar-más; nuevo contenido que aparece a medida que desplazas sin control es desplazamiento infinito. Muchos sitios combinan dos: maneja el que carga los datos.

P: ¿Por qué mi ?page=N pierde datos?
Porque el sitio no utiliza URL numeradas limpias, o la numeración tiene huecos. Sigue el propio enlace de siguiente del sitio en lugar de construir URL.

P: ¿Cómo detengo un bucle de desplazamiento infinito?
Compara document.body.scrollHeight antes y después de cada desplazamiento. Cuando deje de aumentar, no queda nada por cargar.

P: ¿Necesito un proxy para rastreos de varias páginas?
A menudo sí: recorrer muchas páginas desde una sola IP es un desencadenante clásico de límite de velocidad. Asegura el egreso residencial con proxyCountry y controla el ritmo del rastreo.

P: ¿Cómo evito ser bloqueado a mitad de camino?
Agrega un breve retraso entre páginas, mantén la concurrencia moderada y ejecuta en un navegador real de anti-detección para que las páginas posteriores continúen renderizándose.

P: ¿Puedo ejecutar esto sin un agente de IA?
Sí. Es simplemente Puppeteer sobre la sesión de Scrapeless: no se requiere agente.