cheerio vs css-select vs domutils vs htmlparser2 vs jsdom vs xpath
Web Scraping and DOM Manipulation
Search packages..
cheeriocss-selectdomutilshtmlparser2jsdomxpathSimilar Packages:

Web Scraping and DOM Manipulation

Web scraping and DOM manipulation libraries in JavaScript provide tools for parsing, traversing, and manipulating HTML and XML documents. These libraries enable developers to extract data from web pages, modify content, and perform tasks like automated testing or data analysis. They vary in features, performance, and API design, catering to different use cases such as server-side scraping, client-side manipulation, or working with structured data. Popular libraries include cheerio for jQuery-like manipulation, jsdom for a full DOM implementation, and htmlparser2 for fast, streaming HTML parsing.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
cheerio030,2381.01 MB442 months agoMIT
css-select0606213 kB45 days agoBSD-2-Clause
domutils0223119 kB99 days agoBSD-2-Clause
htmlparser204,816235 kB97 days agoMIT
jsdom021,5326.93 MB4168 days agoMIT
xpath0233183 kB242 years agoMIT

Feature Comparison: cheerio vs css-select vs domutils vs htmlparser2 vs jsdom vs xpath

Parsing Capabilities

  • cheerio:

    cheerio parses HTML and XML documents quickly, providing a jQuery-like interface for manipulation. However, it does not handle malformed HTML as robustly as some other parsers.

  • css-select:

    css-select does not parse documents itself; it relies on other parsers to create a DOM. It focuses on selecting elements using CSS selectors, making it lightweight and efficient for that purpose.

  • domutils:

    domutils does not parse documents but provides utilities for manipulating and traversing DOM-like structures. It is designed to work with other libraries that handle parsing.

  • htmlparser2:

    htmlparser2 is a fast, streaming parser for HTML and XML that handles malformed markup gracefully. It supports incremental parsing, making it memory-efficient for large documents.

  • jsdom:

    jsdom provides a complete DOM implementation, including parsing HTML and XML documents. It adheres to web standards, making it suitable for applications that require a fully-featured DOM environment.

  • xpath:

    xpath does not parse documents but operates on existing DOM trees. It allows for querying XML and HTML documents using XPath expressions, which can be more powerful than CSS selectors for complex queries.

DOM Manipulation

  • cheerio:

    cheerio excels at DOM manipulation, offering a wide range of methods similar to jQuery. It allows for easy traversal, modification, and extraction of elements, making it ideal for web scraping and data manipulation.

  • css-select:

    css-select does not provide DOM manipulation capabilities; it is solely focused on selecting elements based on CSS selectors. Manipulation must be done using other libraries.

  • domutils:

    domutils provides basic DOM manipulation utilities, such as inserting, removing, and modifying nodes. It is lightweight and complements other libraries but lacks a comprehensive API.

  • htmlparser2:

    htmlparser2 is primarily a parsing library and does not provide built-in DOM manipulation features. It focuses on efficiently parsing and handling HTML and XML content.

  • jsdom:

    jsdom offers full DOM manipulation capabilities, including support for events, styles, and attributes. It provides a rich API that closely resembles the browser DOM, making it suitable for complex manipulations and testing.

  • xpath:

    xpath does not manipulate the DOM; it is used for querying and selecting nodes based on XPath expressions. Manipulation must be done using other DOM manipulation libraries.

Performance

  • cheerio:

    cheerio is lightweight and fast for parsing and manipulating HTML, but it loads the entire document into memory, which can be a limitation for very large files.

  • css-select:

    css-select is highly efficient for selecting elements, especially when used with a lightweight DOM. Its performance depends on the quality of the input DOM structure.

  • domutils:

    domutils is designed to be lightweight and efficient, with minimal overhead for the utility functions it provides. Its performance is best when used with simple DOM structures.

  • htmlparser2:

    htmlparser2 is one of the fastest HTML parsers available, especially for streaming and incremental parsing. It is optimized for performance and memory usage, making it suitable for large documents.

  • jsdom:

    jsdom is more resource-intensive than lightweight libraries due to its comprehensive DOM implementation. However, it is optimized for performance and is suitable for most server-side applications.

  • xpath:

    xpath performance depends on the complexity of the XPath queries and the size of the DOM being queried. It can be slower than CSS selectors for simple tasks but is more powerful for complex queries.

Use Cases

  • cheerio:

    cheerio is ideal for web scraping, data extraction, and server-side HTML manipulation. Its jQuery-like API makes it easy to work with, especially for tasks that involve traversing and modifying the DOM.

  • css-select:

    css-select is useful for projects that require a lightweight, standalone CSS selector engine. It can be used in conjunction with other libraries for custom selection logic without a full DOM.

  • domutils:

    domutils is best suited for projects that need utility functions for working with DOM-like structures. It is often used alongside other libraries to enhance their functionality.

  • htmlparser2:

    htmlparser2 is perfect for applications that require fast and efficient parsing of HTML and XML, especially when handling large or malformed documents. It is commonly used in web scraping and data processing tools.

  • jsdom:

    jsdom is ideal for testing, server-side rendering, and applications that require a full DOM environment. It is widely used in automated testing frameworks and for simulating browser behavior on the server.

  • xpath:

    xpath is useful for applications that need to perform complex queries on XML or HTML documents. It is often used in data extraction, transformation, and processing tasks where advanced querying capabilities are required.

Ease of Use: Code Examples

  • cheerio:

    Web Scraping with cheerio

    const cheerio = require('cheerio');
const axios = require('axios');

async function scrapeWebsite(url) {
  const { data } = await axios.get(url);
  const $ = cheerio.load(data);
  const titles = [];

  $('h1, h2, h3').each((index, element) => {
    titles.push($(element).text());
  });

  return titles;
}

scrapeWebsite('https://example.com').then(console.log);
  • css-select:

    Selecting Elements with css-select

    const { select } = require('css-select');
const { parse } = require('node-html-parser');

const html = '<div><p class="text">Hello</p><p class="text">World</p></div>';
const root = parse(html);
const elements = select('.text', root);

console.log(elements.map(el => el.text)); // Output: ['Hello', 'World']
  • domutils:

    DOM Manipulation with domutils

    const { createElement, appendChild, removeChild } = require('domutils');

const root = createElement('div');
const child = createElement('span');
appendChild(root, child);

console.log(root); // <div><span></span></div>
removeChild(child);
console.log(root); // <div></div>
  • htmlparser2:

    Parsing HTML with htmlparser2

    const { Parser } = require('htmlparser2');

const parser = new Parser({
  onopentag(name) { console.log('Opening tag:', name); },
  ontext(text) { console.log('Text:', text); },
  onclosetag(name) { console.log('Closing tag:', name); },
});

parser.write('<div>Hello <span>World</span></div>');
parser.end();
  • jsdom:

    DOM Manipulation with jsdom

    const { JSDOM } = require('jsdom');
const dom = new JSDOM('<!DOCTYPE html><p>Hello world</p>');
const document = dom.window.document;
const p = document.querySelector('p');
p.textContent = 'Hello, jsdom!';
console.log(p.textContent); // Output: Hello, jsdom!
  • xpath:

    XPath Querying with xpath

    const xpath = require('xpath');
const { DOMParser } = require('xmldom');

const xml = '<root><item>1</item><item>2</item></root>';
const doc = new DOMParser().parseFromString(xml);
const nodes = xpath.select('//item', doc);

nodes.forEach(node => console.log(node.textContent)); // Output: 1
2

How to Choose: cheerio vs css-select vs domutils vs htmlparser2 vs jsdom vs xpath

  • cheerio:

    Choose cheerio if you need a fast, lightweight library for server-side HTML manipulation with a jQuery-like API. It is ideal for web scraping and data extraction tasks where you don't need a full DOM implementation.

  • css-select:

    Select css-select when you need a standalone CSS selector engine for parsing and selecting elements from HTML or XML. It is useful for projects that require custom selection logic without a full DOM.

  • domutils:

    Use domutils if you need utility functions for working with DOM-like structures, especially in conjunction with other libraries. It provides a lightweight solution for manipulating and traversing trees without a full DOM.

  • htmlparser2:

    Opt for htmlparser2 when you require a fast, flexible HTML and XML parser that supports streaming and incremental parsing. It is suitable for high-performance applications where memory efficiency is critical.

  • jsdom:

    Choose jsdom if you need a full-featured, standards-compliant DOM implementation for Node.js. It is ideal for testing, server-side rendering, and applications that require a complete browser-like environment.

  • xpath:

    Select xpath when you need to perform XPath queries on XML or HTML documents. It is useful for projects that require advanced querying capabilities beyond CSS selectors.

Similar Npm Packages to cheerio

cheerio is a fast, flexible, and lean implementation of core jQuery designed specifically for the server. It allows developers to manipulate and traverse HTML and XML documents easily, making it a popular choice for web scraping and server-side DOM manipulation in Node.js applications. Cheerio provides a familiar jQuery-like syntax, enabling developers to work with the document structure in a straightforward and efficient manner.

While Cheerio is a powerful tool for parsing and manipulating HTML, there are several alternatives in the ecosystem that offer different features and capabilities. Here are a few notable alternatives:

  • htmlparser2 is a forgiving HTML/XML parser that is designed to be fast and efficient. It can handle malformed HTML and provides a simple API for parsing and manipulating documents. Unlike Cheerio, which focuses on jQuery-like manipulation, htmlparser2 is more low-level, allowing developers to work directly with the parsing process. This makes it a great choice for projects that require fine-grained control over parsing and processing HTML or XML data.

  • jsdom is a powerful library that simulates a web browser's environment in Node.js, allowing developers to manipulate the DOM as if they were working in a browser. It provides a complete implementation of the DOM and HTML standards, making it suitable for testing and server-side rendering of web applications. While Cheerio is lightweight and focused on parsing, jsdom offers a more comprehensive solution for developers who need a full DOM environment for their applications.

  • parse5 is an HTML parser that adheres closely to the HTML5 specification. It is designed to be fast and efficient, providing a simple API for parsing HTML documents. parse5 is particularly useful for projects that require strict adherence to HTML5 standards and need to handle complex HTML structures. While it does not provide the same manipulation capabilities as Cheerio, it excels in parsing accuracy and performance.

To see how Cheerio compares with htmlparser2, jsdom, and parse5, check out the comparison: Comparing cheerio vs htmlparser2 vs jsdom vs parse5.

Similar Npm Packages to css-select

css-select is a powerful library for selecting elements from HTML and XML documents using CSS-like selectors. It is particularly useful for parsing and manipulating the structure of documents in a way that is familiar to web developers. By providing a simple API for querying documents, css-select allows developers to easily extract data from HTML or XML structures, making it a popular choice for web scraping and data extraction tasks. However, there are several alternatives in the ecosystem that can also be used for similar purposes. Here are a few notable ones:

  • cheerio is a fast, flexible, and lean implementation of core jQuery designed specifically for the server. It allows you to manipulate and traverse the structure of HTML documents using a jQuery-like syntax. Cheerio is particularly useful for web scraping and server-side manipulation of HTML, as it provides a familiar API for those who have experience with jQuery. If you need to parse and manipulate HTML documents on the server, cheerio is an excellent choice.
  • domutils is a utility library for working with DOM-like structures. It provides a set of functions for manipulating and querying DOM trees, making it a useful companion for libraries that parse HTML or XML. While it does not provide a selector engine like css-select, it can be used in conjunction with other libraries to facilitate DOM manipulation. If you are working with a custom DOM implementation or need utility functions for DOM manipulation, domutils can be a helpful addition to your toolkit.
  • htmlparser2 is a fast and forgiving HTML/XML parser that can handle malformed markup. It is designed to be used in conjunction with other libraries for manipulating and querying parsed documents. While htmlparser2 does not provide a selector engine, it serves as a robust foundation for building custom parsing and manipulation solutions. If you need a reliable parser for HTML or XML documents, htmlparser2 is a solid choice.
  • jsdom is a JavaScript implementation of the DOM and HTML standards, allowing you to create a simulated browser environment in Node.js. It provides a complete DOM API, enabling you to manipulate HTML documents as if you were working in a browser. If your application requires a full-fledged DOM environment for testing or server-side rendering, jsdom is an excellent option.
  • xpath is a library for querying XML documents using XPath expressions. While it is primarily focused on XML, it can also be used with HTML documents. If you are familiar with XPath and need to perform complex queries on XML or HTML documents, this library can be a powerful tool.

To see how css-select compares with cheerio, domutils, htmlparser2, jsdom, and xpath, check out the comparison: Comparing cheerio vs css-select vs domutils vs htmlparser2 vs jsdom vs xpath.

Similar Npm Packages to domutils

domutils is a utility library designed for working with the Document Object Model (DOM) in Node.js. It provides a set of functions to manipulate and traverse DOM structures, making it easier to work with HTML and XML documents. While domutils is a powerful tool for DOM manipulation, there are several alternatives in the ecosystem that offer similar or complementary functionalities. Here are a few notable alternatives:

  • cheerio is a fast, flexible, and lean implementation of core jQuery designed specifically for the server. It allows developers to parse and manipulate HTML and XML documents using a familiar jQuery-like syntax. Cheerio is particularly useful for web scraping and server-side rendering tasks, as it provides an easy way to traverse and manipulate the DOM without the overhead of a full browser environment.

  • dom-serializer is a library that focuses on serializing DOM nodes back into HTML or XML strings. It works well in conjunction with other libraries that manipulate the DOM, allowing developers to easily convert their modified DOM structures back into a string format. If your project requires converting DOM nodes into a string representation after manipulation, dom-serializer is a great choice.

  • htmlparser2 is a robust HTML/XML parser that can handle a wide variety of document structures. It is designed for speed and efficiency, making it suitable for parsing large documents. While it does not provide a full DOM manipulation API like cheerio, it can be used in conjunction with other libraries to parse and manipulate HTML content effectively.

  • jsdom is a powerful library that simulates a web browser's environment in Node.js. It allows developers to create and manipulate a DOM as if they were working in a browser. Jsdom is particularly useful for testing and server-side rendering, as it provides a complete DOM implementation. If your project requires a full browser-like environment for DOM manipulation, jsdom is an excellent option.

  • parse5 is an HTML parsing library that adheres closely to the HTML specification. It provides a fast and reliable way to parse HTML documents into a tree structure. While it does not offer manipulation capabilities out of the box, it can be used alongside other libraries to create a comprehensive solution for parsing and manipulating HTML content.

For a detailed comparison of these libraries, check out the following link: Comparing cheerio vs dom-serializer vs domutils vs htmlparser2 vs jsdom vs parse5.

Similar Npm Packages to htmlparser2

htmlparser2 is a fast and forgiving HTML/XML parser designed for Node.js and browser environments. It is widely used for parsing HTML documents and transforming them into a structured format that can be easily manipulated. Its flexibility and performance make it an excellent choice for developers who need to handle various HTML parsing tasks, from simple document parsing to more complex manipulation.

While htmlparser2 is a robust solution, there are several alternatives in the ecosystem that cater to different needs:

  • cheerio is a fast, flexible, and lean implementation of core jQuery designed specifically for the server. It allows developers to parse HTML and manipulate the resulting DOM structure using a jQuery-like syntax. Cheerio is particularly useful for web scraping and server-side rendering, providing a familiar API for those who are accustomed to jQuery. If you're looking for a lightweight solution that combines the power of jQuery with the speed of a server-side parser, cheerio is an excellent choice.

  • jsdom is a JavaScript implementation of the DOM and HTML standards, allowing developers to create a simulated browser environment in Node.js. It is particularly useful for testing and server-side rendering of web applications. With jsdom, you can run scripts and manipulate the DOM as if you were in a browser, making it a powerful tool for applications that require a full DOM environment. If your project needs a comprehensive DOM manipulation solution that closely mimics browser behavior, jsdom is the way to go.

  • parse5 is a fast and robust HTML parser that adheres closely to the HTML5 specification. It is designed to parse HTML documents into a tree structure, allowing for easy manipulation and traversal. Parse5 is particularly useful for applications that require strict adherence to HTML standards and need to handle malformed HTML gracefully. If you need a parser that prioritizes compliance with HTML5 and offers a detailed parsing approach, parse5 is a strong candidate.

To see how htmlparser2 compares with cheerio, jsdom, and parse5, check out the comparison: Comparing cheerio vs htmlparser2 vs jsdom vs parse5.

Similar Npm Packages to jsdom

jsdom is a popular JavaScript library that simulates a web browser's environment, allowing developers to manipulate and interact with HTML and DOM elements in a Node.js environment. This makes it particularly useful for server-side rendering, testing, and web scraping. While jsdom provides a robust solution for DOM manipulation, there are several alternatives that also cater to similar needs. Here are a few notable options:

  • cheerio is a fast and flexible library that provides a jQuery-like syntax for manipulating and traversing HTML documents. It is designed for server-side use and is particularly useful for web scraping. Cheerio does not implement a full DOM, but rather a subset of it, which makes it lightweight and efficient. If you need to parse and manipulate HTML quickly without the overhead of a full browser environment, cheerio is an excellent choice.

  • domino is a lightweight implementation of the DOM and HTML standards, designed to work in Node.js. It provides a minimalistic approach to DOM manipulation and is particularly useful for scenarios where you need a simple and fast way to create and manipulate DOM elements without the full overhead of a browser simulation. If you are looking for a straightforward solution for basic DOM manipulation in a server-side context, domino might be the right fit.

  • parse5 is an HTML parser that aims to be compliant with the HTML5 specification. It provides a way to parse HTML documents into a tree structure, which can then be manipulated or traversed. Unlike jsdom, parse5 does not provide a DOM API for manipulation, but it is highly efficient for parsing and serializing HTML. If your primary need is to parse HTML documents rather than manipulate them in a browser-like environment, parse5 is a solid choice.

To explore how jsdom compares with cheerio, domino, and parse5, check out the comparison: Comparing cheerio vs domino vs jsdom vs parse5.

Similar Npm Packages to xpath

xpath is a popular library for parsing and querying XML documents using XPath expressions in JavaScript. It allows developers to easily navigate and extract data from XML structures, making it an essential tool for applications that deal with XML data. While xpath provides robust functionality for XML querying, there are several alternatives in the JavaScript ecosystem that offer similar capabilities. Here are a few noteworthy options:

  • cheerio is a fast and flexible library that provides a jQuery-like syntax for parsing and manipulating HTML and XML documents. It is particularly useful for web scraping and server-side manipulation of HTML content. Cheerio allows developers to traverse and manipulate the DOM easily, making it a great choice for projects that require both XML and HTML parsing. If you're looking for a lightweight solution that combines the ease of jQuery with server-side capabilities, cheerio is an excellent option.

  • xml2js is a simple and effective library for converting XML data into JavaScript objects and vice versa. It provides an easy-to-use API for parsing XML strings and files, making it suitable for applications that need to work with XML data in a more JavaScript-friendly format. If your primary goal is to convert XML to JSON and back, xml2js is a straightforward choice that simplifies the process of handling XML data.

  • xmldom is a DOM implementation for XML documents in JavaScript. It allows developers to create, manipulate, and serialize XML documents using a DOM-like API. While xmldom does not provide XPath querying capabilities out of the box, it can be used in conjunction with other libraries like xpath to parse and query XML documents effectively. If you need a DOM implementation for XML that can be integrated with other tools, xmldom is a solid choice.

For a comprehensive comparison of these libraries, check out the following link: Comparing cheerio vs xml2js vs xmldom vs xpath.

README for cheerio

cheerio

The fast, flexible, and elegant library for parsing and manipulating HTML and XML.

中文文档 (Chinese Readme)

import * as cheerio from 'cheerio';
const $ = cheerio.load('<h2 class="title">Hello world</h2>');

$('h2.title').text('Hello there!');
$('h2').addClass('welcome');

$.html();
//=> <html><head></head><body><h2 class="title welcome">Hello there!</h2></body></html>

Installation

Install Cheerio using a package manager like npm, yarn, or bun.

npm install cheerio
# or
bun add cheerio

Features

❤ Proven syntax: Cheerio implements a subset of core jQuery. Cheerio removes all the DOM inconsistencies and browser cruft from the jQuery library, revealing its truly gorgeous API.

ϟ Blazingly fast: Cheerio works with a very simple, consistent DOM model. As a result parsing, manipulating, and rendering are incredibly efficient.

❁ Incredibly flexible: Cheerio wraps around parse5 for parsing HTML and can optionally use the forgiving htmlparser2. Cheerio can parse nearly any HTML or XML document. Cheerio works in both browser and server environments.

API

Loading

First you need to load in the HTML. This step in jQuery is implicit, since jQuery operates on the one, baked-in DOM. With Cheerio, we need to pass in the HTML document.

// ESM or TypeScript:
import * as cheerio from 'cheerio';

// In other environments:
const cheerio = require('cheerio');

const $ = cheerio.load('<ul id="fruits">...</ul>');

$.html();
//=> <html><head></head><body><ul id="fruits">...</ul></body></html>

Selectors

Once you've loaded the HTML, you can use jQuery-style selectors to find elements within the document.

$( selector, [context], [root] )

selector searches within the context scope which searches within the root scope. selector and context can be a string expression, DOM Element, array of DOM elements, or cheerio object. root, if provided, is typically the HTML document string.

This selector method is the starting point for traversing and manipulating the document. Like in jQuery, it's the primary method for selecting elements in the document.

$('.apple', '#fruits').text();
//=> Apple

$('ul .pear').attr('class');
//=> pear

$('li[class=orange]').html();
//=> Orange

Rendering

When you're ready to render the document, you can call the html method on the "root" selection:

$.root().html();
//=>  <html>
//      <head></head>
//      <body>
//        <ul id="fruits">
//          <li class="apple">Apple</li>
//          <li class="orange">Orange</li>
//          <li class="pear">Pear</li>
//        </ul>
//      </body>
//    </html>

If you want to render the outerHTML of a selection, you can use the outerHTML prop:

$('.pear').prop('outerHTML');
//=> <li class="pear">Pear</li>

You may also render the text content of a Cheerio object using the text method:

const $ = cheerio.load('This is <em>content</em>.');
$('body').text();
//=> This is content.

The "DOM Node" object

Cheerio collections are made up of objects that bear some resemblance to browser-based DOM nodes. You can expect them to define the following properties:

  • tagName
  • parentNode
  • previousSibling
  • nextSibling
  • nodeValue
  • firstChild
  • childNodes
  • lastChild

Screencasts

https://vimeo.com/31950192

This video tutorial is a follow-up to Nettut's "How to Scrape Web Pages with Node.js and jQuery", using cheerio instead of JSDOM + jQuery. This video shows how easy it is to use cheerio and how much faster cheerio is than JSDOM + jQuery.

Cheerio in the real world

Are you using cheerio in production? Add it to the wiki!

Sponsors

Does your company use Cheerio in production? Please consider sponsoring this project! Your help will allow maintainers to dedicate more time and resources to its development and support.

Headlining Sponsors

Tidelift Github AirBnB HasData

Other Sponsors

OnlineCasinosSpelen Nieuwe-Casinos.net

Backers

Become a backer to show your support for Cheerio and help us maintain and improve this open source project.

Vasy Kafidoff

License

MIT

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. Please share your feedback via our GitHub repository. For more details, please refer to our Terms & Privacy.