# How to Set Up a Personal RSS Feed Aggregator: A Complete Self-Hosting Guide

> Learn how to set up a personal RSS feed aggregator by self-hosting FreshRSS or Miniflux with Docker. Take full control of your news with this end-to-end private solution.

- Repository: [Michael Royal/Self-Hosting-Guide](https://github.com/mikeroyal/Self-Hosting-Guide)
- Tags: how-to-guide
- Published: 2026-06-17

---

**Deploy FreshRSS or Miniflux in a Docker container, optionally pair it with RSSHub for generating feeds from non-RSS sites, and secure it with a reverse proxy to create a fully private, self-hosted RSS aggregator you control end-to-end.**

The `mikeroyal/Self-Hosting-Guide` repository curates battle-tested open-source tools for running your own infrastructure. According to the guide's [`README.md`](https://github.com/mikeroyal/Self-Hosting-Guide/blob/main/README.md) RSS section, FreshRSS stands out as the recommended solution for a personal RSS feed aggregator, offering a lightweight PHP-based web interface, SQLite or MySQL backend options, and a built-in API compatible with mobile clients.

## Architecture Overview

A robust personal RSS feed aggregator deployment consists of three logical layers working together over a Docker bridge network.

### Core Components

- **Feed Reader (FreshRSS or Miniflux):** Stores, parses, and presents RSS/Atom feeds via a web UI. Exposes an optional API for mobile and desktop clients. Deployed as a Docker container with persistent storage mounted to host directories.
- **Feed Generator (RSSHub):** Optional component that transforms non-RSS sites (YouTube, Reddit, Twitter) into standard RSS feeds on-the-fly via the `/rss` endpoint.
- **Reverse Proxy (Caddy/Nginx):** Terminates TLS and forwards traffic to containers. While optional for local testing, it is strongly recommended for production deployments.
- **Persistent Storage:** Bind-mounts host directories (e.g., `./data/freshrss`) into containers to preserve the feed database and configuration across restarts.

### Why FreshRSS?

According to the `mikeroyal/Self-Hosting-Guide` source code, FreshRSS is described as "a self-hosted RSS and Atom feed aggregator. It is lightweight, easy to work with, powerful, and customizable." It supports OPML import for migrating existing subscriptions, multi-user configurations, and an API that clients like AntennaPod and Feedly can consume.

## Step-by-Step Docker Deployment

The following [`docker-compose.yml`](https://github.com/mikeroyal/Self-Hosting-Guide/blob/main/docker-compose.yml) provisions FreshRSS alongside an optional RSSHub instance. Save this configuration to orchestrate your personal RSS feed aggregator stack.

```yaml
version: "3.8"

services:
  freshrss:
    image: freshrss/freshrss:latest
    container_name: freshrss
    restart: unless-stopped
    ports:
      - "8080:80"
    volumes:
      - ./data/freshrss:/var/www/FreshRSS/data
    environment:
      - TZ=UTC

  rsshub:
    image: diygod/rsshub:latest
    container_name: rsshub
    restart: unless-stopped
    ports:
      - "1200:1200"
    environment:
      - TZ=UTC
      - NODE_ENV=production

```

1. **Create the project directory structure:**

```bash
mkdir -p ~/selfhost/rss && cd ~/selfhost/rss

```

2. **Start the containers:**

```bash
docker compose up -d

```

3. **Initialize FreshRSS:**
Open a browser at `http://<host-ip>:8080` and complete the setup wizard. Choose **SQLite** for simplicity or **MySQL** for larger deployments, set an administrator password, and configure your timezone.

4. **Import existing subscriptions:**
Navigate to *Import/Export* in the FreshRSS UI and upload an `subscriptions.opml` file from your previous reader to migrate all feeds instantly.

## Integrating RSSHub for Custom Feeds

RSSHub generates RSS feeds from websites that do not natively provide them. Once the container is running, construct feed URLs using the pattern:

```

http://<host-ip>:1200/rss/<service>/<identifier>

```

For example, to subscribe to a YouTube channel, use `http://<host-ip>:1200/rss/youtube/channel/UCx...`, then paste this URL into FreshRSS using the **+ Add a feed** button.

## Securing Your Deployment with a Reverse Proxy

For production use, place your personal RSS feed aggregator behind a TLS-terminating proxy. Here is a Caddy configuration that automatically handles HTTPS certificates:

```yaml
services:
  caddy:
    image: caddy:latest
    container_name: caddy
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data
      - caddy_config:/config
    depends_on:
      - freshrss
      - rsshub

volumes:
  caddy_data:
  caddy_config:

```

Create a `Caddyfile` with the following content:

```

freshrss.example.com {
    reverse_proxy freshrss:80
    tls you@example.com
}

rsshub.example.com {
    reverse_proxy rsshub:1200
    tls you@example.com
}

```

## Automated Maintenance

While FreshRSS includes an internal scheduler for refreshing feeds, you can enforce updates via system cron by invoking the application's CLI directly. Add this line to your `crontab -e`:

```bash
*/20 * * * * docker exec freshrss php /var/www/FreshRSS/app/cli.php cron

```

This executes the [`cli.php`](https://github.com/mikeroyal/Self-Hosting-Guide/blob/main/cli.php) script inside the FreshRSS container every 20 minutes, ensuring content remains fresh even if the internal scheduler is disabled.

## Summary

- **FreshRSS** provides the core personal RSS feed aggregator functionality with a web UI and API support, as documented in the `mikeroyal/Self-Hosting-Guide` README.
- **RSSHub** extends your aggregator's capabilities by generating RSS feeds from sites like YouTube and Reddit that lack native RSS support.
- **Docker Compose** simplifies deployment, using bind-mounted volumes at `/var/www/FreshRSS/data` to persist your database and configuration.
- **Reverse proxies** like Caddy or Nginx handle TLS termination and domain routing for secure remote access.
- **Automation** via [`cli.php`](https://github.com/mikeroyal/Self-Hosting-Guide/blob/main/cli.php) cron jobs ensures consistent feed updates without manual intervention.

## Frequently Asked Questions

### What is the difference between FreshRSS and Miniflux?

FreshRSS is a PHP-based application with extensive plugin support and a customizable web interface, making it ideal for users who want granular control. Miniflux is written in Go and prioritizes minimalism and speed, offering a distraction-free reading experience with fewer configuration options. Both are recommended in the `mikeroyal/Self-Hosting-Guide` for self-hosting a personal RSS feed aggregator.

### Can I import my existing feeds from Feedly or other services?

Yes. FreshRSS supports standard **OPML** import and export functionality. Navigate to the *Import/Export* section of the web interface, upload your `subscriptions.opml` file from Feedly, Inoreader, or any other reader, and the system will automatically populate your categories and feeds.

### How do I update my RSS aggregator containers?

Update both FreshRSS and RSSHub by pulling the latest images and recreating the containers:

```bash
cd ~/selfhost/rss
docker compose pull
docker compose up -d

```

This preserves your data in the bind-mounted volumes while applying the latest security patches and features.

### Is it possible to access my self-hosted RSS aggregator from mobile apps?

Yes. FreshRSS exposes a **Google Reader compatible API** that mobile applications like AntennaPod, Reeder, and the Feedly app can consume. Enable API access in the FreshRSS settings, generate an API password, and configure your mobile client to point to `https://freshrss.example.com/api/` using your credentials.