PodcastSync-Local-Mac-App

Turn YouTube channels and playlists into a private podcast feed on your Wi‑Fi. Downloads MP3s locally, keeps them organised, and works with normal podcast apps. Built for Mac (menu bar app + small server).

Python Actively developed MIT pushed 3 days ago
View on GitHub
Field notes

Why this exists

Podcast clients only understand one thing: an RSS feed with enclosure links. PodcastSync makes a YouTube channel look like exactly that, served from your own machine.

Paste a channel or playlist URL. The app polls it, pulls audio as MP3 with embedded cover art, writes a valid feed per source, and serves it on your local network. Subscribe in Apple Podcasts, Downcast, or anything else on the same Wi-Fi.

Why the packaging is the feature

The backend is Python and needs yt-dlp, ffmpeg, and ffprobe. Asking someone to install Homebrew, a Python runtime, and two media tools before the app works is how you ship to nobody.

So the DMG bundles all of it — runtime included — and the menu-bar shell supervises the backend as a child process. The cost is a large download and an yt-dlp that needs updating as YouTube changes. The benefit is that it works the moment you drag it to Applications.

Notes

  • The YouTube API key is optional. With one you get full video history and clean handle resolution. Without one the app falls back to YouTube’s public RSS feeds, roughly the fifteen most recent videos per channel. Zero-setup first, better if you bother.
  • Feed URLs are LAN addresses. http://192.168.x.x:port/... — reachable from your phone at home, not from cellular. Deliberate: it means no port forwarding, no tunnel, and no media server exposed to the internet.
  • GUIDs are derived from the video ID and never change. A shifting GUID makes every podcast client re-download the entire back catalogue.
  • Disk grows quietly. 192 kbps is about 90 MB per hour, and nothing is pruned automatically.

There is a companion deployment for running the same idea on a VPS rather than a Mac, for anyone who wants the feed reachable from anywhere.

From the repository

README

source ↗

PodcastSync

Buy Me a Coffee

Platform App Type License Status Release Downloads

Turn YouTube channels and playlists into self-hosted podcast feeds.

PodcastSync is a macOS menu bar app that monitors YouTube sources, downloads audio as MP3, and serves podcast RSS feeds on your local network. Subscribe to the feeds in Apple Podcasts, Downcast, or another podcast client on your LAN.

Features

  • Add YouTube channels or playlists — paste a URL, the app handles the rest
  • Automatic polling — checks for new videos on a configurable schedule (default: every 30 minutes)
  • Audio-only downloads — extracts audio as MP3 at 192kbps with embedded cover art
  • Podcast RSS feeds — one feed per source, valid for any podcast client
  • LAN accessible — feed URLs work from any device on your network
  • Web UI — manage sources, trigger syncs, copy feed URLs from your browser
  • Menu bar app — runs quietly in the background, no Dock icon

Requirements

  • macOS 13 (Ventura) or later
  • (Optional) YouTube Data API v3 key — enables full video history and handle resolution; without it, the app uses YouTube’s public RSS feeds (~15 most recent videos)

Installation

From DMG

  1. Download the latest PodcastSync.dmg from the GitHub Releases page or build it locally
  2. Open the DMG and drag PodcastSync.app to Applications
  3. Right-click the app → Open (required once, to bypass Gatekeeper for this ad-hoc signed app)
  4. The app appears in your menu bar

The packaged DMG bundles the Python backend, yt-dlp, ffmpeg, and ffprobe, so end users do not need to install Homebrew, Python, or extra media tools first.

Development mode

git clone <repo-url>
cd "Youtube Podcast Sync"

# Set up Python environment
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt

# Development mode still expects ffmpeg on the local machine
brew install ffmpeg

# Run the backend directly
./scripts/dev.sh
# Open http://127.0.0.1:8642 in your browser

Usage

Adding a source

  1. Click the menu bar icon → Open Web UI
  2. Paste a YouTube URL into the “Add Source” form:
    • Channel: https://www.youtube.com/@mkbhd or https://www.youtube.com/channel/UCBJycsmduvYEL83R_U4JriQ
    • Playlist: https://www.youtube.com/playlist?list=PLxxxxxxx
  3. Set a name (optional) and max backfill count
  4. Click Add, then Sync Now

Subscribing in a podcast app

  1. In the web UI, click Copy Feed URL next to a source
  2. In your podcast app:
    • Apple Podcasts: File → Subscribe to Show by URL → paste the URL
    • Downcast: Add → Feed URL → paste
  3. The feed URL looks like http://192.168.x.x:8642/feed/1.xml

Overcast disclaimer: Overcast is known to not work reliably with PodcastSync feeds at the moment. Use Apple Podcasts or Downcast instead.

Setting up the YouTube API key

The API key is optional but recommended — it enables:

  • Resolving @handle URLs to channel IDs
  • Fetching full video history (not just the last ~15)
  • Getting video duration metadata
  1. Go to Google Cloud Console
  2. Create a project and enable the YouTube Data API v3
  3. Create an API key (no OAuth required)
  4. In the PodcastSync web UI, go to Settings and paste the key

Building

# Install Python dependencies for the backend and the packager
pip install -r requirements.txt

# Ensure ffmpeg is available on the build machine so it can be bundled
brew install ffmpeg

# Build a fresh self-contained .app and .dmg
./scripts/build_app.sh

# Output: build/PodcastSync.dmg

How it works

  1. Fetcher layer checks YouTube for new videos (API first, RSS fallback)
  2. Download manager uses yt-dlp to extract audio as MP3 at 192kbps with embedded thumbnails
  3. RSS generator creates valid podcast XML with <enclosure> tags pointing to the local server
  4. HTTP server (FastAPI on port 8642) serves the RSS feeds and audio files
  5. Scheduler (APScheduler) runs the fetch→download cycle on a timer
  6. Menu bar app (Swift) manages the Python backend process

File locations

WhatWhere
Audio files~/PodcastMirror/<source-name>/
Database~/.podcastsync/podcastsync.db
Serverhttp://0.0.0.0:8642

Legal / ToS considerations

  • YouTube Data API usage with an API key is within Google’s Terms of Service
  • YouTube’s public RSS feeds are intended for consumption
  • Audio downloading is performed by yt-dlp as a user-controlled action
  • Downloaded content is served only on your local network and is not redistributed
  • This tool is for personal use only — respect content creators’ rights

Known limitations

  • The app is ad-hoc signed, not notarized, so Gatekeeper will prompt on first launch
  • Building the DMG still requires ffmpeg on the machine doing the build; the finished DMG bundles it for end users
  • Overcast is known to not work reliably with PodcastSync feeds
  • YouTube’s RSS feeds return only ~15 most recent videos (use an API key for full history)
  • Podcast clients may cache feeds aggressively (new episodes can take up to an hour to appear)
  • The server must be running for podcast clients to fetch episodes

Support PodcastSync

If this project is useful to you, you can support its maintenance with a coffee:

Buy Me a Coffee

↳

More in Python

All builds
esc
↑↓ navigate ↵ open esc close