RSS and Atom Feed Validator

Check RSS and Atom XML feeds and export findings.

What Is an RSS and Atom Feed Validator?

An RSS and Atom feed validator helps identify formatting and structure problems in XML feeds used to distribute website updates. RSS 2.0 and Atom 1.0 follow different specifications, so a useful validation review considers the feed format, required elements, dates, identifiers, and XML syntax. Checking a feed can reveal problems that prevent readers or publishing services from interpreting updates correctly. Validation does not, by itself, confirm that every subscriber receives new items.

RSS and Atom Feed Validator

Check RSS and Atom XML feeds and export findings.

Check an RSS or Atom feed

Paste RSS 2.0 or Atom 1.0 XML Or choose an XML/RSS/Atom file

Optional public feed URL

Checks well-formed XML and common RSS 2.0 / Atom 1.0 required fields, dates, duplicate IDs and links. Checks up to 3000 entries. It does not certify the feed against every extension or publisher-specific rule.

Rate this tool 5.0 out of 5 from 1 rating

Find RSS and Atom Feed Problems Before Readers Miss Updates

A feed can look like ordinary XML but still contain metadata readers cannot interpret. A missing Atom identifier, an RSS channel description, or an incorrect date may cause warnings or missing entries. Well-formed XML is not necessarily a valid RSS or Atom document.

This guide explains the rules that matter when investigating syndication feeds, including XML syntax, format-specific requirements, response headers, and WordPress-generated feeds. Start with the input methods actually displayed in the tool above: it might accept a feed URL, pasted XML, or another supported format. Do not assume that it fetches remote feeds, checks every namespace extension, or tests podcast submission rules unless those capabilities appear in its verified interface. After reviewing the results, correct the source that publishes the feed and test again.

Read Full GuideShow Less

Recognize a Feed Before You Diagnose It

RSS and Atom publish lists of updates that applications can monitor. Blogs, news publishers, release notes, and podcasts use feeds to share updates. A reader retrieves entries and determines what is new using identifiers, timestamps, and content.

An RSS 2.0 document normally starts with an <rss version="2.0"> root and includes one <channel> element containing metadata and optional <item> elements. An Atom 1.0 document uses a <feed> root in the http://www.w3.org/2005/Atom namespace and places articles or updates in <entry> elements. These formats are not interchangeable, even though both are XML.

Compare the Fields That RSS and Atom Actually Require

Applying one format’s rules to the other causes misleading errors: an RSS item does not require an Atom-style updated field. RSS 2.0 requires a channel title, link, and description. Atom RFC 4287 requires feed title, id, updated timestamp, and author information under its defined rules.

Validation detail	RSS 2.0	Atom 1.0
Root element	`rss` with version 2.0	`feed` with Atom namespace
Core feed metadata	Channel `title`, `link`, `description`	Feed `id`, `title`, `updated`; author rules apply
Entry container	`item`	`entry`
Entry identifiers	`guid` is optional but useful	`id` is required
Date formats	RSS `pubDate` uses RFC 822-style dates with four-digit years accepted	`updated` uses RFC 3339 timestamps
Typical media type	`application/rss+xml`	`application/atom+xml`

RSS items should contain a title or description so readers have something meaningful to display. Atom entries must contain their own id, title, and updated; where no content element is present, an appropriate alternate link is required. A validator may also issue recommendations about self links or stable identifiers that are not identical to missing required fields.

Read an RSS 2.0 Example Without Guessing at the Structure

This compact illustrative feed contains the required channel information and one item. The guid is deliberately not a URL, so its isPermaLink attribute is set to false. The publication date uses an RSS-compatible weekday and time zone.

<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
  <channel>
    <title>Example News</title>
    <link>https://example.org/</link>
    <description>Recent website updates</description>
    <item>
      <title>New resource published</title>
      <link>https://example.org/resources/new/</link>
      <description>A new resource is available.</description>
      <guid isPermaLink="false">resource-472</guid>
      <pubDate>Fri, 06 Nov 2026 10:00:00 GMT</pubDate>
    </item>
  </channel>
</rss>

These are fictional example addresses, not feeds on SEOToolCheckers. When adapting the structure, keep the item GUID stable for the same published entry. Changing identifiers on every update can make existing items appear new to some subscribers.

Check Atom Namespaces, Identifiers, and Timestamps

Atom uses the default namespace http://www.w3.org/2005/Atom. Without it, tags that look correctly named may not qualify as Atom elements. Every Atom feed must have a stable id, a title, and an updated timestamp, and entry-level metadata has its own requirements. Identifiers are intended to stay the same even if a feed is republished or moved to another URL.

Atom timestamps such as 2026-11-06T10:00:00Z use RFC 3339 notation, unlike RSS dates such as Fri, 06 Nov 2026 10:00:00 GMT. Updates should reflect meaningful changes rather than being indiscriminately regenerated on every request.

In Atom, rel="self" identifies the feed resource, while an alternate link typically identifies an HTML page for an entry. An absent self link may produce a useful best-practice warning, but do not automatically describe it as a violation of every mandatory Atom requirement.

This separate Atom example illustrates required feed and entry metadata. The example.org addresses are fictional.

<?xml version="1.0" encoding="UTF-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
  <title>Example News</title>
  <id>https://example.org/feeds/atom/</id>
  <updated>2026-11-06T10:00:00Z</updated>
  <author><name>Example Editorial</name></author>
  <link rel="self" href="https://example.org/feeds/atom/"/>
  <entry>
    <title>New resource published</title>
    <id>urn:uuid:6f8baf20-0000-4000-a000-000000000047</id>
    <updated>2026-11-06T10:00:00Z</updated>
    <link rel="alternate" href="https://example.org/resources/new/"/>
    <summary>New resource available.</summary>
  </entry>
</feed>

Diagnose XML Parsing Errors Before Feed-Specific Warnings

Feed validation starts with well-formed XML. One unescaped ampersand in a title or URL query string can stop parsing before the validator reaches your channel or entries. Characters such as & and < need correct XML escaping when they occur in text or attributes. CDATA can be appropriate for blocks of content, but it does not make every kind of malformed document valid.

Also check closing tags, encoding, undeclared namespace prefixes, and output before the XML declaration. For line-and-column errors, inspect the original response near that location. Repair the source or escaping rather than deleting content indiscriminately.

Reported symptom	What to investigate
XML parsing error	Unescaped characters, broken nesting, encoding, unexpected output
Missing RSS channel fields	Required `title`, `link`, or `description`
Missing Atom ID or updated	Required feed or entry element at the correct namespace level
Invalid publication date	Format, timezone, day-of-week accuracy, and date source
Duplicate identifier warning	Whether several separate entries use the same `guid` or Atom `id`
Unexpected HTML response	Redirect, firewall, login requirement, server error, or theme/plugin output

Separate Feed Syntax From HTTP Delivery Problems

A valid feed file may still be unusable if the published URL returns a login page, a server error, repeated redirects, or a restrictive access policy. When the validator accepts only pasted XML, it may have no way to confirm response codes or content-type headers. Use the Bulk HTTP Status and Redirect Checker when you need to investigate a feed endpoint’s status and redirects separately.

Web servers commonly identify RSS with application/rss+xml and Atom with application/atom+xml; generic XML content types can also work. A feed sent as text/html or with mismatched character encoding may behave inconsistently across readers. A validator that parses the XML successfully does not prove that every reader will retrieve it in the same way.

Some publishers add podcast extensions or media enclosures. Those extensions can introduce extra requirements from podcast directories or downstream applications. Do not assume a general RSS and Atom checker tests every podcast or proprietary namespace rule.

Find and Repair RSS or Atom Feeds in WordPress

WordPress commonly serves RSS at /feed/ and Atom at /feed/atom/, plus category or comment feeds. Routing and plugins can change or disable these paths, so inspect the real response.

Open the public feed URL directly and confirm it returns feed XML rather than an error or ordinary HTML.
Use whichever input method the current tool interface actually supports to review syntax and format-specific messages.
Prioritize malformed XML and missing required elements, then investigate warnings about identifiers, dates, and discoverability.
If a recent plugin or theme update introduced the error, compare the response before and after that change. Look for PHP warnings, whitespace, or extra markup before the XML declaration.
Fix the feed template, plugin setting, or publishing data responsible for the issue. Revalidate the public response, then test it in an actual feed reader.

The Source vs Rendered HTML Comparison serves a different purpose: HTML rendering is not the same as XML feed validation. Likewise, the WordPress XML Export Inspector works with WordPress export data, not automatically with RSS or Atom syndication feeds.

Know What Passing Validation Does Not Prove

A valid feed is a better starting point for syndication, but it does not guarantee immediate updates, reader compatibility with unusual extensions, or that subscribers will receive every entry. Readers may cache results, filter duplicates, or interpret optional fields differently. Check real delivery behavior by subscribing to the feed and publishing a controlled test update when practical.

RSS feeds deliver updates to subscribing applications; XML sitemaps help search engines discover URLs. For sitemap-specific checks, use the XML Sitemap Validator. Match the format to its intended reader.

Answers to Common Feed Validation Questions

Why does my RSS feed show XML in the browser?

XML is the expected source format. A browser displaying raw XML does not mean the feed is broken. Look for parsing errors, missing required fields, and whether feed readers can subscribe successfully.

Is an RSS GUID required for every item?

Not by the RSS 2.0 core specification. A stable GUID is still helpful for recognizing repeat entries and reducing duplicate notifications. Atom entry IDs, by contrast, are required.

Does valid RSS improve Google rankings?

Feed correctness improves syndication reliability, not rankings by itself. It does not replace crawlable webpages, useful site content, or a properly maintained XML sitemap.

Can a feed pass XML parsing but fail format validation?

Yes. Well-formed XML only means its syntax is acceptable. An RSS document can still lack required channel fields, and an Atom document can omit required IDs, timestamps, or namespace information.