RSS Feed XML Anatomy Explained: What , , GUID, and pubDate Actually Do

Updated: 2026-09-27

Short answer: <channel> holds information about the feed as a whole, <item> is one entry, <guid> is the unique identifier that tells a reader whether an item has been seen before, and <pubDate> is when the item was published. For auto-posting, <guid> matters most: a feed that hands out a new guid every time the site rebuilds will make any tool treat old items as new and republish them.

An RSS feed looks intimidating as raw XML, but it’s built from a small handful of tags that each do one specific job. Once you know what <channel>, <item>, <guid>, and <pubDate> actually mean, reading — or troubleshooting — a feed directly stops being guesswork.

The <channel> Element: Feed-Level Metadata

Everything in a feed lives inside a single <channel> element, which holds information about the feed as a whole rather than any individual post: a <title> (the site or feed’s name), a <link> (the site’s homepage), and a <description>. Think of it as the feed’s header — it appears once, at the top, before any actual content starts.

The <item> Element: One Per Post

Inside <channel>, every individual post gets its own <item> element, each with its own <title>, <link>, and <description> (or full content). A feed with 15 recent posts simply has 15 <item> blocks stacked inside the one <channel>. This is the part every automation tool and reader actually loops over to find what’s new.

<guid>: The Tag That Prevents Duplicate Posts

Every <item> should carry a <guid> — a globally unique identifier, usually just the post’s permalink. This is what automation tools actually use to track “have I already posted this one” rather than relying on titles or dates, which can technically repeat. If a feed generator ever reuses the same GUID for two different posts (a bug, not expected behavior), tools that key off it can skip content that should have posted, or in rarer cases, mishandle what counts as new.

<pubDate>: Why the Format Matters

<pubDate> records when an item was published, and RSS specifically expects it in RFC 822 date format (for example, Tue, 15 Sep 2026 09:30:00 GMT) rather than a plain ISO date. Tools sorting items by recency, or automation platforms deciding what’s “new since last check,” rely on this field parsing correctly — a malformed or missing <pubDate> is a common, easy-to-miss cause of items appearing out of order or not being recognized as new at all.

<enclosure>: How Podcasts Use RSS for Audio

Podcast feeds add one more tag most blog feeds don’t need: <enclosure>, which attaches a media file’s URL, type, and size directly to an <item>. This single tag is the entire mechanism podcast apps use to find and download episode audio — there’s no separate podcast-specific protocol; it’s the same RSS format with one extra tag doing the work.

Other Item Tags Worth Recognising

Beyond the core four, a few more tags show up inside most <item> blocks, and each one affects what an auto-posted update looks like:

• <description> holds the summary or excerpt. Auto-posting tools often use it as the text under the title; PostRSS lets you build posts from the item title, the item description, the page title or your own static text.
• <category> lists the item’s categories or tags. PostRSS can turn these into hashtags, up to a set limit, on networks where hashtags make sense.
• <content:encoded> carries the full article body. It comes from a namespace rather than core RSS, as explained in our guide to RSS namespaces.
• <media:content> or an image-type <enclosure> points to the item’s picture. When a feed item has no image, PostRSS can take the picture from the Open Graph tags of the linked page instead.

Checking Your Own Feed in a Few Minutes

You do not need special software to check whether your feed is in good shape for auto-posting:

1. Open the feed URL directly in a browser and find the first <item>.
2. Confirm the <link> is a full, absolute URL and that <guid> is present and matches the permanent post address.
3. Check that <pubDate> shows the real publication time, not the time the feed was last rebuilt.
4. Edit an old post, reload the feed, and make sure its <guid> did not change.

If all four checks pass, any feed-based tool, PostRSS included, will recognise new items correctly and leave old ones alone.

Frequently Asked Questions

Do I ever need to write this XML by hand?

Almost never — WordPress, Ghost, Squarespace, and virtually every other CMS generates valid <channel>/<item> structure automatically. Knowing the tags mainly helps when troubleshooting why something isn’t posting correctly.

What happens if an <item> is missing a <guid>?

Most tools fall back to using the <link> as an identifier instead, which works fine as long as that URL stays stable — the risk appears only if the URL later changes, which can make a tool see an old post as “new” again.

Is RSS 2.0 the only version I’ll run into?

It’s by far the most common in practice, though Atom is a related-but-differently-structured alternative some platforms use instead; the concepts (a channel-level wrapper, per-item entries, unique identifiers, publish dates) carry over even though the exact tag names differ.

Does PostRSS use the category tags in my feed?

Yes. PostRSS can turn the categories and tags of each feed item into hashtags, up to a set limit, on social networks where hashtags make sense.

The Bottom Line

An RSS feed’s XML boils down to one wrapper (<channel>) holding a list of entries (<item>), each identified uniquely (<guid>) and timestamped (<pubDate>), with podcasts adding one extra tag (<enclosure>) for media files. That’s the entire structure most automation and troubleshooting ever touches.