CorrectFeed

Diagnose podcast feed validation errors

Use this reference after a podcast directory reports a feed error, an episode is missing, artwork or media is rejected, or updates appear stale. If you have not validated the feed yet, begin with how to validate a podcast feed, then run the live feed through CorrectFeed: Validate this podcast feed.

CorrectFeed validates feed structure, podcast metadata, enclosure and artwork declarations, MIME/content-type signals, GUIDs, and delivery symptoms. It may safely repair supported mechanical feed issues, but it does not certify a feed for Apple Podcasts or Spotify, change hosting or redirect configuration, repair inaccessible media, submit a show, or force a platform refresh.

The sections below separate feed-structure and metadata findings from media-host, redirect, caching, and platform changes that CorrectFeed can diagnose but cannot perform.

How Podcast Platforms Validate Your Feed

While podcast RSS feeds are built on top of standard RSS 2.0, major platforms apply additional, stricter rules.

Validation for Apple, Spotify, and others looks at:

  • Required RSS-level metadata (title, description, language)
  • Required podcast-specific tags (e.g., <itunes:author>, <itunes:category>)
  • Media enclosure validity (correct URLs, MIME types, file sizes)
  • Proper GUID format for each episode
  • Episode-level <enclosure> and <pubDate>
  • Feed-level artwork requirements
  • XML structure and encoding

A feed can appear valid in a browser but still fail platform-specific compliance.

This is why podcast feed debugging is trickier than normal RSS troubleshooting.

Technical symptoms behind podcast feed errors

These issue classes can cause podcast directories and players to reject, delay, or omit feeds and episodes. Platform behavior varies, so use the specific diagnostic result rather than assuming one universal rule.

1. Your <enclosure> Tags Are Wrong or Missing

Enclosure declarations are a useful early check because they connect each episode to its media file.

An <enclosure> tag tells podcast players where the actual audio file lives:

<enclosure url="https://example.com/audio/episode1.mp3" length="12345678" type="audio/mpeg" />

The most common mistakes:

  • Missing the length attribute

  • Incorrect type (audio/mp3 instead of audio/mpeg)

  • URL not publicly accessible

  • Using HTTP instead of HTTPS

  • Using query parameters that cause redirect loops

  • Linking to a streaming page instead of a direct file

An unreachable or incorrectly described media file can prevent an episode from being ingested even when the feed XML parses.

2. Incorrect or Missing <guid> Values for Episodes

Podcast platforms rely heavily on GUIDs to determine:

  • Whether an episode is new

  • Whether an episode has been updated

  • Whether episodes have been removed or duplicated

Common errors:

  • GUIDs that change every build

  • GUIDs set equal to the episode title

  • Non-unique GUIDs across episodes

  • GUIDs containing invalid characters

Good GUID examples:

<guid>podcast-episode-001</guid>

or

<guid isPermaLink="true">https://example.com/podcast/episode-001</guid>

Changing GUIDs can make platforms treat existing episodes as new, duplicated, or unrelated items.

3. Your Feed Artwork Doesn’t Meet Requirements

Podcast art must meet strict technical constraints.

Artwork requirements can change by platform. Check the current platform documentation for dimensions and file constraints, and use CorrectFeed to inspect the declared artwork URL, format signals, and feed metadata. CorrectFeed does not resize or host artwork.

4. Your Audio Files Are Too Slow or Unreachable

Podcast platforms must be able to retrieve the media file without authentication or unstable delivery behavior.

Common problems:

  • Server that blocks user agents

  • Download speed too slow

  • File hosted on a private CDN or authenticated bucket

  • 403/404 errors

  • Redirect chains longer than 3 hops

To test, run:

curl -I https://example.com/audio/episode1.mp3

Look for:

  • 200 OK

  • content-type: audio/mpeg

  • content-length present

If your server requires cookies or authentication, the file won’t work.

5. Missing or Invalid <itunes:category> Tags

Apple requires at least one valid category from its official taxonomy.

Example:

<itunes:category text="Education">
  <itunes:category text="Self-Improvement"/>
</itunes:category>

Invalid or obsolete category values can cause platform validation errors.

6. Incorrect or Missing <pubDate> Formats

Each episode needs a valid RFC-822 date, e.g.:

Mon, 10 Jan 2025 15:00:00 GMT

Common mistakes:

  • Using ISO timestamps instead

  • Using non-English month names

  • Using relative formats (“yesterday”, “last week”)

Incorrect time formats can cause episode ordering, freshness, or ingestion problems.

7. Bad or Missing Feed-Level Metadata

Your podcast feed must include:

  • <title>

  • <link>

  • <language>

  • <itunes:author>

  • <itunes:summary> or <description>

  • <itunes:explicit>

Missing required metadata can trigger platform validation errors.

8. Feed Encoding Problems (UTF-8 vs Windows-1252)

Encoding mismatches cause “invisible” failures where your feed appears correct but breaks ingestion pipelines.

Symptoms:

  • Smart quotes or special characters render incorrectly

  • Feed fails Apple validation with cryptic XML errors

  • a destination platform continues to show stale data after the source is corrected

Always specify:

<?xml version="1.0" encoding="UTF-8"?>

…and make sure your hosting actually serves UTF-8.

9. Your Feed Is Too Large

Very large feeds can exceed a destination platform’s processing limits or timeouts.

If your show has hundreds of episodes, you should:

  • follow the destination platform’s current guidance for episode counts and feed size

  • Use archive feeds for older content

CorrectFeed can report feed size and item counts, but it does not control a platform’s ingestion limits.

10. Redirects or HTTPS Issues

Podcast platforms do not like:

  • HTTP → HTTPS redirects

  • Domain changes

  • Multiple chained redirects

  • Expired SSL certificates

TLS certificate or HTTPS delivery failures can prevent any platform from fetching the feed or media.

How to Diagnose Podcast Feed Issues (A Step-by-Step Process)

Here is a robust framework that parallels how professional podcast hosting companies debug feeds.

Step 1: Validate the RSS Structure

Use:

  • Apple Podcasts Connect’s built-in validator

  • CastFeedValidator.com

  • A feed validation tool like CorrectFeed (catches XML + podcast-specific issues)

Look for:

  • XML errors

  • Missing tags

  • Incorrect enclosures

  • Category issues

  • Encoding mismatches

Step 2: Check Your Media Files

Run:

curl -I https://example.com/audio/episode1.mp3

Confirm:

  • The file downloads

  • audio/mpeg as MIME type

  • Reasonable content length

  • No authentication required

Step 3: Inspect Episode GUIDs

Ensure:

  • Unique per episode

  • Never change

  • Match platform expectations

If you migrated from one hosting system to another, GUID changes cause mass duplication.

Step 4: Test Your Feed in Multiple Apps

Try subscribing your feed in:

  • Apple Podcasts

  • Podcast Addict

  • Pocket Casts

  • Overcast

  • Castro

If one app updates but another doesn’t, it’s usually GUID or enclosure related.

If none update, it’s usually XML structure or invalid tags.

Step 5: Check Hosting Performance and Accessibility

Slow or unreachable media files cause:

  • Episodes to “never appear”

  • Partial ingestion

  • Delayed updates

Platforms require consistent uptime.

Step 6: Revalidate After Fixes

Once you correct the source, hosting, media, or redirect issue, validate the live feed again. Then use the destination platform’s current dashboard or refresh workflow if it provides one. CorrectFeed cannot submit the show or force a platform to poll.

Best Practices to Prevent Podcast Feed Errors

These practices reduce common feed failures:

✔ Maintain stable GUIDs

✔ Always include <enclosure> tags with correct MIME types

✔ Use HTTPS for everything

✔ Host audio files on a reliable CDN

✔ Follow each platform’s current artwork requirements

✔ Use valid <pubDate> formatting

✔ Keep the feed within the destination platform’s current size and item limits

✔ Validate every time you publish

✔ Avoid aggressive caching on the feed URL

✔ Use UTF-8 encoding consistently

These steps dramatically improve your feed health and syndication reliability.

Keep diagnosis separate from platform changes

Podcast platforms apply different rules and may change them over time. Start with the concrete feed result and check:

  • Incorrect or missing enclosure tags

  • Bad GUIDs

  • Invalid artwork

  • Wrong encoding

  • Missing podcast-specific metadata

  • Redirect loops

  • Media files that cannot be downloaded

CorrectFeed can validate these technical signals and safely repair supported mechanical feed issues. Hosting performance, inaccessible media, redirect configuration, platform submission, certification, monitoring, alerts, and refresh behavior remain outside the product’s scope.

For the generic workflow, return to how to validate a podcast feed. To run the check, validate this podcast feed.

FAQ

How do I validate my podcast RSS feed?

Use a podcast RSS feed validator to check XML structure, required podcast tags, enclosures, and artwork. CorrectFeed can validate your feed and highlight the exact issue to fix.

Why does Apple Podcasts reject my podcast feed?

Common technical causes include invalid XML, missing or invalid enclosure attributes, MIME-type problems, missing required tags, redirects, or artwork that does not meet current platform requirements.

Why does Spotify say my podcast feed is invalid?

Generic feed diagnostics can surface bad enclosures, redirect loops, unreachable media URLs, or inconsistent GUIDs that may also cause Spotify symptoms. CorrectFeed does not implement Spotify-specific certification rules.

Which podcast RSS errors should I check first?

Start with XML parsing, feed reachability, enclosure URLs and MIME types, required metadata, GUID stability, and artwork declarations.

Why do I see 0 episodes after submitting my feed?

Usually the feed is reachable but episodes fail validation (broken enclosures, invalid pubDate, missing GUIDs) or the platform can’t fetch media URLs quickly enough.

Why is my podcast feed not updating?

Common causes include cached feed responses (ETag/Last-Modified), GUIDs that change on rebuild, incorrect pubDate/updated timestamps, or redirect chains.

Can redirects break podcast validation?

Yes. Long redirect chains or loops often fail, and some platforms are sensitive to HTTP→HTTPS rewrites, www/non-www bouncing, or redirects on enclosure media URLs.

What does 'invalid XML' mean for a podcast feed?

It usually means one unescaped character or broken tag makes the RSS unparsable (e.g., a raw & in text). Fix the first parser error, then re-validate.

How do I fix a podcast RSS feed quickly?

Start by validating the feed, fix the first error shown, re-validate, then resubmit/refresh in Apple Podcasts or Spotify. An autofix tool can help with safe, mechanical XML corrections.

Related help articles

Podcast feed validator Start with reachability, XML, metadata, enclosure, and freshness checks. RSS feed invalid XML error Fix parser failures that make podcast feeds unreadable. RSS feed redirect loop Remove redirect behavior that blocks platform ingestion. Reliable feed publishing Prevent endpoint, caching, GUID, and delivery failures.

Fix RSS/Atom feeds and OPML lists

Check the podcast feed first, then use the diagnostic result to separate feed repairs from host or platform changes.

Validate this podcast feed Back to Help