Understanding Chapters and Timestamps for Audio RSS Feeds

Chapters and timestamps in audio RSS feeds allow listeners to navigate through podcast episodes with the same ease they experience when skipping tracks on an album or jumping to a scene in a video. For podcasters, adding this structured metadata transforms a linear audio file into an interactive, scannable experience. Listeners can quickly locate interviews, Q&A segments, or topic changes without scrubbing blindly through the timeline. This feature is supported natively in most modern podcast apps, including Apple Podcasts, Overcast, Pocket Casts, and Spotify, making it a must-have for any serious creator.

Technically, chapters are a set of time-stamped markers that divide an episode into labelled sections. These markers are embedded either directly in the RSS feed using XML tags or served as a separate JSON file referenced in the feed. The two main standards are the Apple Podcasts chapters format (via the <itunes:chapters> tag) and the Podcast Index (Podcast 2.0) chapter format, which uses a <podcast:chapters> tag. Both achieve the same goal but differ in how the chapter data is stored and retrieved.

Why Add Chapters and Timestamps?

The primary reason to add chapters is improved user experience. Listeners who consume long-form content — interviews, educational courses, or narrative series — often want to jump directly to specific segments. Chapters eliminate friction and reduce drop-off rates because users know exactly where the content they care about begins.

From a content strategy perspective, chapters also increase discoverability. When a listener finds a snippet of a podcast on social media and hears a compelling point, having a timestamp with a chapter title makes it easy for them to find that exact moment in the full episode. This directly supports cross-promotion and shareability. Additionally, podcast apps use chapter titles to display “now playing” information, giving your episode a more polished and professional appearance.

For educational or instructional podcasts, chapters serve as an embedded table of contents. A student revisiting a lesson can jump straight to the core concept rather than re-listening to the entire episode. This practical benefit builds audience loyalty and positions your show as a valuable reference resource.

Preparing Your Chapter Data

Before editing any RSS feed code, you need a clean list of chapters with accurate start times. The standard time format is HH:MM:SS, though MM:SS is accepted for episodes under an hour. Each chapter should have a concise, descriptive title. Avoid vague labels like “Part 1” and instead use titles such as “Interview with Dr. Smith on Climate Science” or “Case Study: Marketing Metrics.”

To generate these timestamps, you can use audio editing software like Audacity (free) or Descript (paid). Play through your episode, note the exact second when each new segment begins, and record the timecode. For shows with dynamic content that changes regularly, many podcast hosting platforms now offer automated chapter generation using AI speech-to-text. Tools like Podium or Alitu can analyse your audio and propose chapter breaks based on topic transitions.

Once you have your list, decide whether you will embed the chapters inline in the RSS feed XML or point to an external chapters file. The inline method is simpler for beginners and is supported by Apple Podcasts. The external file method, defined by the Podcast Index specification, is more flexible and allows chapter data to be updated without regenerating the entire RSS feed.

Adding Chapters to Your RSS Feed

Method 1: Inline XML Using the itunes Namespace

Apple’s podcast RSS namespace includes the <itunes:chapters> element. Inside this element, you place individual <chapter> tags, each with a start attribute and a title attribute. The start attribute uses the HH:MM:SS format. Here is a complete example inside an <item> element:

<item>
  <title>Episode 42 – The Future of AI in Healthcare</title>
  <enclosure url="https://example.com/episode42.mp3" length="45678901" type="audio/mpeg"/>
  <itunes:duration>45:30</itunes:duration>
  <itunes:chapters>
    <chapter start="00:00" title="Introduction and Guest Welcome" />
    <chapter start="04:12" title="The State of AI in Diagnostics" />
    <chapter start="18:30" title="Interview with Dr. Patel" />
    <chapter start="32:00" title="Ethical Considerations" />
    <chapter start="40:15" title="Wrap-up and Next Episode Preview" />
  </itunes:chapters>
</item>

This method is widely supported. Apple Podcasts, Overcast, and many other clients will read these markers and display them during playback. Note that the episode’s duration must be set via the <itunes:duration> tag for chapters to align correctly.

Method 2: External Chapters File (Podcast Index / Podcast 2.0)

The Podcast Index specification introduced a more powerful approach. Instead of bloating your RSS file with all chapter data, you host a separate JSON file and link to it using the <podcast:chapters> tag. This file can be updated independently, which is ideal for episodes that get revised after publication (e.g., correcting a chapter title). The JSON format looks like this:

{
  "version": "1.0.0",
  "chapters": [
    { "start": 0, "title": "Introduction" },
    { "start": 252, "title": "Interview with Expert" },
    { "start": 945, "title": "Deep Dive" },
    { "start": 1510, "title": "Q&A Session" },
    { "start": 1800, "title": "Conclusion" }
  ]
}

In this format, start times are provided in seconds, not HH:MM:SS. The file is then referenced in your RSS item:

<podcast:chapters url="https://example.com/episode42-chapters.json" type="application/json+chapters" />

This method requires the Podcast Index namespace (xmlns:podcast="https://podcastindex.org/namespace/1.0") to be declared in the root <rss> element. It is supported by podcasts apps that implement Podcast 2.0, including Pocket Casts and many Android clients.

Choosing the Right Method

The inline method is easier to set up if you are manually editing a feed or using a plugin that manages the XML for you. However, it means your RSS file contains all the chapter data, and any update requires regenerating the entire feed. The external file method is more scalable and allows third-party services to push chapter updates without touching your feed. For most podcasters using a hosted platform like Podlove or Castos, the external method is abstracted away — you simply fill in a form and the platform handles the rest.

If you are using Directus (the CMS mentioned in your title), you can store chapter data as a relational collection, then generate either the inline XML or the external JSON file programmatically when building your RSS feed. Directus’s flexible API lets you pull chapter arrays and format them on the fly without manual editing.

Tools and Plugins to Help

Manually editing RSS XML is error-prone. Several tools and plugins simplify the process, especially for WordPress and Directus users:

  • Podlove Podcast Publisher – A comprehensive WordPress plugin that builds chapter metadata directly into your feed. It supports both inline chapters and Podcast 2.0 external files.
  • Seriously Simple Podcasting – A lightweight WordPress plugin with chapter support via extensions, ideal for beginners.
  • Chapters for Directus – If you manage your podcast content in Directus, you can create a custom endpoint that outputs chapter JSON or XML. Use a repeatable field group with start_time and title fields, then map that into your feed template.
  • Fireside – A hosted podcast platform that automatically generates chapters from shownotes when you include timestamps in plain text.
  • Zencastr – Recording software that can export chapters as a track file or directly into your podcast host.

These tools abstract the technical complexity, allowing you to focus on content. They also handle namespace declarations, XML validation, and cross-platform testing.

Testing Your Chapters

After adding chapters to your RSS feed, test them in multiple apps. Apple Podcasts has a built-in chapter navigation in the Now Playing screen. Open your episode in the Podcasts app, tap the episode artwork, and you should see the chapter list. Overcast, Pocket Casts, and Google Podcasts (while it lasts) all support chapters. Use a validator like Cast Feed Validator to check for XML syntax errors, missing namespace declarations, or invalid timecodes.

One common mistake is misaligned timestamps. Ensure the start time of the last chapter does not exceed the episode duration. Also, check that your episode duration (<itunes:duration>) is accurate; if it is shorter than the last chapter start, some apps will ignore the chapters entirely.

For Podcast 2.0 external chapters, verify that the JSON file is served over HTTPS with a correct MIME type (application/json+chapters). Many podcast apps cache this file, so if you update it later, listeners may not see changes immediately unless you also update the RSS file’s modification date.

Best Practices for Chapters

  • Use clear, actionable titles. Instead of “Segment 2”, write “How to Optimise Your Landing Page.” Listeners should know instantly what they will hear.
  • Keep chapter durations reasonable. Very short chapters (under 30 seconds) can be disruptive. Combine brief topics into a single chapter when possible.
  • Include a table of contents in your shownotes as a fallback. Not all apps render chapters, so text timestamps in the episode description ensure no listener is left out.
  • Update chapter data when episodes are re-edited. If you correct an error in the audio, adjust the chapter timestamps accordingly and republish the feed or JSON file.

Conclusion

Adding chapters and timestamps to your audio RSS feed is a straightforward upgrade that delivers significant value. It improves navigation, increases listener retention, and marks your show as professional and listener-focused. Whether you choose the inline <itunes:chapters> method for simplicity or the Podcast Index external file for flexibility, the effort is minimal compared to the payoff in user experience. Start by preparing your chapter data with accurate timestamps and descriptive titles, then integrate them using your podcast host, CMS (like Directus), or a dedicated plugin. Test across popular apps and refine as needed. Your audience will appreciate the ability to jump straight to the parts that matter most to them, and you will benefit from deeper engagement and shareability.