Syncing Podcast RSS Feed to a Static Website

Alright, let’s talk about a quick win that has a big impact. A few months back, I was spending way too much time manually updating our company’s static site every time marketing dropped a new podcast episode. It was a tedious copy-paste job, and frankly, a waste of engineering time. I realized I could completely automate this by having our build process pull directly from the podcast’s RSS feed.

This setup creates a single source of truth. The marketing team updates the podcast, and the website reflects it automatically within hours. It’s a classic “set it and forget it” DevOps solution that saves time and eliminates human error. Here’s how I build it.

Prerequisites

Before we dive in, make sure you have the following ready. We’re busy people, so having this stuff handy will make the process much smoother.

• Python 3: You should have a recent version of Python installed on your local machine and available in your CI/CD environment.
• A Static Site Generator (SSG): This guide uses Hugo as an example, but the logic applies perfectly to Jekyll, Eleventy, Next.js, or any SSG that can read from data files (like JSON).
• Your Podcast RSS Feed URL: The public URL for your podcast’s XML feed.
• A Git Repository: Your site’s code should be hosted on a platform like GitHub, which we’ll use for automation.

The Guide: Step-by-Step

Our game plan is simple: a Python script will fetch the RSS feed, parse it into a clean JSON file, and commit that file to our repository. Our SSG will then read this JSON file to build the podcast page. Let’s get to it.

Step 1: The Python Sync Script

First, we need a script to do the heavy lifting. I’ll skip the standard `virtualenv` setup since you likely have your own workflow for that. Let’s jump straight to the Python logic. You’ll need one external library, `feedparser`, which is excellent for making sense of RSS feeds. You can add it to your project with a simple `pip install feedparser` command in your active environment.

Create a Python file, let’s call it sync_feed.py.

import feedparser
import json
from datetime import datetime

# --- Configuration ---
# The public URL of your podcast's RSS feed
RSS_FEED_URL = "https://feeds.simplecast.com/your-show-id" 
# The output file our static site generator will use
# This should be in the data directory of your SSG (e.g., Hugo's `data/`)
OUTPUT_FILE = "data/episodes.json"

def fetch_and_parse_feed():
    """Fetches the RSS feed and returns a structured list of episodes."""
    print(f"Fetching feed from: {RSS_FEED_URL}")
    feed = feedparser.parse(RSS_FEED_URL)

    # The 'bozo' flag is set to 1 if the feed is malformed.
    # It's good practice to check this in a production setup.
    if feed.bozo:
        print(f"Warning: The RSS feed may be malformed. Error: {feed.bozo_exception}")

    episodes = []
    for entry in feed.entries:
        # Safely get the audio file URL from the 'enclosures' section
        audio_url = ""
        if 'enclosures' in entry and len(entry.enclosures) > 0:
            audio_url = entry.enclosures[0].get('href', '')

        # Parse the publication date into a more usable format (YYYY-MM-DD)
        pub_date_str = "Date not available"
        if 'published_parsed' in entry and entry.published_parsed:
            try:
                # The 'published_parsed' attribute is a time.struct_time object
                dt_obj = datetime(*entry.published_parsed[:6])
                pub_date_str = dt_obj.strftime("%Y-%m-%d")
            except Exception as e:
                print(f"Could not parse date for entry '{entry.get('title', 'N/A')}': {e}")


        episode_data = {
            "title": entry.get('title', "No Title Provided"),
            "link": entry.get('link', "#"),
            "published_date": pub_date_str,
            # We use 'summary' here, but 'description' might also be available
            "summary": entry.get('summary', "No summary available."),
            "audio_url": audio_url
        }
        episodes.append(episode_data)
    
    print(f"Successfully parsed {len(episodes)} episodes.")
    return episodes

def write_to_file(episodes):
    """Writes the list of episodes to the specified JSON file."""
    print(f"Writing {len(episodes)} episodes to {OUTPUT_FILE}...")
    # Make sure the directory exists before trying to write to it.
    # In an automated environment, the 'data/' directory should be part of your repo.
    try:
        with open(OUTPUT_FILE, 'w', encoding='utf-8') as f:
            json.dump(episodes, f, ensure_ascii=False, indent=2)
        print("File written successfully.")
    except IOError as e:
        print(f"Error writing to file: {e}")
        # In a real-world scenario, you might want to return an error code here.
        return

if __name__ == "__main__":
    podcast_episodes = fetch_and_parse_feed()
    if podcast_episodes:
        write_to_file(podcast_episodes)
    else:
        print("No episodes found or an error occurred. Halting.")

Pro Tip: Notice the use of .get('key', 'default_value'). RSS feeds can be inconsistent. Some entries might be missing a summary or a link. Using .get() prevents your script from crashing if a key doesn’t exist. Always code defensively when dealing with external APIs or feeds.

Step 2: Template Integration with Your Static Site

Now that we have a script generating data/episodes.json, we need to tell our SSG how to render it. In Hugo, this is incredibly straightforward. You can create a partial template to display the episodes.

Here’s an example of what layouts/partials/podcast_list.html might look like:

{{/* This template reads from data/episodes.json */}}
<div class="podcast-episode-list">
  <h2>Our Latest Episodes</h2>
  <ul>
    {{/* The 'range' function loops over the data file */}}
    {{ range .Site.Data.episodes }}
      <li class="episode-item">
        <h3><a href="{{ .link }}" target="_blank" rel="noopener">{{ .title }}</a></h3>
        <small class="publish-date">Published: {{ .published_date }}</small>
        <p>{{ .summary | safeHTML | truncate 180 }}</p>

        {{/* Only show the audio player if an audio_url exists */}}
        {{ if .audio_url }}
          <audio controls preload="none" style="width: 100%;">
            <source src="{{ .audio_url }}" type="audio/mpeg">
            Your browser does not support the audio element.
          </audio>
        {{ end }}
      </li>
    {{ end }}
  </ul>
</div>

You would then include this partial in your main page layout with {{ partial "podcast_list.html" . }}. The key here is .Site.Data.episodes, which is Hugo’s magic for loading the data/episodes.json file.

Step 3: Automation with a CI/CD Pipeline

Manually running the script is better than nothing, but the real power comes from automation. In my production setups, I use GitHub Actions for this. It’s reliable and integrated right into the repository.

Create a file at .github/workflows/sync_podcast.yml in your repository:

name: Sync Podcast Feed

on:
  # Allows you to run this workflow manually from the Actions tab
  workflow_dispatch:
  # Runs on a schedule (e.g., every day at 4 AM UTC)
  schedule:
    - cron: '0 4 * * *'

jobs:
  sync-feed:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.10'
          cache: 'pip'

      - name: Install dependencies
        run: pip install -r requirements.txt

      - name: Run sync script
        run: python3 sync_feed.py

      - name: Commit and push if data changed
        run: |
          git config user.name "github-actions[bot]"
          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
          # Add the generated file to the staging area
          git add data/episodes.json
          # Commit only if there are changes
          if ! git diff --staged --quiet; then
            git commit -m "Automated: Sync podcast feed data"
            git push
          else
            echo "No changes to commit."
          fi

This workflow will automatically run on the schedule you define, execute your Python script, and commit the updated episodes.json file back to your repository. If your site is hosted on a platform like Netlify or Vercel, this new commit will trigger a fresh build and deployment of your site, making the new episodes live.

Pro Tip: For older or simpler setups, you can still use a classic cron job on a server. The command would look something like this, assuming your script is in your home directory: 0 2 * * 1 python3 sync_feed.py. This would run at 2 AM every Monday. However, I strongly recommend a solution like GitHub Actions for better visibility, logging, and integration.

Common Pitfalls

Here is where I usually mess up on the first try, so you can avoid it:

• File Paths: The script assumes it’s being run from the root of your repository. If your script is in a sub-folder, make sure the path to OUTPUT_FILE (e.g., "../data/episodes.json") is correct.
• Missing `requirements.txt`: The GitHub Action relies on a `requirements.txt` file to install dependencies. Make sure you create one containing `feedparser`.
• Git Permissions: The `actions/checkout@v4` action automatically uses a `GITHUB_TOKEN` with permissions to push back to your repository, so you typically don’t need to worry about SSH keys. However, if your branch is protected, you may need to adjust your repository’s security settings to allow the bot to commit.
• Timezones: RSS feed dates can be tricky. The `feedparser` library does a good job of parsing them, but always double-check the output. If you need hyper-accurate timezone conversions, you might need a library like `python-dateutil`.

Conclusion

And that’s it. You’ve now decoupled your website’s content from your codebase. This simple pipeline ensures your site stays current with zero manual intervention, freeing you up to focus on more complex problems. It’s a small investment in automation that pays dividends in time and reliability. Let me know if you have any questions.

Darian Vance

Lead Cloud Architect & DevOps Strategist

With over 12 years in system architecture and automation, Darian specializes in simplifying complex cloud infrastructures. An advocate for open-source solutions, he founded TechResolve to provide engineers with actionable, battle-tested troubleshooting guides and robust software alternatives.

🤖 Frequently Asked Questions