Cheerio FAQ

How fast is Cheerio compared to other HTML parsing libraries?

Cheerio is designed for speed and efficiency. It uses a lightweight DOM model based on domhandler, which is significantly faster than full browser DOM implementations like JSDOM. Unlike browser-based solutions, Cheerio removes DOM inconsistencies and browser overhead, resulting in blazing fast parsing and manipulation operations.

import * as cheerio from 'cheerio';

// Fast parsing - no browser overhead
const $ = cheerio.load('<div>Large HTML document...</div>');

// Efficient manipulation
$('div').addClass('processed').attr('data-timestamp', Date.now());

For large documents or batch processing, consider using streaming APIs like cheerio.stringStream() for optimal memory usage.

When should I use Cheerio instead of the browser DOM or JSDOM?

Use Cheerio for server-side HTML parsing, web scraping, and static HTML manipulation. It's ideal when you need jQuery-like syntax without browser overhead. Choose browser DOM for client-side interactions, JSDOM for full browser simulation, or Puppeteer for dynamic content scraping.

// Perfect for server-side scraping
const $ = cheerio.load(htmlResponse);
const titles = $('h1, h2, h3').map((i, el) => $(el).text()).get();

// Great for email template processing
const emailHtml = cheerio.load(template);
emailHtml('.username').text(user.name);
emailHtml('.content').html(processedContent);

How do I handle different HTML parsers in Cheerio?

Cheerio supports both htmlparser2 (fast, forgiving) and parse5 (standards-compliant). The choice depends on your needs: use htmlparser2 for speed and flexibility with malformed HTML, or parse5 for strict HTML5 compliance.

// Using htmlparser2 (default, faster)
const $ = cheerio.load(html, {
  xml: false,
  decodeEntities: true
});

// Using parse5 (more compliant)
const $strict = cheerio.load(html, {
  _useHtmlParser2: false,
  xml: false
});

// For XML documents
const $xml = cheerio.load(xmlString, {
  xmlMode: true,
  decodeEntities: true
});

What's the difference between `.attr()`, `.prop()`, and `.data()`?

.attr() manages HTML attributes as strings
.prop() handles DOM properties with type coercion and computed values
.data() manages HTML5 data attributes with automatic JSON parsing

const $ = cheerio.load('<input type="checkbox" checked data-config=\'{"enabled": true}\'>');

// Attributes (string values)
$('input').attr('checked'); // 'checked' 
$('input').attr('type'); // 'checkbox'

// Properties (computed/coerced values)
$('input').prop('checked'); // true (boolean)
$('input').prop('tagName'); // 'INPUT'

// Data attributes (with JSON parsing)
$('input').data('config'); // { enabled: true } (object)

How do I properly handle TypeScript types with Cheerio?

Import types explicitly and use generic parameters for better type safety. The library provides comprehensive TypeScript support with proper type inference.

import * as cheerio from 'cheerio';
import type { CheerioAPI, Cheerio, Element } from 'cheerio';

// Type the main API
const $: CheerioAPI = cheerio.load('<div>Content</div>');

// Type specific selections
const $elements: Cheerio<Element> = $('div');

// Use proper typing for element extraction
const elements: Element[] = $('div').get();
const firstElement: Element | undefined = $('div').get(0);

// Type function parameters correctly
$('div').each(function(this: Element, index: number) {
  // 'this' is properly typed as Element
  const $this = $(this);
});

Why am I getting "Cannot read property of undefined" errors?

This usually happens when selectors don't match any elements. Always check if elements exist before chaining methods or accessing properties.

// ❌ Dangerous - may throw if no elements found
const title = $('.title').text().toUpperCase();

// ✅ Safe approach
const $title = $('.title');
const title = $title.length > 0 ? $title.text().toUpperCase() : '';

// ✅ Alternative with optional chaining
const title = $('.title').first().text() || '';

// ✅ Check before manipulating
if ($('.content').length > 0) {
  $('.content').addClass('processed');
}

How do I handle malformed HTML or XML documents?

Cheerio is forgiving with malformed HTML when using htmlparser2. For strict parsing, use the parse5 parser or enable XML mode for well-formed XML documents.

// Forgiving HTML parsing (default)
const $ = cheerio.load('<div><p>Unclosed paragraph</div>');

// Strict XML parsing
const $xml = cheerio.load('<root><item/></root>', {
  xmlMode: true,
  withStartIndices: false,
  withEndIndices: false
});

// Handle parsing errors gracefully
try {
  const $ = cheerio.load(possiblyBadHTML);
  return $('title').text();
} catch (error) {
  console.error('HTML parsing failed:', error);
  return '';
}

How can I efficiently process large HTML documents?

For large documents, use streaming APIs to avoid loading everything into memory at once. This is especially important for web scraping or processing large files.

import * as cheerio from 'cheerio';
import { createReadStream } from 'fs';

// Stream processing for large files
const stream = cheerio.stringStream({}, (err, $) => {
  if (err) throw err;
  
  // Process the document
  const data = $('h1, h2, h3').map((i, el) => $(el).text()).get();
  console.log(data);
});

createReadStream('large-file.html', { encoding: 'utf8' }).pipe(stream);

// For URLs with automatic encoding detection
const $ = await cheerio.fromURL('https://example.com', {
  encoding: { defaultEncoding: 'utf8' }
});

What are the memory implications of using Cheerio?

Cheerio creates lightweight DOM representations that use less memory than full browser DOMs. However, be mindful of keeping references to large documents or creating many Cheerio instances simultaneously.

// ✅ Good - reuse the same instance
const $ = cheerio.load(html);
const results = [];
$('article').each((i, article) => {
  const $article = $(article);
  results.push({
    title: $article.find('h1').text(),
    content: $article.find('.content').text()
  });
});

// ❌ Avoid - creates many instances
const articles = $('article').map((i, article) => {
  return cheerio.load(article); // Don't do this
}).get();

How do I clone elements without breaking references?

Use the .clone() method to create deep copies of elements. This is essential when you need to reuse elements multiple times or avoid modifying original elements.

const $ = cheerio.load('<div class="template">Template content</div>');

// Clone before modifying
const $template = $('.template');
const $copy1 = $template.clone().addClass('instance-1').text('Instance 1');
const $copy2 = $template.clone().addClass('instance-2').text('Instance 2');

// Original remains unchanged
console.log($template.text()); // 'Template content'

// Append clones to different parents
$('#container1').append($copy1);
$('#container2').append($copy2);

How can I extract structured data efficiently from HTML?

Use the .extract() method for complex data extraction patterns. It provides a declarative way to pull multiple values from documents with proper TypeScript support.

const $ = cheerio.load(productPageHtml);

// Extract structured data with type safety
const productData = $.root().extract({
  title: 'h1.product-title',
  price: '.price .amount',
  images: [{ selector: '.gallery img', value: 'src' }],
  features: ['.features li'],
  specifications: {
    selector: '.specs',
    value: {
      weight: '.weight',
      dimensions: '.dimensions',
      model: { selector: '.model', value: 'data-model' }
    }
  }
});

// Result is properly typed
console.log(productData.title); // string | undefined
console.log(productData.images); // string[]
console.log(productData.specifications?.model); // string | undefined

What are the best practices for CSS selector performance?

Use specific selectors and avoid overly complex queries. ID selectors are fastest, followed by class selectors, then attribute selectors. Avoid deep descendant selectors when possible.

// ✅ Fast - specific selectors
const $navItems = $('#navigation .nav-item');
const $activeButton = $('.btn.active');

// ❌ Slower - overly complex selectors
const $badSelector = $('div > div > div span.small[data-type="special"]');

// ✅ Better - break down complex selections
const $container = $('.content-area');
const $items = $container.find('[data-type="special"]');

// ✅ Cache frequently used selections
const $document = $.root();
const $body = $document.find('body');

How do I handle form data and serialization properly?

Use .serializeArray() for structured data and .serialize() for URL-encoded strings. These methods automatically handle form validation rules and element types.

const $ = cheerio.load(formHtml);

// Get structured form data
const formData = $('form').serializeArray();
// [{ name: 'email', value: 'user@example.com' }, ...]

// Get URL-encoded string
const queryString = $('form').serialize();
// 'email=user@example.com&name=John'

// Handle specific form elements
const selectedOptions = $('select[multiple]').val(); // string[]
const checkboxValue = $('input[type="checkbox"]:checked').val(); // string | undefined

// Set form values programmatically
$('input[name="email"]').val('new@example.com');
$('select').val(['option1', 'option2']); // for multiple select

How can I safely modify HTML attributes to prevent XSS?

Cheerio automatically encodes attribute values to prevent XSS attacks. However, be cautious with HTML content insertion and always validate user input.

const $ = cheerio.load('<div></div>');

// ✅ Safe - attributes are automatically encoded
const userInput = '<script>alert("XSS")</script>';
$('div').attr('title', userInput);
// Result: <div title="&lt;script&gt;alert(&quot;XSS&quot;)&lt;/script&gt;"></div>

// ✅ Safe text insertion
$('div').text(userInput); // Automatically escaped

// ❌ Dangerous - raw HTML insertion
$('div').html(userInput); // Don't do this with user input

// ✅ Better - sanitize first or use text()
$('div').text(sanitizeInput(userInput));

What's the correct way to handle asynchronous operations with Cheerio?

Cheerio itself is synchronous, but you can combine it with async operations for tasks like fetching URLs or processing multiple documents concurrently.

// Load from URL (async)
const $ = await cheerio.fromURL('https://example.com');
const title = $('title').text();

// Process multiple URLs concurrently
const urls = ['https://site1.com', 'https://site2.com'];
const results = await Promise.all(
  urls.map(async (url) => {
    const $ = await cheerio.fromURL(url);
    return {
      url,
      title: $('title').text(),
      links: $('a[href]').map((i, el) => $(el).attr('href')).get()
    };
  })
);

// Combine with other async operations
async function processDocument(html: string) {
  const $ = cheerio.load(html);
  
  // Extract image URLs
  const imageUrls = $('img[src]').map((i, el) => $(el).attr('src')).get();
  
  // Process images asynchronously
  const processedImages = await Promise.all(
    imageUrls.map(url => processImage(url))
  );
  
  return { processedImages };
}

← In-Depth Guides Version History & Migration →