An Atom feed is an XML document, standardized by the IETF, that lists a website's published entries so feed readers can detect new and updated content without visiting every page. It exists as a formal specification, RFC 4287, a 43-page document published in December 2005 as an IETF Proposed Standard.
You probably have a handful of sites you check most mornings. A blog about your industry, a news page, a friend's portfolio. You open each one, scan the top of the homepage, and notice that two of them haven't changed since yesterday. Ten minutes gone, most of it wasted.
That's the problem a feed solves. Instead of you visiting every site, each site publishes a single machine-readable file that lists what's new. Your feed reader downloads that file from every site you follow, merges the results, and shows you one list of updates. You read one screen instead of opening eight tabs.
The file format behind that handshake has a name, and getting clear on it takes about five minutes. This covers what an Atom feed is, how it delivers content, and where people mix up three terms that sound alike but do different jobs.
Table of Contents
- What an Atom Feed Is in Plain Terms
- How an Atom Feed Delivers New Content
- Required Elements Inside an Atom Document
- How Atom Entry IDs Keep Updates Clean
- Where They Differ
- Common Misconceptions About Atom Feeds
- Subscribe to a Feed Once You Confirm It Works
What an Atom Feed Is in Plain Terms
Think of a newspaper front desk with a clipboard. You walk up and ask what's been printed since your last visit. The clerk runs a finger down the list and reads out the headlines, the bylines, and the times they went to press. You get everything new without walking to every kiosk in the building.
An Atom feed is that clipboard.
The IETF specification for Atom describes it as an XML-based web content and metadata syndication format. Its job is to represent a collection of related information, called a feed, as a machine-readable document containing multiple items, called entries. Three words carry the whole idea, so pin them down now:
- The feed is the entire document. One file, one URL, the whole list.
- An entry is a single item inside it, such as one blog post or one product update.
- The feed reader is the software that downloads the file and renders it as something you can read.
The specification distinguishes two document types. An Atom Feed Document describes the overall channel, its title, its author, and the entries it carries. An Atom Entry Document describes one piece of content on its own, detached from the channel it came from.
Why anyone bothered to standardize it
Before a shared format existed, every platform published updates in its own style. A tool that wanted to watch several sites needed a separate parser for each one. The IETF's version gave blogs, news services, and other publishers one consistent shape, so feed readers and automated software could process updates without requiring anyone to visit each page manually.
What travels inside is more than a list of links. Atom carries standardized structures for titles, authors, identifiers, timestamps, links, summaries, and full content. That's why a feed reader can show you a post's headline, publish time, and opening paragraph without fetching the article page at all.
The specification also sets expectations for the software on the other end, called Atom processors, and uses XML namespaces to keep Atom elements identifiable when a document mixes vocabularies.
So the next time you spot an Atom link on a site, whether in the footer, the page source, or a browser's address bar, you'll know what it points to. It's a machine-readable list of that site's recent updates, sitting at a fixed address, waiting to be picked up.
How an Atom Feed Delivers New Content
The cycle runs the same way whether you follow one site or fifty. Here it is in order, with the reason each step matters to you.
- A publisher adds or edits a post. The content management system regenerates the feed XML at a fixed URL, often
/feed/or/atom.xml. You never trigger this. It just happens when content changes. - Your feed reader requests that URL over HTTP on a schedule it controls, sometimes every few minutes, sometimes every few hours. The schedule is the reader's decision, not the site's, which is why two people following the same blog may see a new post at different times.
- The reader parses the XML and walks through every
atom:entryelement in the document. Each one gets read as structured data, not as a blob of text. - It compares each entry's
atom:idandatom:updatedvalue against what it has already stored locally. This is the step that does the work, and it's the one readers often overlook. - Unseen IDs appear as new items. A known ID with a later updated timestamp appears as a revised item. Nothing else gets touched.
- The reader displays only the changes. You see a short list of what moved since yesterday, not the entire site.

What the feed leaves out
A feed shows you only what the publisher chooses to include, and that's usually the most recent entries. Some feeds cap at ten. Some cap at fifty. Older posts often don't appear at all.
Practical rule: if you're hunting for something a site published two years ago, don't scroll a feed. Use the site's own archive or search.
That limitation trips people up constantly. They subscribe expecting a complete index and find a rolling window. The feed is a notification channel, not a database.
Why you can't post through it
For the overwhelming majority of sites, the feed is a one-way stream. Your reader downloads the file and does nothing else with it. No writes, no edits, no comments. That's deliberate, and the next few sections explain why the distinction matters more than it sounds.
The thing worth checking yourself is simple. Paste the feed URL into a browser and look at it. You should see XML listing your chosen site's latest posts with timestamps attached. If the newest entry is from six months ago and the site published yesterday, something on the publishing side is stale.
Tools that turn a feed into a campaign, like SendX RSS campaign capabilities, rely on exactly this read-only behavior. They poll the same URL on a schedule and act on what's new, which is why a feed that regenerates reliably and timestamps accurately is worth more than one that merely looks correct.
Required Elements Inside an Atom Document
Open any Atom feed and the first thing you'll see is the root element. Every Atom feed is identified by a top-level atom:feed element, which holds the feed's own metadata followed by zero or more atom:entry elements nested inside.
Zero is allowed. A feed with no entries is still a valid document, just an empty one.
The Atom 1.0 specification published by the RFC Editor assigns these documents the MIME type application/atom+xml, with no mandatory parameters. That explicit media type lets feed readers distinguish an Atom document from ordinary XML and process it under the Atom rules, instead of guessing from a file extension.
Here's the element map, with what each one does for the software reading your feed.
| Element | Appears in | Required | Purpose |
|---|---|---|---|
atom:feed |
Document root | Yes | Wraps the whole feed and its entries |
atom:id |
Feed and each entry | Yes | Stable identifier that does not change when content is edited |
atom:title |
Feed and each entry | Yes | Human-readable heading |
atom:updated |
Feed and each entry | Yes | Last modification time as a date-time value |
atom:author |
Feed or entry | Yes at feed level when entries have no author | Names the writer or publisher |
atom:link |
Feed and each entry | Optional, rel="alternate" recommended |
Points to the web page for the item |
atom:entry |
Inside atom:feed |
Zero or more | One item such as a post or update |
atom:summary |
Entry | Optional | Short excerpt of the item |
atom:content |
Entry | Optional | Full body of the item |
The two rules that trip people up
The first is authorship. A feed can carry atom:author once at the feed level and let every entry inherit it, or repeat it per entry. What it can't do is leave both empty. If your entries have no author element of their own, the feed-level one becomes mandatory.
The second is dates. atom:updated must be a valid date-time value, not a phrase like "last Tuesday" and not a locale-formatted string your platform happens to produce. Invalid dates break sorting, and sorting is how readers decide what's new.
Two link types that look identical
An atom:link with rel="alternate" usually points at the human-readable web page for the item, the one you'd open in a browser. The feed's own address is declared separately, using rel="self". Mixing those up sends readers to the wrong place, or worse, creates a loop where a feed points at itself as the article.
Content comes in two optional flavours. atom:summary gives an excerpt, and atom:content holds the full body. Publishers pick one or both, which is why some feeds show you complete articles and others show two lines and a link. If you want the fuller picture of how these documents compare across formats, this walkthrough of an RSS feed format example shows the same structures in their RSS equivalents.
To check any feed yourself, do three things. Find the root element and confirm it says atom:feed. Count the entries. Then spot-check that each entry carries an id, a title, and an updated value.
How Atom Entry IDs Keep Updates Clean
Say a small store publishes a post called Spring Sale on Monday. On Wednesday the owner drops the prices and retitles it Spring Sale Extended.
Now watch what happens to a subscriber if the identifier is just the page URL or the title.
The reader sees a document it half recognizes. The title changed, so it may treat the item as brand new. The subscriber's list now shows two Spring Sale posts, one of which is stale. Multiply that by every correction, retitle, and price fix across a year of publishing, and the feed turns into noise.
The fix is identity, not detection
Atom solves this with the required atom:id element, which the RFC 4287 specification record defines as a stable identifier rather than a page URL or title. The ID stays put when the wording changes.
RFC 4287 states the rule plainly. If multiple atom:entry elements with the same atom:id appear in a feed, they represent the same entry, and their atom:updated timestamps should normally differ. Same ID means same thing. Later timestamp means it changed.

What that buys the reader
Three things follow, and all three are invisible when they work.
Aggregators stop duplicating. An edited post updates in place rather than landing as a second item in your reader.
Republished content keeps its anchor. When the same entry appears in several feed documents, or gets syndicated elsewhere, the shared ID ties the copies back to one original.
Your timeline stays truthful. You see a clean sequence of distinct posts, with revisions folded into the item they belong to.
A stable ID plus an advancing timestamp is the whole trick. Change either one and readers start inventing duplicates.
The check to run after your next edit is quick. Open the feed, find the post you just changed, and confirm two things at once. The ID should be the same string as before. The updated value should be later than it was. If the ID changed, the entry got a new identity and subscribers will see a duplicate. If the timestamp didn't advance, they'll see nothing at all.
Most publishing platforms handle this correctly by default by deriving the ID from the post's permanent identifier. It's worth verifying once, early, because the damage from a bad ID only shows up in other people's readers, where you can't see it.
Where They Differ
You open a reader in the morning and expect one clean list of what changed overnight. Atom 1.0 and RSS 2.0 can both deliver that list, often with the same posts. They were written under different rules, and those rules show up when a reader has to decide whether an item is new, revised, or a duplicate.
Atom reached its standardization milestone in December 2005. The finalized document runs to 43 pages and was issued as a Proposed Standard when the IETF published RFC 4287. Mark Nottingham and Robert Sayre authored and edited it. That length is a clue: Atom was built as a detailed interoperability specification, not a short informal note.
RSS 2.0 grew up outside that process. A looser specification, maintained outside the IETF, left more choices to each tool. The practical differences land in six places.
| Aspect | Atom 1.0 | RSS 2.0 |
|---|---|---|
| Standard | IETF, RFC 4287 (2005) | Informal specification maintained outside the IETF |
| Media type | application/atom+xml |
application/rss+xml |
| Entry identifier | atom:id required |
guid optional |
| Date format | RFC 3339 date-times | RFC 822-style pubDate values |
| Content types | text, html, or xhtml via the type attribute |
description, with extensions for full content |
| Typical use today | Standards-based feeds and tools that need strict IDs | Broad compatibility with older readers and tools |
What the table means in practice
A library card works because every book has one number and the due date is written one way. Atom asks for the same discipline. Every entry must carry an atom:id, and dates use RFC 3339, so a reader can match an edit to the original item and sort the list without guessing. Tools that care about revisions tend to prefer that strictness.
RSS 2.0 keeps guid optional and dates in an older RFC 822 style. It stays simpler, and older readers already know how to open it.
Those columns differ because of how Atom was written. The IETF's Atom Publishing Format and Protocol Working Group had a charter covering two jobs people still mix up: the syndication format (the feed you subscribe to) and a protocol for editing web resources such as weblogs, online journals, and wikis. The format is what your reader consumes. The editing protocol is a separate exchange between a client and a server that has agreed to accept changes. Atom answered the need for an open, vendor-neutral way to distribute web updates across different applications and services. Later IETF work, RFC 5005, added paging and archiving for large collections.
The decision rule you actually need
Modern feed readers accept both formats. The choice is usually the publisher's, not yours. You subscribe to the feed the site offers.
Simple rule: if a site lists both an Atom and an RSS link, they show you the same posts. Subscribe to the one offered first and switch only if your reader fails to parse it.
Pick the link that loads. Checking a feed is a pull: your reader asks, on a schedule, whether anything changed. A pipeline that starts by triggering builds from webhook payloads works the other way. The sender pushes a notice the moment something happens, so there is nothing to poll. For the older format sitting beside Atom, the explainer on what an RSS feed is walks through that side of the pair.
Common Misconceptions About Atom Feeds
Three beliefs come up again and again. Each one is wrong in a specific, fixable way.
"An Atom feed lets people edit my site."
Atom defines the XML representation. The Atom Publishing Protocol, standardized in RFC 5023, is a separate thing entirely. It defines the HTTP operations for creating, editing, and deleting entries, and the IETF's RFC 5023 document treats Atom documents as transferred resources, letting clients discover collections and submit, modify, or delete entries when a server implements the protocol.
A public /feed/ endpoint is ordinarily read-only syndication. Editing needs explicit AtomPub server support and authorization. The presence of Atom XML alone does not imply write access.
"Any XML file with a feed-like shape is an Atom feed."
Software looks for the atom:feed root element and the application/atom+xml media type. Well-formed XML without those is just XML. It may be a sitemap, a config file, or someone's export. None of those will work in a reader.
"A feed is the same as the website, just in a different shape."
A feed carries a recent subset of entries. It doesn't replace the site's archive, its search, or its category pages. Older posts need the site itself, or a paged archive built with the later paging extension.

The reliability question hiding underneath
A feed that parses cleanly depends on consistent metadata, stable entry IDs, and valid date-times. A valid feed is a reliability question as much as a format question.
Before publishing changes to a feed, validate the generated document against the Atom 1.0 rules, verify the namespace and required metadata, confirm stable identifiers, and preserve valid date-time values. The W3C Feed Validation Service supports the IETF Atom format explicitly and identifies it as version 1.0, which makes it a useful pre-publication check for interoperability with readers, aggregators, and automation systems.
Those controls reduce parsing failures caused by malformed XML or inconsistent metadata. A broken feed doesn't announce itself. It just stops showing up in other people's readers, while the site looks perfectly fine to everyone browsing it.
Subscribe to a Feed Once You Confirm It Works
Five steps, in order, and you'll know within a minute whether a feed is worth subscribing to.
- Find the address. Look for a feed link in the page header or footer, or try the site's
/feed/path directly. Many WordPress sites also respond at/feed/atom/if they offer Atom specifically. - Open it in a browser and read the root element. An Atom feed starts with
atom:feed. An RSS feed starts withrss. Either way, you should see recent entries with titles and dates. - Validate it through the W3C Feed Validation Service, which recognizes Atom 1.0, to confirm the document is well formed and carries the required metadata.
- Paste the URL into your feed reader. Most readers accept Atom and RSS identically, so you don't need to know which one you're adding.
- Check back the next day. New posts should appear with titles and dates attached. If they don't, the feed is stale on the publishing side, not in your reader.
Read More Info makes a decent test case. The site-wide feed sits at https://readmore.info/feed/ and the comments feed at https://readmore.info/comments/feed/. Open the first one and read its root element to see which format it uses. A WordPress /feed/ address is usually RSS, so this check tells you whether an Atom version is offered at all.
That last point is the one to carry forward. We publish articles on RSS and feed readers, site search, responsive design, and web basics, and the format question comes up constantly because the answer is usually "whichever one loads." If you want to go deeper on the reading side, this guide to RSS readers explains how the software handles both formats.
Subscribe to the feed that works and stop thinking about the format. The label on the file matters far less than whether your reader keeps showing you new posts on time.
If this cleared up what an Atom feed is and how it differs from RSS and the Atom Publishing Protocol, Read More Info has more where that came from. We publish plain-language explainers on feeds, site search, responsive design, and the web basics that keep a site usable, all written for people who'd rather understand a thing than work around it. Visit Read More Info and subscribe to the feed once you've checked it, so the next post reaches you without another tab.




