Miniflux on VPS: Installation, Configuration, and Maintenance

Miniflux on a VPS is installed and configured as a lightweight, private RSS aggregator, allowing you to independently control your news feed, with maintenance including regular Docker container updates, PostgreSQL database backups, and server resource monitoring. This solution ensures complete independence from third-party services, guaranteeing privacy and high performance. In this article, we will detail the process of deploying Miniflux on your virtual server using Docker and Docker Compose, and also touch upon security, optimization, and choosing the right VPS configuration.

What is Miniflux and Why Choose a Self-Hosted Solution?

Miniflux is a minimalistic, fast, and efficient open-source RSS aggregator designed for reading news feeds. It focuses on simplicity, performance, and privacy, offering a clean user interface without unnecessary features or intrusive ads. Unlike many other RSS readers, Miniflux does not try to be a social hub or a publishing platform. Its primary goal is to deliver content from your chosen sources as quickly as possible and without distractions.

Advantages of Self-Hosted Miniflux on a VPS

Choosing Miniflux self-hosted on your own VPS server offers several significant advantages:

• Full Data Control: All your subscriptions, read articles, and settings are stored on your server, not with a third-party provider. This is critically important for users who value privacy and sovereignty over their data.
• High Performance: Miniflux is inherently designed to be lightweight. Running on a powerful VPS, it demonstrates outstanding speed in loading and processing feeds, even with hundreds of subscriptions.
• Flexibility and Customization: Although Miniflux is minimalistic, installing it on your own server allows you to integrate it with other services (e.g., for read-it-later), configure server parameters, and adapt it to your unique needs.
• Cost Savings: The long-term cost of owning a VPS and Miniflux is often lower than subscriptions to paid RSS services, especially if you already have a VPS for other tasks. Moreover, you pay for resources, not for "features" you might not use.
• Independence: You are not dependent on the decisions or fate of third-party companies. If a service shuts down or changes its policy, your Miniflux continues to operate. For those interested in the general principles of server operation, we recommend reading the article What is a Server and Dedicated Server: A Complete Guide for Beginners.

Miniflux vs. Other RSS Aggregators

There are many RSS aggregators on the market, both cloud-based and self-hosted. Miniflux stands out among them with its philosophy:

• Lightweight: It is written in Go, which ensures low resource consumption. This allows it to run even on the most modest VPS instances.
• Simplicity: The absence of unnecessary features means no distractions and fast navigation.
• API: Miniflux provides a well-documented API, allowing you to create your own clients or integrate with other applications.
• Automatic Original Content Extraction: If an RSS feed provides only a summary, Miniflux can attempt to extract the full article text from the original website using its built-in parser.

If you are looking for a more functional, yet still self-hosted option with extensive customization and social features, you might consider FreshRSS on VPS: Installation, Configuration, and Maintenance.

Miniflux System Requirements and VPS Selection

Miniflux is known for its efficiency, making it an excellent choice for deployment on virtual servers with limited resources. However, for comfortable operation and scaling to a larger number of feeds or users, it is important to choose the right VPS configuration.

Minimum and Recommended Server Specifications

For a successful Miniflux installation and stable operation, you will need:

• Operating System: Ubuntu Server (20.04 LTS or newer) or Debian (11 or newer) are preferred, as extensive documentation and Docker packages are available for them.
• Processor (CPU): 1 vCPU with a clock speed of 1 GHz or higher. Miniflux is not a CPU-intensive application under normal conditions.
• Random Access Memory (RAM): Minimum 512 MB. 1 GB is recommended for more comfortable operation, especially if you plan to run other services on the same VPS or have a very large number of feeds (over 1000).
• Disk Space: Minimum 10 GB. Miniflux stores a PostgreSQL database, which can grow depending on the number of feeds, update frequency, and article retention period. An NVMe drive is recommended for better database performance.
• Database: PostgreSQL (version 10 or newer). Miniflux does not support MySQL or SQLite for production environments.
• Docker and Docker Compose: For the simplest and most reliable installation.

Which VPS to Choose for Miniflux?

Choosing the optimal VPS depends on your needs. Valebyte offers various plans suitable for Miniflux:

Usage Scenario	Recommended VPS Config (Valebyte)	Estimated Cost/Month	Notes
Personal Use (up to 200 feeds)	1 vCPU, 1 GB RAM, 20 GB NVMe	From $5 to $8	Excellent for a single user, low load.
Small Team (2-5 users, up to 1000 feeds)	2 vCPU, 2 GB RAM, 40 GB NVMe	From $10 to $15	Good balance of performance and cost.
Active Use / Bloggers (many feeds, frequent updates)	2-4 vCPU, 4 GB RAM, 80 GB NVMe	From $20 to $35	For maximum speed and stability under high load.

For most users looking to install Miniflux for personal use, Valebyte's entry-level plans will be more than sufficient. It's also important to consider the virtualization type. KVM VPS provides better isolation and performance compared to OpenVZ, which can be crucial for stable operation. You can read more about the differences in the article KVM VPS vs OpenVZ VPS in 2026: Still Relevant.

Preparing Your VPS for Miniflux Installation: Docker and PostgreSQL

Before proceeding with the Miniflux installation, you need to prepare your VPS server. We will use Docker and Docker Compose to simplify application deployment and management. This will allow Miniflux and its dependencies to be isolated, and components to be easily updated.

System Update and Docker Installation

Connect to your VPS via SSH. First, update the package list and installed packages:

sudo apt update && sudo apt upgrade -y

Next, install Docker Engine and Docker Compose. Follow the official Docker documentation for your operating system. For Ubuntu/Debian, this typically looks like this:

1. Install necessary packages:

sudo apt install ca-certificates curl gnupg lsb-release -y

2. Add Docker's official GPG key:

sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

3. Set up the Docker repository:

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

4. Update package list and install Docker Engine, Docker CLI, and containerd:

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

5. Add your current user to the docker group to avoid using sudo for every Docker command:

sudo usermod -aG docker $USER
newgrp docker # Apply group changes immediately or reconnect via SSH

6. Verify Docker installation:

docker run hello-world

You should see a welcome message from Docker.

Firewall Configuration (UFW)

For the security of your VPS, you need to configure a firewall. UFW (Uncomplicated Firewall) is an easy-to-use tool for managing iptables.

If UFW is not installed, install it:

sudo apt install ufw -y

Configure firewall rules:

sudo ufw allow OpenSSH # Allow SSH connections
sudo ufw allow http    # Allow HTTP (port 80)
sudo ufw allow https   # Allow HTTPS (port 443)
sudo ufw enable        # Enable firewall
sudo ufw status        # Check status

Ensure that the SSH port (usually 22) is allowed, otherwise you will lose access to the server after enabling UFW.

Step-by-Step Miniflux Installation on VPS via Docker Compose

Now that your VPS is prepared, we can proceed directly to installing Miniflux using Docker Compose. This method allows you to easily manage Miniflux and its PostgreSQL database as a single service.

Creating the docker-compose.yml File

Create a directory for Miniflux configuration files and navigate into it:

mkdir ~/miniflux
cd ~/miniflux

Create the docker-compose.yml file using a text editor (e.g., nano):

nano docker-compose.yml

Paste the following content. This file defines two services: PostgreSQL for the database and Miniflux for the application itself.

version: '3.8'

services:
  db:
    image: postgres:15-alpine
    restart: always
    environment:
      POSTGRES_USER: ${DB_USER}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_DB: ${DB_NAME}
    volumes:
      - db-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${DB_USER} -d ${DB_NAME}"]
      interval: 10s
      timeout: 5s
      retries: 5

  app:
    image: miniflux/miniflux:latest
    restart: always
    ports:
      - "8080:8080"
    environment:
      # Database settings
      DATABASE_URL: postgres://${DB_USER}:${DB_PASSWORD}@db:5432/${DB_NAME}?sslmode=disable
      # Miniflux settings
      BASE_URL: ${MINIFLUX_BASE_URL} # E.g., https://miniflux.yourdomain.com
      TZ: Europe/Moscow             # Your timezone
      LOG_LEVEL: info
      # Additional settings (optional)
      POLLING_INTERVAL: 60          # Feed update frequency in minutes
      CLEANUP_ARCHIVED_DAYS: 30     # Days after which archived articles are deleted
      CLEANUP_READ_DAYS: 60         # Days after which read articles are deleted
      # Activate content parser for full article text
      CONTENT_SCRAPING_ENABLED: "true"
      # Disable new user registration (recommended for self-hosted)
      ALLOW_SELF_REGISTRATION: "false"
      # Proxy parameters for content extraction (if your VPS is behind NAT or requires bypassing blocks)
      # HTTP_PROXY: http://proxy.example.com:8080
      # HTTPS_PROXY: http://proxy.example.com:8080
    depends_on:
      db:
        condition: service_healthy
    command: miniflux -c /etc/miniflux.conf

volumes:
  db-data:

Configuring Environment Variables

To securely store sensitive data (DB login/password), create a .env file in the same ~/miniflux directory:

nano .env

Fill it with the following data, replacing the values with your own (use strong passwords):

DB_USER=minifluxuser
DB_PASSWORD=your_strong_db_password
DB_NAME=minifluxdb
MINIFLUX_BASE_URL=http://localhost:8080 # Temporary, will be changed to a domain with HTTPS

Important: Replace your_strong_db_password with a complex, unique password. Replace http://localhost:8080 with your domain when configuring the reverse proxy with HTTPS.

Starting Miniflux Containers

Now you are ready to start Miniflux. Make sure you are in the ~/miniflux directory, where docker-compose.yml and .env are located. Execute the command:

docker compose up -d

This command will download the necessary Docker images (PostgreSQL and Miniflux), create the containers, and run them in the background (-d). The process may take a few minutes on the first run, as image downloads are required.

You can check the status of the running containers:

docker compose ps

If everything is running correctly, you will see an Up status for both services.

Initial Miniflux Setup: Creating an Administrator

After successfully starting the containers, you need to create an administrator account for Miniflux. This is done using a Docker command. Make sure you are in the ~/miniflux directory.

docker compose exec app miniflux -c /etc/miniflux.conf create-admin --username admin --password your_admin_password

Replace admin and your_admin_password with your desired login and password for your administrator account. Immediately change your_admin_password to a strong password.

Miniflux should now be accessible at http://YOUR_VPS_IP_ADDRESS:8080. You can log in using the created administrator credentials. However, for secure use of Miniflux, we will need to set up a reverse proxy and HTTPS.

Configuring a Reverse Proxy (Nginx/Caddy) and HTTPS for Miniflux

Direct access to Miniflux on port 8080 is neither secure nor convenient. We will set up a reverse proxy (Nginx or Caddy) to redirect traffic to Miniflux, and also obtain a free SSL certificate from Let's Encrypt to enable HTTPS.

Before proceeding, ensure you have a domain name pointing to your VPS's IP address (e.g., miniflux.yourdomain.com). Update the MINIFLUX_BASE_URL variable in your .env file to your domain with HTTPS:

MINIFLUX_BASE_URL=https://miniflux.yourdomain.com

Then, restart the Miniflux container for the changes to take effect:

docker compose restart app

Option 1: Nginx Configuration with Certbot (Recommended for Experienced Users)

Nginx is a powerful and widely used web server and reverse proxy. Certbot from Let's Encrypt automates the process of obtaining and renewing SSL certificates.

1. Install Nginx:

sudo apt install nginx -y

2. Create Nginx configuration file for Miniflux:

sudo nano /etc/nginx/sites-available/miniflux.conf

Paste the following content, replacing miniflux.yourdomain.com with your domain:

server {
        listen 80;
        listen [::]:80;
        server_name miniflux.yourdomain.com;

        location / {
            proxy_pass http://127.0.0.1:8080;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_http_version 1.1;
            proxy_buffering off;
            proxy_request_buffering off;
            proxy_read_timeout 900;
        }
    }

3. Activate the configuration and check Nginx syntax:

sudo ln -s /etc/nginx/sites-available/miniflux.conf /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

4. Install Certbot and obtain an SSL certificate:

sudo snap install core
sudo snap refresh core
sudo snap install --classic certbot
sudo ln -s /snap/bin/certbot /usr/bin/certbot
sudo certbot --nginx -d miniflux.yourdomain.com

Follow Certbot's instructions. It will automatically modify your Nginx configuration, adding HTTPS and setting up HTTP to HTTPS redirection.

5. Verify Certbot's automatic renewal:

sudo systemctl status snap.certbot.renew.service

Your Miniflux should now be accessible at https://miniflux.yourdomain.com.

Option 2: Caddy Configuration (Recommended for Simplicity)

Caddy is a modern web server that automatically obtains and manages Let's Encrypt SSL certificates. It is significantly simpler to configure for HTTPS than Nginx.

1. Stop Nginx if it's running:

sudo systemctl stop nginx
sudo systemctl disable nginx

2. Install Caddy:

Follow Caddy's official instructions for your OS. For Debian/Ubuntu, this typically is:

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install caddy

3. Create the Caddyfile configuration file:

sudo nano /etc/caddy/Caddyfile

Remove existing content and paste the following, replacing miniflux.yourdomain.com with your domain:

miniflux.yourdomain.com {
    reverse_proxy 127.0.0.1:8080
}

4. Check Caddy configuration and restart the service:

sudo caddy validate --config /etc/caddy/Caddyfile
sudo systemctl reload caddy

Caddy will automatically request an SSL certificate and configure HTTPS. Your Miniflux will be accessible at https://miniflux.yourdomain.com.

Miniflux Maintenance: Backups, Updates, and Monitoring

Regular maintenance is key to the stable and secure operation of Miniflux on a server. This includes data backups, component updates, and resource monitoring.

PostgreSQL Database Backup Strategies

The most important part of Miniflux is the PostgreSQL database, which contains all your subscriptions and read articles. Regular backups are absolutely essential.

We will use pg_dump to create a database dump. Create a backup script:

nano ~/miniflux/backup_miniflux.sh

Paste the following content, replacing minifluxuser, minifluxdb, and your_strong_db_password with the values from your .env file:

#!/bin/bash

# Load environment variables
source /home/$USER/miniflux/.env

TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
BACKUP_DIR="/home/$USER/miniflux/backups"
BACKUP_FILE="$BACKUP_DIR/miniflux_db_backup_$TIMESTAMP.sql"
RETENTION_DAYS=7 # Keep backups for 7 days

mkdir -p $BACKUP_DIR

echo "Starting Miniflux PostgreSQL database backup..."

# Perform database backup from Docker container
docker compose exec db pg_dump -U $DB_USER -d $DB_NAME > $BACKUP_FILE

if [ $? -eq 0 ]; then
    echo "Database backup successful: $BACKUP_FILE"
    # Delete old backups
    find $BACKUP_DIR -name "miniflux_db_backup_*.sql" -mtime +$RETENTION_DAYS -delete
    echo "Old backups cleaned up."
else
    echo "Database backup FAILED!"
fi

Make the script executable:

chmod +x ~/miniflux/backup_miniflux.sh

To automate backups, add a job to Cron. Open crontab:

crontab -e

Add the following line to perform a backup daily at 03:00 AM:

0 3 * * * /home/$USER/miniflux/backup_miniflux.sh >> /var/log/miniflux_backup.log 2>&1

Don't forget to replace $USER with your username on the VPS.

It is also recommended to configure external storage for backups (e.g., S3-compatible storage or a remote FTP server) to protect against complete server failure.

Updating the Miniflux Docker Image

Updating Miniflux installed via Docker is very simple:

1. Navigate to the Miniflux directory:

cd ~/miniflux

2. Stop and remove old containers:

docker compose down

3. Download the latest images:

docker compose pull

4. Start the new containers:

docker compose up -d

All your data is stored in the db-data volume and will not be affected when updating the Miniflux container.

VPS Resource Monitoring

Although Miniflux is lightweight, it's important to monitor the state of your VPS. Monitoring allows you to timely identify performance issues or resource shortages. You can use tools like htop for a quick check or install a full-fledged monitoring system, such as Netdata. A detailed guide on its installation can be found here: Netdata on VPS: Installation, Configuration, and Maintenance.

Which VPS Config for Real-World Load: From Personal to Corporate

The choice of VPS configuration for Miniflux on a server depends on several key factors, including the number of users, the number of RSS feeds and their update frequency, as well as the presence of other services on the same VPS. Valebyte offers flexible solutions that allow you to precisely select the necessary resources.

Needs Analysis

To determine the optimal VPS, answer the following questions:

• Number of Users: Miniflux can be used by a single person or a small team. Each active user, especially with simultaneous feed updates, increases the load.
• Number of RSS Feeds: From 50 to 5000 or more. The more feeds, the more data is stored in the database, and the more CPU and RAM are required to process them.
• Feed Update Frequency: Miniflux by default updates feeds every 60 minutes. If you set a more frequent interval (e.g., 15-30 minutes), this will increase the load on the CPU and network.
• Article Retention: How many days do you want to keep read and archived articles? Long-term storage requires more disk space.
• Other Services on VPS: Will Miniflux be the only application on your VPS, or do you plan to host something else (e.g., Calibre-web, AudioBookshelf, a mail server)? If so, overall resources should be increased.

CPU, RAM, NVMe Recommendations

Based on the needs analysis, the following recommendations can be made:

• Personal Use (1 user, up to 500 feeds, hourly updates):
  • CPU: 1 vCPU
  • RAM: 1 GB
  • Disk: 20 GB NVMe
  • Valebyte Example: "Standard-1" plans or similar. Cost around $5-8/month.

  For this scenario, Miniflux will consume minimal resources. The main load falls on PostgreSQL during feed updates and on Miniflux itself when viewing articles.

• Small Group / Blogger (2-5 users, up to 2000 feeds, every 30 minutes updates):
  • CPU: 2 vCPU
  • RAM: 2-4 GB
  • Disk: 40-80 GB NVMe
  • Valebyte Example: "Standard-2" or "Standard-3" plans. Cost around $10-25/month.

  With this number of feeds and more frequent updates, PostgreSQL may require more memory for caching, and Miniflux more CPU for content parsing. NVMe disks are critical for database performance.

• Corporate / High-Load (5+ users, 5000+ feeds, every 15 minutes updates):
  • CPU: 4+ vCPU
  • RAM: 8+ GB
  • Disk: 100+ GB NVMe
  • Valebyte Example: "High-Performance" or "Dedicated Server" plans. Cost from $40/month.

  In this case, Miniflux becomes quite resource-intensive. It might be worth considering a dedicated server or a more powerful VPS. High network bandwidth will also be important for timely content loading.

Savings on Long-Term Rental

When choosing a VPS for long-term use, such as Miniflux self-hosted, it's worth considering annual payment options. Providers, including Valebyte, often offer significant discounts for paying a year in advance compared to monthly payments. This can significantly reduce the total cost of ownership. You can learn more about this in the article Annual vs. Monthly VPS Payment: What's Cheaper in the Long Run.

Also, for those seeking maximum performance and control, there are Bare-metal server options, although this is usually overkill for Miniflux.

Advanced Miniflux Configuration and Optimization

After the basic installation of Miniflux on a VPS, you can perform additional configuration to improve performance, functionality, and integration with other services.

Configuring Cron Jobs for Feed Updates (Alternative to Built-in Poller)

By default, Miniflux updates feeds via its built-in scheduler. However, for more precise control or if you have many feeds that need to be updated asynchronously, you can disable the built-in scheduler and use an external Cron job.

1. Disable Miniflux's built-in poller:

   Edit your .env file and add/modify:

   POLLING_INTERVAL=0

   Restart the Miniflux container:

   docker compose restart app

2. Create a Cron job:

   Open crontab:

   crontab -e

   Add a line to update feeds, for example, every 30 minutes:

   */30 * * * * cd /home/$USER/miniflux && docker compose exec app miniflux -c /etc/miniflux.conf refresh-all --user-id 1 >> /var/log/miniflux_refresh.log 2>&1

   Replace $USER with your username. --user-id 1 assumes your administrator has ID 1. If you have multiple users, you can create separate Cron jobs for each or use refresh-all without --user-id to update feeds for all users.

Using Cron gives you more flexibility; for example, you can configure some "heavy" feeds to update less frequently than others, or distribute the load throughout the day.

Integration with External Services

Miniflux supports integration with various services for read-it-later or saving articles:

• Pocket: To save articles to Pocket, add to .env:

  POCKET_CONSUMER_KEY=YOUR_POCKET_CONSUMER_KEY
  POCKET_ACCESS_TOKEN=YOUR_POCKET_ACCESS_TOKEN

  You will need to obtain these keys from the Pocket developer website.

• Wallabag: If you are using self-hosted Wallabag (Wallabag on VPS), you can configure integration:

  WALLABAG_URL=https://wallabag.yourdomain.com
  WALLABAG_CLIENT_ID=YOUR_WALLABAG_CLIENT_ID
  WALLABAG_CLIENT_SECRET=YOUR_WALLABAG_CLIENT_SECRET
  WALLABAG_USERNAME=YOUR_WALLABAG_USERNAME
  WALLABAG_PASSWORD=YOUR_WALLABAG_PASSWORD

  Obtain Client ID and Secret from Wallabag settings.

• Instapaper, Pinboard, Readability, etc.: Miniflux supports many other services. A complete list and configuration instructions can be found in the official Miniflux documentation.

After making changes to .env, don't forget to restart the Miniflux container: docker compose restart app.

Fine-Tuning Performance and Security

• Configuring Docker Resource Limits: If Miniflux or PostgreSQL start consuming too many resources, you can limit them in the docker-compose.yml file:

    app:
      # ...
      deploy:
        resources:
          limits:
            cpus: '0.5' # Limit to 50% of one core
            memory: 512M # Limit to 512 MB RAM
    db:
      # ...
      deploy:
        resources:
          limits:
            cpus: '0.5'
            memory: 512M

  This can be useful on resource-constrained VPS instances to prevent other services from "starving."

• PostgreSQL Optimization: For high-load PostgreSQL installations, additional configuration may be required. This is beyond the scope of this article but includes parameters like shared_buffers, work_mem, maintenance_work_mem, and others.
• Fail2ban: To protect your VPS from brute-force attacks on SSH and Nginx/Caddy, consider installing Fail2ban.
• VPS Backup: In addition to Miniflux database backups, regularly take full snapshots or backups of the entire VPS through the Valebyte control panel. This will ensure quick recovery in case of serious issues.

Conclusion

Installing, configuring, and maintaining Miniflux on a VPS using Docker Compose is an effective way to get a fast, private, and fully controlled RSS aggregator. Adhering to security recommendations, regular updates, and backups will ensure the stable operation of your Miniflux instance. For most users, a VPS with 1-2 vCPU, 1-2 GB RAM, and an NVMe disk, offered by Valebyte, will be the optimal choice.