Lighthouse - Inbox Zero for RSS Feeds

RSS (Really Simple Syndication) is an XML-based web feed format that provides updates of website content in a standardized, computer-readable format.

Basically, RSS is a technology for content syndication. It allows software to continuously get content updates of websites and process it further. This can mean showing an aggregated view for readers, automatically posting content on social media, following podcasts, or anything else.

The format, and web feeds in general, give control to both publishers (to distribute their content) and users (to choose exactly what they want to follow).

History and evolution

RSS was originally created at Netscape in 1999. And it evolved through several versions, including RSS 0.90, 0.91, 0.92, RSS 1.0 (which took a detour into RDF), and finally RSS 2.0, released in 2002. After RSS 2.0, the format was frozen. The core specification remains unchanged to ensure backward compatibility, and new development happens in extensions to RSS.

Netscape created RSS as a way to let other sites supply headlines and news to its portal “My Netscape”. So that there is one standard way they could use to get content from many different websites.

A lot of bloggers wanted their content to show up in the portal, so they quickly adopted the technology and added RSS feeds to their websites.

When Yahoo added RSS feeds to their sites in 2003, and allowed users to follow feeds from other sites in 2004, they played a key role in popularizing RSS among mainstream internet users. Many of them were unfamiliar or even unaware of the technology, but benefited from it nonetheless.

Since then RSS had its ups and downs. Today most publishing software create feeds out of the box, which makes support on the publisher side almost ubiquitous.

On the consumer side usage of RSS declined in the 2010s, as social media was eating into its market share, with an uptick in usage in the 2020s.

Technical specification

On the technical level, RSS is an XML document with a standardized structure. The root element is <rss> with a mandatory version attribute (typically "2.0"). It contains a single <channel> element which contains metadata about the feed, and multiple <item> elements representing individual content pieces.

The `<channel>` element

The <channel> describes the feed as a whole. Required elements include:

<title>: The name of the feed (e.g., “My Blog”)
<link>: The homepage of the website
<description>: A short summary of the feed

Optional elements can include language, copyright, categories, image, and more.

The `<item>` element

Each <item> is a single article, podcast episode, or update. At minimum, an item should include:

<title>: The headline or title
<link>: The URL to the full content
<description>: A brief summary or the content itself

If the description includes the full content, the title and link can be omitted.

Other optional elements cover publication date, author, categories, unique identifiers, and media attachments.

This is an example of a minimal RSS feed of this blog:

<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
    <channel>
        <title>Lighthouse Blog</title>
        <link>https://lighthouseapp.io/blog/rss.xml</link>
        <description>The main blog of the Lighthouse feed reader</description>
        <lastBuildDate>Tue, 15 Apr 2025 13:52:15 GMT</lastBuildDate>
        <language>en</language>
        <item>
            <title><![CDATA[What are web feeds?]]></title>
            <link>https://lighthouseapp.io/blog/what-are-web-feeds</link>
            <guid>what-are-web-feeds</guid>
            <pubDate>Tue, 15 Apr 2025 00:00:00 GMT</pubDate>
        </item>
    </channel>
</rss>

Extensions to the specification

While RSS 2.0 itself is frozen, a couple extensions have been developed to expand its capabilities. They use XML namespaces to add new elements without breaking backwards compatibility.

Media RSS adds better support of multimedia content, with elements for images, audio, and video, along with associated metadata like thumbnails, duration, and rating.

The Dublin Core module provides standardized metadata elements like <dc:creator>, <dc:subject>, and <dc:rights>, enabling more precise attribution and classification of content.

iTunes extensions added podcast distribution by adding elements specifically for audio content, including <itunes:author>, <itunes:duration>, <itunes:image>, and <itunes:category>. These extensions were used by Apple's podcast ecosystem which effectively standardized how podcast metadata is structured across the industry.

Comparison with Atom and JSON Feeds

RSS isn't the only feed format. Atom and JSON Feed are alternative formats, each with their own strengths and weaknesses.

Atom

Atom, standardized as RFC 4287, was developed to resolve ambiguities and inconsistencies in RSS.

It requires unicode everywhere which enables proper representation of international characters, provides clearer content type handling by explicitly differentiating between HTML and plain text, and requires unique IDs for each entry. Atom's specification is also more precise about data types, making it more predictable for developers.

JSON Feed

JSON Feed was created in 2017, and updated to version 1.1 in 2020. It's a modern alternative to RSS and Atom. The primary improvement is using JSON instead of XML as file format, making it easier for modern web applications and APIs to handle.

Item comparison

Every feed format supports the basic fields necessary for content syndication, but they differ in terminology and support of specific fields. This is a relatively shallow comparison, since especially with Atom many details are in the specific definitions of content types, but it provides a good overview.

	RSS 2.0 `<item>`	Atom `<entry>`	JSON Feed `items[]`
Unique identifier	`<guid>`	`<id>`	`id`
Title	`<title>`	`<title>`	`title`
Summary	`<description>`	`<summary>`	`summary`
Content	`<description>` (either summary or content) `<content:encoded>`	`<content>` (can include text, HTML, or URL to external content)	`content_html` `content_text`
URL	`<link>`	`<link>`	`url`
Item source	`<source>` (feed URL)	`<source>` (source construct, with all feed metadata)	`external_url` (link to source page)
Author	`<author>` (email)	`<author>` (person construct: name, email, uri)	`authors[]` (array of objects: name, url, avatar)
Contributor		`<contributor>` (person construct: name, email, uri)
Publication date	`<pubDate>`	`<published>`	`date_published`
Modified date		`<updated>`	`date_modified`
Tags	`<category>`	`<category>`	`tags[]`
Comments URL	`<comments>`
Rights / license		`<rights>`
Attachments	`<enclosure>`	`<link rel="enclosure" type="">`	`attachments[]`
Item image			`image` (main image) `banner_image`
Language			`language` (per item, optional)
Item‑level extensions	Namespaced elements	Extension elements	Custom keys prefixed with `_`

Creating RSS feeds

Most content creators don't have to create RSS feeds manually because modern content management systems and blogging platforms automatically generate them. WordPress, Ghost, Substack, Medium, and virtually all major blogging platforms produce RSS feeds out of the box, typically available at predictable URLs like yourdomain.com/feed or yourdomain.com/rss.

For custom websites or applications without built-in RSS support, developers can use libraries to generate valid feeds. JavaScript developers, for example, can use npm packages like rss or feed make it easy to programmatically create RSS or Atom feeds.

Here's a basic example of using feed to create an RSS 2.0 feed:

import { Feed } from "feed";

const feed = new Feed({
  title: "Feed Title",
  description: "This is my personal feed!",
  id: "http://example.com/",
  link: "http://example.com/"
});

feed.addItem({
  title: post.title,
  id: post.url,
  link: post.url,
  description: post.description,
  content: post.content,
  date: post.date
});

console.log(feed.rss2());
// Output: RSS 2.0

Common use-cases

News aggregation is one of the most common applications. Feed readers let users follow multiple news sources in a single interface with a chronological timeline, which gives readers control over their information diet. Products in this area are for example Feedly, Inoreader, and Lighthouse.

Content curation platforms and newsletters often pull from RSS feeds to identify and aggregate content worth sharing.

Podcast distribution is almost entirely built on RSS extensions. When you subscribe to a podcast in Apple Podcasts, Spotify, or any other podcast app, you're essentially subscribing to an RSS feed with media enclosures and iTunes extensions.

Automation systems often use RSS as a trigger mechanism. Services like IFTTT or Zapier can monitor RSS feeds and initiate actions when new items appear. This enables workflows like automatically sharing new blog posts to social media.

Conclusion

RSS was the first standard of its kind, and it's still the most-used web feed format today. So much so that "RSS" is often used as synonym to describe all web feed formats.

There's practically no news about RSS itself. iTunes extensions and Media RSS extended the standard so it can be used for more modern video and audio content as well. Besides that no new additions are necessary.

Most innovation happens in the ecosystem around RSS, the readers, aggregators, and applications that use feeds to deliver content to users.

What makes RSS particularly valuable is its open nature. It's a technology that everyone can use and interact with, giving control to users rather than algorithms. There's no platform in the middle deciding which content gets seen and by whom.

With social media becoming ever more polarized, having such an open alternative has never been more important.

What is RSS?