Deploy and Host RSSHub on Railway

RSSHub RSS feed generator

RSSHub is the open-source RSS feed generator with 41k+ GitHub stars that makes everything RSSible — turn YouTube channels, Reddit threads, Telegram groups, Twitter/X accounts, GitHub releases, Bilibili, Weibo, and 1,000+ other sources into clean RSS feeds, even when the site dropped native RSS years ago. Maintained by DIYgod and 800+ contributors, with new routes added constantly and a companion browser extension (RSSHub Radar) that detects feeds on any page.

The public rsshub.app instance is rate-limited to ~200 requests/IP/hour and logs your requests. Self-hosting on Railway removes the rate limits, keeps your reading private, and lets you tune cache TTLs to your usage — for ~$5/month flat.

What This Template Deploys

Service	Purpose
RSSHub	The feed generator — 1,000+ routes turning websites into RSS/Atom/JSON feeds, on port `1200`
Redis	Caches feed responses so repeated requests don't hammer source sites — required for a healthy instance

Both services connect over Railway's private network. REDIS_URL is pre-wired between them — Redis is never exposed publicly. Point any RSS reader at your Railway URL plus a route and you have a private, unlimited feed generator.

About Hosting RSSHub

RSSHub is a route-driven feed generator: each route is a small module that knows how to extract content from one site and normalize it into a standard feed. Running it well means a Node.js runtime, Redis for caching (so you don't get rate-limited by the sites you pull from), and a public HTTPS endpoint your reader can reach. The public instance handles this for everyone — which is why it's rate-limited and shared.

Railway runs your own private instance. This template wires RSSHub to a managed Redis over private networking with automatic HTTPS, so your feeds refresh on your schedule with no shared rate limits and no third party logging what you read.

Image choice: the diygod/rsshub:chromium-bundled image (~1 GB) includes a headless Chromium for JavaScript-rendered sources and is the most compatible option. If you only pull static sources, the base diygod/rsshub image uses far less memory — swap it in service settings to cut RAM.

Typical cost: ~$5/month on Railway's Hobby plan for RSSHub and Redis. RSSHub itself is free and open source; you only pay compute.

Deploy in Under 3 Minutes

Click Deploy on Railway — RSSHub and Redis build automatically (~2 minutes)
REDIS_URL and CACHE_TYPE=redis are pre-wired between the services
Open your Railway URL — you'll see the RSSHub homepage with a searchable route list
Build a feed URL: your domain + a route, e.g. /youtube/user/@channelname or /telegram/channel/name
Paste that URL into any RSS reader — FreshRSS, Miniflux, Inoreader, NetNewsWire, or Folo

No Docker commands. No Redis setup. No rate limits.

Common Use Cases

YouTube, Twitter/X, and Telegram as RSS — follow channels, accounts, and public groups as feeds even though these platforms killed or never offered native RSS
Developer monitoring — track GitHub releases, npm/PyPI package updates, and Hacker News mentions of your project in your reader instead of checking manually
Private social following — subscribe to public social feeds without an account and without handing your engagement data to the platform's algorithm
Media and competitor monitoring — follow brand mentions and competitor activity across Reddit, forums, and social platforms from one unified feed
Self-hosted alternative to the public rsshub.app — remove the ~200 req/IP/hour rate limit, keep requests private, and tune cache TTLs to your own refresh needs
Feed pipeline for automation — RSSHub outputs RSS, Atom, or JSON; pipe feeds into n8n, a newsletter builder, or any tool that consumes structured feed data

Configuration

Variable	Required	Description
`CACHE_TYPE`	✅ Pre-set	`redis` — enables Redis caching (strongly recommended)
`REDIS_URL`	✅ Auto-injected	Redis connection string via Railway reference variable
`CACHE_EXPIRE`	Optional	Feed cache TTL in seconds — raise to reduce load on source sites
`ALLOW_USER_HOTLINK_TEMPLATE`	Optional	Control hotlinking behaviour for media in feeds
`PROXY_URI`	Optional	Route traffic through a proxy for geo-restricted or blocked sources
`ACCESS_KEY`	Recommended	Set an access key to require it on requests — keeps your instance private
`PORT`	✅ Pre-set	`1200` — RSSHub's default port

Some routes (certain Twitter/X, Instagram, and authenticated sources) need extra credentials set as environment variables — check each route's docs. Set ACCESS_KEY if you don't want your instance open to anyone who finds the URL.

RSSHub vs. Alternatives

	RSSHub (Railway)	rsshub.app (public)	RSS-Bridge	Feed readers (Feedly)
Rate limits	✅ None (your instance)	❌ ~200/IP/hour	✅ Self-hosted	N/A
Route coverage	✅ 1,000+	✅ 1,000+	⚠️ Smaller (PHP)	❌ Consumes feeds only
Generates feeds from any site	✅ Yes	✅ Yes	✅ Yes	❌ No
Privacy (no request logging)	✅ Your instance	❌ Shared/logged	✅ Self-hosted	❌ Cloud
Custom cache TTLs	✅ Yes	❌ Fixed	⚠️ Limited	N/A
Self-hostable	✅ Yes	N/A	✅ Yes	❌ No
Open source	✅ AGPL-3.0	✅ Yes	✅ Yes	❌ No

Dependencies for RSSHub Hosting

Railway account — Hobby plan (~$5/month) for RSSHub and Redis
An RSS reader to consume the feeds — FreshRSS, Miniflux, Inoreader, NetNewsWire, or Folo
Optional: API keys for routes that require authentication (per-route, see the docs)

Deployment Dependencies

RSSHub GitHub Repository — source and releases
RSSHub Documentation — full route catalog and parameters
RSSHub Route List — 1,000+ supported sources
RSSHub Radar — browser extension for feed discovery

Implementation Details

This template deploys diygod/rsshub:chromium-bundled with a managed Redis over Railway's private network. CACHE_TYPE=redis and REDIS_URL are pre-wired, so caching works out of the box — essential for avoiding rate-limits from the sites RSSHub pulls from. Redis is private-only and never exposed publicly.

The chromium-bundled image (~1 GB) includes a headless browser for JavaScript-rendered sources and is the most compatible choice. If you only need static sources, switch the service to the base diygod/rsshub image to reduce memory use. Build feed URLs as your Railway domain plus a route path; RSSHub returns RSS by default, or append .atom / .json for other formats.

Frequently Asked Questions

Why self-host RSSHub instead of using the public instance? The public rsshub.app instance is rate-limited (~200 requests per IP per hour), shared by everyone, and may log requests. A self-hosted Railway instance has no rate limits beyond your compute, keeps your reading private, lets you tune cache TTLs to your usage, and doesn't depend on a community server staying online.

What sources does RSSHub support? Over 1,000 routes covering YouTube, Twitter/X, Reddit, Telegram, Instagram, GitHub, Bilibili, Weibo, Hacker News, WeChat public accounts, and hundreds more. The full, searchable list is in the official documentation. RSSHub is a feed generator — pair it with a reader to actually read.

Why does it need Redis? Redis caches feed responses so repeated requests don't hit the source site every time. Without caching, high-traffic instances get rate-limited or blocked by the sites they pull from. This template wires Redis automatically with CACHE_TYPE=redis.

Which image should I use — chromium-bundled or base? The chromium-bundled image (~1 GB) handles JavaScript-rendered sources and is the most compatible, so it's the default here. If all your sources are static, the base diygod/rsshub image uses much less memory — switch it in service settings to save on RAM.

How do I keep my instance private? Set ACCESS_KEY in the variables — requests then require that key, so a stranger who finds your Railway URL can't use your instance to generate feeds. Without it, the instance is open to anyone with the URL.

Do some routes need extra setup? Yes. Most routes work out of the box, but certain authenticated sources (some Twitter/X, Instagram, and login-gated platforms) require credentials or cookies set as environment variables. Each route's documentation lists what it needs.

Why Deploy and Host RSSHub on Railway?

Railway is a singular platform to deploy your infrastructure stack. Railway will host your infrastructure so you don't have to deal with configuration, while allowing you to vertically and horizontally scale it.

By deploying RSSHub on Railway, you get a private RSS feed generator for 1,000+ sources — no rate limits, no request logging, Redis caching pre-wired, and cache TTLs tuned to you — at ~$5/month flat, turning any website into a feed you own.