feedparser vs rss vs rss-parser
RSS and Atom Feed Handling in Node.js
Search packages..
feedparserrssrss-parserSimilar Packages:

RSS and Atom Feed Handling in Node.js

feedparser, rss, and rss-parser are npm packages used for working with RSS and Atom feeds in JavaScript applications, but they serve fundamentally different purposes. feedparser and rss-parser are feed parsers that convert XML feed content into structured JavaScript objects, while rss is a feed generator that creates RSS or Atom XML from JavaScript data. Understanding this distinction is crucial: you cannot parse feeds with rss, nor can you generate feeds with feedparser or rss-parser. Each package offers different APIs—feedparser uses a streaming, event-driven model suitable for large-scale or memory-constrained scenarios; rss-parser provides a modern promise-based interface that simplifies fetching and parsing from URLs or XML strings; and rss uses a builder pattern to construct valid RSS 2.0 or Atom 1.0 feeds for publishing content.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
feedparser01,97972 kB1521 hours agoMIT
rss01,041-489 years agoMIT
rss-parser01,5091.87 MB803 years agoMIT

Parsing RSS and Atom Feeds in Node.js: feedparser vs rss vs rss-parser

When you need to consume or generate RSS/Atom feeds in a JavaScript application, three npm packages often come up: feedparser, rss, and rss-parser. But they serve very different purposes — two are for parsing feeds, and one is for generating them. Let’s cut through the confusion and compare them based on real-world usage.

📥 Core Purpose: Parser vs Generator

First, it’s critical to understand what each package actually does:

  • feedparser: A streaming XML parser for RSS and Atom feeds. It reads raw XML (as a stream or string) and emits structured JavaScript objects.
  • rss-parser: A promise-based RSS/Atom feed parser that fetches and parses feeds from URLs or XML strings.
  • rss: A feed generator, not a parser. It helps you create RSS 2.0 or Atom 1.0 XML from JavaScript objects.

⚠️ Important: You cannot use rss to parse incoming feeds. It only builds them. Confusing it with the others is a common mistake.

Let’s look at how each handles its role.

🔍 Parsing Feeds: feedparser vs rss-parser

Both feedparser and rss-parser parse RSS/Atom, but their APIs and execution models differ significantly.

feedparser: Streaming, Event-Driven Parsing

feedparser works with Node.js streams. It’s ideal when you’re dealing with large feeds or want fine-grained control over parsing (e.g., processing items as they arrive).

import FeedParser from 'feedparser';
import { createReadStream } from 'fs';

const parser = new FeedParser();
const stream = createReadStream('feed.xml');

stream.pipe(parser);

parser.on('readable', function () {
  let item;
  while ((item = this.read())) {
    console.log(item.title);
  }
});

parser.on('error', (err) => {
  console.error('Parse error:', err);
});

You can also pipe HTTP responses directly:

import https from 'https';
import FeedParser from 'feedparser';

https.get('https://example.com/feed.xml', (res) => {
  const parser = new FeedParser();
  res.pipe(parser);
  // ... handle 'readable' and 'error' events
});

This approach is memory-efficient for large feeds but requires managing streams and events.

rss-parser: Simple Promise-Based API

rss-parser abstracts away streams and gives you a clean async/await interface. It can fetch from a URL or parse a raw XML string.

import Parser from 'rss-parser';
const parser = new Parser();

// Parse from URL
const feed = await parser.parseURL('https://example.com/feed.xml');
console.log(feed.title);
feed.items.forEach(item => console.log(item.title));

// Or parse from XML string
const xmlString = `<rss version="2.0"><channel>...</channel></rss>`;
const feedFromXml = await parser.parseString(xmlString);

It normalizes fields across RSS and Atom formats (e.g., pubDate becomes isoDate), which reduces boilerplate.

✍️ Generating Feeds: Only rss Does This

If you need to create an RSS feed (e.g., for a blog or podcast), rss is your go-to. The other two cannot do this.

import RSS from 'rss';

const feed = new RSS({
  title: 'My Blog',
  description: 'A tech blog',
  feed_url: 'https://example.com/rss.xml',
  site_url: 'https://example.com',
  pubDate: new Date(),
});

feed.item({
  title: 'New Post',
  description: 'Learn about RSS!',
  url: 'https://example.com/post1',
  date: new Date()
});

const xml = feed.xml(); // Returns XML string

This is straightforward and widely used in static site generators and CMS backends.

🛑 Maintenance and Deprecation Status

As of the latest checks:

  • feedparser: Actively maintained. No deprecation notice. Works well in modern Node.js environments.
  • rss-parser: Actively maintained. Regular updates and issue responses.
  • rss: Actively maintained. Used by many production systems for feed generation.

None of these packages are deprecated, so all are safe for new projects — as long as you use them for their intended purpose.

🧩 Real-World Decision Guide

When to Use feedparser

  • You’re building a high-throughput feed aggregator that processes thousands of feeds.
  • You need to handle large feeds without loading everything into memory.
  • You’re already working with streams (e.g., piping from HTTP responses or files).
  • You want to react to each item as it’s parsed (real-time processing).

When to Use rss-parser

  • You want a simple, modern async API with minimal setup.
  • You’re fetching feeds from URLs and don’t need streaming.
  • You prefer normalized output (e.g., consistent date formats across RSS/Atom).
  • Your app is frontend-adjacent (e.g., Next.js API routes) and you value code clarity over low-level control.

When to Use rss

  • You need to generate an RSS or Atom feed from your own content.
  • You’re building a blog, podcast, or news site that publishes updates via RSS.
  • You’re integrating with platforms that require RSS output (e.g., podcast directories).

❌ Never try to use rss to parse a feed — it will not work.

🔁 Can They Work Together?

Yes! A common pattern is:

  1. Use rss-parser to fetch and parse a third-party feed.
  2. Transform the data.
  3. Use rss to generate your own aggregated feed.
import Parser from 'rss-parser';
import RSS from 'rss';

const parser = new Parser();
const sourceFeed = await parser.parseURL('https://news.example.com/feed');

const myFeed = new RSS({
  title: 'My Aggregated News',
  site_url: 'https://myapp.com',
  feed_url: 'https://myapp.com/aggregated.rss'
});

sourceFeed.items.slice(0, 10).forEach(item => {
  myFeed.item({
    title: item.title,
    url: item.link,
    date: item.pubDate
  });
});

const xml = myFeed.xml();

📊 Summary Table

PackagePurposeAPI StyleFetches URLs?Generates Feeds?Streaming?
feedparserParserEvent-driven❌ (use with http)❌✅
rss-parserParserPromise-based✅❌❌
rssGeneratorBuilder pattern❌✅❌

💡 Final Advice

Don’t pick based on popularity — pick based on what you’re trying to do:

  • Consuming feeds? Choose between feedparser (for performance and control) and rss-parser (for simplicity).
  • Publishing feeds? Use rss — it’s the standard tool for the job.

Mixing up parsers and generators is the #1 mistake developers make with these packages. Keep their roles clear, and you’ll save hours of debugging.

How to Choose: feedparser vs rss vs rss-parser

  • feedparser:

    Choose feedparser if you need a streaming, event-driven parser for RSS/Atom feeds and are working in a Node.js environment where memory efficiency or real-time item processing matters (e.g., aggregating thousands of feeds). It integrates naturally with Node streams but requires handling events and errors manually. Avoid it if you prefer a simpler async/await API or need built-in HTTP fetching.

  • rss:

    Choose rss only when you need to generate RSS 2.0 or Atom 1.0 feeds from your own content, such as for blogs, podcasts, or news sites. It cannot parse incoming feeds, so never use it for consumption. It’s the standard choice for feed publishing in Node.js backends and static site generators due to its straightforward builder API.

  • rss-parser:

    Choose rss-parser if you want a simple, promise-based API to fetch and parse RSS/Atom feeds from URLs or XML strings with minimal setup. It normalizes feed metadata across formats and is ideal for typical web apps (e.g., Next.js API routes) where you don’t need streaming. Avoid it if you’re processing very large feeds or require fine-grained control over parsing performance.

Similar Npm Packages to feedparser

feedparser is a popular Node.js library designed for parsing RSS and Atom feeds. It provides a simple and efficient way to extract data from feeds, making it easier for developers to integrate feed content into their applications. With its robust parsing capabilities, feedparser can handle various feed formats and structures, allowing for seamless data extraction and manipulation.

While feedparser is a solid choice for parsing feeds, there are alternatives available that may better suit specific needs or preferences. One notable alternative is:

  • rss-parser is another lightweight library for parsing RSS and Atom feeds in Node.js. It offers a straightforward API and is designed to be easy to use, making it a great option for developers looking for a simple solution to fetch and parse feed data. rss-parser supports both RSS and Atom formats and provides features like promise-based parsing, making it a modern choice for handling feed data in applications.

For a detailed comparison of these two libraries, you can visit the following link: Comparing feedparser vs rss-parser.

Similar Npm Packages to rss

rss is a Node.js package designed for parsing RSS feeds. It allows developers to easily retrieve and manipulate content from various RSS sources, making it a valuable tool for applications that aggregate or display news and updates from different websites. The rss package provides a straightforward API for fetching and parsing RSS feeds, enabling developers to integrate external content seamlessly into their applications.

While rss is a solid choice for working with RSS feeds, there are several alternatives in the ecosystem that offer similar functionalities. Here are a couple of notable options:

  • feedparser is a streaming parser for RSS and Atom feeds. It is designed to handle large feeds efficiently, allowing developers to process data as it is received rather than waiting for the entire feed to download. This can be particularly useful for applications that need to handle high volumes of feed data or require real-time updates. feedparser is known for its flexibility and performance, making it a popular choice for developers looking to integrate RSS and Atom feeds into their applications.
  • rss-parser is another lightweight and easy-to-use library for parsing RSS feeds. It provides a simple API for fetching and parsing feeds, allowing developers to quickly retrieve and work with feed data. rss-parser is particularly user-friendly, making it suitable for developers who want a straightforward solution without the complexity of more extensive libraries. Its simplicity and ease of use make it a great option for smaller projects or those who need to get up and running quickly.

To explore how these packages compare, check out the comparison link: Comparing feedparser vs rss vs rss-parser.

Similar Npm Packages to rss-parser

rss-parser is a popular Node.js library used for parsing RSS and Atom feeds. It simplifies the process of fetching and extracting data from various feed formats, making it easier for developers to integrate feed content into their applications. With its straightforward API, rss-parser allows you to quickly retrieve and manipulate feed data, making it an excellent choice for projects that require feed integration.

While rss-parser is a robust option for handling RSS feeds, there are other libraries available that serve similar purposes. Here are a couple of alternatives:

  • feedparser is another library designed for parsing RSS and Atom feeds. It is a streaming parser, which means it can handle large feeds efficiently without consuming excessive memory. feedparser is particularly useful for applications that need to process feeds in real-time or handle large datasets. Its streaming capabilities allow developers to work with incoming data as it arrives, making it a great choice for performance-sensitive applications.
  • xml2js is a versatile XML parsing library that can also be used to parse RSS feeds. Unlike rss-parser and feedparser, which are specifically tailored for feed formats, xml2js provides a more general-purpose XML parsing solution. It converts XML data into JavaScript objects, allowing developers to work with the data in a more familiar format. If your application requires parsing XML data beyond just RSS feeds, xml2js is a flexible option that can handle a variety of XML structures.

To see how rss-parser compares with feedparser and xml2js, check out the comparison: Comparing feedparser vs rss-parser vs xml2js.

README for feedparser

Feedparser - Robust RSS, Atom, and RDF feed parsing in Node.js

CI

NPM

Feedparser is for parsing RSS, Atom, and RDF feeds in node.js.

It has a couple features you don't usually see in other feed parsers:

  1. It resolves relative URLs (such as those seen in Tim Bray's "ongoing" feed).
  2. It properly handles XML namespaces (including those in unusual feeds that define a non-default namespace for the main feed elements).

Installation

npm install feedparser

Usage

This example is just to briefly demonstrate basic concepts.

Please also review the complete example for a thorough working example that is a suitable starting point for your app.


var FeedParser = require('feedparser');
var fetch = require('node-fetch'); // for fetching the feed

var req = fetch('http://somefeedurl.xml')
var feedparser = new FeedParser([options]);

req.then(function (res) {
  if (res.status !== 200) {
    throw new Error('Bad status code');
  }
  else {
    // The response `body` -- res.body -- is a stream
    res.body.pipe(feedparser);
  }
}, function (err) {
  // handle any request errors
});

feedparser.on('error', function (error) {
  // always handle errors
});

feedparser.on('readable', function () {
  // This is where the action is!
  var stream = this; // `this` is `feedparser`, which is a stream
  var meta = this.meta; // **NOTE** the "meta" is always available in the context of the feedparser instance
  var item;

  while (item = stream.read()) {
    console.log(item);
  }
});

You can also check out this nice working implementation that demonstrates one way to handle all the hard and annoying stuff. :smiley:

options

  • normalize - Set to false to override Feedparser's default behavior, which is to parse feeds into an object that contains the generic properties patterned after (although not identical to) the RSS 2.0 format, regardless of the feed's format.

  • addmeta - Set to false to override Feedparser's default behavior, which is to add the feed's meta information to each article.

  • feedurl - The url (string) of the feed. FeedParser is very good at resolving relative urls in feeds. But some feeds use relative urls without declaring the xml:base attribute any place in the feed. This is perfectly valid, but we don't know know the feed's url before we start parsing the feed and trying to resolve those relative urls. If we discover the feed's url, we will go back and resolve the relative urls we've already seen, but this takes a little time (not much). If you want to be sure we never have to re-resolve relative urls (or if FeedParser is failing to properly resolve relative urls), you should set the feedurl option. Otherwise, feel free to ignore this option.

  • resume_saxerror - Set to false to override Feedparser's default behavior, which is to silently handle them and then automatically resume parsing. In my experience, SAXErrors are not usually fatal, so this is usually helpful behavior. If you prefer to abort parsing the feed when there's a SAXError, set resume_saxerror to false, which will cause the SAXError to be emitted on error and abort parsing.

Examples

See the examples directory.

API

Transform Stream

Feedparser is a transform stream operating in "object mode": XML in -> Javascript objects out. Each readable chunk is an object representing an article in the feed.

Events Emitted

  • meta - called with feed meta when it has been parsed
  • error - called with error whenever there is a fatal Feedparser error. SAXErrors are only emitted here when resume_saxerror is false; otherwise they are silently collected in feedparser.errors.

What is the parsed output produced by feedparser?

Feedparser parses each feed into a meta (emitted on the meta event) portion and one or more articles (emited on the data event or readable after the readable is emitted).

Regardless of the format of the feed, the meta and each article contain a uniform set of generic properties patterned after (although not identical to) the RSS 2.0 format, as well as all of the properties originally contained in the feed. So, for example, an Atom feed may have a meta.description property, but it will also have a meta['atom:subtitle'] property.

The purpose of the generic properties is to provide the user a uniform interface for accessing a feed's information without needing to know the feed's format (i.e., RSS versus Atom) or having to worry about handling the differences between the formats. However, the original information is also there, in case you need it. In addition, Feedparser supports some popular namespace extensions (or portions of them), such as portions of the itunes, media, feedburner and pheedo extensions. So, for example, if a feed article contains either an itunes:image or media:thumbnail, the url for that image will be contained in the article's image.url property.

All generic properties are "pre-initialized" to null (or empty arrays or objects for certain properties). This should save you from having to do a lot of checking for undefined, such as, for example, when you are using jade templates.

In addition, all properties (and namespace prefixes) use only lowercase letters, regardless of how they were capitalized in the original feed. ("xmlUrl" and "pubDate" also are still used to provide backwards compatibility.) This decision places ease-of-use over purity -- hopefully, you will never need to think about whether you should camelCase "pubDate" ever again.

The title and description properties of meta and the title property of each article have any HTML stripped if you let feedparser normalize the output. If you really need the HTML in those elements, there are always the originals: e.g., meta['atom:subtitle']['#'].

List of meta properties

  • title
  • description
  • link (website link)
  • xmlurl (the canonical link to the feed, as specified by the feed)
  • date (most recent update)
  • pubdate (original published date)
  • author
  • language
  • image (an Object containing url and title properties)
  • favicon (a link to the favicon -- only provided by Atom feeds)
  • copyright
  • generator
  • categories (an Array of Strings)

List of article properties

  • title
  • description (frequently, the full article content)
  • summary (frequently, an excerpt of the article content)
  • link
  • origlink (when FeedBurner or Pheedo puts a special tracking url in the link property, origlink contains the original link)
  • permalink (when an RSS feed has a guid field and the isPermalink attribute is not set to false, permalink contains the value of guid)
  • date (most recent update)
  • pubdate (original published date)
  • author
  • guid (a unique identifier for the article)
  • comments (a link to the article's comments section)
  • image (an Object containing url and title properties)
  • categories (an Array of Strings)
  • source (an Object containing url and title properties pointing to the original source for an article; see the RSS Spec for an explanation of this element)
  • enclosures (an Array of Objects, each representing a podcast or other enclosure and having a url property and possibly type and length properties)
  • meta (an Object containing all the feed meta properties; especially handy when using the EventEmitter interface to listen to article emissions)

Help

  • Don't be afraid to report an issue.

Contributors

View all the contributors.

Although node-feedparser no longer shares any code with node-easyrss, it was the original inspiration and a starting point.

License

(The MIT License)

Copyright (c) 2011-2026 Dan MacTough and contributors

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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.