Web Scraping com JavaScript e Node.js: Cheerio vs Puppeteer

Principais Conclusões:

• A primeira decisão é estática vs dinâmica, e isso define toda a sua cadeia de ferramentas. Se os dados estão no HTML inicial, faça o parsing com Cheerio; se o JavaScript os constrói, você precisa de um navegador real como o Puppeteer.
• Cheerio é um parser, não um navegador — e esse é o ponto. Ele carrega HTML e fornece seletores estilo jQuery na velocidade nativa, sem sobrecarga de renderização, para páginas cujo conteúdo já está na marcação.
• Puppeteer renderiza, então vê o que os usuários veem. Para páginas renderizadas pelo cliente, rolagem infinita e conteúdo por trás de interações, o Puppeteer executa o JavaScript e entrega o DOM finalizado.
• Ambos rodam na mesma sessão do Scrapeless. Busque o HTML através do navegador em nuvem, então faça o parsing com Cheerio ou extraia ao vivo com Puppeteer — mesmo anti-detecção e saída residencial por trás.
• Verificado lado a lado. A mesma página de catálogo abaixo gera 20 itens através do Cheerio e 20 através do Puppeteer — prova de que os dois caminhos concordam quando o conteúdo está presente.
• Gratuito para começar. Novas contas do Scrapeless incluem tempo de execução gratuito do Navegador de Scraping — inscreva-se em app.scrapeless.com.

Introdução: escolha a ferramenta certa para a página

JavaScript e Node.js são uma combinação natural para scraping na web — a mesma linguagem que o navegador executa, com um ecossistema maduro para HTTP e HTML. Mas "scrape com Node" se divide imediatamente em dois trabalhos muito diferentes, e escolher o errado desperdiça esforço.

Se os dados que você deseja já estão no HTML inicial da página, você não precisa de um navegador — você precisa de um parser rápido. Esse é o Cheerio: carregue a marcação, execute seletores, pronto. Se os dados são construídos pelo JavaScript após o carregamento — um aplicativo React, um feed de rolagem infinita, conteúdo que aparece apenas após um click — então um parser não vê nada, porque o HTML que ele analisa é uma casca vazia. É aí que entra o Puppeteer (ou Playwright): ele executa o JavaScript da página e entrega o DOM renderizado.

O problema prático para ambos é o acesso: sites reais fazem fingerprinting, limitam a taxa e geo-restrições. Este guia executa ambas as abordagens no Navegador de Scraping Scrapeless — um navegador em nuvem anti-deteção — para que a busca tenha sucesso, e depois mostra quando usar Cheerio e quando usar Puppeteer. Ambos os caminhos abaixo foram executados ao vivo contra a mesma página.

Estático vs Dinâmico: como diferenciar

O teste rápido: veja o código-fonte da página (não o inspetor). Se os dados estão no HTML bruto, o Cheerio é suficiente. Se a fonte é uma casca quase vazia e o conteúdo aparece apenas no DOM ao vivo, você precisa do Puppeteer.

Por que o Navegador de Scraping Scrapeless

O Navegador de Scraping Scrapeless é um navegador em nuvem personalizável e anti-deteção, projetado para crawlers da web e agentes de IA. Para scraping em Node especificamente, ele traz:

• Uma conexão padrão do Puppeteer — Puppeteer.connect() retorna um normal Browser, então seu código não muda.
• Renderização de JS do lado da nuvem — páginas dinâmicas realmente constroem seu conteúdo, então tanto page.content() (para Cheerio) quanto a extração ao vivo funcionam.
• Proxies residenciais em mais de 195 países — fixe a saída para que a busca tenha sucesso e permaneça consistente.
• Fingerprinting anti-deteção — a sessão se apresenta como um navegador real, então as páginas são renderizadas em vez de desafiadas.
• Persistência de sessão — mantenha cookies quentes em uma execução de várias páginas.

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

Pré-requisitos

• Node.js 18 ou mais recente
• Uma conta do Scrapeless e chave da API — inscreva-se em app.scrapeless.com
• Familiaridade básica com seletores CSS

Instalar

npm install @scrapeless-ai/sdk puppeteer-core cheerio

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: 'js-node-scraping',
  proxyCountry: 'US',
  sessionTTL: 300,
});

const page = await browser.newPage();
await page.goto('https://books.toscrape.com/', {
  waitUntil: 'domcontentloaded',
  timeout: 60000,
});

Caminho A — Cheerio (parsing estático)

Quando o conteúdo está no HTML, pegue a marcação com page.content() e faça o parsing com Cheerio. A API de seletores é no estilo jQuery, então é fácil de ler:

import * as cheerio from 'cheerio';

const html = await page.content();
const $ = cheerio.load(html);

const titles = $('.product_pod h3 a')
  .map((i, el) => $(el).attr('title'))
  .get();

console.log(titles.length, '—', titles[0]);
// 20 — A Light in the Attic

Cheerio não renderiza nada — ele apenas analisa a string que você fornece. Isso o torna rápido e ideal quando você já possui o HTML. Você também pode usá-lo em HTML de qualquer fonte, não apenas de um navegador.

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

Caminho B — Puppeteer (extração dinâmica)

Quando o conteúdo é construído por JavaScript, extraia-o do DOM ao vivo dentro da página renderizada. Mesmos seletores, mas avaliados no navegador após os scripts da página terem sido executados:

const titles = await page.evaluate(() =>
  [...document.querySelectorAll('.product_pod h3 a')].map((a) => a.getAttribute('title')),
);

console.log(titles.length, '—', titles[0]);
// 20 — A Light in the Attic

Na mesma página de catálogo, ambos os caminhos retornam os mesmos 20 títulos — porque o conteúdo está presente no HTML, qualquer uma das abordagens funciona. A diferença aparece em uma página renderizada pelo cliente: Cheerio no HTML cru não encontraria nada, enquanto o caminho do Puppeteer ainda retorna os itens porque a página foi renderizada primeiro.

Para conteúdo dinâmico que carrega na interação, acesse a página antes de extrair — role para conteúdo preguiçoso, clique para revelar e, em seguida, waitForSelector no resultado:

await page.evaluate(() => window.scrollTo(0, document.body.scrollHeight));
await page.waitForSelector('.product_pod', { timeout: 10000 });
// ...então extraia como acima

Escolhendo entre eles

• Conteúdo no HTML cru? Use Cheerio — é mais rápido e simples.
• Conteúdo construído por JavaScript, rolagem infinita ou atrás de um clique? Use Puppeteer para renderizar, depois extraia.
• Ambos em uma página? Comum — renderize com Puppeteer e depois passe page.content() para Cheerio se você preferir a ergonomia de seletores dele para as partes estáticas.

O que você recebe de volta

Qualquer caminho produz a mesma lista plana quando os dados estão presentes:

{
  "count": 20,
  "first": "A Light in the Attic"
}
// Captura real: tanto Cheerio quanto Puppeteer retornaram 20 títulos da mesma página.

Algumas observações honestas:

• Não renderize quando não precisa. Se o HTML já tem os dados, Cheerio evita totalmente o custo de renderização.
• Renderize quando a fonte é uma casca. Um HTML cru praticamente vazio com um DOM ao vivo populado é o sinal para usar Puppeteer.
• Espere pelo conteúdo, não pelo relógio. Para páginas dinâmicas, waitForSelector é melhor do que um setTimeout fixo.
• Seletores são conhecimento compartilhado. Os mesmos seletores CSS funcionam em Cheerio e em querySelectorAll, portanto, mudar entre os caminhos é barato.

Conclusão: uma decisão, dois caminhos limpos

A extração de dados da web com JavaScript e Node.js se resume a uma única chamada inicial — os dados estão no HTML ou são gerados por JavaScript? Cheerio lida com o primeiro caso na velocidade do analisador; Puppeteer lida com o segundo renderizando a página. Executar ambos no Scrapeless Scraping Browser significa que a busca tem sucesso de qualquer maneira, com egressos residenciais e anti-detecção por baixo. Para um fluxo de trabalho anti-bot mais profundo, veja o guia Scrapling + Scrapeless; a página do produto Scraping Browser e documentos cobrem toda a superfície do SDK. Verifique o HTML cru primeiro, busque Cheerio quando puder e Puppeteer quando precisar, e espere pelo conteúdo, não pelo relógio.

Pronto para construir seu pipeline de dados alimentado por IA?

Junte-se à nossa comunidade para reivindicar um plano gratuito e conectar-se com desenvolvedores construindo scrapers em Node: Discord · Telegram.

Inscreva-se em app.scrapeless.com para o runtime gratuito do Scraping Browser e adapte os padrões acima para as páginas estáticas e dinâmicas que seu fluxo de trabalho precisa. Veja preços para escala.

FAQ

P: Quando devo usar Cheerio em vez de Puppeteer?
Quando os dados já estão no HTML inicial da página. Cheerio apenas analisa marcação, então é mais rápido e simples — sem renderização. Use Puppeteer quando o JavaScript constrói o conteúdo.

P: Como sei se uma página é estática ou dinâmica?
Visualize o código-fonte da página (não o inspetor). Se os dados estão na fonte, é estática — Cheerio funciona. Se a fonte é uma casca praticamente vazia e o conteúdo só aparece no DOM ao vivo, é dinâmica — use Puppeteer.

P: Posso usar ambos na mesma página?
Sim. Renderize com Puppeteer, depois passe page.content() para Cheerio se você preferir a ergonomia do seletor para as partes estáticas.

P: Cheerio vs Playwright vs Puppeteer — qual?
Cheerio para análise estática. Puppeteer ou Playwright (ambos navegadores completos) para renderização dinâmica — escolha o que sua pilha já usa; a sessão Scrapeless funciona com ambos via CDP.

P: Preciso de um proxy?
Para páginas estáticas públicas, muitas vezes não — mas fixar proxyCountry fornece um IP residencial consistente que sites reais tratam como um visitante normal, o que é mais importante à medida que você escala.

P: Posso rodar isso sem um agente de IA?
Sim. É o SDK Scrapeless mais o Puppeteer e Cheerio simples — nenhum agente é necessário.