Podgrab vs PodFetch vs Podsync: Best Self-Hosted Podcast Tools 2026

Podcast consumption has never been more popular, yet the tools to manage your podcast library remain scattered across proprietary apps and cloud services. If you want full control over your podcast downloads, storage, and feeds, self-hosted solutions give you exactly that — without subscriptions, tracking, or platform lock-in.

This guide compares three popular open-source podcast tools, each with a different focus: Podgrab for automatic RSS-based podcast downloading, PodFetch for a modern full-featured podcast manager, and Podsync for converting YouTube and Vimeo channels into podcast feeds you can subscribe to from any podcast app.

Why Self-Host Your Podcast Tools

Cloud-based podcast apps like Spotify, Pocket Casts, or Apple Podcasts control your library, recommend content algorithmically, and may remove shows without notice. Self-hosting flips this model:

• Own your library — every downloaded episode is stored on your hardware, accessible forever
• No subscriptions or ads — all three tools are free and open-source
• Offline listening — download once, listen anywhere without streaming
• Privacy — no listening habits sent to third-party servers
• Flexibility — expose feeds to any podcast client (AntennaPod, gPodder, Overcast, Pocket Casts)
• Automation — new episodes download automatically the moment they are published

For related reading, check out our guide on self-hosted podcast hosting platforms for the complementary side of the equation — publishing your own podcast rather than consuming others.

Podgrab: The Established All-in-One Downloader

Podgrab is the most popular self-hosted podcast downloader with 1,963 GitHub stars. Built in Go with a Gin web framework backend and SQLite database, it focuses on one job: automatically downloading podcast episodes as soon as they are published.

Key stats (as of April 2026):

• Stars: 1,963
• Language: Go
• Last update: April 2024
• License: MIT

Features

• Automatic episode downloading with configurable check frequency
• Built-in podcast search via iTunes API
• Integrated web player for streaming downloaded episodes
• Tag/label system for organizing podcasts into groups
• OPML import and export for bulk feed management
• Basic authentication support
• Existing file detection to prevent duplicate downloads
• Customizable episode naming patterns
• Dark mode interface

Strengths

Podgrab’s biggest advantage is its maturity and feature completeness. The built-in iTunes search means you can discover and add podcasts without leaving the interface. The integrated player handles both streaming from the original source and playing locally downloaded files. File deduplication is particularly useful if you rebuild your container — it won’t waste bandwidth re-downloading episodes you already have.

Limitations

The project has seen less frequent updates in recent years (last major commit was April 2024). While still functional, the Go-based backend means the web interface is server-rendered rather than a modern SPA. There is no gPodder API sync, so you cannot use your favorite mobile podcast app with Podgrab’s library.

Docker Compose Setup

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

version: "2.1"
services:
  podgrab:
    image: akhilrex/podgrab
    container_name: podgrab
    environment:
      - CHECK_FREQUENCY=240
      # - PASSWORD=your_secure_password  # Uncomment to enable basic auth (username: podgrab)
    volumes:
      - ./podgrab/config:/config
      - ./podgrab/data:/assets
    ports:
      - 8080:8080
    restart: unless-stopped

The CHECK_FREQUENCY value is in minutes — 240 means Podgrab checks for new episodes every 4 hours. Lower this value if you need near-real-time downloads for daily shows.

PodFetch: The Modern Rust-Powered Manager

PodFetch is a newer but rapidly growing podcast manager written in Rust with a React frontend. With 472 stars and very active development (last updated April 2026), it represents the next generation of self-hosted podcast tools.

Key stats (as of April 2026):

• Stars: 472
• Language: Rust
• Last update: April 20, 2026
• License: MIT

Features

• Modern React-based web interface
• SQLite or PostgreSQL database support
• gPodder API compatibility — sync subscriptions with any gPodder-compatible mobile app (AntennaPod, CatchUp, etc.)
• Automatic episode downloading with configurable polling intervals
• Clean, responsive design optimized for mobile browsers
• Built-in audio playback
• Docker images built automatically from every main branch commit

Strengths

PodFetch’s standout feature is its gPodder integration. Unlike Podgrab, which keeps your library isolated to its own web player, PodFetch syncs with the gPodder ecosystem. This means you can subscribe to feeds in PodFetch’s web UI, then use AntennaPod on Android or any gPodder-compatible client on iOS to stream or download episodes — all with playback state synced back to the server.

The Rust backend provides excellent performance and memory efficiency. The PostgreSQL option makes it suitable for multi-user deployments or large libraries with thousands of episodes.

Limitations

With fewer stars and a younger codebase, PodFetch has less battle-testing than Podgrab. The iTunes search and built-in player are less feature-rich than Podgrab’s equivalent. There is no YouTube/Vimeo conversion capability — it works purely with podcast RSS feeds.

Docker Compose Setup (SQLite)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

version: '3'
services:
  podfetch:
    image: samuel19982/podfetch:latest
    user: ${UID:-1000}:${GID:-1000}
    ports:
      - "8000:8000"
    volumes:
      - podfetch-podcasts:/app/podcasts
      - podfetch-db:/app/db
    environment:
      - POLLING_INTERVAL=60
      - DATABASE_URL=sqlite:///app/db/podcast.db

volumes:
  podfetch-podcasts:
  podfetch-db:

Docker Compose Setup (PostgreSQL)

For larger deployments, PodFetch supports PostgreSQL:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

version: '3'
services:
  podfetch:
    image: samuel19982/podfetch:latest
    user: ${UID:-1000}:${GID:-1000}
    ports:
      - "8000:8000"
    volumes:
      - ./podcasts:/app/podcasts
    environment:
      - POLLING_INTERVAL=300
      - DATABASE_URL=postgresql://postgres:changeme@postgres/podfetch
    depends_on:
      - postgres

  postgres:
    image: postgres:16
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: changeme
      POSTGRES_DB: podfetch
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped

volumes:
  postgres_data:

The PostgreSQL setup is ideal when you expect hundreds of feeds with thousands of episodes. For personal use with a dozen shows, SQLite is perfectly adequate.

Podsync: YouTube and Vimeo to Podcast Converter

Podsync takes a fundamentally different approach. Instead of managing podcast RSS feeds, it converts YouTube channels, playlists, and Vimeo videos into podcast feeds that any podcast app can subscribe to. With 1,892 stars and regular updates, it solves a unique problem.

Key stats (as of April 2026):

• Stars: 1,892
• Language: Go
• Last update: April 15, 2026
• License: MIT

Features

• Converts YouTube channels, playlists, and user videos into podcast feeds
• Vimeo and SoundCloud support
• Video-to-audio conversion (mp3 encoding via ffmpeg)
• Configurable feed quality settings (video/audio, resolution limits)
• Cron-based update scheduling
• Episode filtering by title and duration
• Custom feed artwork, category, and language metadata
• OPML export for bulk feed management
• S3-compatible storage backend support
• Web UI with feed management
• API key rotation for YouTube and Vimeo tokens
• Configurable hooks for custom integrations

Strengths

Podsync fills a gap that no other tool addresses. Many educational creators, musicians, and commentators publish exclusively on YouTube — but YouTube’s app experience is not ideal for passive listening. Podsync bridges this by turning any YouTube channel into a proper podcast feed with automatic downloads, position remembering, and offline playback through your preferred podcast app.

The S3 storage option is unique among the three tools — you can store downloaded episodes on Backblaze B2, Cloudflare R2, or any S3-compatible provider, keeping your local disk free.

Limitations

Podsync requires a YouTube API key to function, which has a daily quota limit. Heavy usage with many feeds may hit rate limits. It also depends on yt-dlp and ffmpeg for video processing, which means larger Docker images and higher CPU usage during downloads. Unlike Podgrab and PodFetch, it does not work with traditional podcast RSS feeds — it only converts video platforms.

Docker Compose Setup

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

services:
  podsync:
    container_name: podsync
    image: mxpv/podsync:latest
    restart: always
    ports:
      - 8080:8080
    volumes:
      - ./podsync/data:/app/data/
      - ./podsync/db:/app/db/
      - ./podsync/config.toml:/app/config.toml
    environment:
      - PODSYNC_YOUTUBE_API_KEY=your_youtube_api_key_here

Podsync Configuration File

Create a config.toml alongside your docker-compose.yml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

[server]
port = 8080

[storage]
  [storage.local]
  data_dir = "/app/data/"

[tokens]
youtube = "YOUR_YOUTUBE_API_KEY"

[feeds]
  [feeds.LinuxChannel]
  url = "https://www.youtube.com/channel/UC_x5XG1OV2P6uZZ5FSM9Ttw"
  page_size = 50
  update_period = "12h"
  format = "audio"
  quality = "high"
  clean = { keep_last = 20 }

Each feed needs a unique identifier (like LinuxChannel above), a YouTube or Vimeo URL, and optional settings for update frequency, format (audio or video), quality, and how many episodes to retain.

Feature Comparison

Which Tool Should You Choose?

Choose Podgrab if: You want the simplest, most established podcast downloader with a built-in player and iTunes search. It is ideal for users who want an all-in-one solution — add feeds, auto-download episodes, and listen in the browser without needing a separate podcast app. For users already running media automation stacks like Sonarr and Radarr, Podgrab fits the same self-hosted media management philosophy.

Choose PodFetch if: You want active development, a modern UI, and gPodder ecosystem integration. The ability to sync with mobile podcast apps like AntennaPod makes PodFetch the best choice for users who want the convenience of a familiar mobile app with the control of self-hosted storage. If you are already using Navidrome for music streaming, PodFetch complements it nicely as the podcast counterpart.

Choose Podsync if: Your primary content comes from YouTube or Vimeo creators rather than traditional podcast feeds. It is perfect for educational content, music channels, talk shows, and any video-first creator you want to listen to in a podcast app. The YouTube tools ecosystem is well-covered in our TubeArchivist vs Invidious vs Piped comparison, and Podsync fits alongside those as the podcast-bridge solution.

Deployment Tips

Reverse Proxy Setup

All three tools benefit from being behind a reverse proxy for TLS termination. Here is a basic Caddy configuration:

1
2
3
4

podcast.example.com {
    reverse_proxy localhost:8080
    encode gzip
}

Storage Planning

Podcast episodes are typically 30–100 MB each. A moderate library of 10 podcasts with 50 episodes each requires 15–50 GB of storage. Plan your volume mounts accordingly:

1
2
3
4
5

# Check current podcast storage usage
du -sh /path/to/podcast/data/

# Find largest episodes
find /path/to/podcast/data/ -type f -exec du -h {} + | sort -rh | head -20

Automatic Updates

Use Watchtower to keep containers updated automatically:

1
2
3
4
5
6

services:
  watchtower:
    image: containrrr/watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: --interval 86400 --cleanup podgrab podfetch podsync

This checks for new images daily and restarts containers when updates are available — essential for Podgrab users since the project recommends staying on the latest build.

FAQ

Can I run Podgrab, PodFetch, and Podsync on the same server?

Yes. All three tools are designed to run as separate Docker containers and use different default ports (Podgrab: 8080, PodFetch: 8000, Podsync: 8080). Just ensure Podsync or Podgrab uses a different port if they share the same host. Each tool stores data in its own volume, so there are no conflicts.

Does PodFetch work with AntennaPod on Android?

Yes. PodFetch implements the gPodder sync API, which AntennaPod supports natively. In AntennaPod, go to Settings → gPodder Sync and enter your PodFetch server URL. Your subscriptions, playback position, and episode status will sync bidirectionally.

Do I need a YouTube API key for Podsync?

Yes. Podsync requires a YouTube Data API v3 key to query channel and video metadata. You can get one free from the Google Cloud Console. The free tier allows 10,000 queries per day, which is sufficient for most personal setups. For heavy use, consider API key rotation — Podsync supports multiple keys that it rotates automatically.

Can Podsync convert any YouTube video to audio?

Podsync converts YouTube channels, playlists, and individual user uploads — not arbitrary single videos. You provide the channel or playlist URL, and Podsync creates a podcast feed that updates when new videos are published. The audio extraction is handled by yt-dlp and ffmpeg, producing mp3 files.

How much storage do I need for self-hosted podcasts?

It depends on your listening habits. A single podcast episode ranges from 30 MB to 150 MB. If you follow 15 podcasts that each publish 3 episodes per week and keep the last 10 episodes per show, you need approximately 15 × 10 × 60 MB ≈ 9 GB. Add a buffer for growth — 20 GB is a comfortable starting point.

Is it legal to download and store podcast episodes?

Podcasts distributed via RSS feeds are generally intended for download — that is how podcast apps work. Storing copies for personal use falls under the same category as caching done by any podcast client. For Podsync’s YouTube conversion, the legality depends on your jurisdiction and the content creator’s terms. Many creators explicitly allow personal offline use.

Can I access my self-hosted podcast tools from outside my home network?

Yes. Set up a reverse proxy (Caddy, Nginx, Traefik) with TLS, configure port forwarding on your router, or use a VPN/Tailscale for secure remote access. PodFetch’s gPodder sync is particularly useful for remote access since it lets your mobile app connect to your home server.