How to Use Miniflux: The Beginner's Guide (Compose File, First Feeds, Fever API)

CodexFuse Team · 2026-10-31T14:15:35.328Z · 14 min read

A beginner's guide to using Miniflux: the Compose file, first login, first feeds, OPML import, categories and filters, and the Fever API for your phone.

How to Use Miniflux: The Beginner's Guide (Compose File, First Feeds, Fever API)

Learning how to use Miniflux is the simplest way to take your news back from the algorithm. Miniflux is a minimalist, opinionated RSS and Atom feed reader you host on your own server — written in Go, Apache 2.0 licensed, and built for people who want a fast, quiet place to read. This Miniflux tutorial takes you from an empty compose file to your first feeds, an OPML import, categories and filters, and reading everything on your phone through the Fever API. If you can follow the Docker beginner guide, you already have every skill this guide needs.

What is Miniflux?

Miniflux is a minimalist, opinionated feed reader written in Go that aggregates RSS, Atom, and JSON feeds into one fast reading interface you host yourself. There is no social feed, no recommendation engine, and no tracking — just your feeds, your entries, and keyboard-driven reading. The official GitHub repository (miniflux/miniflux) holds about 9,900 stars and is licensed Apache 2.0, with version 2.3.4 released on 2026-10-20. It is deliberately small: the whole thing is a single Go binary talking to PostgreSQL, which is why pages load in well under 100 milliseconds even on a cheap VPS.

What do you need before installing Miniflux?

You need a server, Docker, and PostgreSQL — and the PostgreSQL part is non-negotiable. Miniflux requires PostgreSQL; there is no SQLite or filesystem-storage option, unlike FreshRSS which also supports SQLite and MySQL (per OSSAlt's 2026 comparison). A small what is VPS hosting server is plenty: Miniflux is one of the lightest self-hosted apps in its category, and a few hundred feeds run comfortably on minimal hardware. Docker Compose is the standard way to run it, because it lets you define both Miniflux and its database in one file.

How do you set up Miniflux in Docker?

You set up Miniflux with one Compose file, then run it with docker compose up -d — follow these seven steps and you will be reading your own feeds within the hour.

1. Write the Compose file. Define two services — Miniflux and PostgreSQL — with the environment variables below. The three that matter most: RUN_MIGRATIONS=1 (runs the database migrations automatically on boot), CREATE_ADMIN=1 plus ADMIN_USERNAME/ADMIN_PASSWORD (creates your first admin account), and DATABASE_URL pointing at the database container.
2. Start the stack. Run docker compose up -d. Miniflux applies its migrations on first boot (that is the RUN_MIGRATIONS=1 doing its job) and the admin account is created.
3. Log in. Open http://your-server:8080 and sign in with the username and password you set.
4. Remove the bootstrap variables. Delete CREATE_ADMIN, ADMIN_USERNAME, and ADMIN_PASSWORD from the Compose file and restart the stack — Miniflux only reads them on the very first boot, and leaving them lying around is sloppy.
5. Add your first feed. Click Add a subscription, paste a feed URL, and let Miniflux detect it. Paste the site's homepage URL if you do not know its feed address — it usually figures it out.
6. Import the rest. Go to Settings → Import/Export → Import OPML and upload your subscriptions file from Feedly, NewsBlur, or your previous reader.
7. Connect your phone. Enable the Fever API under Settings → Integrations → Fever API, point your RSS app at https://your-domain/fever, and your feeds are on your phone.

services:
  miniflux:
    image: miniflux/miniflux:latest
    restart: unless-stopped
    ports:
      - "8080:8080"
    environment:
      DATABASE_URL: "postgres://miniflux:secret@db/miniflux?sslmode=disable"
      RUN_MIGRATIONS: 1
      CREATE_ADMIN: 1
      ADMIN_USERNAME: admin
      ADMIN_PASSWORD: "change-me-immediately"
    depends_on:
      db:
        condition: service_healthy
  db:
    image: postgres:alpine
    restart: unless-stopped
    environment:
      POSTGRES_DB: miniflux
      POSTGRES_USER: miniflux
      POSTGRES_PASSWORD: "change-me-immediately"
    volumes:
      - db_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U miniflux"]
      interval: 5s
      start_period: 20s
volumes:
  db_data:

The official image is miniflux/miniflux:latest (also published to ghcr.io/miniflux/miniflux and quay.io/miniflux/miniflux). The docs recommend pinning a version tag like 2.3.4 instead of latest to avoid surprise updates — reasonable once you have read the release notes. The depends_on with the pg_isready healthcheck keeps Miniflux from starting before PostgreSQL is ready, which avoids the classic first-boot race.

How do you create the first admin account?

The first admin account is created from three environment variables on the very first boot: CREATE_ADMIN=1, ADMIN_USERNAME, and ADMIN_PASSWORD. Set them in the Compose file, start the stack once, log in — and then remove all three and restart. If you ever need another admin later, you re-add the variables and restart again; the same first-boot mechanism fires. Never keep the plaintext admin password in your Compose file longer than the one boot that needs it.

How do you add your first feeds?

Click Add a subscription in the top navigation and paste a feed URL or a site URL. Miniflux handles feed discovery, so pasting a plain homepage URL usually works — it finds the feed on its own. After the first poll cycle (default: every 60 minutes), new entries appear in the Unread view.

YouTube channel feeds are the sleeper feature: they turn subscription-box videos into plain reading-list entries, minus the autoplay. The GitHub releases pattern is how you watch a project's versions without ever opening its repository page.

How do you import feeds with OPML?

Export an OPML file from your current reader — Feedly (Organize → Export → OPML), NewsBlur, Inoreader, and NetNewsWire all support this — then go to Settings → Import/Export → Import OPML and upload it. Miniflux recreates every feed and category from the file, which makes migrating from a paid reader a ten-minute job. This is the same mechanism you would use to move from Feedly's paid tiers to your own server: export, upload, done.

How do you organize feeds with categories and filters?

Sort feeds into categories (tech, news, research — whatever fits your brain) and use filters to keep or block entries by keyword. Keep/block rules are how Miniflux stays quiet: block a keyword like "sponsored" and matching entries never reach your Unread view. Miniflux is opinionated by design — it does one thing (aggregate and display feeds) and aims to do it extremely well — so organization is the main thing you will customize. A sensible starter split: one category for must-reads you check daily, one for low-priority sources you skim weekly, and one for release feeds that can wait.

How do you read Miniflux on your phone?

Enable the Fever API under Settings → Integrations → Fever API, set a separate Fever password, and point your RSS app at https://your-domain/fever. Miniflux speaks the Fever protocol, so any Fever-compatible app works: Reeder 5 (iOS/macOS), Unread (iOS), NetNewsWire (iOS/macOS, free and open source), ReadKit (macOS), and Fluent Reader (Windows/Linux). Mark an entry read on your phone and it is marked read everywhere — the server stays the single source of truth. For a secure way to reach the Fever API from outside your home network without exposing ports, the Tailscale beginner guide pairs naturally with this setup.

How do you get full article text from truncated feeds?

Turn on Miniflux's built-in full-text scrapers: it can fetch the full article content for feeds that only publish summaries, using readability-style scrapers that already cover 100+ popular sites. For YouTube channels, FETCH_YOUTUBE_WATCH_TIME=1 pulls the video watch time into entries. Two polling knobs are worth knowing: POLLING_FREQUENCY (default 60 minutes between feed checks) and CLEANUP_FREQUENCY_HOURS (default 24 hours between entry cleanups). Drop them into the Miniflux service's environment block:

environment:
  POLLING_FREQUENCY: 60
  CLEANUP_FREQUENCY_HOURS: 24
  FETCH_YOUTUBE_WATCH_TIME: 1
  BASE_URL: "https://rss.yourdomain.com"

BASE_URL is the public URL of your instance — Miniflux uses it when generating links in notifications and integrations, so set it once you have a domain.

How do you put Miniflux behind HTTPS?

Proxy port 8080 through a reverse proxy with a single Caddy block. The Caddy beginner guide covers the full HTTPS setup; the Miniflux-specific part is this:

rss.yourdomain.com {
    reverse_proxy localhost:8080
}

Caddy handles the certificate automatically, and once HTTPS is live, update BASE_URL to the https address. The Fever API endpoint and the web UI share the same domain, so your phone apps just work over TLS.

Miniflux vs FreshRSS: which should you choose?

Miniflux is the minimalist, opinionated lane: Go binary, mandatory PostgreSQL, designed for a single user or a small team. FreshRSS is the customizable lane: PHP, SQLite/MySQL/PostgreSQL options, extensions, and multi-user hosting for hundreds of users. Per OSSAlt's 2026 head-to-head, both support the Fever API and Google Reader API, so they work with the same phone apps — the difference is philosophy, not protocol.

If you want to set it up once and never think about it again, Miniflux wins. If you need themes, extensions, or a reader for a whole household or team, FreshRSS is the answer.

What mistakes do Miniflux beginners make?

Most early Miniflux frustration comes from a short list of predictable traps. Recognize them now and you will skip them all.

Sources

• GitHub miniflux/miniflux — 9,863 stars, Apache 2.0, Go; release 2.3.4 published 2026-10-20; fetched 2026-10-31
• OSSAlt Guides, "FreshRSS vs Miniflux: Self-Hosted RSS 2026" (220 days ago) — full Compose arc (RUN_MIGRATIONS=1, CREATE_ADMIN=1), PostgreSQL mandatory with no SQLite option, Fever API + Google Reader API compatibility
• DEV Community, "Self-Host Miniflux: Minimalist RSS Feed Reader 2026" (228 days ago) — 8-part beginner arc: Docker deploy, OPML import, poll cycle, Fever API, categories and filters, REST API
• Railway, "Deploy & Host Miniflux | Open Source Feedly Alternative" (172 days ago) — CREATE_ADMIN/ADMIN_USERNAME/ADMIN_PASSWORD read once on first boot, PostgreSQL as the only persistent state, 60-minute default poll
• miniflux.app/docs/docker.html (official documentation) — container registries (Docker Hub, ghcr.io, quay.io), amd64/arm64/arm/v7/arm/v6, tag naming, pinned-version recommendation, healthcheck via miniflux -healthcheck

Frequently asked questions

Does Miniflux need PostgreSQL? Can I use SQLite?

Miniflux requires PostgreSQL — there is no SQLite or filesystem-based storage mode. PostgreSQL is the app's only persistent state: users, feeds, entries, sessions, and integrations all live in the database. If you need a SQLite-backed reader, FreshRSS is the alternative.

How do I create the first Miniflux admin user?

Set CREATE_ADMIN=1, ADMIN_USERNAME, and ADMIN_PASSWORD in the Compose file and start the stack once — Miniflux reads them only on the very first boot. Then remove all three variables and restart, so the password is not sitting in your config forever.

How do I move from Feedly to Miniflux?

Export an OPML file from Feedly (Organize → Export → OPML), then go to Settings → Import/Export → Import OPML in Miniflux and upload it. Every feed and category is recreated, so the migration takes minutes.

Can I use Reeder, Unread, or NetNewsWire with Miniflux?

Yes. Enable the Fever API under Settings → Integrations → Fever API, set a separate Fever password, and point your app at https://your-domain/fever. Read state syncs both ways because Miniflux stays the single source of truth.

Should I use Miniflux or FreshRSS?

Choose Miniflux if you are one person (or a small team) who wants a fast, minimal, set-and-forget reader — it is a Go binary that answers in well under 100 ms. Choose FreshRSS if you need multiple users, extensions, themes, or a SQLite deployment. Both work with the same Fever-compatible phone apps.