How to Use Podcast Schema to Get Cited by AI Search Engines

Why podcasts are invisible to AI search engines by default

AI search engines like ChatGPT, Perplexity, and Gemini do not listen to audio. They read text. So if your podcast lives primarily as an audio file embedded in a player, with a thin show notes page that says "Episode 47 - we talk about marketing," you are essentially invisible to any AI trying to recommend shows or episodes on a topic.

This is a real problem because podcast recommendations are increasingly appearing inside AI-generated answers. Ask Perplexity "what are the best podcasts about e-commerce SEO?" and it will return a list. The shows on that list are not necessarily the best ones. They are the ones that have given the AI enough structured, readable information to work with.

Podcast schema markup is the mechanism that changes this. It tells AI crawlers and search engines exactly what your show is about, who hosts it, what each episode covers, where to listen, and how often you publish. Without it, the AI is guessing. With it, you are giving the AI the raw material it needs to cite you confidently.

The schema types that matter for podcasts

Schema.org does not have a single "Podcast" type that covers everything. In practice, you need to combine two or three schema types to give a complete picture of your show.

PodcastSeries

This is the top-level type for your show as a whole. It maps to schema.org/PodcastSeries and is where you declare the show's name, description, host, publisher, language, and feed URL. Think of it as the identity card for the podcast itself, separate from any individual episode.

Key properties to include:

• name - the exact show title as it appears on Apple Podcasts and Spotify
• description - a substantive paragraph about the show's topic and audience, not a tagline
• author - the host or production company as a Person or Organization entity
• url - the canonical URL of your podcast homepage
• webFeed - the RSS feed URL, which is how AI crawlers can discover all your episodes
• inLanguage - the language code (e.g. en-GB)
• image - your podcast cover art URL

PodcastEpisode

Each episode gets its own schema block. This is where the citation potential really lives, because AI engines cite specific episodes when they are relevant to a query, not just shows in general. A well-marked-up episode page gives the AI a self-contained unit of knowledge it can reference.

Properties to prioritise:

• name - the full episode title
• description - a detailed summary of what was discussed, ideally 150 to 300 words. This is the single most important field.
• datePublished - ISO 8601 format (e.g. 2025-06-15)
• duration - in ISO 8601 duration format (e.g. PT42M for 42 minutes)
• episodeNumber - the episode number within the series
• partOfSeries - a reference back to the parent PodcastSeries
• associatedMedia - an AudioObject pointing to the actual audio file
• transcript - a MediaObject linking to a full transcript page, if you have one

When to use CreativeWorkSeries instead

If you are using a CMS or schema plugin that does not yet support PodcastSeries natively, CreativeWorkSeries is a reasonable fallback. It is a parent type of PodcastSeries, so the properties overlap significantly. You lose a little specificity, but it is far better than no markup at all.

A worked JSON-LD example

Here is what a complete, production-ready implementation looks like for a fictional podcast called "The E-Commerce Growth Show." This would go in a <script type="application/ld+json"> tag on each episode page.

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "PodcastSeries",
      "@id": "https://example.com/podcast/#series",
      "name": "The E-Commerce Growth Show",
      "description": "A weekly podcast for e-commerce founders covering SEO, paid media, conversion rate optimisation, and AI-driven discovery. Hosted by Sarah Finn, each episode features in-depth interviews with operators who share what is actually working in their stores.",
      "url": "https://example.com/podcast/",
      "webFeed": "https://example.com/podcast/feed.xml",
      "inLanguage": "en-GB",
      "author": {
        "@type": "Person",
        "name": "Sarah Finn",
        "url": "https://example.com/about/sarah-finn"
      },
      "image": {
        "@type": "ImageObject",
        "url": "https://example.com/podcast/cover-art.jpg",
        "width": 3000,
        "height": 3000
      }
    },
    {
      "@type": "PodcastEpisode",
      "@id": "https://example.com/podcast/ep-112-schema-markup-for-ai/#episode",
      "name": "Episode 112: How Schema Markup Drives AI Visibility for Online Stores",
      "description": "Sarah speaks with structured data consultant James Flinn about why e-commerce stores are missing out on AI-generated recommendations and what they can do about it. Topics include Product schema best practices, how AI crawlers differ from Googlebot, and a step-by-step walkthrough of adding JSON-LD to Shopify product pages.",
      "datePublished": "2025-06-10",
      "duration": "PT48M",
      "episodeNumber": 112,
      "url": "https://example.com/podcast/ep-112-schema-markup-for-ai/",
      "partOfSeries": {
        "@id": "https://example.com/podcast/#series"
      },
      "associatedMedia": {
        "@type": "AudioObject",
        "contentUrl": "https://example.com/podcast/audio/ep-112.mp3",
        "encodingFormat": "audio/mpeg"
      }
    }
  ]
}

Notice the use of @id to link the episode back to the series. This creates a relationship graph that AI systems can traverse. It also means if you have 200 episodes on the same domain, the AI can understand they all belong to the same show without having to infer it from the URLs.

The description field is doing the heavy lifting

Most podcast websites treat the episode description as an afterthought. They copy the same two sentences from the RSS feed, or worse, they leave it as "In this episode we chat about..." and nothing more.

For AI citability, the description is the most critical field in your schema. Here is why: AI search engines cannot play your audio. They are reading the text signals around your content. If your description does not contain the specific claims, topics, names, and conclusions discussed in the episode, the AI has nothing to cite.

A good episode description for AI purposes should:

• Name the specific topics covered, not just the theme (e.g. "discusses why JSON-LD outperforms Microdata for Shopify stores" rather than "talks about SEO")
• Name any guests and their credentials
• Include specific statistics, claims, or conclusions if the episode contains them
• Be at least 150 words. Longer is better as long as it stays accurate.
• Use natural language sentences, not bullet lists

You should write this description specifically for the schema field. It can differ from your show notes summary. Think of it as the blurb a librarian would use to catalogue the episode.

Transcripts and their relationship to AI citation

Full episode transcripts dramatically increase the likelihood of AI citation. This is not just about schema. A transcript gives AI crawlers a complete, indexable text document. The schema markup then acts as a label on that document, helping the AI understand what it is, who made it, and when.

If you publish transcripts, link to them using the transcript property on your PodcastEpisode schema:

"transcript": {
  "@type": "MediaObject",
  "url": "https://example.com/podcast/ep-112-schema-markup-for-ai/transcript/"
}

Even a partial transcript covering the main discussion points is worth having. Tools like Otter.ai, Descript, and Riverside all produce reasonable transcripts automatically. The cost of publishing them is low and the AI visibility benefit is real.

If you want to go further, you can use SpeakableSpecification on your transcript pages to indicate which passages are the most quoteable. We cover that technique in detail in this guide to SpeakableSpecification.

Platform-specific considerations

Shopify stores with a podcast section

If you run a Shopify store and host a podcast as part of your content marketing, you typically publish episodes as blog posts. Shopify's blog schema is limited by default. You will need to either inject JSON-LD via your theme's theme.liquid file or use an app that supports custom structured data. Do not rely on Shopify's auto-generated schema here as it will output Article type, not PodcastEpisode.

WordPress with a podcast plugin

Plugins like Seriously Simple Podcasting and Podlove generate some schema automatically, but they often produce incomplete markup. Check what they output using Google's Rich Results Test, then supplement with a custom JSON-LD block added via a code snippet plugin or your theme's functions.php. The partOfSeries link in particular is frequently missing from auto-generated plugin output.

Standalone podcast websites

If your podcast has its own dedicated site (built on Webflow, Ghost, or a custom stack), you have the most flexibility. Add the JSON-LD directly in the <head> of each episode template. Make sure the series-level schema appears on your homepage or main podcast page, not repeated on every episode page.

Checking your implementation

Three tools are worth using once you have implemented podcast schema:

1. Google Rich Results Test (search.google.com/test/rich-results) - confirms the schema is valid and parses correctly. Podcast-specific rich results are limited, but it will catch syntax errors.
2. Schema Markup Validator (validator.schema.org) - tests against the full schema.org specification, not just Google's subset. More useful for catching missing properties.
3. Your server access logs or a crawler monitoring tool - check whether GPTBot, ClaudeBot, PerplexityBot, and Googlebot are actually visiting your episode pages. If they are not, your schema cannot help you. This guide on checking which AI crawlers visit your site walks through the process.

At FlinnSchema, we run an AI visibility audit that includes a review of structured data across podcast, product, and service pages. It is a quick way to spot gaps before you spend time fixing the wrong things.

What AI engines are actually doing with podcast schema

It helps to understand the mechanism. When Perplexity or ChatGPT with browsing enabled encounters your episode page, it is processing the text content and the structured data together. The schema gives it confidence that what it is reading is an episode of a specific podcast series, published on a specific date, by a named host. That confidence is what allows it to cite you as a source rather than just paraphrase content without attribution.

The more complete your schema, the more the AI can "trust" the source. An episode with a full description, a named author, a publication date, a series link, and a transcript is significantly more citable than one with just a title and an embedded audio player.

This is directly connected to the broader principle of E-E-A-T (Experience, Expertise, Authoritativeness, and Trustworthiness) that AI systems use when deciding which sources to surface. Our guide on E-E-A-T and AI search covers this in more depth if you want to understand the wider picture.

Schema markup is not a magic button, but it is one of the clearest signals you can give an AI engine. Most podcasters are not doing it. That is your opportunity.

Frequently Asked Questions

Does podcast schema work for video podcasts as well?

Yes, with some adjustments. For video episodes, replace the AudioObject in the associatedMedia property with a VideoObject, and include properties like thumbnailUrl and videoQuality. The rest of the PodcastEpisode structure stays the same. If you publish both audio and video versions, you can include both as separate associatedMedia entries in an array.

Will podcast schema help me rank on Google as well as AI engines?

Partially. Google does support podcast rich results in some contexts, particularly in Google Podcasts and audio features within Search. However, the main benefit of podcast schema right now is AI citability rather than traditional rich result display. The two goals are complementary, and a well-structured episode page tends to perform better in both contexts.

How often do I need to update my podcast schema?

The series-level schema should be updated any time the show details change (new host, new description, new image). Episode schema, once published, typically does not need updating unless you correct an error. If you regularly republish or significantly update old episodes, treat those as new publications and refresh the datePublished and dateModified fields accordingly. Our post on how often to update schema markup covers the broader principles.

My podcast is on Spotify and Apple Podcasts but I don't have a website. Can I still use podcast schema?

Schema markup requires a webpage you control. If you have no website at all, you cannot implement schema directly. However, even a basic site with one page per episode, containing a description and an embedded player, is enough. Many podcasters use free or low-cost tools like Buzzsprout or Transistor which generate episode pages automatically. Once those pages exist, you can add schema markup to them and gain the AI visibility benefits.