---
title: "Deploy Miniflux"
description: "Feedly alternative. Minimalist self-hosted RSS/Atom feed reader"
category: "Other"
url: https://railway.com/deploy/miniflux-railway
---

# Deploy Miniflux

Feedly alternative. Minimalist self-hosted RSS/Atom feed reader

**[Deploy Miniflux on Railway](https://railway.com/template/miniflux-railway)**

- **Creator:** A3A
- **Category:** Other
- **Total deploys:** 3

## Template content

### miniflux-scheduler https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons/svg/miniflux.svg

- **Image:** miniflux/miniflux:latest
- **Start command:** `/bin/sh -c 'for i in $(seq 1 60); do /usr/bin/miniflux -migrate && exec /usr/bin/miniflux; echo "waiting for database ($i/60)"; sleep 5; done; echo "database never became ready"; exit 1'`
- **Health check:** /healthcheck

### miniflux https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons/svg/miniflux.svg

- **Image:** miniflux/miniflux:latest
- **Start command:** `/bin/sh -c 'for i in $(seq 1 60); do /usr/bin/miniflux -migrate && exec /usr/bin/miniflux; echo "waiting for database ($i/60)"; sleep 5; done; echo "database never became ready"; exit 1'`
- **Health check:** /healthcheck
- **Public domain:** Yes

### Postgres https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons/svg/postgresql.svg

- **Image:** ghcr.io/railwayapp-templates/postgres-ssl:18

## Documentation

# Deploy and Host Miniflux on Railway

Miniflux is a minimalist, opinionated feed reader written in Go: subscribe to RSS, Atom, JSON Feed or RDF sources and get a fast, distraction-free reading list with keyboard shortcuts, full-text search, article scraping, filter rules and a tracker-stripping media proxy. It is what you reach for when Feedly or Inoreader feel heavy, ad-supported or too interested in what you read — everything lives in your own PostgreSQL database.

Deploy Miniflux on Railway in the production shape rather than the demo shape. The template runs three services: a **Miniflux web service** on a public HTTPS domain serving the UI, the REST API and the Fever and Google Reader compatible APIs; a private **Miniflux scheduler service** from the same image, owning background feed polling, the worker pool and the nightly cleanup job; and a managed **PostgreSQL 18** database holding feeds, entries, sessions and settings. Splitting the background tier out lets you scale the web tier without every replica polling the same feeds twice, and the first administrator is created on boot from the username and password you supply.

![Miniflux Railway architecture](https://res.cloudinary.com/rroe4rtk/image/upload/v1786978893/2485256a-3db1-4930-add6-9f759650c7b9.png)

## Getting Started with Miniflux on Railway

Deploy the template, set `ADMIN_USERNAME` and `ADMIN_PASSWORD`, and wait for the three services to go green. Open the public URL of the `miniflux` service and sign in — there is no registration form, so this is the only account until you add more under **Settings → Users**. Click **Feeds (+)** and paste a feed or site URL (`https://go.dev/blog` finds the feed itself), or **Import** an OPML file from Feedly. The first fetch is immediate: entries appear under **Unread**, where you read an article inline, press `s` to star it or `m` to toggle read state. Later refreshes come from the scheduler service — watch "Last check" advance on the **Feeds** page on its own. **Settings → Integrations** wires up Wallabag, Readeck, Telegram and webhooks; **API Keys** issues tokens for clients such as Reeder or NetNewsWire.

![Miniflux unread list showing Go Blog articles](https://res.cloudinary.com/rroe4rtk/image/upload/v1786950848/miniflux-unread-entries.png)
![Miniflux article view of a starred Go Blog post](https://res.cloudinary.com/rroe4rtk/image/upload/v1786950849/miniflux-article-reader.png)
![Miniflux feeds page listing three subscribed feeds](https://res.cloudinary.com/rroe4rtk/image/upload/v1786950853/miniflux-feed-list.png)

## About Hosting Miniflux

Miniflux solves one problem well: following hundreds of sources without handing your reading history to an ad network. Self-host it when you want subscriptions and read state to outlive any vendor.

- Fetches full article content from truncated feeds using per-feed scraper rules
- Blocklist, keeplist and rewrite rules that filter entries on arrival
- PostgreSQL-backed full-text search, plus Fever and Google Reader API compatibility
- Media proxy that strips referrers and trackers from images
- Passkeys/WebAuthn, OIDC single sign-on and API keys beside password login

The two Miniflux services are one image in different roles: the web service answers requests, while the scheduler picks feeds whose next check has expired, hands them to its worker pool and archives old entries daily. Both reach PostgreSQL over the private network.

## Why Deploy Miniflux on Railway

Railway removes the parts of self-hosting that are not about reading feeds:

- One-click deploy with database, scheduler and web tier already wired together
- Managed PostgreSQL with backups — no volume or `initdb` management
- Free HTTPS on a generated domain, plus custom domains when you want one
- Private networking between app, scheduler and database out of the box
- Health checks and restart policies preconfigured on both services

## Common Use Cases for Self-Hosted Miniflux

- A personal news hub syncing read state across desktop and phone over the Google Reader API
- A team watchlist of release feeds, changelogs and security advisories
- Filtered feeds that drop noise with blocklist rules and push the rest to a webhook

## Dependencies for Miniflux

- **Miniflux** — `miniflux/miniflux:latest` (Alpine, Apache 2.0), deployed twice: public web service and private scheduler
- **PostgreSQL 18** — Railway's managed database holding feeds, entries, users, sessions and settings. Miniflux keeps nothing on disk, so no volume is needed

### Environment Variables Reference

| Variable | Description | Required |
|---|---|---|
| `DATABASE_URL` | PostgreSQL connection string, wired to `${{Postgres.DATABASE_URL}}` | Yes |
| `ADMIN_USERNAME` | Username of the first administrator, created on first boot | Yes |
| `ADMIN_PASSWORD` | Password for that administrator (minimum 6 characters) | Yes |
| `CREATE_ADMIN` | `1` creates the admin account from the two variables above | Yes |
| `BASE_URL` | Public URL used in generated links: `https://${{RAILWAY_PUBLIC_DOMAIN}}` | Yes |
| `PORT` | Listening port; overrides `LISTEN_ADDR` to `0.0.0.0:$PORT` | Yes |
| `HTTPS` | `1` enables secure cookies and the HSTS header | Recommended |
| `TRUSTED_REVERSE_PROXY_NETWORKS` | `100.64.0.0/10,fd00::/8` trusts Railway's edge for `X-Forwarded-For` | Recommended |
| `DISABLE_SCHEDULER_SERVICE` | `1` on the web service so only the scheduler polls | Yes (web) |
| `POLLING_FREQUENCY` | Minutes between scheduler batches (default `60`) | No |
| `POLLING_SCHEDULER` | `round_robin` or `entry_frequency` (adaptive) | No |
| `OAUTH2_PROVIDER` | `oidc` or `google` for single sign-on | No |

### Deployment Dependencies

- Source: ; docs at 
- Images: `miniflux/miniflux` on Docker Hub, mirrored to `ghcr.io/miniflux/miniflux` and `quay.io/miniflux/miniflux`
- Runtime: nothing to install — one static Go binary; PostgreSQL is the only dependency

## Hardware Requirements for Self-Hosting Miniflux

Miniflux is famously light: idle memory sits in the tens of megabytes; the database is what grows.

| Resource | Minimum | Recommended |
|---|---|---|
| CPU | 0.5 vCPU per service | 1 vCPU per service |
| RAM | 128 MB per service | 256–512 MB per service |
| Storage | 1 GB PostgreSQL | 5–10 GB for hundreds of feeds |
| Runtime | PostgreSQL 12+ | PostgreSQL 18 |

Storage tracks entry retention, not feed count — lower `CLEANUP_ARCHIVE_READ_DAYS` if the database grows fast.

## How to Self-Host Miniflux Outside Railway

On your own server, Docker Compose is the shortest path — this runs Miniflux against PostgreSQL and creates the first administrator on boot:

```
services:
  miniflux:
    image: miniflux/miniflux:latest
    ports:
      - "80:8080"
    depends_on:
      - db
    environment:
      - DATABASE_URL=postgres://miniflux:secret@db/miniflux?sslmode=disable
      - RUN_MIGRATIONS=1
      - CREATE_ADMIN=1
      - ADMIN_USERNAME=admin
      - ADMIN_PASSWORD=change-me
  db:
    image: postgres:18
    environment:
      - POSTGRES_USER=miniflux
      - POSTGRES_PASSWORD=secret
      - POSTGRES_DB=miniflux
    volumes:
      - miniflux-db:/var/lib/postgresql
volumes:
  miniflux-db:
```

To split the roles as this template does, run a second container from the same image with `DISABLE_HTTP_SERVICE=1` and set `DISABLE_SCHEDULER_SERVICE=1` on the web container. The binary also exposes maintenance commands:

```
docker compose exec miniflux /usr/bin/miniflux -migrate
docker compose exec miniflux /usr/bin/miniflux -refresh-feeds
```

## Miniflux vs FreshRSS vs Feedly

| | Miniflux | FreshRSS | Feedly |
|---|---|---|---|
| Licence | Apache 2.0 | AGPL-3.0 | Proprietary |
| Stack | Go binary + PostgreSQL | PHP + MySQL/PostgreSQL/SQLite | SaaS only |
| Google Reader API | Yes | Yes | No |
| Price | Free self-hosted, $15/year hosted | Free self-hosted | Pro from ~$8/month |

Pick Miniflux for the smallest, fastest reader; FreshRSS for extensions and themes.

## How Much Does Miniflux Cost to Self-Host?

Miniflux is free and open source under the Apache 2.0 licence, so the software costs nothing however you run it — on Railway you pay only for the infrastructure the three services use, and a personal instance is among the cheaper things you can host. The maintainer also sells a managed instance at miniflux.app for $15 a year.

## FAQ

**What is Miniflux and why self-host it?**
An open source RSS, Atom and JSON Feed reader written in Go. Self-hosting keeps subscriptions, read history and starred articles in a database you control.

**What does this Railway template deploy?**
Three services: a public Miniflux web service, a private scheduler service that refreshes feeds in the background, and a managed PostgreSQL 18 database shared by both.

**Why does the Miniflux template include PostgreSQL?**
It is Miniflux's only storage backend — feeds, entries, search, users and sessions all live there. There is no SQLite option, which is also why no volume is needed.

**Are there default credentials for self-hosted Miniflux?**
No. The administrator is created on first boot from `ADMIN_USERNAME` and `ADMIN_PASSWORD`, and there is no public sign-up page, so nobody can register behind your back.

**Can I use self-hosted Miniflux with mobile apps like Reeder or NetNewsWire?**
Yes. Miniflux implements the Google Reader and Fever APIs plus its own REST API, so most readers connect with your instance URL and an API key from Settings → API Keys.

**Can I run more than one Miniflux web replica on Railway?**
Yes — the web service has the scheduler disabled, so extra replicas serve traffic without duplicating feed polling. Keep the scheduler at one replica.


## Similar templates

- [Rocky Linux](https://railway.com/deploy/rocky-linux) — Hosted Rocky Linux 9 workspace with SSH and persistent storage. 🚀
- [Foundry Virtual Tabletop](https://railway.com/deploy/X5tR6G) — A Self-Hosted & Modern Roleplaying Platform
- [Letta Code Remote](https://railway.com/deploy/letta-code-remote) — Run a Letta Code agent 24/7. No inbound ports, just deploy.

Open this page in a browser: https://railway.com/deploy/miniflux-railway