Como Lidar com a Paginação em Web Scraping: Todos os Tipos Explicados

TL;DR:

• Existem quatro tipos de paginação e cada um tem sua própria condição de parada. Botão de próxima página, páginas numeradas, carregar mais e rolagem infinita — errar a condição de parada pode fazer você perder páginas ou entrar em um loop infinito.
• Siga o próprio link de "próxima" do site; não adivinhe URLs. Ler li.next a e segui-lo página por página sobrevive a lacunas e numeração irregular que um loop ?page=N pularia silenciosamente.
• A rolagem infinita termina quando a página para de crescer. Role, espere e compare scrollHeight — quando parar de aumentar, você chegou ao fim; esse é o único sinal confiável.
• A paginação é onde você é limitado por taxa. Navegar por dezenas de páginas de um único IP é exatamente o padrão que os sistemas anti-bot monitoram; o egressso residencial e um navegador real mantêm a execução limpa.
• Tudo roda no Scrapeless Scraping Browser com Puppeteer simples. Inicie uma sessão, navegue, extraia, avance — o navegador em nuvem cuida da renderização e da anti-detecção para que as páginas continuem carregando.
• Gratuito para começar. Novas contas no Scrapeless incluem tempo de execução gratuito do Scraping Browser — inscreva-se em app.scrapeless.com.

Introdução: a paginação é a parte que quebra os scrapers

Extrair uma página é fácil. Extrair todas elas é onde a maioria dos scrapers falham silenciosamente — eles pegam a página um e param, ou entram em um loop além do fim buscando páginas vazias, ou ficam limitados por taxa pelas defesas anti-bot no meio do caminho. O motivo é que "paginação" não é uma coisa só. Um site usa um dos quatro mecanismos, e cada um precisa de uma maneira diferente de avançar e de saber que terminou.

Acertar o tipo e o resto é mecânico: extraia a página atual, encontre o caminho à frente, repita até a condição de parada. Erre — assuma ?page=N quando o site usa um botão de "Carregar mais", ou durma um tempo fixo ao invés de esperar por novo conteúdo — e você perde dados sem um erro que te avise.

Este guia cobre todos os quatro tipos e os executa no Scrapeless Scraping Browser, um navegador em nuvem anti-detecção conectado ao Puppeteer. A navegação por botão de próxima página abaixo foi executada contra um site paginado ao vivo; os outros padrões compartilham a mesma forma de loop.

Os quatro tipos de paginação

O erro mais comum é tratar um site com botão de próxima ou carregar mais como se tivesse URLs numeradas limpas. Siga os próprios controles do site em vez de construir URLs e você permanece correto mesmo quando a numeração tem lacunas.

Por que Scrapeless Scraping Browser

O Scrapeless Scraping Browser é um navegador em nuvem personalizável e anti-detecção projetado para crawlers da web e agentes de IA. Para crawls de várias páginas especificamente, ele traz:

• Uma conexão padrão com Puppeteer — Puppeteer.connect() retorna um Browser normal, então seu código de navegação e extração não muda.
• Proxies residenciais em mais de 195 países — navegue por muitas páginas sem o impacto na reputação do IP que aciona a limitação de taxa.
• Fingerprinting anti-detectação — crawls longos são lidos como um navegador real, então páginas posteriores continuam sendo renderizadas.
• Renderização JS do lado da nuvem — conteúdo de carregar mais e rolagem infinita (construído por JavaScript) realmente aparece.
• Persistência de sessão — mantenha os cookies quentes durante todo o crawl.

Obtenha sua chave de API no plano gratuito em app.scrapeless.com.

Pré-requisitos

• Node.js 18 ou mais recente
• Uma conta Scrapeless e chave de API — inscreva-se em app.scrapeless.com
• Familiaridade básica com Puppeteer e o DOM da página e seletores

Instalar

npm install @scrapeless-ai/sdk puppeteer-core

export SCRAPELESS_API_KEY="seu_token_api_aqui"

Conectar

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

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

const page = await browser.newPage();

Tipo 1 — Botão de próxima (o mais robusto)

Siga o próprio link de "próxima" do site até que não esteja mais disponível. Isso sobrevive a lacunas na numeração porque você nunca constrói uma URL — você lê a que o site lhe dá:

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(() => 

[...document.querySelectorAll('.quote .text')].map((q) => q.textContent),
  );
  items.push(...pageItems);

  // Leia o próximo link; null quando estamos na última página
  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, 'itens');
// 10 páginas, 100 itens

O loop termina naturalmente quando li.next a não existe mais — sem suposições sobre a contagem de páginas, sem erros de um a mais.

Obtenha sua chave de API no plano gratuito: app.scrapeless.com

Tipo 2 — Páginas numeradas

Quando o site expõe URLs numerados limpos e uma última página visível, leia o maior número de página uma vez e, em seguida, itere. Ainda prefira ler o link da última página em vez de assumir:

await page.goto(`${BASE}/page/1/`, { waitUntil: 'domcontentloaded' });
// por ex., leia o último link da página, se presente, caso contrário avance até uma página não gerar nada
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 vazia = passado o fim
  // ...extraia
}

A verificação de página vazia é a rede de segurança: mesmo se você subestimar o número da última página, você para no momento em que uma página retorna nenhum item.

Tipo 3 — Botão carregar mais

O conteúdo é uma página; um botão adiciona mais. Clique até que ele desapareça, aguardando novos itens entre os cliques:

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;                       // sem mais botões = concluído
  await btn.click();
  await page.waitForFunction(
    (n) => document.querySelectorAll('.item').length > n,
    {},
    before,
  );                                      // aguarde novos itens, não um sono fixo
}

Esperar que a contagem de itens aumente — em vez de um atraso fixo — é o que torna isso confiável em respostas lentas.

Tipo 4 — Scroll infinito

Novos itens carregam enquanto você rola. Role, aguarde e pare quando a altura da página parar 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;       // a altura parou de crescer = fim
  prevHeight = height;
  await page.evaluate(() => window.scrollTo(0, document.body.scrollHeight));
  await new Promise((r) => setTimeout(r, 1500)); // deixe o próximo lote carregar
}
const items = await page.evaluate(() =>
  [...document.querySelectorAll('.item')].map((el) => el.textContent),
);

O Que Você Recebe

Qualquer que seja o tipo, você termina com uma lista plana montada em várias páginas — para a execução confirmada do botão seguinte, 100 itens em 10 páginas. Algumas observações honestas:

• Desduplicar defensivamente. Carregar mais e o scroll infinito podem reemitir itens; baseie-se em um id estável.
• Limite o loop. Adicione um limite de páginas para que um site que se comporta mal não possa girar indefinidamente.
• Cuidado com um seletor estável. Se li.next ou o botão carregar mais mudar de classe, o loop termina cedo — verifique os seletores novamente quando as contagens parecerem baixas.
• Regule a velocidade da coleta. Um pequeno atraso entre as páginas e uma concorrência modesta mantém o sinal de reputação do IP limpo.

Conclusão: escolha o tipo, então o loop é mecânico

Todo rastreamento paginado tem a mesma forma — extrair, avançar, verificar a condição de parada — uma vez que você tenha identificado qual dos quatro tipos o site usa. Siga os próprios controles next/load-more do site em vez de adivinhar URLs, e pare no sinal real (sem próximo link, página vazia, botão faltando, altura estável). Executar no Scrapeless Scraping Browser mantém longos rastreamentos renderizando e desbloqueados com egresso de proxy residencial. Para coletar as URLs das páginas a serem rastreadas em primeiro lugar, veja o guia do scraper do Etsy; a página do produto do Scraping Browser e docs cobrem toda a superfície do SDK. Leia os controles do site, aguarde o conteúdo, não o relógio, e proteja o loop.

Pronto para Construir Seu Pipeline de Dados Poderado por IA?

Junte-se à nossa comunidade para reivindicar um plano gratuito e conectar-se com desenvolvedores que constroem rastreadores de várias páginas: Discord · Telegram.
Inscreva-se em app.scrapeless.com para obter a execução gratuita do Scraping Browser e adapte os padrões acima aos sites paginados de que seu fluxo de trabalho precisa. Veja preços para escalabilidade.

FAQ

P: Como sei qual tipo de paginação um site usa?
Olhe para a página: um link "Próximo" é um botão de próximo; links numerados são páginas numeradas; um botão "Carregar mais" é carregar mais; novo conteúdo que aparece enquanto você rola sem controle é scroll infinito. Muitos sites misturam dois — trate aquele que carrega os dados.

P: Por que meu loop ?page=N perde dados?
Porque o site não usa URLs numeradas limpas, ou a numeração tem lacunas. Siga o próprio link "próximo" do site em vez de construir URLs.

P: Como interrompo um loop de scroll infinito?
Compare document.body.scrollHeight antes e depois de cada rolagem. Quando parar de aumentar, não há mais nada para carregar.

P: Preciso de um proxy para rastreios de várias páginas?
Frequentemente sim — percorrer muitas páginas a partir de um IP é um clássico gatilho de limite de taxa. Fixe a saída residencial com proxyCountry e controle o ritmo do rastreamento.

P: Como evito ser bloqueado no meio do caminho?
Adicione um pequeno atraso entre as páginas, mantenha a concorrência modesta e execute em um navegador real de anti-detecção para que as páginas posteriores continuem sendo renderizadas.

P: Posso executar isso sem um agente de IA?
Sim. É apenas Puppeteer sobre a sessão do Scrapeless — nenhum agente necessário.