Deploy RSSHub

Deploy and Host RSSHub on Railway

RSSHub is an open-source feed generator that manufactures RSS, Atom and JSON feeds for the roughly 1,600 sites that no longer publish one — social networks, video platforms, forums, universities, notice boards, code hosts and newspapers. Each supported site has a route: a small piece of TypeScript that fetches the source and normalises it into feed items. If you have ever wanted a subscribe button on a page that only offers an algorithmic timeline, RSSHub is the piece that makes it exist.

Self-host RSSHub on Railway and you get a private feed factory instead of a shared one. This template runs the official diygod/rsshub image alongside a Railway-managed Redis holding the route and content cache, so repeat requests are answered from memory rather than by re-fetching the source. The app is the only service on the public internet; Redis stays private. Every route sits behind an access key, so your instance answers you and not the whole internet.

Getting Started with RSSHub on Railway

Open the generated Railway URL once the deploy finishes. The "Welcome to RSSHub!" page confirms the instance is installed and serving. There is no login screen and no admin account — RSSHub has no user model. Instead a single ACCESS_KEY is generated at deploy time; copy it from the app service's Variables tab, because every feed URL needs it. Pick a route from the route catalogue and append the key, for example https://your-app.up.railway.app/github/issue/DIYgod/RSSHub?key=YOUR_ACCESS_KEY. A working route returns XML full of `` elements; paste that whole URL, key included, into any reader and you are subscribed.

Two extras are worth knowing on day one. Your instance publishes its own machine-readable route catalogue at /api/namespace?key=YOUR_ACCESS_KEY and a browsable explorer at /api/reference?key=YOUR_ACCESS_KEY. And any feed reshapes with query parameters — &format=json returns JSON Feed, &limit=10 truncates, and &filter= / &filterout= take regular expressions, turning a firehose route into a narrow one.

About Hosting RSSHub

RSSHub sits between a website and your reader. A request arrives as a path such as /bilibili/user/video/2267573; RSSHub matches it to a route module, fetches the upstream page or API, parses it and renders a standards-compliant feed. Nothing is stored permanently, so a restart costs you nothing but a cold cache.

Teams self-host it for three reasons. The public demo is shared infrastructure, so your polling competes with everyone else's. Some routes need credentials — a YouTube API key, a GitHub token, site cookies — and those belong on hardware you control. And an internal instance can read intranet pages a public service never could.

Key features:

• Roughly 1,600 site namespaces and several thousand routes, community-maintained
• RSS 2.0, Atom, JSON Feed and RSS3 output from the same URL
• Regex include/exclude filters and item limits as query parameters
• Access-key auth, plus per-route codes that never expose the master key

The template runs two services. rsshub is the Node.js application on port 1200, with a public domain and a health check on /. Redis is Railway's managed instance, private, with its own volume; RSSHub writes two cache tiers into it — one keyed by route, a longer one for fetched article bodies — which is what stops a popular feed hammering its source on every poll.

Why Deploy RSSHub on Railway

Railway removes the server work from running a feed generator.

• One click provisions the app, Redis and the private network between them
• TLS and a public domain are issued automatically; custom domains are one field
• Redis is managed, with its own volume and no tuning to do
• Usage-based pricing suits a service that idles between reader polls

Common Use Cases

• Follow accounts without the app. Turn creator profiles on video and social platforms into feeds, with no algorithmic ordering.
• Watch releases and issues. Track a dependency's GitHub releases or a vendor's changelog page that publishes no feed.
• Automation triggers. Point n8n, Zapier or Node-RED at an RSSHub URL and use "a new item appeared" as a trigger for sites with no webhook.
• Monitoring notices. Subscribe to government tenders, university announcements or job boards and read them alongside everything else.

Dependencies for RSSHub

• rsshub — diygod/rsshub:latest from Docker Hub, source at github.com/DIYgod/RSSHub. Route matching, fetching, parsing and feed rendering.
• Redis — Railway-managed redis:8.2. Holds the route and content caches. Without it RSSHub falls back to an in-process LRU lost on every restart, so every poll hits the source site.

Environment Variables Reference

Route-specific credentials are added the same way — GITHUB_ACCESS_TOKEN, YOUTUBE_KEY and the rest are listed in the configuration docs.

Deployment Dependencies

• Runtime: Node.js 24 (baked into the image)
• Image: hub.docker.com/r/diygod/rsshub
• Source: github.com/DIYgod/RSSHub, AGPL-3.0
• Documentation: docs.rsshub.app

Hardware Requirements for Self-Hosting RSSHub

RSSHub is I/O-bound: most of a request is spent waiting on the upstream site. Scale up when many readers poll many routes.

Self-Hosting RSSHub with Docker

The upstream project ships a Compose file; this is the minimal equivalent:

services:
  rsshub:
    image: diygod/rsshub:latest
    ports: ["1200:1200"]
    environment:
      CACHE_TYPE: redis
      REDIS_URL: "redis://redis:6379/"
      ACCESS_KEY: change-me
  redis:
    image: redis:8.2
    volumes: ["redis-data:/data"]

volumes:
  redis-data:

Then confirm it is alive and pull a real feed:

curl -s -o /dev/null -w '%{http_code}' http://localhost:1200/
curl -s "http://localhost:1200/github/issue/DIYgod/RSSHub?key=change-me" | head -20

How Much Does RSSHub Cost to Self-Host?

RSSHub is free and open source under AGPL-3.0, with no paid tier, licence key or seat count. The project runs a public demo and accepts sponsorship, but the software you deploy here is the complete thing. On Railway you pay only for the compute and memory the two services use.

RSSHub vs RSS-Bridge

RSS-Bridge is simpler to drop onto shared PHP hosting. RSSHub has far broader coverage and is easier to run as a container with a cache tier, which is the shape this template deploys.

FAQ

What is RSSHub?

An open-source feed generator that creates RSS, Atom and JSON feeds for websites that do not publish one, using community-written route modules — roughly 1,600 site namespaces at the time of writing.

What does this Railway template deploy?

Two services: the RSSHub application on a public URL behind an access key, and a private Railway-managed Redis used as its cache. Nothing needs configuring by hand afterwards.

Why does the template include Redis?

Without a shared cache every reader poll re-fetches the source website. Redis holds a route cache and a longer content cache, keeping your instance polite towards the sites it reads and making repeat polls near-instant. It also survives app restarts, which an in-process cache does not.

How do I use the access key in my RSS reader?

Append ?key=YOUR_ACCESS_KEY to the feed path and subscribe to the whole URL. If you would rather not put the master key in a reader, RSSHub also accepts ?code=, an MD5 of the request path plus the key, which grants access to that one route only.

Why does a route error when the site loads fine in my browser?

Some sources need credentials or a real browser. Check the route's documentation page for a required variable such as YOUTUBE_KEY or a cookie, add it to the app service and redeploy. Routes marked as needing a browser additionally require PLAYWRIGHT_WS_ENDPOINT.