The Best Self-Hosted RSS Readers in 2026: FreshRSS, Miniflux, Tiny Tiny RSS, CommaFeed and Yarr
Nate Holbrook
November 16, 2026
You follow a few dozen blogs, changelogs, newsletters and news sites through RSS, and you want the subscription list, read state and starred items to live on a server you control instead of a hosted service that might change its pricing or disappear. You also want to keep reading on your phone with a good native app. That second requirement narrows the field more than the first, because a self-hosted RSS reader is only as pleasant as the apps that can sync with it.
This roundup covers the five self-hosted readers worth considering in 2026: FreshRSS, Miniflux, Tiny Tiny RSS, CommaFeed and Yarr. For each one you get the stack, how heavy it is to run, which sync APIs it speaks and therefore which mobile apps work, whether it can fetch full article text from truncated feeds, and whether it handles more than one user. The last section makes a specific recommendation for several kinds of reader. If you are still weighing whether RSS is worth the setup at all, our piece on the case for using RSS in 2026 covers the why.
Why the sync API decides which phone apps you can use
Most good mobile RSS apps do not talk to a self-hosted server directly. They speak one of a few protocols, and the server has to speak the same one:
- Google Reader API: the most capable of the common options, supporting folders, read and starred state and incremental sync. Many apps label it “FreshRSS” or “Google Reader compatible”.
- Fever API: older and simpler, with limited folder handling and an MD5-based login scheme. It is widely supported but should be a fallback.
- Project-specific APIs: Miniflux and Tiny Tiny RSS each have their own API, used by apps written specifically for them.
Apple-side readers worth knowing: NetNewsWire (free, open source) syncs with self-hosted servers through its FreshRSS account type, which uses the Google Reader API. Reeder Classic supports FreshRSS and Miniflux among its services; the newer Reeder app syncs through iCloud only and does not connect to self-hosted servers. Unread and Fiery Feeds use Fever with FreshRSS. On Android, Read You (GPL, free) lists Fever, Google Reader, FreshRSS, Miniflux and Tiny Tiny RSS integrations, Capy Reader supports FreshRSS and Miniflux, and FeedMe (proprietary, free with a paid tier) supports FreshRSS, Miniflux, Tiny Tiny RSS and Fever servers. Desktop clients such as Fluent Reader, RSS Guard and NewsFlash cover the same ground on computers.
| Reader | Stack | License | Sync APIs | Multi-user |
|---|---|---|---|---|
| FreshRSS | PHP; SQLite, PostgreSQL, MySQL or MariaDB | AGPL-3.0 | Google Reader, Fever | Yes |
| Miniflux | Go; PostgreSQL only | Apache-2.0 | Google Reader, Fever, Miniflux REST | Yes |
| Tiny Tiny RSS | PHP; PostgreSQL | GPL-3.0 | Own JSON API; Fever and Google Reader via third-party plugins | Yes |
| CommaFeed | Java (Quarkus); H2, PostgreSQL, MySQL or MariaDB | Apache-2.0 | Google Reader, Fever, REST | Yes |
| Yarr | Go; SQLite (PostgreSQL also listed) | MIT | Fever | No, single account |
FreshRSS: the widest app support and the most knobs
FreshRSS is a PHP application released under the AGPL v3. It needs PHP 8.2 or newer and works with SQLite, PostgreSQL, MySQL or MariaDB, so it fits on shared hosting as well as in Docker, where the official image is freshrss/freshrss. With SQLite it is a single container and a data volume; it runs comfortably on modest hardware, though PHP plus a large article history uses more memory than the Go options below.
Its main strength is compatibility. It implements both the Google Reader API, which the project itself recommends, and the Fever API, and its README lists a long set of tested clients: Read You, Capy Reader and Readrops on Android; FeedFlow across platforms; Fluent Reader and RSS Guard on desktop; Reeder Classic and ReadKit on Apple devices; and Unread and Fiery Feeds over Fever. API access has to be enabled by the admin, and each user sets a separate API password in their profile, which trips up many first setups.
For truncated feeds, FreshRSS can fetch the original page per feed and extract the article with a CSS selector you supply, and it can build feeds from sites that have none using XPath-based scraping, plus JSON sources. It supports multiple users, an optional anonymous public reading mode, a system of extensions, and filters that mark articles read or apply labels automatically. The trade-off is an interface with many settings; it is powerful rather than minimal.

Miniflux: fast, opinionated and built around PostgreSQL
Miniflux is written in Go and ships as a single statically compiled binary, published under the Apache 2.0 license. The one hard requirement is PostgreSQL, which it also uses for full-text search. In Docker that means two containers, the miniflux/miniflux image plus Postgres, and images are published for ARM as well as x86. It is one of the lightest options to run day to day, and the interface is deliberately minimal and keyboard-friendly.
Miniflux exposes the Fever and Google Reader APIs plus its own REST API with Go and Python client libraries. The Google Reader API is off by default and enabled per user under the integrations settings; once on, NetNewsWire connects through its FreshRSS account type, Read You through Google Reader, and apps such as FluxNews, Lire and PoweReader use the native Miniflux API. Reeder Classic, FeedMe and Capy Reader also list Miniflux support.
Full-text handling is a strong point. Miniflux can fetch the original article and extract the main content with a built-in Readability parser, either on demand or automatically for a feed, and you can write custom scraper rules with CSS selectors and rewrite rules for difficult sites. It supports multiple users with local accounts, passkeys, OpenID Connect or reverse-proxy authentication, and it has more than 25 integrations, including sending articles to Wallabag, Pinboard or a webhook. If you want items forwarded into wider automations, compare that built-in webhook with a dedicated tool from our Huginn vs n8n for RSS-to-webhook comparison.
The opinionated side: Miniflux intentionally leaves out features its author considers bloat, and the PostgreSQL requirement is not negotiable. If you already run Postgres for other services, that is a non-issue.
Tiny Tiny RSS after the 2025 handover
Tiny Tiny RSS is the veteran of the group, a PHP application licensed under the GPL v3. Its project status changed in late 2025: the original author announced in October that the tt-rss.org infrastructure (the Git hosting, forum and site) would be taken down on November 1, 2025. A long-time contributor had already forked the code, and development now continues on GitHub at tt-rss/tt-rss, with documentation rebuilt in a separate repository and plugins mirrored to their own repos. The fork describes its main branch as stable and says no major breaking changes are planned.
Installation is Docker-first. The fork publishes images for amd64 and arm64 to the GitHub Container Registry as ghcr.io/tt-rss/tt-rss and ghcr.io/tt-rss/tt-rss-web-nginx, with Docker Hub mirrors, and it runs with PostgreSQL. That makes it a multi-container stack: the app, a web container, and a database.
Tiny Tiny RSS is multi-user and highly extensible through plugins, including a Readability-based plugin for fetching full article content and filters with rich matching rules. Its own JSON API is what dedicated clients use; FeedMe on Android supports it directly. The official Android app was not continued after the infrastructure shutdown, though a community fork has kept releasing builds. Fever and Google Reader compatibility come only from third-party plugins, and the project itself warns that third-party plugins may be unmaintained. Unless you depend on its filters or plugins, the app-support story is weaker than FreshRSS or Miniflux.
CommaFeed: Google Reader-style reading on the JVM
CommaFeed is a Java server built on Quarkus with a React frontend, licensed under Apache 2.0. Its interface is modeled on the old Google Reader, which suits people who liked that layout. It runs with no configuration on its embedded H2 database, and it also supports PostgreSQL, MySQL and MariaDB. Docker images are published as athou/commafeed.
Resource use depends on the package. The JVM build is, in the project’s own words, greedy with memory by default, while the native-compiled build starts faster and uses less memory; the README recommends the native package for that reason. Both are still heavier than a Go binary, but the native build makes CommaFeed reasonable on a small server.
It exposes a REST API plus Fever and Google Reader APIs for native mobile apps, so the same Android and Apple clients that work with Google Reader-compatible servers should connect. It is built for multiple users. Full-text fetching of truncated feeds is not among its documented features, so if many of your feeds only publish summaries, FreshRSS or Miniflux handles them better.

Yarr: one binary, one reader, no database server
Yarr, short for “yet another RSS reader”, is a Go application under the MIT license that runs either as a desktop app on Windows, macOS and Linux or as a self-hosted web server. It is a single binary with an embedded SQLite database by default, and the project’s documentation also lists PostgreSQL and a Docker install. Nothing else needs to run alongside it, which makes it the lightest option here.
It has a built-in Readability engine for reading full articles inside the app and full-text search across everything stored. For mobile, it offers a Fever-compatible API, so Fever clients such as Read You or FeedMe can sync with it. It is designed for one person: you protect it with a single username and password set at startup, and there are no user accounts to manage. Check yarr -h on your install for the current authentication and TLS flags.
The limits follow from that design. There is no Google Reader API, so apps that only speak Google Reader, such as NetNewsWire, cannot sync with it, and there is no multi-user mode, plugin system or rule engine. For a personal reader on a small VPS or a home server, those absences are the point.
FreshRSS for most readers, Miniflux for truncated feeds, Yarr for one person
You read mostly on an iPhone or Mac with NetNewsWire or Reeder Classic: run FreshRSS. Its Google Reader API is the one those apps are built and tested against, and it gives you the most client choices if you switch apps later. Miniflux also works through NetNewsWire’s FreshRSS account type, but FreshRSS is the path of least surprise.
You read on Android, care about speed and many of your feeds are truncated: run Miniflux with Read You or Capy Reader. Its original-content fetching and scraper rules handle summary-only feeds better than anything else here, and the single Go binary plus Postgres needs very little attention.
You run a household or small team server with several readers: run FreshRSS if people want different apps and you would rather use SQLite or MySQL, or Miniflux if you already operate PostgreSQL and prefer fewer settings. Both handle multiple users and both speak the APIs every common client uses.
You want the smallest possible footprint for one person: run Yarr. A single binary with SQLite is about as low-maintenance as self-hosting gets, and a Fever client covers mobile. Move to Miniflux the day you need Google Reader sync or full-text rules.
You liked the old Google Reader interface and read mainly in the browser: run CommaFeed, using the native build to keep memory down.
You already run Tiny Tiny RSS with filters and plugins you rely on: move to the tt-rss/tt-rss fork images and keep going; it is maintained. For a new install, though, FreshRSS gives you similar depth with broader app support and a less uncertain recent history.
If this is your first home server and you are deciding what else belongs on it, an RSS reader pairs well with the other week-one services in our list of self-hosted apps for a first home server. Whichever reader you choose, export your subscriptions as OPML once it is set up; every option here imports and exports OPML, and that file is what keeps you free to switch later.