Saltar para o conteúdo
Comece grátis
Voltar ao blogue

Web scraping com JavaScript e Node.js: Um guia prático

Robert SfichiÚltima atualização em 26 min read
Web scraping com JavaScript e Node.js: Um guia prático
Resumo: O web scraping com JavaScript e Node.js requer o Node.js 22.12 ou posterior, o fetch integrado para os pedidos e o Cheerio para analisar HTML. Utilize o Cheerio quando os dados estão no HTML que o seu pedido recebe, e o Playwright quando o JavaScript constrói a página ou esta exige cliques e esperas. Este guia constrói um único scraper, da paginação e do JSON oculto aos testes offline e a uma API de scraping como alternativa.

A extração de dados da Web com JavaScript começa com uma tarefa simples: os dados estão numa página Web, escreves código JavaScript e queres esses dados num formato JSON limpo, sem teres de lidar com blocos ou matrizes vazias. Se esta ideia for nova para ti, lê primeiro o que é a extração de dados da Web.

Este guia utiliza o books.toscrape.com, uma livraria de treino criada para scrapers, como exemplo prático. Irá obter e analisar uma página com o fetch e Cheerio, percorrerá um catálogo paginado de forma educada, verificará se o JavaScript constrói uma página, renderizará e percorrerá páginas com o Playwright, testará o seu analisador offline e transferirá páginas bloqueadas para uma API de scraper sem alterar o analisador.

Início rápido

  • Utilize o Node.js 22.12 ou posterior (recomenda-se a versão 24 ou 26 LTS)
  • npm install cheerio para páginas cujos dados estejam no HTML
  • npm install playwright para páginas que necessitem de um navegador real
  • Verifique o ficheiro robots.txt e os termos do site antes de iniciar o rastreio

O que é necessário para começar a extrair dados da Web com JavaScript?

Precisa do Node.js 22.12 ou posterior, de um editor de código e de dois pacotes: o Cheerio para analisar HTML e o Playwright para renderizar páginas que necessitem de um navegador. O `fetch` integrado no Node.js trata dos pedidos, pelo que não precisa do Axios. Aprenda também a utilizar as DevTools do seu navegador, porque encontrar o seletor certo e a fonte de dados da página é metade do trabalho.

O Node.js adapta-se bem aos scrapers. Fala a mesma linguagem que os próprios scripts da página, pelo que a leitura do JavaScript de um site resulta familiar. O seu modelo de E/S assíncrona lida com muitas solicitações de rede sem recorrer a threads. E as principais ferramentas de automação de navegadores, o Playwright e o Puppeteer, são orientadas para o JavaScript.

A tabela abaixo apresenta as ferramentas utilizadas neste guia. Para uma visão mais abrangente, consulte a comparação entre seis bibliotecas de scraping para Node.js.

Ferramenta

Tarefa

Utilize-a quando

Versão mais recente no npm (outubro de 2026)

Node floor

fetch (integrado)

Pedidos HTTP

Sempre; não é necessária instalação

Parte do Node

Estável desde o Node 21

Cheerio

Analisa HTML com seletores CSS

Os dados estão no HTML

1.2.0

20.18.1

jsdom

Um DOM semelhante ao de um navegador no Node

Precisa de APIs DOM, não apenas de seletores

30.1.3

22.22.2, 24.15 ou 26

Playwright

Controla o Chromium, o Firefox e o WebKit

As páginas requerem cliques, tempos de espera ou renderização

1.64.1

20

Puppeteer

Controlar o Chrome ou o Firefox

Código Puppeteer existente, ferramentas do Chrome

25.16.0

22.12.0

p-limit

Limitar promessas simultâneas

Muitas URLs em sites que permitem pedidos paralelos

7.3.3

20

Axios / Got

Clientes HTTP com funcionalidades adicionais

Já os utiliza

1.21.0 / 16.1.0

— / 22

O jsdom constrói um DOM mais completo do que o Cheerio, mas é mais lento e executa scripts de página apenas com uma opção que a própria documentação descreve como insegura; por isso, o Cheerio é a melhor opção por predefinição. O Axios é adequado se o seu projeto já o utilizar. As notas sobre o Node explicam a recomendação de versão: o Puppeteer requer a versão 22.12 e o Node 20 já ultrapassou o fim do ciclo de vida, de acordo com o calendário de lançamentos do Node.js.

Como se configura um projeto de scraping com o Node.js?

Cria uma pasta, muda o projeto para módulos ES para que import o código de nível superior await funcionem, e instale os dois pacotes principais. O Playwright descarrega a sua própria compilação do Chromium com um 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

A fixtures/ pasta contém páginas guardadas para testes offline e out/ armazena os resultados. O Puppeteer descarrega o Chrome durante a instalação, e o npm 11 pode apresentar um aviso relativo aos scripts de instalação. Pode rever esses scripts com npm install-scripts ls. Se programares em TypeScript, o mesmo código é executado em .ts ficheiros através da remoção de tipos integrada no Node ou de um executor como o tsx.

É possível extrair dados de um site com JavaScript no navegador?

Apenas em páginas do mesmo site. Os navegadores impedem que o JavaScript de um site leia respostas de outro, a menos que esse servidor o permita através de cabeçalhos CORS, e a maioria não o permite. É por isso que os scrapers são executados no Node.js, que não tem essa regra. Utilize o JavaScript do navegador para testar seletores na consola do DevTools, não para recolher dados.

A regra subjacente a isto é a política de mesma origem. Um script carregado a partir de uma origem pode enviar um pedido para outra, mas o navegador oculta a resposta, a menos que o outro servidor autorize isso através de Access-Control-Allow-Origin cabeçalhos. O guia CORS da MDN explica os detalhes.

O Node.js não é um navegador, pelo que lê qualquer resposta que receba. Isso torna-o o local ideal para um scraper e mantém credenciais, como chaves de API, fora dos computadores dos visitantes. As extensões de navegador e os bookmarklets são a única exceção: podem ler a página que já está a visualizar, o que é adequado para cópias pontuais, mas não para a recolha programada.

Como se faz o scraping de uma página web com o `fetch` do Node.js e o Cheerio?

Recupere o HTML da página com `fetch()`, verifique se a resposta está correta e carregue o texto no Cheerio com `cheerio.load()`. Selecione cada cartão ou linha repetida com um seletor CSS, leia o texto ou os atributos a partir dela e converta os números à medida que avança. Devolva objetos simples e resolva links relativos com `new URL(href, pageUrl)`.

O site books.toscrape.com lista 1 000 livros distribuídos por 50 páginas de catálogo, 20 por página, com preços, classificações por estrelas e estado de stock. Um banner no site indica que se trata de uma demonstração para prática de scraping e que os preços e classificações são aleatórios, pelo que é um local seguro para aprender.

Comece com um auxiliar de recuperação que irá reutilizar em todo o lado. Este envia um agente de utilizador descritivo, desiste após 15 segundos com AbortSignal.timeout(), verifica res.oke tenta novamente em caso de limites de taxa e erros de servidor. Quando o servidor envia o cabeçalho «Retry-After», ele aguarda esse tempo. Caso contrário, ele recua exponencialmente.

// 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);
  }
}

Substitua o URL de contacto pelo seu, para que o proprietário do site possa contactá-lo em vez de o bloquear. fetch está integrado no Node, e a API Fetch funciona da mesma forma que no navegador. Se estiver a ponderar utilizar uma biblioteca, consulte a comparação entre o fetch nativo, o Axios, o Got e o Ky.

O analisador recebe HTML e o URL da página e devolve registos tipados. Mantê-lo livre de código de rede facilita os testes e a reutilização quando alterares a forma como fazes o fetch.

// 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 };
}

A saída não necessita de uma segunda passagem de limpeza. O preço torna-se um número, e não uma cadeia de caracteres "£51.77". A classificação por estrelas está no nome de uma classe (star-rating Three), pelo que um pequeno mapa o transforma num valor de 1 a 5, e qualquer coisa inesperada torna-se null em vez de uma estimativa errada. E todas as ligações passam por new URL(), porque os hrefs do site são relativos.

Guarde uma cópia da primeira página do catálogo e execute o analisador nela sem recorrer à rede:

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

Guarde cada tipo de página que pretenda extrair da mesma forma, uma curl -o por página, com um segundo de intervalo entre elas. Esses ficheiros tornar-se-ão os teus fixtures de teste mais tarde. O Cheerio tem mais para oferecer do que isto, incluindo extract() a leitura de JSON a partir de tags de script. Ambos são abordados no nosso guia completo do Cheerio, e a documentação do Cheerio apresenta a API completa.

Como encontrar os seletores CSS certos?

Abre a página no teu navegador, clica com o botão direito do rato nos dados que desejas e seleciona «Inspecionar». Encontre o elemento que se repete uma vez por registo, como um cartão de produto com uma classe, e teste o seu seletor na consola do DevTools com document.querySelectorAll(). Dê preferência a seletores curtos baseados em classes em vez de percursos longos copiados do DevTools, que deixam de funcionar quando o layout muda.

Em books.toscrape.com, clique com o botão direito do rato em qualquer título de livro e selecione «Inspecionar». Cada livro encontra-se num <article class="product_pod">, pelo que esse é o elemento que se repete. Teste-o no separador «Console»:

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"

A segunda linha mostra uma armadilha fácil de ignorar. Os títulos longos são encurtados no texto visível do link, mas o título completo encontra-se no atributo title . Compare sempre o que extrai com o que a página realmente significa, e não apenas com o que mostra. A classificação funciona da mesma forma: não há nenhum «3» em nenhum lugar do cartão, apenas a classe star-rating Three.

Saiba também a diferença entre «Ver Código-fonte» e «Inspecionar». «Ver Código-fonte» mostra o HTML que o servidor enviou, que é exatamente o que fetch recebe. «Inspecionar» mostra o DOM ativo após a execução dos scripts. Quando um seletor funciona em «Inspecionar», mas não devolve nada no Node.js, significa que o conteúdo foi criado pelo JavaScript, e as secções abaixo mostram o que fazer.

Ancore os seletores em classes e atributos, em vez de na posição (li.next a, e não ul > li:nth-child(2) > a). Além disso, os IDs CSS não podem começar por um algarismo, a menos que sejam escapados; por isso, um elemento com id="2015" precisa de [id="2015"] em vez de #2015. Para tudo o resto, mantenha uma referência completa aos seletores à mão.

Como é que se faz o scraping de várias páginas de forma educada?

Verifique primeiro o ficheiro robots.txt e, em seguida, siga a ligação «Seguinte» de cada página, em vez de adivinhar padrões de URL. Mantenha um conjunto de URLs visitadas para que uma ligação incorreta não entre em loop, elimine registos duplicados com base numa chave estável e aguarde entre os pedidos. Respeite as regras de frequência do próprio site e os cabeçalhos «Retry-After», e limite o número total de páginas enquanto estiver a desenvolver.

Comece pelo ficheiro robots.txt. Este leitor minimalista recolhe as Disallow regras para o User-agent: * grupo. Ele lida com regras simples de prefixo, enquanto a norma do ficheiro robots.txt (RFC 9309) define caracteres curinga e Allow precedência; por isso, utilize um analisador completo em sites que dependam deles. De acordo com esse padrão, uma resposta 4xx significa que não se aplicam regras e uma 5xx significa que deve tratar todo o site como fora dos limites.

// 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));

O rastreador começa na primeira página do catálogo, segue o link seguinte até não haver mais nenhum, espera um segundo entre os pedidos e guarda os ficheiros em JSON e 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 com o limite padrão 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

Execute-o com MAX_PAGES=100 node crawl-books.js e ele pára por si próprio após a página 50, porque a última página não tem nenhum link seguinte:

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 site mostra por que razão cada medida de segurança existe. O link seguinte na página inicial é catalogue/page-2.html, mas na página 2 é apenas page-3.html. Ao inserir isso na raiz do site, obtém-se https://books.toscrape.com/page-3.html, o que devolve um erro 404. new URL(href, pageUrl) resolve cada link em função da página de onde veio, por isso está sempre correto.

A página inicial e catalogue/page-1.html também apresentam os mesmos 20 livros em dois URLs, e ambos apontam o seu link seguinte para a página 2. Um rastreador que comece a partir de ambos, ou que siga um link «anterior» de volta à página 1, pouparia 40 linhas para 20 livros. O conjunto de páginas visitadas evita a repetição de páginas, e a indexação dos registos pela URL do livro evita a repetição de linhas. Para conhecer mais práticas como estas, leia o nosso guia sobre as melhores práticas de scraping ao longo do ciclo de vida do projeto.

Quantas solicitações pode executar ao mesmo tempo?

A simultaneidade é uma decisão que depende de cada site. Quando um site publica um limite de taxa, cumpra-o, mesmo que isso signifique uma solicitação de cada vez. Quando não o faz, limite as solicitações paralelas por host a um valor baixo, faça uma pausa e recue ao receber um erro 429. Mais velocidade raramente ajuda se isso fizer com que seja bloqueado.

O books.toscrape.com não publica um limite, pelo que este script recupera páginas de detalhes de livros duas de cada vez com p-limit (npm install p-limit) para adicionar o UPC e a quantidade exata em stock de cada livro:

// 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() impede que uma página com falha faça com que os outros nove resultados sejam descartados.

Como se guardam os dados extraídos em JSON e CSV?

O JSON mantém os tipos de dados: os números continuam a ser números e null permanece null. O CSV é o formato preferido das folhas de cálculo, mas requer aspas; por isso, o rastreador envolve cada célula em aspas e duplica quaisquer aspas dentro de um valor. Os valores vazios transformam-se em células vazias.

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 trabalhos maiores, escreva um objeto JSON por linha (JSON Lines), tal como details.js faz, para que uma falha a meio do processo não te faça perder o ficheiro inteiro. Se a tua fonte for uma tabela em vez de cartões, consulta o nosso guia para exportar tabelas HTML para CSV limpo.

Como saber se uma página precisa de renderização em JavaScript?

Carregue a página com o comando fetch() simples e execute o seu seletor. Se este não encontrar nada, mas o navegador mostrar os dados, significa que o JavaScript constrói esse conteúdo após o carregamento. Em seguida, abra o DevTools, selecione o separador «Rede», filtre por «Fetch/XHR» e recarregue ou clique: o pedido que devolve os seus dados é normalmente mais fácil de utilizar do que o navegador.

Pode automatizar essa verificação. Este script conta as correspondências do seu seletor no HTML bruto e numa página renderizada, e lista todas as solicitações fetch ou XHR que a página efetua durante o carregamento:

// 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 o catálogo de livros:

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

Essa é a resposta que esperas: o servidor envia todos os livros no HTML, pelo que um navegador apenas aumentaria o tempo de execução. Executa o mesmo script com outro URL e seletor (node check-js.js <url> "<selector>") antes de criares um scraper para um novo site.

Quando a contagem bruta é 0, os dados estão escondidos num de dois outros locais. Podem ser dados JSON dentro de uma <script> , que o Cheerio consegue ler e JSON.parse() descodificar. Ou o JavaScript solicita-os após o carregamento, e o pedido aparece na lista do script e no separador «Rede». Seja como for, muitas vezes pode dispensar o navegador. Para saber mais sobre o que um navegador de renderização faz, veja como funcionam os navegadores sem interface gráfica.

Como é que se extraem dados JavaScript sem um navegador?

Encontre a solicitação que a página faz para obter os seus dados no separador «Rede» das DevTools, copie o seu URL e parâmetros e chame-a você mesmo com o `fetch()`. Obterá JSON sem análise de HTML e sem necessidade de executar um navegador. Mantenha o mesmo limite de taxa e agente de utilizador, e chame apenas os pontos de extremidade que a própria página utiliza para dados públicos.

Os passos são os mesmos em qualquer site:

  1. Abra as DevTools, selecione o separador «Rede» e filtre por «Fetch/XHR».
  2. Atualize a página ou clique no botão, separador ou link «carregar mais» que carrega os dados.
  3. Clique em cada pedido e verifique o separador «Resposta» até encontrar aquele que contém os seus registos.
  4. Anote o URL e os parâmetros de consulta que se alteram (frequentemente page, offsetou cursor), bem como qualquer campo que indique quando parar, como has_next ou um array vazio.
  5. Recrie a URL no Node.js com URLSearchParams e recupere-a num ciclo.

Um endpoint JSON paginado costuma ficar assim. Substitua pelo endpoint e pelos campos que encontrou:

// 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;
}

Quando existe, este é o caminho mais rápido e estável: os campos JSON raramente mudam quando um site reformula o seu HTML. Normalize à medida que avança, da mesma forma que o analisador Cheerio faz: corte as cadeias de caracteres, converta números e transforme chaves em falta em null ou false de propósito.

Saiba também quando parar. Um endpoint que exija um login, um token de sessão ou parâmetros assinados não é dado público, e contornar essas verificações já não é «scraping». Trate-o como um sinal de stop, não como um quebra-cabeças.

Como se faz o scraping de páginas renderizadas em JavaScript com o Playwright?

Inicie o Chromium com o Playwright, abra a página e faça o que um utilizador faria, como clicar num link. Aguarde pelos dados em vez de entrar em espera: o `waitForURL()` capta a navegação iniciada por um clique, e o `waitFor()` de um localizador aguarda até que existam linhas. Em seguida, leia as linhas dentro da página com `evaluateAll()` e feche o navegador num bloco `finally`.

Utilize um navegador quando os dados só aparecerem após cliques, deslocamento, digitação ou outros passos controlados por script. Este script navega em books.toscrape.com tal como um leitor faria: abre a página inicial, clica na categoria «Mistério», lê cada cartão e clica em «seguinte» até esgotar a categoria.

// 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'
}

Algumas opções aqui são importantes em qualquer site. getByRole('link', { name: 'Mystery', exact: true }) Encontra o link tal como o utilizador o vê, pelo que resiste a alterações no nome da classe. waitForURL() Após cada clique, garante que se lê a nova página, e não a antiga. cards.first().waitFor() espera até que os dados existam, o que é melhor do que um tempo de espera fixo que ou é demasiado curto num dia lento ou é tempo desperdiçado num dia rápido. A espera automática do Playwright também verifica se um elemento está visível e estável antes de clicar.

No interior de evaluateAll(), o código é executado na própria página, pelo que a.href já é absoluto. Bloquear imagens com page.route() poupa largura de banda tanto para si como para o site. A única espera fixa que resta é um atraso deliberado por cortesia, não uma estimativa do tempo de carregamento.

Quando um clique desencadeia um pedido de dados em vez de uma navegação, envolva o clique e page.waitForResponse() num único Promise.all() para que a resposta não chegue antes de começares a ouvir. Para proxies, deslocamento infinito e interceção de pedidos, consulta o nosso guia detalhado do Playwright.

Como fica o mesmo scraper no Puppeteer?

O Puppeteer cobre o mesmo fluxo com chamadas ligeiramente diferentes: page.click() em conjunto com page.waitForNavigation(), e depois page.waitForSelector() e page.$$eval() para ler os cartões. O Puppeteer 25 requer o Node.js 22.12 ou 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

Repare no Promise.all() em torno do clique: comece a aguardar a navegação antes de clicar, caso contrário, uma página rápida pode terminar de carregar antes de o Puppeteer começar a ouvir. Para capturas de ecrã, PDFs e mais padrões do Puppeteer, consulte o nosso guia do Puppeteer e do Node.js. Para guardar os ficheiros que uma página disponibiliza para download, o nosso guia de download de ficheiros com Puppeteer compara quatro métodos.

Deve usar o Playwright ou o Puppeteer para web scraping?

Utilize o Playwright para novos scrapers: ele aguarda os elementos automaticamente, controla o Chromium, o Firefox e o WebKit a partir de uma única API e lida bem com várias sessões isoladas. Utilize o Puppeteer quando a sua equipa já tiver código do Puppeteer ou pretender ferramentas específicas para o Chrome. Para o scraping, ambos renderizam as mesmas páginas, por isso escolha com base na facilidade de utilização da API, e não nas alegações de velocidade.


Playwright

Puppeteer

Navegadores

Chromium, Firefox, WebKit

Chrome, Firefox

Em espera

Os localizadores aguardam automaticamente até que os elementos estejam prontos

Explícito waitForSelector() e semelhantes

Sessões isoladas

Contextos do navegador, integrados

Contextos do navegador, integrados

Captar o pedido de dados

page.waitForResponse()

page.waitForResponse()

Linguagens

JavaScript/TypeScript, Python, Java, .NET

JavaScript/TypeScript

Versão mais recente no npm (outubro de 2026)

1.64.1

25.16.0

Escolha-o quando

Novos projetos, verificações de compatibilidade entre navegadores

Código existente do Puppeteer, trabalho com o Protocolo Chrome DevTools

Ambos os projetos são de código aberto e mantidos ativamente, e ambos descarregam um navegador compatível para si. A diferença prática é visível no código do dia-a-dia: os localizadores do Playwright esperam e tentam novamente por si próprios, pelo que os scripts necessitam de menos esperas explícitas. Se já utiliza o Puppeteer em produção, não há qualquer motivo relacionado com a extração de dados para o reescrever.

Como se extrai páginas bloqueadas a partir do Node.js com uma API de scraping?

Mantém o teu analisador e altera apenas a chamada de recuperação. Envia o URL de destino para a API de scraping da WebScrapingAPI com a tua chave a partir de uma variável de ambiente, adiciona render_js=1 quando a página precisar de JavaScript e adiciona o país para conteúdo específico da localização. Recebes o HTML da página e passas-o para a mesma função Cheerio que já escreveste.

Não precisas disto para um site de treino. Precisas disso quando um alvo real começa a responder com erros 403 ou páginas de desafio que as tentativas de repetição não resolvem, quando o conteúdo varia consoante o país ou quando preferes não executar uma frota de navegadores para renderizar páginas em grande volume. Experimenta primeiro outras formas de reduzir os bloqueios se estiveres a encontrar apenas erros ocasionais.

A API do Scraper recebe um URL e devolve a página, enquanto a WebScrapingAPI lida com proxies, novas tentativas e renderização opcional em JavaScript. wsaFetch() é um equivalente direto 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);
  }
}

A chave provém de process.env.WSA_API_KEY e nunca aparece no código. URLSearchParams codifica o URL de destino, o que é importante: se um URL de destino contivesse a sua própria cadeia de consulta, um ? ou & seria interpretado como um parâmetro da API. O tempo limite do cliente situa-se ligeiramente acima do máximo de 120 segundos da API, e apenas os estados que a API documenta como temporários são repetidos. A renderização em JavaScript e a segmentação geográfica não implicam créditos adicionais, mas a renderização é mais lenta; por isso, ative-a apenas quando o HTML não incluir os seus dados.

Troque a camada de recuperação e mantenha parseBooks() exatamente como estava:

// 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);
}

Coloque a chave num .env ficheiro que contenha WSA_API_KEY=your_key_here, adicione .env a .gitignoree carregue-o com a flag integrada do Node --env-file , para que não seja necessário o pacote dotenv:

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

A execução de teste apresenta os URLs dos pedidos com a chave ocultada, para que possa ver a codificação:

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

A execução real passa o HTML devolvido ao mesmo analisador:

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

Os erros permanecem explícitos. Sem a variável de ambiente, o script interrompe-se com Error: Set WSA_API_KEY in your environment first. antes de enviar qualquer coisa, e uma chave errada é devolvida como WebScrapingAPI HTTP 401: {"error":"Invalid API key"} em vez de um resultado vazio. Para cada parâmetro e código de erro, consulte o nosso guia completo da API do Scraper. As páginas que requerem cliques ou introdução de texto adaptam-se melhor a um navegador hospedado do que a um comando `fetch`, o que será abordado na secção seguinte.

Que método de scraping em JavaScript deve utilizar?

Utilize o `fetch` e o Cheerio quando os dados estiverem no HTML. Chame o endpoint JSON quando o JavaScript carregar dados a partir de um. Utilize o Playwright quando for necessário clicar, percorrer ou aguardar na página. Utilize uma API de scraper quando blocos, localização ou renderização em grande volume tornem a recuperação local pouco fiável. A maioria dos projetos combina duas destas opções.

Situação

Utilização

Porquê

Os dados estão em «Ver código-fonte»

fetch + Cheerio

Mais rápido, com menos componentes móveis

Muitas páginas

fetch + Cheerio com robots.txt, atraso, novas tentativas, deduplicação

Cortês e reiniciável

O JavaScript carrega dados a partir de um XHR que pode ser chamado

fetch no ponto final JSON

Sem análise sintática, sem navegador

Os dados estão em formato JSON dentro de um <script>

Cheerio + JSON.parse

Sem navegador

Cliques, deslocamento ou espera na página

Playwright (ou Puppeteer)

Navegador real, eventos reais

Erros 403, páginas de autenticação, conteúdo específico por país ou renderização em grande volume

API de scraper proveniente de fetch

Proxies geridos, novas tentativas e renderização; analisador inalterado

Sessões de navegador hospedadas com ações

API do navegador

Sessões sem ter de executar o Chrome manualmente

Execute estas verificações por ordem para cada novo site:

  1. Os dados aparecem em «Ver código-fonte»? Utilize fetch e o Cheerio.
  2. Chegam através de um pedido Fetch/XHR? Executa esse pedido.
  3. Precisa de cliques, deslocamento ou tempos de espera? Utilize o Playwright.
  4. Está bloqueado ou o conteúdo é específico da localização? Encaminhe a recolha através da API Scraper.
  5. Precisas de sessões de navegador hospedadas que cliquem e digitem? Usa a API do navegador.

Como testar um scraper Node.js para que não falhe silenciosamente?

Guarde uma cópia de cada tipo de página como um ficheiro HTML e teste o seu analisador com base nela, utilizando o executor de testes integrado do Node. Verifique o número de linhas, os tipos dos campos-chave e o link para a página seguinte. Quando o site alterar o seu layout, o teste falhará de forma evidente, em vez de o seu scraper guardar silenciosamente dados vazios ou errados.

Os scrapers raramente falham quando um site muda. Continuam a funcionar e guardam cadeias vazias, zeros ou nada de todo. Os testes de fixture detetam isso antes que os dados incorretos cheguem à sua base de dados. Guarde a última página do catálogo e uma página de categoria ao lado da primeira página que guardou 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"

Em seguida, escreva os testes com node:test e node:assert/strict. Não são necessários pacotes adicionais:

// 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);
});

Execute 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

O segundo teste protege contra a armadilha dos links relativos: as páginas de categoria ligam os livros como ../../../sharp-objects_997/index.html, e um analisador que não lide corretamente com isso continuaria a devolver 20 registos, apenas com URLs inválidas. Volte a guardar os seus fixtures periodicamente e compare a saída analisada, para que detete alterações no layout antes dos seus utilizadores. O executor de testes integrado do Node também suporta o modo de vigilância, cobertura e instantâneos.

O JavaScript ou o Python são melhores para a extração de dados da Web?

Ambos funcionam bem. Escolha JavaScript se a sua equipa já o utiliza, se pretender automatizar navegadores ou se o scraper estiver integrado num serviço Node.js. Escolha Python se os dados alimentarem o pandas, notebooks ou aprendizagem automática, ou se pretender utilizar a estrutura de rastreamento do Scrapy. As defesas do site são muito mais importantes do que a linguagem que escolher.

Os componentes básicos correspondem quase um a um. Os fetch corresponde aos clientes HTTP do Python, o Cheerio desempenha o papel de um analisador HTML rápido e o Playwright existe em ambas as linguagens com praticamente a mesma API. A vantagem do JavaScript é a automatização do navegador e o facto de ser uma única linguagem, desde os scripts da página até ao seu backend. A vantagem do Python é a pilha de análise a jusante e uma estrutura de rastreamento madura para tarefas de grande dimensão. Se a sua equipa trabalha com Python, leia o nosso guia sobre web scraping com Python. As recomendações deste guia mantêm-se inalteradas.

Como se faz scraping de forma responsável com JavaScript?

Leia os termos do site e o ficheiro robots.txt antes de iniciar o rastreamento, mantenha as taxas de pedidos baixas, identifique o seu scraper com um agente de utilizador honesto e recolha apenas os campos de que necessita. Evite dados pessoais, a menos que tenha uma base legal para tal, nunca faça scraping atrás de um login sem autorização e utilize a API oficial do site, caso exista.

A maior parte disso já está no seu código. robots.js verifica as regras antes da primeira página. O atraso de um segundo e o limite de dois «workers» mantêm a sua carga baixa. O User-Agent cabeçalho identifica o seu scraper e dá ao site uma forma de o contactar. E o analisador mantém apenas os campos de que necessita, tipificados e limpos, em vez de armazenar páginas inteiras.

O resto é uma questão de bom senso. As páginas públicas não são um «vale-tudo»: os termos de serviço, os direitos de autor e a legislação de privacidade continuam a aplicar-se, especialmente no que diz respeito aos dados pessoais. Leia os nossos princípios de utilização responsável de dados da Web e a nossa visão geral sobre a legalidade do web scraping, e procure aconselhamento jurídico antes de proceder ao scraping para um projeto comercial.

Perguntas frequentes

O Node.js é adequado para o web scraping?

Sim. O Node.js processa muitos pedidos de rede em simultâneo sem threads, inclui o fetch integrado e executa as principais ferramentas de automação de navegadores, o Playwright e o Puppeteer. O Cheerio analisa HTML rapidamente com seletores CSS familiares. É uma excelente opção quando a sua equipa já programa em JavaScript ou quando o scraper é executado dentro de um serviço Node.js.

Por que é que o Cheerio devolve um array vazio?

Normalmente, porque os dados não se encontram no HTML que o seu pedido recebeu. O JavaScript adiciona-os no navegador após o carregamento da página, pelo que o Cheerio nunca os vê. Verifique a opção «Ver código-fonte» no seu navegador: se os dados não estiverem lá, procure o pedido JSON no separador «Rede» ou renderize a página com o Playwright.

Qual é a diferença entre o Cheerio e o Playwright?

O Cheerio analisa o HTML que já foi obtido. É rápido e leve, mas não consegue executar JavaScript nem clicar em nada. O Playwright controla um navegador real, pelo que vê a página após a execução dos scripts e consegue clicar, percorrer e aguardar. Utilize o Cheerio por predefinição e recorra ao Playwright apenas quando a página necessitar de um navegador.

O JavaScript consegue extrair dados de sites dinâmicos?

Sim. Para páginas que carregam dados com JavaScript, procure primeiro a solicitação JSON que a página faz e chame-a com `fetch()`, o que é mais rápido e mais estável. Quando precisar de clicar, percorrer ou aguardar na página, utilize o Playwright ou o Puppeteer para carregar a página num navegador sem interface gráfica e ler os elementos renderizados.

Como evito ser bloqueado ao fazer scraping com o Node.js?

Abremente o ritmo, envie um user agent legítimo, tente novamente após respostas 429 e 503, respeitando o atraso definido em Retry-After, e armazene as páginas em cache para não as ir buscar duas vezes. Se um site continuar a devolver erros 403 ou páginas de autenticação, encaminhe os pedidos através de uma API de scraping que gere proxies e renderização, e mantenha o seu analisador Cheerio inalterado.

Ainda preciso do Axios ou do node-fetch para o web scraping?

Não. O Node.js 18 e versões posteriores incluem o `fetch`, que é estável em todas as versões suportadas, pelo que um novo scraper não necessita de nenhuma biblioteca HTTP. O Axios e o Got continuam a funcionar e oferecem funcionalidades úteis, como interceptores e tentativas de repetição integradas. Mantenha-os se o seu projeto já os utilizar. Caso contrário, o `fetch` nativo, juntamente com um pequeno auxiliar de repetição de tentativas, é suficiente.

Como devo armazenar uma chave de API num scraper Node.js?

Guarde a chave numa variável de ambiente, como WSA_API_KEY, e leia-a com process.env. Para trabalho local, coloque-a num ficheiro .env, execute node --env-file=.env e adicione .env ao .gitignore. Nunca cole chaves no código, em URLs que partilhe ou no JavaScript do front-end, onde qualquer visitante as possa ler.

Posso fazer scraping de sites com TypeScript?

Sim. Todos os exemplos deste guia funcionam em TypeScript, porque o Cheerio, o Playwright e o Puppeteer incluem as suas próprias definições de tipos. As versões recentes do Node.js podem executar ficheiros .ts diretamente, removendo os tipos, ou pode utilizar um executor como o tsx. Definir os tipos dos seus registos também permite detetar erros de análise antes de guardar dados incorretos.

Como faço para extrair dados de uma página com deslocamento infinito?

Abra o DevTools, percorra a página e observe o separador «Rede» para identificar o pedido que carrega cada novo lote. Normalmente, este pedido utiliza um número de página ou a posição do cursor, pelo que pode chamá-lo com `fetch()` num ciclo até que indique que não há mais resultados. Se não houver nenhum pedido utilizável, percorra a página com o Playwright e leia as linhas.

A linguagem não altera o panorama jurídico. O scraping de dados públicos é frequentemente lícito, mas depende dos termos do site, do tipo de dados e da legislação local, especialmente no que diz respeito a dados pessoais e conteúdos protegidos por direitos de autor. Respeite o ficheiro robots.txt, evite recolher dados pessoais sem fundamento legal e procure aconselhamento jurídico para projetos comerciais.

Mantenha o seu analisador Node.js e delegue as páginas mais complexas

O seu analisador Cheerio não precisa de ser alterado quando um site começa a bloqueá-lo ou requer JavaScript. Direcione a sua chamada para a API Scraper da WebScrapingAPI e continue a analisar em Node.js. A renderização em JavaScript e a segmentação geográfica não implicam créditos adicionais, e as solicitações falhadas não são cobradas. Compare os planos da Scraper API, começando com um período de teste gratuito de 5 000 pedidos.

Sobre o autor

Robert Sfichi, Desenvolvedor Full-Stack @ WebScrapingAPI

Robert Sfichi

Desenvolvedor Full-Stack

Robert Sfichi é membro da equipa da WebScrapingAPI, contribuindo para o produto e ajudando a criar soluções fiáveis que apoiam a plataforma e os seus utilizadores.

Web Scraping com AWS Lambda: Guia para Python e Java 2026
Guias

Web Scraping com AWS Lambda: Guia para Python e Java 2026

TL;DR: Resumo: A extração de dados da Web com o AWS Lambda funciona melhor quando cada invocação é curta, delimitada e pode ser repetida de forma independente. Comece com HTTP direto, AWS SAM e S3 e, só depois, adicione SQS, contentores, renderização no navegador, proxies ou uma camada de recuperação gerida, apenas quando a carga de trabalho demonstrar que precisa deles.

Suciu Dan32 min read
Ler artigo
Como utilizar o GoSpider: rastrear, limpar URLs e extrair dados
Guias

Como utilizar o GoSpider: rastrear, limpar URLs e extrair dados

TL;DR: Resumo: O GoSpider é um rastreador de linha de comandos destinado a descobrir URLs, não um extrator completo de dados estruturados. Este guia sobre como utilizar o GoSpider mostra como realizar um rastreio limitado, gerir resultados de forma organizada, fazer a transferência de dados do Colly para CSV e seguir um percurso de diagnóstico para respostas 403 ou páginas que exijam renderização em JavaScript.

Suciu Dan23 min read
Ler artigo
Como fazer o Scrape Redfin: Guia Python para Dados de Propriedade
Guias

Como fazer o Scrape Redfin: Guia Python para Dados de Propriedade

TL;DR: A Redfin expõe pontos de extremidade de API ocultos que retornam JSON estruturado para listagens de propriedades, tornando possível ignorar totalmente a análise HTML frágil. Este guia orienta-o na construção de um scraper Python que extrai dados de aluguer e venda, pesquisa por localização, monitoriza novas listagens através de sitemaps XML e exporta resultados limpos para CSV ou JSON.

Suciu Dan14 min read
Ler artigo

Comece a construir

Pronto para expandir a sua recolha de dados?

Junte-se a mais de 2.000 empresas que utilizam a WebScrapingAPI para extrair dados da Web à escala empresarial, sem quaisquer custos de infraestrutura.