Introduction

If you have a library of audio content—whether it's a collection of recorded lectures, interviews, or music tracks—turning those files into a podcast RSS feed opens up a world of distribution. Listeners can subscribe using any podcast app, and new episodes appear automatically when you update the feed. Converting existing audio files into an RSS feed‑compatible format is a straightforward process, but it requires attention to file structure, metadata, and hosting. This guide walks through every step, from organizing your audio to validating the final feed, with practical tips for using a headless CMS like Directus to manage the workflow.

What Makes an Audio File RSS‑Compatible?

An RSS feed for audio is an XML document that follows the RSS 2.0 specification. Each episode is represented by an <item> that includes a <enclosure> tag pointing directly to the audio file. For a feed to be compatible with podcast directories and aggregators, the audio files must meet several criteria:

  • File format: Most podcast platforms accept MP3, AAC, M4A, WAV, and OGG. MP3 is the safest choice because of universal support.
  • Fixed audio specs: Use a consistent bitrate (128 kbps MP3 is standard) and sample rate (44.1 kHz). This avoids playback issues across devices.
  • Direct URLs: The file must be accessible at a permanent, publicly accessible URL that does not require authentication or redirects.
  • Accurate file size: The length attribute in the <enclosure> tag must match the actual file size in bytes. Incorrect values can break playback.
  • MIME type: Use the correct MIME type, such as audio/mpeg for MP3 files.

Many existing audio collections contain files in formats like WAV or AIFF, which are large and not supported by all podcast apps. You may need to convert them to a more efficient format before adding them to the feed.

Preparing Your Audio Files for RSS

Organize and Name Consistently

Start by gathering all audio files into a dedicated directory. Use a naming convention that includes a date, episode number, or descriptive title, for example 2024-10-15-interview-with-expert.mp3. This helps when generating the feed automatically later.

Convert to a Podcast‑Friendly Format

If any files are in a non‑standard format or have exotic codecs, convert them. Free tools like FFmpeg can batch‑convert audio to MP3:

ffmpeg -i input.wav -codec:a libmp3lame -b:a 128k output.mp3

Use a constant bitrate (CBR) rather than variable bitrate (VBR) to avoid complications with some podcast directory validators.

Embed ID3 Tags

ID3 metadata (title, artist, album art, episode number) should be embedded directly into the audio file. Many podcast apps read this metadata and use it for display. Tools like mp3tag or FFmpeg can add tags:

ffmpeg -i output.mp3 -metadata title="Interview with Expert" -metadata artist="Your Podcast" -id3v2_version 3 tagged_episode.mp3

Include the episode artwork as a cover image (at least 1400×1400 pixels) for best results on Apple Podcasts and Spotify.

Normalize Audio Levels

To avoid huge volume jumps between episodes, normalize the loudness. The loudness unit (LUFS) standard for podcasts is typically −16 LUFS (integrated). Many audio editors can apply loudness normalization, or you can use FFmpeg with the loudnorm filter:

ffmpeg -i episode.mp3 -af loudnorm=I=-16:LRA=11:TP=-1.5 episode_normalized.mp3

Hosting Your Audio Files

Your RSS feed’s <enclosure> URLs must point to a server that supports direct HTTP downloads (no streaming protocols). Options include:

  • Cloud storage: Amazon S3, Google Cloud Storage, or DigitalOcean Spaces. These services provide public URLs and can handle high traffic.
  • CDN: Add a CDN like Cloudflare or Fastly to reduce latency for global audiences.
  • Podcast‑specific hosting: Services like Libsyn, Buzzsprout, and Podbean host your files and generate the RSS feed automatically. But if you want full control over the XML, you need custom hosting.
  • Headless CMS (Directus): Directus can store audio files as assets and expose them via a public API. You can then build a script that generates the RSS feed from the API data—perfect for dynamic catalogs.

Important: Ensure your hosting provider does not throttle bandwidth or block hotlinking. Many podcast directories expect files to be served without CORS issues. Set the Content-Type header to the correct MIME type (e.g., audio/mpeg) and enable caching for performance.

Creating the RSS Feed XML

The RSS XML file contains a <channel> element with global podcast metadata and multiple <item> elements, one per episode. At a minimum, each item must include <title>, <enclosure>, <guid>, and <pubDate>.

Basic Structure

<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" 
     xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd">
  <channel>
    <title>My History Podcast</title>
    <link>https://example.com/podcast</link>
    <description>A deep dive into historical events.</description>
    <language>en-us</language>
    <itunes:author>Your Name</itunes:author>
    <itunes:image href="https://example.com/podcast-cover.jpg"/>
    <itunes:category text="History"/>

    <item>
      <title>Episode 2: The Roman Empire</title>
      <enclosure url="https://cdn.example.com/audio/ep2.mp3" 
                 length="45678901" type="audio/mpeg"/>
      <guid isPermaLink="false">uuid-1234-5678</guid>
      <pubDate>Wed, 15 Jan 2025 12:00:00 GMT</pubDate>
      <description>Exploring the rise of the Roman Empire.</description>
      <itunes:duration>45:30</itunes:duration>
    </item>
  </channel>
</rss>

Key Elements to Get Right

  • <guid>: Must be globally unique. Use a permanent URL or a UUID. Setting isPermaLink="false" avoids redirect issues.
  • <enclosure>: The url must be a direct link to the file (no HTML pages). The length is the file size in bytes. Get this from your file manager or using curl -sI and parsing Content-Length.
  • <pubDate>: Use RFC 2822 date format. For example, Mon, 01 Jan 2024 10:00:00 GMT.
  • <itunes:duration>: Provide the duration in HH:MM:SS or minutes:seconds. Optional but strongly recommended.

iTunes‑Specific Namespace

Most podcast directories rely on iTunes RSS extensions. Include additional tags like <itunes:subtitle>, <itunes:summary>, <itunes:explicit> (yes/no), and <itunes:episodeType> (full, trailer, bonus).

Validating and Testing Your Feed

Before submitting your feed to directories, validate it to catch common errors. Use:

  • W3C Feed Validation Service – Checks XML syntax and basic RSS compliance.
  • Podbase Podcast Feed Validator – Tests for podcast‑specific issues (enclosure size, iTunes tags).
  • Manual testing: Subscribe to your own feed in a podcast app like Apple Podcasts (on macOS, use the Podcasts app and select “Add a Show by URL…”). Check that episodes appear and play correctly.

Common validation failures include: missing guid, incorrect MIME type (audio/mp3 instead of audio/mpeg), or file size mismatch. Fix those before proceeding.

Submitting to Podcast Directories

Once your feed passes validation, submit its URL (the direct link to the XML file) to major directories:

Each directory may take a few days to review and index your feed. After approval, new episodes appear automatically whenever you update the XML.

Automating Updates with Directus

Managing a growing podcast library manually is tedious. Directus, a headless CMS, can simplify the workflow. Here’s how:

  1. Store audio files: Upload your MP3 files into a Directus project. The system generates a unique filename and a direct file URL.
  2. Create a data model: Define a collection called episodes with fields: title, description, audio_file (file relation), pub_date, duration, explicit, etc.
  3. Build a feed generator: Write a script (Node.js, PHP, or Python) that queries the Directus API for published episodes, then generates the RSS XML. Schedule it to run after each episode publish, or trigger it via webhook.
  4. Serve the XML: Upload the generated RSS file to a static server or use a serverless function to serve it dynamically. Directus itself can also serve static content.

This approach gives you a database‑backed podcast management system without manual XML editing. You can also use Directus’s built‑in role permissions to allow contributors to upload audio without touching the feed code.

Tools and Scripts for Conversion

If you already have many audio files and need to batch‑create the RSS feed, consider these options:

  • Podcast Generator: Open‑source PHP tool that reads a directory of audio files and outputs an RSS feed. Customizable with templates.
  • Python with feedgen: The feedgen library can programmatically build RSS 2.0 feeds. Example:
from feedgen.feed import FeedGenerator
fg = FeedGenerator()
fg.title('My Podcast')
fg.link(href='https://example.com', rel='alternate')
fe = fg.add_entry()
fe.title('Episode 1')
fe.enclosure('https://cdn.example.com/ep1.mp3', 0, 'audio/mpeg')
fg.rss_file('podcast.xml')
  • FFmpeg + shell scripts: Use ffprobe to extract file size and duration, then fill an XML template. This is great for one‑time conversions of legacy collections.

Conclusion

Converting existing audio files into an RSS feed‑compatible format is a systematic process: ensure your files are in a standard format, host them with direct URLs, build a compliant RSS XML with all required elements, validate, and submit. For ongoing podcasts, using a headless CMS like Directus can automate the entire pipeline—from uploading audio to generating the feed. By following these steps, you can turn any collection of audio into a fully distributed podcast that reaches listeners on every major platform.