Cheerio vs Puppeteer

Cheerio's own docs put the trade-off plainly: it does no visual rendering, no CSS, no loading of external resources and no JavaScript execution, which makes it "much faster than browser-based tools", but content a single-page app renders on the client will not be there (Cheerio introduction).

Open the page, then view its source (Ctrl+U or Cmd+Option+U), not the Elements panel. If the prices, names or links you want are in that raw source, Cheerio can read them. If the source holds only an empty <div id="root"> and script tags, JavaScript builds the content in the browser, and Cheerio sees nothing.

You can test it in code. The practice site Quotes to Scrape serves the same quotes as plain HTML at / and as JavaScript-built content at /js/:

// npm i cheerio   (Node.js 20.18.1+ has fetch built in)
import * as cheerio from 'cheerio';

const res = await fetch('https://quotes.toscrape.com/');
const $ = cheerio.load(await res.text());
const quotes = $('.quote').map((_, el) => ({
  text: $(el).find('.text').text(),
  author: $(el).find('.author').text(),
})).get();
console.log(quotes.length, quotes[0]);   // 10 quotes

const js = await fetch('https://quotes.toscrape.com/js/');
const $js = cheerio.load(await js.text());
console.log($js('.quote').length);       // 0: the quotes are built by JavaScript

We ran this on October 23, 2026: 10 quotes from /, 0 from /js/. Before you reach for Puppeteer on a page like /js/, look for the data itself. It is often in a <script> tag as JSON or in a request the page makes to an API, and you can read either without a browser; see how to scrape hidden APIs and embedded JSON.

Puppeteer opens the page in Chrome, lets the scripts run and reads the result:

// npm i puppeteer   (downloads a matching Chrome for Testing)
import puppeteer from 'puppeteer';

const browser = await puppeteer.launch();
const page = await browser.newPage();
await page.goto('https://quotes.toscrape.com/js/');
await page.waitForSelector('.quote');
const quotes = await page.$$eval('.quote', els => els.map(el => ({
  text: el.querySelector('.text').textContent,
  author: el.querySelector('.author').textContent,
})));
console.log(quotes.length, quotes[0]);
await browser.close();

It gets the quotes Cheerio missed, but it starts a browser, downloads every script and stylesheet, and uses far more memory and CPU than a parser. For a tutorial that goes further (waits, infinite scroll, many pages), see web scraping with Puppeteer.

The difference is large because the work is different, not because one library is better written. A Cheerio scraper downloads one HTML document and parses it in memory. Puppeteer runs a browser that downloads the document plus its scripts, styles, fonts and images, and executes the JavaScript. We do not quote a ratio, because it depends on the page, but you can measure it: log the bytes of the HTML response for Cheerio, and the sum of all responses in Puppeteer.

This matters for proxy cost. Residential proxies are priced per GB, so every script, image and font a browser pulls is billed traffic. As an assumed example, a page whose HTML is 100 KB but which loads 2 MB in a browser costs about 20 times more traffic in Puppeteer than in Cheerio; measure your own pages as above. If you must use Puppeteer, block what you do not need:

await page.setRequestInterception(true);
page.on('request', req =>
  ['image', 'font', 'media', 'stylesheet'].includes(req.resourceType()) ? req.abort() : req.continue());

A common pattern is to let Puppeteer do only what needs a browser and hand the HTML to Cheerio: log in or click through a cookie banner in Puppeteer, take await page.content(), and parse it with cheerio.load(). Your parsing code stays the same for static and dynamic pages, and you can switch pages from the browser to plain fetch as soon as you find they do not need JavaScript. Node.js crawling libraries such as Crawlee offer both modes, an HTTP crawler with Cheerio and a browser crawler with Puppeteer or Playwright, behind one API.

Python has the same split. Beautiful Soup is "a Python library for pulling data out of HTML and XML files" (Beautiful Soup docs), paired with Requests or httpx to download pages, like Cheerio with fetch. Selenium, or Playwright for Python, plays Puppeteer's role. The decision rule is identical: parse the HTML when the data is in it, start a browser only when JavaScript builds it. Python tool choices are compared in Scrapy vs BeautifulSoup vs Selenium vs Playwright, and the languages themselves in Python vs JavaScript for web scraping.

• Data in the page source: Cheerio with fetch. Faster, lighter and less traffic per page.
• Data in a JSON request or a <script> tag: neither; call the API or parse the JSON directly.
• Content built by JavaScript, logins, clicks, infinite scroll: Puppeteer, with heavy resources blocked.
• Mixed sites: Puppeteer for the steps that need a browser, Cheerio for the parsing.

More on the Node.js stack in JavaScript web scraping and HTML scraping.