Podcast SEO in WordPress: Your RSS Feed Is the Index

Google Podcasts stopped working outside the United States on June 23, 2024. In the US it had already gone that April. Nothing replaced it inside Google Search: no podcast tab, no episode carousel, no form for submitting a show.

A lot of podcast SEO advice still reads as if the app is alive. It tells you to claim your show, verify your episodes, and watch the podcast report in Search Console. None of those steps exist now. What exists is a feed that podcast apps read, and a web page that Google treats like any other page. Two surfaces, two sets of rules, and they fail in different ways.

What Google Actually Removed

The announcement came in December 2023 on the YouTube blog:

As part of this investment, we will be discontinuing Google Podcasts in the US as early as April 2024.

The same post says where podcasters were being sent: “RSS uploads to YouTube”. Listeners could “add any podcast to their YouTube Music library with its RSS feed URL”. 9to5Google recorded the end for everyone else — June 23, 2024 was the last day for international users.

The documentation followed the product. Google’s podcast structured data page now returns a 404. The gallery of structured data Google supports has no podcast entry; the only mentions of the word on that page are navigation links. There is no podcast feature to be eligible for.

Three practical consequences, none of which require a code change:

  • Episode pages are crawled and ranked as ordinary pages. They need text, a reason to exist, and a URL that is the episode rather than the archive.
  • There is no podcast index to submit to. The old Search Console path is gone with the product behind it.
  • The distribution layer consolidated rather than disappeared. The feed that fed Google Podcasts now feeds YouTube Music and every other app that reads RSS.

That last point is the one to sit with. The feed did not become less important. It became the only part of the system that reaches listeners, which makes it the part worth auditing first.

What Still Reads the Feed

Apple publishes a detailed public list of requirements, and it is the one worth satisfying even if you never submit there. The RSS feed requirements cover the tags, the artwork, the date format, and the server behavior. Get those right and the other apps generally follow.

The feed is also the only piece of the system you control end to end. Your theme can change, your host can migrate, your analytics can break. If the feed URL stays up and the enclosures resolve, the show keeps arriving on people’s phones.

The page is the opposite kind of asset. It is the thing Google can read, and it is the only part of the podcast that can rank for what was said in the episode. A feed describes an episode to a player. A page has to describe it to a reader who has not pressed play. Whether the show is worth the work at all is a different question, and the marketing case for podcasts covers it.

Four Things the Feed Has to Get Right

Most rejected feeds fail on one of these. The rest is detail.

The enclosure. Apple’s wording leaves little room: “Each episode must have a unique <enclosure> tag, along with its three required components — URL, length, and type.” Duplicate enclosure URLs are ignored, so two episodes pointing at the same file usually means one disappears.

The attribute people get wrong is length. It is the byte count of the file, not the runtime. A 42-minute episode is not 2520; it is the size of the MP3. type must be the real media type, audio/mpeg for MP3 and audio/mp4 for M4A.

The GUID. Every episode needs “a globally unique identifier (GUID), which never changes”. The emphasis belongs to Apple. The GUID is how an app knows this item is an episode it already has.

WordPress fills its guid column with a ?p=123 permalink at publish. That value is stable while the post exists, but it is not globally unique, and it does not survive a rebuild. A migration that imports posts as new rows creates new GUIDs, and the show republishes everything. So does deriving the GUID from the title, which is common in hand-built feeds: retitle an episode for search, and the app sees a new one.

A URN avoids all of it. urn:uuid:6f1c1f0e-... has no host in it, so moving domains does not touch it, and <guid isPermaLink="false"> tells readers not to open it as a link.

The dates. RFC 2822, with a timezone offset. Apple’s example is the clearest explanation:

Incorrect date format: <pubDate>7/6/2014 1:00:00 PM</pubDate> Correct date format: <pubDate>Wed, 6 Jul 2014 13:00:00 PDT</pubDate>

In WordPress, DATE_RSS is the constant for that shape. A date without a timezone is a validation error even when it looks right.

The server. The requirement that has nothing to do with XML: “allow streaming playback of your episodes by enabling your hosting server for HTTP HEAD requests and byte-range requests.”

Byte ranges are what let a player seek to 31:40 without downloading the first 31 minutes. A host that answers Accept-Ranges: none, or a cache that strips the Range header, gives you a feed that validates and an episode nobody can scrub. Listeners notice that long before they notice your markup.

Audit the Feed Before You Touch the Site

One script, run against the feed rather than the site. It checks the four things above in the order they fail.

# Set this to your show's feed, then run from any machine with curl.
FEED="https://yourdomain.com/feed/podcast/"
curl -sS "$FEED" -o feed.xml

echo "== structure"
grep -o "<item>" feed.xml | wc -l              # episodes declared
grep -o "<enclosure" feed.xml | wc -l          # enclosures present; should match

echo "== duplicates"
grep -o '<enclosure[^>]*url="[^"]*"' feed.xml \
  | sed 's/.*url="//; s/"$//' | sort | uniq -d

grep -o "<guid[^>]*>[^<]*</guid>" feed.xml \
  | sed 's/<[^>]*>//g' | sort | uniq -d

echo "== files"
grep -o '<enclosure[^>]*>' feed.xml | while read -r tag; do
  url=$(printf '%s' "$tag" | sed 's/.*url="\([^"]*\)".*/\1/')
  declared=$(printf '%s' "$tag" | sed 's/.*length="\([^"]*\)".*/\1/')
  actual=$(curl -sSI "$url" | tr -d '\r' | awk 'tolower($1)=="content-length:"{print $2}')
  head_code=$(curl -sS -o /dev/null -w '%{http_code}' -I "$url")
  range_code=$(curl -sS -o /dev/null -w '%{http_code}' -r 0-1 "$url")

  [ "$declared" != "$actual" ] && echo "LENGTH $url declared=$declared actual=$actual"
  [ "$head_code" != "200" ] && echo "HEAD $url returned $head_code"
  [ "$range_code" != "206" ] && echo "RANGE $url returned $range_code"
done

Read the output in three passes. If the item count and enclosure count differ, an episode is missing its audio. Anything printed under == duplicates is a defect, not a warning. Under == files, a length mismatch means the feed is lying to the player, a HEAD other than 200 means the file is unreachable, and a range response other than 206 means seeking will fail.

The 206 check is the one people skip. A server that answers a two-byte range request with the whole file returns 200, and the player still starts at zero. It looks fine in a browser and feels broken in a car.

The Page Has to Carry the Text

If Google indexes episode pages as ordinary pages, the page has to do what an article does. A title, a player, and two lines of description give it almost nothing to work with. It cannot quote the guest, cannot surface the correction at 31:40, and cannot tell episode 47 from episode 48.

The transcript is the fix, and it does more than one job. It gives the page its text. It makes the episode accessible to deaf and hard-of-hearing visitors and to anyone reading with the sound off. It creates the quotable passage that a featured snippet needs. And it gives podcast indexes something to search inside the audio.

Show notes are the other half. A useful set runs 150 to 300 words: what the episode covers, who the guest is with a link to their work, the claims worth checking, and timestamps for the segments. That is enough for a reader to decide whether to listen. Padding it to 800 words with “in this episode we discuss” filler makes the page worse, not longer.

One structural rule matters more than the writing. One episode, one URL. An archive page with 140 players is a browse page; it will not rank for what any single episode says, for the same reason a video gallery does not earn video results. A dedicated post type for episodes puts the transcript field, the feed template, and the schema in one place, which is what the custom post type guide describes for any repeated content shape.

podcast:transcript, and Why It Is Not a Transcript Page

The podcast namespace adds tags RSS 2.0 does not have. The one that matters for search is podcast:transcript. The specification is short: it links “to a transcript or closed captions file”, and multiple tags are allowed for multiple formats.

Two attributes are required, url and type, and the documented types are text/plain, text/html, text/vtt, application/json, and application/x-subrip. language is optional and defaults to the feed’s language. Adding rel="captions" marks the file as captions with time codes, whatever the MIME type says.

The mistake is pointing the tag at the episode page. A player expecting text/vtt will not parse an HTML page, even a page that contains the transcript. Serve the file. If you want both, serve transcript.vtt for players and transcript.html for people, as two tags.

The page transcript and the feed transcript should be the same words. Divergence is a maintenance bug that surfaces months later when someone edits one and not the other. Generate both from one source file, even if that source is a plain text file in the repo.

PodcastEpisode Markup Will Not Get You a Rich Result

PodcastEpisode is a real type with useful properties: name, episodeNumber, partOfSeries, datePublished, duration, and associatedMedia pointing at the audio. It describes an episode accurately.

It does not produce anything in Google, because Google documents no podcast feature. The Rich Results Test will parse the block and report no eligible feature; that is correct behavior, not a failure. Structured data is not a ranking factor, and the ranking guide covers what does move a page.

If you are already generating markup for the site, adding it costs little and helps machines connect the page, the series, and the file. The shape is not complicated:

{
  "@context": "https://schema.org",
  "@type": "PodcastEpisode",
  "url": "https://yourdomain.com/podcast/ep-047-caching-woocommerce/",
  "name": "Episode 47: Caching a WooCommerce Store at 10,000 Orders a Month",
  "episodeNumber": 47,
  "datePublished": "2026-11-18",
  "duration": "PT42M18S",
  "partOfSeries": {
    "@type": "PodcastSeries",
    "name": "The Store Build",
    "url": "https://yourdomain.com/podcast/"
  },
  "associatedMedia": {
    "@type": "AudioObject",
    "contentUrl": "https://cdn.yourdomain.com/podcast/ep-047.mp3",
    "encodingFormat": "audio/mpeg"
  }
}

duration is ISO 8601, so PT42M18S rather than 42:18. And associatedMedia.contentUrl is the audio file, not the page that embeds it.

What I Would Do First

If a show came to me with this problem, the first week would look like this.

  1. Run the audit above. Fix duplicate enclosures, length mismatches, and range support before anything else. Those are the failures that cost listeners.
  2. Move the audio off PHP. A 60 MB file served through WordPress ties up a worker for the length of the download, and a shared host with a 30-second limit will cut it off. Object storage or a CDN handles ranges and HEAD requests properly. The syndication guide covers the rights side of distributing the same audio elsewhere.
  3. Write one real episode page. Transcript, notes, guest links, timestamps. Measure what it does in Search Console for a month before converting the other 139. The recording is also the raw material for clips and articles, which the hybrid video strategy covers from the other direction.
  4. Point the show at a feed you own. https://host.example.com/shows/yours/feed/ is a URL you do not control. A feed on your own domain survives a host change, which is the one migration that kills shows.

Hosting details break players in ways that look like feed problems. Hotlink protection returns 403 to the player’s user agent. A page cache that strips Range makes seeking fail silently. A redirect to a signed CDN URL with an expiry date breaks every subscriber when it expires. The podcast plugin roundup is the place to check whether your plugin emits a compliant feed or needs help.

FAQ

Does Google still index podcast episodes?

Yes, as ordinary web pages. There is no podcast surface left in Google Search, so an episode page competes on its text like any article. Indexing is not the problem; having nothing to index is.

Why does Apple say my feed is invalid?

Usually one of four things: an enclosure missing length or type, a length holding the runtime instead of the byte count, a date that is not RFC 2822, or a non-ASCII filename. Duplicate GUIDs often validate and then duplicate the episode instead.

Do I need podcast schema to rank?

No. Google documents no podcast rich result, so PodcastEpisode cannot produce one. Add it for entity clarity if you already generate markup; skip it if the only reason is a rich result.

Should the transcript live on the page or in the feed?

Both, from one source. The page transcript is what search reads; the podcast:transcript tag is what apps and indexes use. Two copies that are edited separately will drift.

A WP Life
A WP Life

Hi! We are A WP Life, we develop best WordPress themes and plugins for blog and websites.