Pinchflat

Self-hosted YouTube downloading, honestly reviewed. For people who want their media server to include YouTube — without the YouTube UI.

TL;DR

• What it is: Self-hosted YouTube channel and playlist downloader built on yt-dlp, designed to feed Plex, Jellyfin, and Kodi [README].
• Who it’s for: Media center users who want to archive YouTube channels automatically, people who want offline access to content they care about, and homelab operators tired of fighting the YouTube algorithm for content they’ve already watched [1][5].
• Cost framing: Pinchflat doesn’t replace a SaaS subscription — it replaces manual yt-dlp scripts and duct-taped cron jobs. If you’re paying YouTube Premium mainly for ad-free playback, SponsorBlock integration here gets you there for free [README].
• Key strength: Single Docker container, no external dependencies. Compared to alternatives like TubeArchivist (which requires Elasticsearch and Redis), Pinchflat’s footprint is almost nothing [README].
• Key weakness: AGPL-3.0 license has implications if you redistribute. More importantly: it’s explicitly not a full media manager or in-app viewer — it downloads to disk and hands off to your existing media server. If you want YouTube-as-a-streaming-library, you’ll need Jellyfin or Plex alongside it [README][4].

---

What is Pinchflat

Pinchflat is a self-hosted app that subscribes to YouTube channels and playlists and downloads their content automatically to your local storage. The tagline is “your next YouTube media manager,” though “YouTube content pipeline” is more accurate — it has no video playback of its own. You point it at a channel URL, configure naming rules and filters, and it handles the rest: periodic checks, downloads, metadata, SponsorBlock tagging, and optional notifications when new content arrives [README].

The project is built on top of yt-dlp, which handles the actual downloading. What Pinchflat adds on top is the scheduling layer, the rule system, the web UI, and the media center integration story. It’s written in Elixir/Phoenix, uses SQLite, and ships as a single Docker container. As of this review it has 4,705 GitHub stars and 127 forks [merged profile].

What separates it from “just running yt-dlp in a cron job” is the UI-driven rule system, the novel approach to faster new-content detection (rather than re-scanning full channel histories), and first-class presets for outputting in formats that Plex, Jellyfin, and Kodi understand directly [README].

The project is run by a single maintainer (kieraneglin) with community contributions. The AGPL-3.0 license means it’s free to use and self-host, with no commercial license gating on features — the tradeoff being that if you modify and redistribute the software, you’re required to share source code [merged profile].

---

Why people choose it

The self-hosting wave described by Android Police in January 2026 is real and Pinchflat sits squarely in its path [1]. The motivating pattern is: you already run a media server, you have decades of YouTube subscriptions to channels you actually care about, and you’re tired of the algorithm deciding what you see and when. One homelab operator’s public infrastructure config lists Pinchflat alongside Plex, Sonarr, and Radarr under the Media section — treating it as a first-class component of a self-hosted media stack, on equal footing with tools people have used for years [5].

The XDA Developers article on watching YouTube in Jellyfin [4] chose TubeArchivist as its recommended approach — but that choice highlights exactly why Pinchflat exists. The author describes TubeArchivist as “an essential tool” but the setup requires both TubeArchivist and a separate Jellyfin plugin to bridge the two. Pinchflat’s pitch is: skip the bridge, skip Elasticsearch and Redis, download directly to a path your existing media center already watches.

The trade-off is capability depth. TubeArchivist has a full in-app viewing experience, detailed statistics, and a richer search interface [4]. Pinchflat doesn’t try to compete with that — it does one thing (download, organize, name correctly) and relies on your existing media setup for everything else.

---

Features

Core downloading:

• Automatic periodic checks for new content from subscribed channels and playlists [README]
• Novel detection approach designed to surface new uploads faster than full-channel rescan methods [README]
• Audio-only download support (useful for podcasts, music) [README]
• One-off video downloads supported, though not the primary use case [README]
• Custom rules for YouTube Shorts and livestreams — you can treat these differently from regular uploads [README]
• Cutoff dates so it doesn’t backfill an entire 10-year-old channel [README]
• Title-based filtering for cherry-picking from noisy channels [README]

Media center integration:

• Presets for Plex, Jellyfin, and Kodi naming conventions out of the box [README]
• Powerful naming system — full control over how downloaded content is organized on disk [README]
• SponsorBlock integration removes sponsor segments from downloads [README]

Content management:

• Automatic re-download of content after a set period — useful for refreshed SponsorBlock tags or higher-quality re-encodes [README]
• Optional automatic deletion of old content with configurable retention policies [README]
• Cookie passthrough so it can download your private playlists [README]

Notifications and automation:

• Apprise support for notifications (covers ntfy, Slack, Discord, email, and 50+ others) [README]
• RSS feed generation so you can subscribe to a channel’s downloads in any podcast app [README]
• Post-download and post-delete script hooks (currently alpha) [README]
• Advanced yt-dlp option passthrough for anything the UI doesn’t expose [README]

Deployment:

• Single Docker container, no external service dependencies [README]
• Available on Unraid Community Apps, Portainer, standard Docker, and Docker Compose [README]
• SQLite database (no Postgres required) [merged profile]
• Authentication via username/password with separate wiki documentation [README]

---

Pricing: SaaS vs self-hosted math

Pinchflat is free software. The cost equation here is different from automation tools with per-task pricing — there’s no SaaS version of Pinchflat to escape from.

The relevant comparison is what you’re currently doing to solve this problem:

YouTube Premium (US pricing): ~$13.99/mo. You’re partly paying for ad-free viewing and background play. Pinchflat with SponsorBlock removes sponsor segments from downloaded content. Offline playback in Plex or Jellyfin eliminates the need for background play entirely. If Premium was your ad-avoidance strategy, the math on a $6/mo VPS or spare hardware is clear [README].

Third-party archiving services: Some SaaS tools offer YouTube archiving at $10–30/mo. Data not available on specific competitors, but the existence of a free, self-hosted option changes the calculation entirely.

Self-hosted operating cost:

• Existing NAS or homelab server: $0 incremental cost [5]
• Dedicated VPS (Hetzner CX22 or equivalent): ~$5–6/mo
• Pinchflat software: $0

The storage cost is the honest variable: archiving an active YouTube channel in 1080p will eat disk space continuously. Budget for storage based on your channel list. That’s hardware cost, not software cost, and it exists regardless of whether you use Pinchflat or any competitor.

One thing worth noting: Pinchflat isn’t the cheapest operation — storing years of video takes real disk. The cost savings are in software and subscription fees, not storage hardware.

---

Deployment reality check

The single-container design is genuine. The Docker Compose file in the README is five lines of meaningful configuration: image, timezone, port, config volume, downloads volume. No Redis, no Postgres, no Elasticsearch [README].

version: '3'
services:
  pinchflat:
    image: ghcr.io/kieraneglin/pinchflat:latest
    environment:
      - TZ=America/New_York
    ports:
      - '8945:8945'
    volumes:
      - /host/path/to/config:/config
      - /host/path/to/downloads:/downloads

What you actually need:

• Docker installed (any Linux host, NAS, Unraid, or VPS)
• Two writable directories: config and downloads
• The download path accessible to your media server (shared volume or network share)

What can go sideways:

• The README includes an explicit note about storing config on a network file share: it’s preferred to use a local disk. This isn’t a minor caveat — SQLite on network storage can corrupt under certain conditions [README].
• Authentication is documented separately in the wiki, not inline. If you’re putting this behind a reverse proxy, read that page before you expose it to the internet [README].
• YouTube rate limiting and cookie handling require setup attention. For private playlists or high-volume archiving, cookie passthrough is required and adds a maintenance surface [README].
• The custom scripts feature is listed as “alpha” — if you’re building automation on top of it, expect the interface to change [README].
• The project has a “Pre-release disclaimer” section in its README table of contents. With 4,700 stars it’s clearly used in production by many, but the maintainer is being honest about maturity level. For mission-critical archiving, have a backup strategy [README].

Realistic setup time for someone who has run Docker before: 20–30 minutes including getting media visible in Jellyfin. For someone new to Docker: 2–3 hours including reading the docker-compose docs and wiki.

---

Pros and Cons

Pros

• Genuinely single-container. No dependency sprawl. The contrast with TubeArchivist (Elasticsearch + Redis + the app itself) is significant if you’re resource-constrained [README][4].
• Integrates with existing media servers rather than replacing them. If you already run Jellyfin or Plex, Pinchflat slots into your stack without requiring a new viewing interface [README][5].
• RSS feed output is an underrated feature. Subscribe to a downloaded channel in Overcast or Pocket Casts — it shows up like a podcast [README].
• SponsorBlock built in. Not a plugin, not a workaround — it’s in the feature list [README].
• Unraid native via Community Apps. For Unraid users this is a one-click install [README].
• Active development. 390 commits, consistent release history, Discord community [README].
• Novel fast detection. Claims to find new uploads faster than polling full channel histories — useful for channels you want to grab quickly [README].

Cons

• AGPL-3.0, not MIT. For personal self-hosting this doesn’t matter. If you’re building a product on top of it or offering it as a service, the copyleft terms apply [merged profile].
• Not a viewer. You need Plex, Jellyfin, Kodi, or at minimum a file browser to watch downloaded content. Pinchflat itself shows no video [README].
• Alpha feature surface. Post-download scripts are explicitly alpha. The “Pre-release disclaimer” in the README suggests the maintainer considers the project still maturing [README].
• Network share caution. SQLite + network storage = risk. This trips up NAS users who try to store config on their NAS share rather than locally [README].
• Single maintainer. Community contributions exist but the bus factor is real. Compared to TubeArchivist which has multiple active contributors, Pinchflat’s longevity depends more on one person [GitHub].
• yt-dlp dependency risk. Any YouTube archiving tool that wraps yt-dlp inherits yt-dlp’s cat-and-mouse with YouTube’s API changes. When YouTube changes something, yt-dlp breaks, Pinchflat breaks, and you wait for yt-dlp to catch up. This is not Pinchflat’s fault, but it’s the reality of the category.
• Storage is your problem. No built-in storage management beyond deletion policies. If you subscribe to 20 active channels, disk consumption becomes a real operational concern [README].

---

Who should use this / who shouldn’t

Use Pinchflat if:

• You already run Jellyfin, Plex, or Kodi and want YouTube channels in your library alongside your movies and TV shows.
• You follow specific YouTube channels and want to archive them regardless of whether YouTube keeps them up.
• You’re on Unraid and want a one-click install without dependency headaches.
• You want SponsorBlock applied to downloaded content without manual intervention.
• You listen to YouTube content as podcasts and want an RSS feed from channels you subscribe to.

Skip it (use TubeArchivist instead) if:

• You want a self-contained YouTube library with in-app viewing, rich search, and per-video statistics [4].
• You want channel analytics and watch history tracking inside the archive tool itself.
• You’re okay with the heavier infrastructure footprint (Elasticsearch, Redis) in exchange for a more complete feature set.

Skip it (use ytdl-sub instead) if:

• You prefer config-file-driven automation over a web UI.
• You need highly customized output formats and metadata manipulation that a UI would constrain.

Skip it (just run yt-dlp directly) if:

• You download videos occasionally, not on a schedule.
• You have one or two channels to watch and a cron job is genuinely sufficient.

Skip it entirely if:

• You don’t have a media server to send downloaded content to. Pinchflat doesn’t replace Plex — it feeds it.
• You need in-app playback as part of the same tool.

---

Alternatives worth considering

• TubeArchivist — the full-stack YouTube archive tool with its own viewer, search, and statistics. Heavier (Elasticsearch + Redis), more capable as a standalone system. The XDA Developers guide [4] covers the Jellyfin integration path.
• ytdl-sub — configuration-file-based YouTube downloading with powerful metadata customization. No web UI, steeper learning curve, more flexibility for complex naming schemes.
• TubeSync — older tool in the same category. Less actively developed than Pinchflat; mentioned in the Pinchflat README itself as an alternative to consider if Pinchflat doesn’t fit [README].
• yt-dlp directly — the underlying tool Pinchflat wraps. All the capability, none of the scheduling or UI. Right for power users, wrong for “set and forget” channel archiving.
• Jellyfin + tubearchivist-jf-plugin — the TubeArchivist + Jellyfin bridge approach documented by XDA [4]. More moving parts, richer viewing experience.

For a homelab operator who already has Jellyfin and wants YouTube channels without extra infrastructure: Pinchflat is the pragmatic choice. For someone who wants YouTube as a first-class streaming experience with its own interface: TubeArchivist.

---

Bottom line

Pinchflat does a narrow thing well. It subscribes to YouTube channels and playlists, downloads new content on a schedule, applies SponsorBlock, names files correctly for Plex and Jellyfin, and optionally serves RSS feeds. That’s the scope and it doesn’t pretend to be more. The single-container, no-external-dependencies design is a genuine differentiator in a category where TubeArchivist asks you to also run Elasticsearch and Redis. For a homelab already running a media server, adding Pinchflat is a 20-minute operation that turns YouTube subscriptions into first-class library entries. The caveats are real — single maintainer, alpha feature surface, yt-dlp dependency risk, SQLite-on-network-share trap — but none of them are dealbreakers for personal archiving. If you have Jellyfin and you’ve ever manually downloaded a YouTube video, Pinchflat is the obvious next step.

---

Sources

1. Dhruv Bhutani, Android Police — “Why I’m self-hosting my entire digital life in 2026” (Jan 28, 2026). https://www.androidpolice.com/why-im-self-hosting-my-entire-digital-life-in-2026/
2. Marius Hosting — Synology NAS self-hosting guides and community. https://mariushosting.com/page/78/
3. Marius Bogdan Lixandru, Marius Hosting — NAS self-hosting tutorials. https://mariushosting.com/author/marius/page/129/
4. Yash Patel, XDA Developers — “I finally found a way to watch YouTube on Jellyfin — and it’s incredibly easy” (Jul 23, 2025). https://www.xda-developers.com/free-plugin-to-watch-youtube-on-jellyfin/
5. Chase — “infrastructure: My homelab configuration” — lists Pinchflat as YouTube Archiver alongside Plex, Sonarr, Radarr. https://git.chse.sh/chase/infrastructure

Primary sources:

• GitHub repository and README: https://github.com/kieraneglin/pinchflat (4,705 stars, AGPL-3.0)
• Docker Hub mirror: https://hub.docker.com/r/keglin/pinchflat
• Project wiki: https://github.com/kieraneglin/pinchflat/wiki
• Discord community: https://discord.gg/j7T6dCuwU4