Podsync

Self-hosted feed conversion, honestly reviewed. No marketing fluff, just what you get when you run it yourself.

TL;DR

• What it is: Open-source (MIT) tool that converts YouTube channels, playlists, and Vimeo content into standard RSS podcast feeds you can subscribe to in any podcast client [README].
• Who it’s for: People who want to consume YouTube content in podcast apps — commuters, gym-goers, anyone who wants background play, auto-downloads, position sync, and offline listening without paying YouTube Premium [README].
• Cost savings: YouTube Premium runs ~$13.99/mo for background play and offline downloads. Podsync self-hosted runs on a $5–10/mo VPS with unlimited feeds and no per-download fees [README].
• Key strength: Does one thing and does it well — converts any YouTube channel, playlist, or user into a podcast feed your existing app already knows how to handle. Supports audio-only extraction via mp3 encoding, which is the whole point for most users [README].
• Key weakness: Requires a YouTube Data API key (with quota limits), depends on yt-dlp staying compatible with YouTube’s constantly changing anti-scraping measures, and the project — while functional — has 1,866 stars and a solo maintainer rather than a funded team behind it [README][GitHub].

---

What is Podsync

Podsync is a small Go server you run on your own infrastructure. Point it at a YouTube channel URL, a playlist, or a Vimeo user — and it generates a standard podcast RSS feed. You paste that feed URL into Apple Podcasts, Pocket Casts, AntennaPod, Overcast, or any other podcast client, and from that point on your podcast app handles everything: automatic episode downloads, playback position sync across devices, offline listening, background audio while your phone is locked [README].

The pitch is simple and it’s not trying to be more than it is. YouTube doesn’t have background play without Premium. It doesn’t remember where you stopped watching on a different device. It doesn’t auto-download episodes for offline use. Podcast apps, on the other hand, have been doing all of that for over a decade [README][3]. Podsync is just the translation layer between those two worlds.

The project lives at github.com/mxpv/podsync, has been around since at least 2019 based on commit history, and as of this review sits at 1,866 stars and 303 forks. It’s written in Go, MIT-licensed, and maintained by a single developer (mxpv) with community contributions. The GitHub repository includes a CLAUDE.md file — a sign the maintainer uses AI tooling — and nightly builds push from main every midnight, which suggests the project is actively developed even if quietly [README][GitHub].

---

Why people choose it

Podsync doesn’t have a large body of third-party reviews the way tools like n8n or Nextcloud do. What it has is a consistent use case that people in the self-hosted community keep rediscovering.

The YouTube problem. Podcast apps were designed around RSS — open, decentralized, works with any app. YouTube is the opposite: a walled garden where content is tied to their player, their algorithm, and their subscription model. If you want to consume a lecture series, an educational channel, or a creator who releases long-form content you’d rather listen to than watch, YouTube gives you no good option without Premium [3]. Podsync converts any channel or playlist into something your existing podcast infrastructure already handles.

Audio extraction is the real use case. The mp3 encoding feature isn’t an afterthought — it’s the primary reason most people run this. A 45-minute YouTube video converted to an audio-only podcast episode uses a fraction of the bandwidth, plays in the background on iOS without workarounds, and integrates with your existing listening queue. People don’t want to watch a two-hour interview; they want to listen to it on a run [README][3].

The self-hosted podcast ecosystem context. The r/selfhosted community has produced multiple full-featured podcast managers — tools like Pinepods that replicate an entire Spotify-style experience with multi-user support, chapter markers, and cross-device sync [2]. Podsync is not trying to compete in that category. It’s infrastructure: a feed generator that slots cleanly into whatever podcast app or manager you already use. Where Pinepods is the house, Podsync is a water pipe fitting.

Alternatives in the same niche are mostly closed SaaS. AlternativeTo lists several competitors: vod2pod-rss (MIT, no storage needed, transcodes on the fly), YouCast (GPL-2.0, Windows-only), Castify (proprietary desktop app), and PODTUBE.ME (freemium web service) [5]. The common thread is that the free open-source options are sparse, and the managed services either have usage limits, are proprietary, or depend on someone else’s server staying up. Podsync running on your own VPS means no rate limits beyond your own YouTube API quota and no service disappearing because a solo developer shut down their Heroku dyno [README][5].

---

Features

Based directly on the README and config documentation:

Core feed generation:

• YouTube channels, playlists, and user pages → RSS [README]
• Vimeo channels and users → RSS [README]
• SoundCloud and Twitch support via API key configuration [README]
• Video or audio mode per feed — audio extracts mp3, video downloads the actual file [README]
• Configurable quality: max video height, high/low quality presets [README]
• mp3 encoding via ffmpeg [README]

Feed management:

• Cron expression scheduling per feed — update hourly, daily, or on a custom schedule [README]
• Episode filtering by title match or duration [README]
• Episode cleanup: keep only the last N episodes, saving disk space [README]
• Custom feed metadata: artwork, category, language [README]
• OPML export for importing your feed list into other apps [README]
• Configurable hooks for custom integrations (e.g., notify a webhook when a new episode downloads) [README]

Infrastructure:

• Docker and docker-compose deployment [README]
• Binary builds for Windows, macOS, Linux — including ARM [README]
• Homebrew install on Mac [README]
• One-click AWS deployment via CloudFormation [README]
• Automatic yt-dlp self-update — yt-dlp breaks frequently due to YouTube countermeasures; auto-update reduces maintenance burden [README]
• API key rotation: supply multiple YouTube/Vimeo keys space-separated and Podsync rotates them to stay under quota limits [README]
• Reverse proxy support via hostname config field [README]
• REST API for programmatic feed management [README]

Configuration approach: Everything lives in a TOML config file. The minimal setup is about 8 lines. The full config supports per-feed overrides for quality, format, episode count, filters, and scheduling. Environment variables override config file values, which makes Docker secrets and container orchestration straightforward [README].

---

Pricing: SaaS vs self-hosted math

Podsync has no cloud SaaS tier. It’s self-hosted software only, MIT licensed, no paid plans [README].

The cost comparison is against what you’d pay to get the same functionality through official channels:

YouTube Premium: $13.99/mo (individual) for background play, offline downloads, and no ads. If your primary use case is listening to YouTube channels while commuting, that’s the incumbent solution. Over a year: ~$168.

Self-hosted Podsync:

• Software: $0
• VPS (Hetzner CX11 or similar): ~$4–6/mo
• Your time: 1–2 hours initial setup

Over a year: ~$48–72 in hosting. Plus you keep using your preferred podcast app rather than being forced into YouTube’s player.

The math gets more interesting if you subscribe to multiple podcast platforms. If you already pay for a podcast app (Pocket Casts is $3.99/mo, for example) and want to fold YouTube channels into the same app rather than also paying for YouTube Premium, Podsync makes the consolidation possible.

vod2pod-rss (the main open-source competitor) [5] takes a different architectural approach: it transcodes audio on the fly without storing files on your server, which reduces storage costs but increases CPU load per playback. Podsync downloads and stores files, which costs more disk but means playback doesn’t depend on your server being responsive in real time. Neither is strictly better — it depends on your server size and how many simultaneous listeners you expect.

---

Deployment reality check

Podsync is genuinely straightforward to deploy compared to most self-hosted tools, with one exception: the YouTube API key requirement adds an out-of-band step that trips up new users.

What you need:

• Docker (recommended) or Go build environment if running as binary
• yt-dlp and ffmpeg (bundled in the Docker image; manual install if running as binary)
• A YouTube Data API v3 key (free, but requires a Google Cloud account and the API enabled)
• A domain and reverse proxy if you want HTTPS and external access
• Disk space proportional to how many feeds you run and how many episodes you keep

Getting the YouTube API key is the friction point. You need to create a Google Cloud project, enable the YouTube Data API v3, generate credentials, and stay under the free quota (10,000 units/day). A channel with frequent updates can consume quota faster than expected, which is why the API key rotation feature exists — you can add multiple keys from different Google accounts and Podsync cycles through them [README].

The yt-dlp dependency is a double-edged sword. yt-dlp is the best YouTube downloader available and is actively maintained, but YouTube regularly changes their internal APIs to break scrapers. Podsync’s automatic yt-dlp self-update feature mitigates this, but there will be periods — sometimes days — where downloads fail until a yt-dlp update catches up. This is not a Podsync problem specifically; it’s the nature of any tool that depends on unofficial YouTube access [README].

Storage sizing: if you’re running 10 feeds keeping the last 20 episodes each, and each audio episode is ~50MB, you’re looking at ~10GB of storage as a steady state. Tune the max_episodes config per feed to control this.

Realistic setup time: 30–60 minutes for someone comfortable with Docker and DNS. The docker-compose file in the repository is a working starting point. The YouTube API key setup adds ~20 minutes if you haven’t done it before.

---

Pros and Cons

Pros

• MIT licensed, no strings. Self-host, fork, embed, use commercially — no licensing agreement required [README].
• Does one thing well. Feed conversion is the entire feature set. There’s no scope creep, no feature bloat, no premium tier trying to upsell you on features you don’t need [README].
• Audio-only extraction. The mp3 mode is the killer feature for most users — consume video content through a podcast app without the video overhead [README].
• Automatic yt-dlp updates. The most common failure mode (YouTube breaking yt-dlp) is handled automatically [README].
• API key rotation. Running multiple feeds across multiple channels can hit quota limits; key rotation is a practical solution that most similar tools don’t offer [README].
• ARM support. Runs on a Raspberry Pi or ARM VPS without recompilation — useful for homelabbers who want to host on cheap ARM hardware [README].
• OPML export. Your feed list is portable; you can move between podcast apps or share your subscription list [README].
• Configurable hooks. If you want to trigger a notification, a script, or a webhook when a new episode arrives, the hook system handles it without third-party integrations [README].
• Actively maintained nightly builds. Daily builds from main signal ongoing development even if releases are infrequent [README].

Cons

• Requires a YouTube API key. This is a non-trivial setup step compared to “just run Docker.” New users regularly hit this as the first friction point, and the quota limits mean heavy usage requires managing multiple keys [README].
• yt-dlp dependency. When YouTube breaks yt-dlp (and it will), your feeds stop updating until yt-dlp releases a fix. This can be days. Auto-update helps but doesn’t eliminate the window [README].
• Solo maintainer. 1,866 stars and 303 forks is a healthy project, but it’s one person’s side project, not a funded company. There’s no SLA, no dedicated support, and no guarantee of continued development [GitHub].
• Disk storage required. Unlike vod2pod-rss which transcodes on the fly, Podsync stores downloaded files. On a small VPS, you’ll need to manage max_episodes actively or watch your disk fill up [README][5].
• No web UI. Configuration is entirely file-based (TOML). There’s no browser interface for managing feeds, checking status, or adding new channels without editing a config file and restarting the service [README].
• YouTube quota anxiety. The free YouTube Data API quota is 10,000 units/day. A large number of feeds updating frequently can exhaust this. The key rotation feature is a workaround, not a solution [README].
• No multi-user support. The feed URLs are just HTTP endpoints — anyone with the URL can subscribe. There’s no authentication layer, user management, or access control built in [README].

---

Who should use this / who shouldn’t

Use Podsync if:

• You listen to YouTube channels regularly and want to do it through a podcast app (background play, offline, position sync) without paying for YouTube Premium.
• You’re comfortable editing a TOML config file and running Docker.
• You want an MIT-licensed, no-cloud-dependency tool you can run on a $5 VPS indefinitely.
• You need audio extraction — you want to listen to content, not watch it.
• You’re aggregating educational channels, interview series, or lecture content that you’d rather queue up in Overcast or Pocket Casts alongside your actual podcasts.

Skip it (use vod2pod-rss instead) if:

• You don’t want to manage disk storage — vod2pod-rss transcodes on the fly without storing files [5].
• You have a small VPS with limited disk and many feeds.
• You’re fine with slightly higher CPU load in exchange for zero storage overhead.

Skip it (use a managed service) if:

• You’re not comfortable with a Google Cloud console, API keys, and Docker.
• The YouTube API quota system sounds like something you don’t want to think about.
• Services like PODTUBE.ME or Castify would cover your use case without server management [5].

Skip it entirely if:

• Your goal is listening to mainstream podcasts — this tool is specifically for converting YouTube/Vimeo content. For regular podcasts, just use a podcast app directly.
• You need multi-user support, a web UI, or anything beyond basic feed generation.

---

Alternatives worth considering

From the AlternativeTo alternatives list and the self-hosted podcast ecosystem:

• vod2pod-rss (MIT, self-hosted) — closest alternative. Converts YouTube and Twitch channels to podcast RSS without storing files. Transcodes on the fly, which means no disk usage but more CPU and latency per playback request [5].
• YouCast (GPL-2.0) — Windows-only, older project, limited platforms [5].
• Castify (proprietary, free) — desktop app for Windows/Mac/Linux. Uploads to cloud, generates a feed. No self-hosting, no control over the pipeline [5].
• PODTUBE.ME (freemium, managed) — web service, no self-hosting. Works, but you depend on their infrastructure [5].
• Pinepods — a full self-hosted podcast manager with multi-user support, cross-device sync, chapter support, and RSS feed hosting. If you want a complete Spotify-replacement for podcasts and want to fold in YouTube content, Pinepods is the fuller solution. Podsync is just one component you’d add to it [2].
• TubeArchivist — if archiving is your goal rather than listening, TubeArchivist is the more complete YouTube archival tool with a proper web UI and media server integration. Not a podcast feed generator, but often the right tool when people think they want Podsync but actually want a local YouTube archive.

---

Bottom line

Podsync is a narrow tool that solves a specific problem well: you want to listen to YouTube channels in your podcast app, and you don’t want to pay for YouTube Premium or trust a third-party service to stay up. The setup takes an afternoon, requires a YouTube API key from Google Cloud, and produces unlimited podcast feeds you control entirely. The tradeoffs are real — a solo maintainer, yt-dlp fragility when YouTube changes its APIs, no web UI, disk storage requirements — but for the target use case (convert YouTube content into something your podcast app can handle), nothing in the self-hosted space matches it for simplicity and license freedom.

If the YouTube API key setup and Docker configuration are the blocking friction, that’s the kind of one-time deployment work that upready.dev handles for clients.

---

Sources

1. Ethan Sholly, selfh.st — “This Week in Self-Hosted (24 May 2024)” — context on self-hosted software landscape. https://selfh.st/weekly/2024-05-24/
2. r/selfhosted — itsmecollinp — “Pinepods 0.7.2 - The rust based self-hosted podcast platform” — context on self-hosted podcast ecosystem and competing tools. https://www.reddit.com/r/selfhosted/comments/1hkugvo/pinepods_072_the_rust_based_selfhosted_podcast/
3. AntennaPod Forum — cburton — “Video Playback Behavior” — context on podcast app behavior with video content and why users want audio-only listening. https://forum.antennapod.org/t/video-playback-behavior/2176
4. AlternativeTo — “podsync Alternatives” — alternatives list including vod2pod-rss, YouCast, Castify, PODTUBE.ME. https://alternativeto.net/software/podsync/

Primary sources:

• GitHub repository and README: https://github.com/mxpv/podsync (1,866 stars, MIT license)
• Config example: https://github.com/mxpv/podsync/blob/main/config.toml.example