Why a self-hosted RSS reader in 2026
RSS — an open, decentralised, algorithm-free standard — is regaining ground. The HN State of Homelab 2026 report lists eight mentions of FreshRSS among the most deployed tools on personal VPS servers, a sign that the movement extends beyond historical enthusiasts.
Beyond cost, privacy is a strong argument: a self-hosted RSS reader shares no reading data with any third party. You control polling frequency, article storage and retention rules. On a standard VPS (2 vCPU, 2 GB RAM), you can follow hundreds of feeds without saturating resources — provided you pick the right tool.
What FreshRSS and Miniflux have in common
- OPML import/export — both tools read and write the standard OPML format, making migration reversible at any time
- Google Reader and Fever API compatibility — virtually all mobile clients (Reeder, NetNewsWire, FeedMe) connect without special configuration
- Official Docker deployment — a core-team maintained image with regular updates and versioned tags
- Multi-user — each instance can serve multiple accounts with independent subscriptions and preferences
- Configurable polling — refresh interval adjustable per feed or globally, with ETag and Last-Modified header support to limit bandwidth
- Free software — source code available, auditable, without telemetry or dependency on a proprietary external service
- Native HTTPS — both integrate behind a reverse proxy (nginx, Caddy, Traefik) to serve over HTTPS without additional configuration
FreshRSS vs Miniflux — technical comparison
| Criterion | FreshRSS | Miniflux |
|---|---|---|
| RAM footprint | ~50-80 MB (PHP-FPM + web server) | < 20 MB (static Go binary) |
| Licence | AGPL-3.0 | Apache-2.0 |
| Web interface | Rich, customisable, multiple themes | Minimalist, clean, keyboard-first |
| API | Google Reader + partial REST | Full REST + Fever + Google Reader |
| Extensions / plugins | Third-party PHP extensions available | No extensions — features built-in |
| External auth | HTTP Basic, OpenID Connect via plugin | HTTP Basic, proxy auth, built-in OAuth2 |
| Themes | Multiple built-in themes + community themes | One system theme (light/dark) |
| Database | SQLite, MySQL, PostgreSQL | PostgreSQL only |
FreshRSS — when the interface matters
FreshRSS is a PHP project started in 2012, hosted on GitHub under the AGPL-3.0 licence. With over 10,000 GitHub stars, it benefits from an active community producing extensions, themes and thorough documentation. It is the natural choice when the reading interface is central — for intensive daily use or for a deployment shared among users with different habits.
- PHP extensions — an extension ecosystem allows adding non-RSS sources (Twitter via Nitter, Reddit, YouTube), advanced filtering rules and integrations (Wallabag, Instapaper)
- Visual themes — several built-in themes (including dark mode) and community CSS themes installable in a few clicks from the administration interface
- Full Google Reader API — proven compatibility with the most popular mobile clients, without special configuration on the client side
- Bulk OPML import — import feed lists of thousands of entries with no declared limit, with duplicate detection
- Built-in reader mode — full article content extraction via the internal library, similar to a readability reader, with no external dependency
- Granular category management — hierarchical feed organisation with automatic marking rules and persistent per-category filters
- Database flexibility — SQLite for a zero-configuration start, PostgreSQL or MySQL for scaling with multiple active users
Install FreshRSS on a VPS with Docker
Prepare the data directory
Create a persistent directory for FreshRSS data:
Create the docker-compose.yml file
yaml
services:
freshrss:
image: freshrss/freshrss:latest
container_name: freshrss
restart: unless-stopped
ports:
- "8080:80"
volumes:
- /opt/freshrss/data:/var/www/FreshRSS/data
- /opt/freshrss/extensions:/var/www/FreshRSS/extensions
environment:
TZ: Europe/Paris
CRON_MIN: "*/15"
Start the container
Wait for the AH00558: apache2 line to confirm startup.
Complete the installation via browser
Open http://your-ip:8080 and follow the installation wizard: choose SQLite for a personal instance or PostgreSQL for multiple users. Create the administrator account.
Configure the nginx reverse proxy
Add a server block in your nginx configuration with proxy_pass http://127.0.0.1:8080; and the standard headers (X-Real-IP, X-Forwarded-For, X-Forwarded-Proto). Enable HTTPS with Let's Encrypt (Certbot or acme.sh).
Import your OPML feeds
In the interface, go to Settings > Subscription management > Import. Upload your .opml file — FreshRSS detects duplicates and imports existing categories.
Miniflux — when performance comes first
Miniflux is an RSS reader written in Go, distributed under the Apache-2.0 licence, designed from the ground up as a single binary with no dependencies — except PostgreSQL. Its memory consumption under normal load is under 20 MB according to the official miniflux.app documentation, making it the reference choice for low-RAM VPS instances or for those hosting many services in parallel. The interface is deliberately minimalist: no themes, no extensions — but complete keyboard navigation and a well-documented REST API.
- Static Go binary — no system dependencies (no PHP, no separate web server): a single executable is sufficient, simplifying updates and backups
- Under 20 MB RAM — measured memory footprint under normal load, ideal for 512 MB VPS or servers already hosting multiple services
- PostgreSQL exclusively — a single database engine to master, with versioned schema migrations applied automatically at startup
- Full REST API — OpenAPI documentation included, ideal for integrating Miniflux into automation workflows (n8n, Make, custom scripts)
- Keyboard navigation — vi-like shortcuts (j/k to navigate, v to open original) making reading fast without a mouse
- Native OAuth2 and proxy auth — direct integration with Authelia, Keycloak or any OpenID Connect provider without additional plugins
- Fever API support — compatibility with clients still using this protocol, in addition to the Google Reader API
Install Miniflux on a VPS with Docker
Prepare the PostgreSQL environment
Create a .env file with the connection variables:
Create the docker-compose.yml file
yaml
services:
db:
image: postgres:16-alpine
restart: unless-stopped
environment:
POSTGRES_USER: miniflux
POSTGRES_PASSWORD: changeme
POSTGRES_DB: miniflux
volumes:
- /opt/miniflux/postgres:/var/lib/postgresql/data
miniflux:
image: miniflux/miniflux:latest
restart: unless-stopped
depends_on:
- db
ports:
- "8080:8080"
environment:
DATABASE_URL: postgres://miniflux:changeme@db/miniflux?sslmode=disable
RUN_MIGRATIONS: "1"
CREATE_ADMIN: "1"
ADMIN_USERNAME: admin
ADMIN_PASSWORD: changeme
Apply schema migrations on first start
The RUN_MIGRATIONS=1 variable automatically triggers PostgreSQL migrations at startup. Miniflux refuses to start if the database is in an inconsistent state — this behaviour protects against partial updates.
Verify the service responds
The expected response is 200. Miniflux exposes this endpoint without authentication for your orchestrator's health checks.
Configure the reverse proxy
Miniflux includes its own HTTP server — simply proxy port 8080. Example nginx:
Import your OPML subscriptions
In Settings > Import, upload your OPML file. OPML categories are converted to Miniflux groups. After import, trigger a manual refresh (Settings > Refresh all feeds) to populate the database immediately.
How to choose between FreshRSS and Miniflux
The deciding factor is rarely the feature list — it is the usage philosophy. Here is a quick decision grid.
- Choose FreshRSS if you value a comfortable reading interface with themes, need extensions to ingest non-RSS sources, or multiple users with different habits share the instance
- Choose Miniflux if your VPS has under 1 GB RAM, you already host many services and every megabyte counts, or you prefer a distraction-free keyboard-oriented interface
- You use SQLite (lightweight database, no PostgreSQL on your VPS): FreshRSS is the only viable choice of the two — Miniflux requires PostgreSQL
- You need native OAuth2 without third-party plugins: Miniflux includes this feature out of the box, where FreshRSS requires additional configuration
- You plan heavy automation (webhooks, n8n integration, processing scripts): Miniflux's documented REST API is more complete and stable than FreshRSS's
- You come from Feedly or Inoreader and want a similar experience: FreshRSS, with its themes and reader mode, will reduce the learning curve
Mobile client compatibility: FreshRSS exposes a Fever API (compatible with Reeder, Unread, NetNewsWire) and a Google Reader API (for Capy, FeedMe, ReadKit). Miniflux implements the Fever API and its own REST/GraphQL endpoint. Both work with most popular mobile RSS clients.
Conclusion: choose based on your profile
Choose FreshRSS if you need a versatile reader used by multiple people with different interface preferences, and you want maximum compatibility with third-party extensions and clients. Choose Miniflux if you prioritise performance, low resource footprint and a modern REST API you can use in your own scripts or integrations. Both can be installed in 15 minutes on a 1 GB RAM VPS.
Our Cloud VPS plans include pre-configured images for self-hosting, daily snapshots and secure SSH access. For more, see our guide on backing up your FreshRSS instance with Restic, and our self-hosted password manager comparison to complete your sovereign stack.
