htmlparser2 vs jsdom vs cheerio vs html
HTML Parsing Libraries for Node.js Comparison
Search packages..
1 Year
htmlparser2jsdomcheeriohtmlSimilar Packages:
What's HTML Parsing Libraries for Node.js?

HTML parsing libraries in Node.js are essential tools for developers who need to manipulate and extract data from HTML documents. These libraries provide various functionalities, including DOM manipulation, parsing HTML strings, and traversing the document structure. They are widely used in web scraping, testing, and server-side rendering of web applications. Each library has its unique features, performance characteristics, and use cases, making it crucial to choose the right one based on project requirements.

Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
htmlparser237,536,7654,555489 kB203 months agoMIT
jsdom29,152,32020,9173.11 MB4883 months agoMIT
cheerio10,622,77629,3121.25 MB468 months agoMIT
html209,68876-119 years agoBSD
Feature Comparison: htmlparser2 vs jsdom vs cheerio vs html

Parsing Efficiency

  • htmlparser2:

    htmlparser2 is known for its high performance and ability to handle large documents efficiently. Its streaming capabilities allow for incremental parsing, which is beneficial for performance-sensitive applications.

  • jsdom:

    jsdom, while comprehensive, may have a higher overhead compared to other libraries due to its full DOM emulation. However, it provides a robust environment for applications that require extensive DOM manipulation.

  • cheerio:

    Cheerio is designed for speed and efficiency, making it ideal for web scraping tasks where performance is crucial. It uses a lightweight implementation that allows for quick parsing and manipulation of HTML documents.

  • html:

    HTML is focused on minimalism and speed, providing a straightforward parsing mechanism without the overhead of additional features, making it efficient for simple parsing tasks.

DOM Manipulation

  • htmlparser2:

    htmlparser2 does not provide built-in DOM manipulation capabilities. It focuses on parsing and allows developers to build their own manipulation logic on top of the parsed structure.

  • jsdom:

    jsdom provides a complete DOM API, allowing for extensive manipulation of the document. It supports a wide range of browser features, making it suitable for applications that require complex interactions.

  • cheerio:

    Cheerio offers a jQuery-like syntax for DOM manipulation, allowing developers to easily traverse and modify HTML documents. This makes it user-friendly for those familiar with jQuery.

  • html:

    HTML provides basic parsing capabilities but lacks advanced DOM manipulation features. It is primarily focused on converting HTML strings into structured data rather than manipulating the DOM.

Error Handling

  • htmlparser2:

    htmlparser2 excels in handling malformed HTML, providing robust error handling and recovery mechanisms. It can parse broken HTML documents without crashing, making it a reliable choice for web scraping.

  • jsdom:

    jsdom provides error handling that mimics browser behavior, allowing developers to catch and manage errors as they would in a real browser environment. This is beneficial for applications that need to simulate user interactions.

  • cheerio:

    Cheerio does not have built-in error handling for malformed HTML, as it assumes well-formed input. Developers need to ensure the input is valid before parsing.

  • html:

    HTML is minimalistic and does not provide advanced error handling features. It is best suited for well-formed HTML strings.

Use Cases

  • htmlparser2:

    htmlparser2 is perfect for applications that need to parse large or malformed HTML documents efficiently, such as web crawlers and data extraction tools.

  • jsdom:

    jsdom is designed for testing and server-side rendering of applications that require a full DOM environment, making it suitable for projects that rely on browser-like behavior.

  • cheerio:

    Cheerio is best suited for server-side web scraping and data extraction tasks, where a lightweight and fast library is needed to manipulate HTML documents.

  • html:

    HTML is ideal for simple parsing tasks where performance is critical, such as extracting data from well-structured HTML strings without complex manipulation requirements.

Learning Curve

  • htmlparser2:

    htmlparser2 has a steeper learning curve due to its streaming interface and focus on performance. Developers may need to invest time to understand its parsing model.

  • jsdom:

    jsdom has a moderate learning curve, as it provides a comprehensive DOM API that may require familiarity with browser concepts. However, it is well-documented, easing the learning process.

  • cheerio:

    Cheerio has a gentle learning curve, especially for developers familiar with jQuery. Its API is intuitive and easy to grasp, making it accessible for quick adoption.

  • html:

    HTML is straightforward and easy to use for basic parsing tasks, but its minimalistic approach may require additional logic for more complex scenarios.

How to Choose: htmlparser2 vs jsdom vs cheerio vs html
  • htmlparser2:

    Choose htmlparser2 if you need a highly efficient and flexible parser that can handle malformed HTML and offers a streaming interface. It is particularly useful for large documents or when performance is critical, as it allows for incremental parsing.

  • jsdom:

    Choose jsdom if you need a full-fledged DOM implementation that closely resembles a browser environment. It is suitable for testing and server-side rendering of applications that rely on browser APIs, providing a comprehensive simulation of the browser's behavior.

  • cheerio:

    Choose Cheerio if you need a fast and lightweight library for manipulating HTML and XML documents with a jQuery-like syntax. It is ideal for server-side web scraping and offers a simple API for traversing and modifying the DOM.

  • html:

    Choose HTML if you require a minimalistic library focused on parsing HTML strings into a structured format without additional features. It is suitable for basic parsing tasks where performance is a priority and complex DOM manipulation is not needed.

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 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 html

html is a versatile npm package that provides utilities for working with HTML in JavaScript applications. It allows developers to manipulate and parse HTML content easily, making it a useful tool for web scraping, data extraction, and DOM manipulation. While the html package offers a solid foundation for handling HTML, there are several alternatives in the ecosystem that provide similar functionalities. Here are a few notable options:

  • cheerio is a fast and flexible library designed for server-side jQuery-like manipulation of HTML and XML documents. It allows developers to parse HTML and traverse/manipulate the resulting data structure using a familiar jQuery syntax. Cheerio is particularly useful for web scraping and data extraction tasks, as it provides a lightweight and efficient way to work with HTML content without the overhead of a full browser environment.

  • htmlparser2 is a robust and efficient HTML/XML parser that is designed to handle large documents and malformed HTML. It provides a streaming interface, making it suitable for parsing large amounts of data without consuming excessive memory. htmlparser2 is often used as a foundation for other libraries, including cheerio, and is ideal for applications that require a high-performance parser for HTML content.

  • jsdom is a powerful library that simulates a web browser's environment in Node.js. It provides a complete DOM and HTML parsing implementation, allowing developers to manipulate HTML documents as if they were in a browser. jsdom is particularly useful for testing and server-side rendering of web applications, as it enables developers to run scripts and interact with the DOM in a way that closely resembles a real browser.

For a comprehensive comparison of these packages, check out the following link: Comparing cheerio vs html vs htmlparser2 vs jsdom.

README for htmlparser2

htmlparser2

NPM version Downloads Node.js CI Coverage

The fast & forgiving HTML/XML parser.

htmlparser2 is the fastest HTML parser, and takes some shortcuts to get there. If you need strict HTML spec compliance, have a look at parse5.

Installation

npm install htmlparser2

A live demo of htmlparser2 is available on AST Explorer.

Ecosystem

| Name | Description | | ------------------------------------------------------------- | ------------------------------------------------------- | | htmlparser2 | Fast & forgiving HTML/XML parser | | domhandler | Handler for htmlparser2 that turns documents into a DOM | | domutils | Utilities for working with domhandler's DOM | | css-select | CSS selector engine, compatible with domhandler's DOM | | cheerio | The jQuery API for domhandler's DOM | | dom-serializer | Serializer for domhandler's DOM |

Usage

htmlparser2 itself provides a callback interface that allows consumption of documents with minimal allocations. For a more ergonomic experience, read Getting a DOM below.

import * as htmlparser2 from "htmlparser2";

const parser = new htmlparser2.Parser({
    onopentag(name, attributes) {
        /*
         * This fires when a new tag is opened.
         *
         * If you don't need an aggregated `attributes` object,
         * have a look at the `onopentagname` and `onattribute` events.
         */
        if (name === "script" && attributes.type === "text/javascript") {
            console.log("JS! Hooray!");
        }
    },
    ontext(text) {
        /*
         * Fires whenever a section of text was processed.
         *
         * Note that this can fire at any point within text and you might
         * have to stitch together multiple pieces.
         */
        console.log("-->", text);
    },
    onclosetag(tagname) {
        /*
         * Fires when a tag is closed.
         *
         * You can rely on this event only firing when you have received an
         * equivalent opening tag before. Closing tags without corresponding
         * opening tags will be ignored.
         */
        if (tagname === "script") {
            console.log("That's it?!");
        }
    },
});
parser.write(
    "Xyz <script type='text/javascript'>const foo = '<<bar>>';</script>",
);
parser.end();

Output (with multiple text events combined):

--> Xyz
JS! Hooray!
--> const foo = '<<bar>>';
That's it?!

This example only shows three of the possible events. Read more about the parser, its events and options in the wiki.

Usage with streams

While the Parser interface closely resembles Node.js streams, it's not a 100% match. Use the WritableStream interface to process a streaming input:

import { WritableStream } from "htmlparser2/lib/WritableStream";

const parserStream = new WritableStream({
    ontext(text) {
        console.log("Streaming:", text);
    },
});

const htmlStream = fs.createReadStream("./my-file.html");
htmlStream.pipe(parserStream).on("finish", () => console.log("done"));

Getting a DOM

The DomHandler produces a DOM (document object model) that can be manipulated using the DomUtils helper.

import * as htmlparser2 from "htmlparser2";

const dom = htmlparser2.parseDocument(htmlString);

The DomHandler, while still bundled with this module, was moved to its own module. Have a look at that for further information.

Parsing Feeds

htmlparser2 makes it easy to parse RSS, RDF and Atom feeds, by providing a parseFeed method:

const feed = htmlparser2.parseFeed(content, options);

Performance

After having some artificial benchmarks for some time, @AndreasMadsen published his htmlparser-benchmark, which benchmarks HTML parses based on real-world websites.

At the time of writing, the latest versions of all supported parsers show the following performance characteristics on GitHub Actions (sourced from here):

htmlparser2        : 2.17215 ms/file ± 3.81587
node-html-parser   : 2.35983 ms/file ± 1.54487
html5parser        : 2.43468 ms/file ± 2.81501
neutron-html5parser: 2.61356 ms/file ± 1.70324
htmlparser2-dom    : 3.09034 ms/file ± 4.77033
html-dom-parser    : 3.56804 ms/file ± 5.15621
libxmljs           : 4.07490 ms/file ± 2.99869
htmljs-parser      : 6.15812 ms/file ± 7.52497
parse5             : 9.70406 ms/file ± 6.74872
htmlparser         : 15.0596 ms/file ± 89.0826
html-parser        : 28.6282 ms/file ± 22.6652
saxes              : 45.7921 ms/file ± 128.691
html5              : 120.844 ms/file ± 153.944

How does this module differ from node-htmlparser?

In 2011, this module started as a fork of the htmlparser module. htmlparser2 was rewritten multiple times and, while it maintains an API that's mostly compatible with htmlparser, the projects don't share any code anymore.

The parser now provides a callback interface inspired by sax.js (originally targeted at readabilitySAX). As a result, old handlers won't work anymore.

The DefaultHandler was renamed to clarify its purpose (to DomHandler). The old name is still available when requiring htmlparser2 and your code should work as expected.

The RssHandler was replaced with a getFeed function that takes a DomHandler DOM and returns a feed object. There is a parseFeed helper function that can be used to parse a feed from a string.

Security contact information

To report a security vulnerability, please use the Tidelift security contact. Tidelift will coordinate the fix and disclosure.

htmlparser2 for enterprise

Available as part of the Tidelift Subscription.

The maintainers of htmlparser2 and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. Learn more.

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