docs.rsshub.app

RSSHub is a feed generator that converts websites and services which do not publish their own RSS into subscribable feeds. It works by running a route for a given source, fetching and parsing that source's content, and returning it as a standard RSS or Atom document. You use it when a site you follow has no native feed and you want updates delivered to an RSS reader instead of checking the page manually.

The core mechanism

RSSHub sits between the source and your feed reader. Instead of asking the website for a feed (which it does not offer), your reader asks RSSHub for one.

The flow has three stages:

1. Route selection — Each supported source has a route, a URL path that identifies what to fetch. The route encodes the site and the specific content you want, such as a user's posts, a tag, or a search result.
2. Fetch and parse — RSSHub requests the underlying page or API, then extracts the relevant items (titles, links, timestamps, content) according to rules written for that source.
3. Format as a feed — The extracted items are assembled into a standard RSS/Atom XML document and returned to the requester.

Because the output is ordinary RSS, any feed reader can consume it. The reader does not need to know anything about how the source was scraped.

What a route looks like

A route is the part of the RSSHub URL that describes the source. The general shape is:

https://<rsshub-instance>/<route-path>

For example, a route might target a user's timeline on a social platform, a category on a news site, or a channel on a video service. The exact path depends on the source; the documentation lists the available routes and their parameters.

When you subscribe, you paste the full generated URL into your reader. The reader polls it on its normal schedule, and RSSHub produces a fresh feed each time.

Why this matters

Many sites and platforms stopped offering RSS, or never offered it. RSSHub restores a subscribable feed for them without requiring the site to change. This lets you:

• Follow updates from sources that only expose a web page or an app.
• Consolidate many sources into one reader.
• Apply your reader's own filtering, search, and notification rules to content that would otherwise be locked in a browser tab.

Practical considerations

• Route availability varies. Not every site has a route, and routes can break when a source changes its page structure or API. Check the documentation for the current list.
• Some routes need parameters. Routes for user-specific or query-specific content require you to supply values such as a username or ID.
• You need somewhere to run it. RSSHub can be used through a public instance or self-hosted. The documentation covers both, including deployment options.
• Feed freshness depends on polling. The feed reflects the source at the time RSSHub fetches it, so update frequency is governed by how often the feed is requested and how the route caches results.

When to use it

Use RSSHub when a source you want to follow has no built-in feed and you want it in an RSS reader. If the site already publishes a native RSS feed, subscribe to that directly instead. If a route does not exist for your source, RSSHub cannot generate a feed for it without a new route being written.

RSSHub is a feed generator that turns many websites and services into subscribable RSS feeds. docs.rsshub.app is its official documentation site: you go there to find the route for a site you want to follow, learn how to use it, and check configuration details. If you want to read a platform that has no native RSS support, RSSHub is the tool, and docs.rsshub.app is where you learn which route to use.

What RSSHub does

Many sites and services don't publish an RSS feed. RSSHub fills that gap by generating one for them. Its stated idea is "Everything is RSSible" — the goal is to make almost any content subscribable.

In practice, that means:

• You pick a website or service you want to follow.
• You find its route in the documentation.
• You subscribe to the generated feed URL in your RSS reader.

The result behaves like any normal feed: new items appear in your reader as the source updates.

What docs.rsshub.app provides

The documentation site is the reference layer for the tool. It's where you look up:

• Routes — the path that maps to a specific site or service, so you know what URL to use.
• Usage instructions — how to construct and consume a feed.
• Configuration information — the settings and options that affect how a route behaves.

Because RSSHub covers a large and growing set of sources, the docs are the practical starting point: instead of guessing a URL, you search the docs for the source you care about and copy the route.

When it's useful

RSSHub fits situations like:

• A site you read regularly has no built-in feed.
• You want to consolidate many sources into one RSS reader.
• You want to follow a specific section, account, or category rather than a whole site.

If a source already offers a working feed, you may not need RSSHub at all. The tool matters most where native feeds are missing.

How to get started

1. Open docs.rsshub.app.
2. Find the route for the website or service you want to follow.
3. Build the feed URL from that route.
4. Add the URL to your RSS reader and subscribe.

The documentation is the authoritative place to confirm the exact route and any options, since routes change as sources are added or updated.

Open docs.rsshub.app and use the site search or the left-hand category tree to locate the service you want. RSSHub organizes routes by category (social media, news, programming, university, etc.) and then by service name. Once you find the service page, copy the route path shown, replace the :parameter placeholders with real values, and prepend your RSSHub instance domain to get a working feed URL.

Two ways to locate a route

1. Search the docs

The documentation site includes a search box. Type the name of the website or service (for example, a social platform, a news outlet, or a video site). Search matches route titles and paths, so partial names usually work.

2. Browse the category tree

If you don't know the exact name, browse the sidebar. Routes are grouped under broad categories, then under individual services. This is useful when you want to discover what's available for a given platform (e.g., all routes for one social network).

Reading a route entry

Each route page typically shows:

The path is relative to your RSSHub instance. If your instance is https://rsshub.example.com, a route /service/user/:uid with uid=123 becomes:

https://rsshub.example.com/service/user/123

Steps to get a working feed

1. Find the service — search or browse to its page.
2. Identify the route — note the path and which parameters are required vs. optional.
3. Collect parameter values — these usually come from the target site's URL. For example, a user ID or a channel slug.
4. Substitute the values — replace every :parameter with the real value, keeping the slashes.
5. Prepend your instance domain — combine the base URL with the path.
6. Test in a browser — open the full URL. A valid feed returns XML; an error page or empty result means a wrong parameter or an unsupported route.
7. Add to your reader — paste the URL into your RSS client.

Common snags

• Missing a required parameter — the route won't resolve. Check the parameter table for which ones are mandatory.
• Wrong parameter format — some routes expect an ID, others a username or a full path segment. Match the example exactly.
• Route requires configuration — some routes need environment variables or credentials set on the RSSHub instance (for example, API keys for certain platforms). The route page notes this; without it, the feed fails.
• Self-hosted vs. public instance — the public demo instance may rate-limit or block certain routes. If a route works in the docs example but not on your instance, check instance-level configuration.

Choosing between similar routes

When a service has multiple routes, compare them on:

• Scope — does it cover a whole site, a category, or a single user?
• Parameters — fewer required parameters means easier setup.
• Output type — some routes return full articles, others only titles or links.

Pick the narrowest route that matches what you actually want to follow; it's usually more stable and produces less noise.

An RSSHub feed usually fails for one of four reasons: the route path or parameters don't match the docs, the target site changed or blocks automated access, the public instance is unreachable or rate-limited, or the route needs a self-hosted instance or extra configuration. Work through these in order — most failures resolve at the first or second check.

1. Verify the route path and parameters

RSSHub feeds follow a predictable URL shape:

https://rsshub.app/<namespace>/<route>/<parameter>

Common mistakes:

• Wrong namespace or route name. Routes are grouped by site (e.g. a namespace for the service, then the specific route). Copy the path directly from the docs rather than typing it from memory.
• Missing required parameters. Many routes need a user ID, channel ID, or keyword. If a parameter is required and omitted, the route returns an error or empty feed.
• Wrong parameter type. Some routes expect a numeric ID, others a slug or username. Passing the wrong type often produces an empty result rather than a clear error.
• Extra or trailing slashes. A stray / at the end can route to a different handler.

Check: Open the feed URL directly in a browser. A working route returns XML. An error page, redirect, or empty <channel> points to the route itself.

2. Check whether the target site changed or blocks access

RSSHub scrapes or calls the underlying site, so it breaks when the site changes.

• Site redesign or API change. If the source site restructured its pages or changed its internal API, the route may return empty or stale content until it's updated.
• Anti-bot protection. Sites behind aggressive bot detection, login walls, or CAPTCHAs often can't be scraped from a shared instance.
• Login-required content. Routes that need an account usually require you to supply credentials or cookies — a public instance won't have them.

Check: Visit the source page manually. If it now requires login, shows a CAPTCHA, or looks structurally different, the route is likely affected. Check the RSSHub docs or project issue tracker for that route's status.

3. Confirm the instance is reachable and not rate-limited

The public instance at rsshub.app is shared, so it can be slow, rate-limited, or temporarily down.

• Rate limiting. Too many requests in a short window can return errors. Space out requests and avoid polling aggressively.
• Instance downtime. The public instance occasionally goes down or is blocked in some regions.
• Network/region blocks. Your network or region may not reach the instance reliably.

Check: Try a known-good route (a simple, popular one from the docs). If that also fails, the problem is the instance or your connection, not the route.

4. Consider whether you need a self-hosted instance or extra config

Some routes only work reliably on your own deployment.

Self-hosting also lets you add routes that the public instance disables for policy or load reasons.

Quick diagnostic order

1. Paste the feed URL in a browser — does it return XML?
2. Compare the path and parameters against the docs, character by character.
3. Test a different, known-working route on the same instance.
4. Check the source site for login walls, CAPTCHAs, or redesigns.
5. If the route needs credentials or you hit rate limits, self-host.

Most "broken feed" reports trace back to step 1 or 2. Only move to self-hosting once you've confirmed the route and instance are otherwise fine.

RSSHub turns websites and services that don't offer their own feeds into subscribable RSS URLs. The basic workflow is: find the route for your target site in the docs, build the feed URL from a running RSSHub instance plus that route and any required parameters, then paste the URL into your RSS reader. This works for any site that already has a documented route; sites without one need a new route to be written first.

Step 1: Find the route for your target site

Routes are the core of RSSHub — each one describes how to extract content from a specific website or service and is documented on docs.rsshub.app.

• Open the docs and browse or search for the site or service you want (for example, a news site, a social platform, or a video channel).
• Each route page shows the route path (the part that comes after the instance domain) and any parameters it accepts.
• Routes are organized by category, so searching by the site name or the platform type is usually the fastest way to locate one.

If no route exists for your target, RSSHub can't generate a feed for it out of the box — you'd need to write a custom route.

Step 2: Build the feed URL

A feed URL has two parts: the RSSHub instance address and the route path (with parameters filled in).

https://<your-rsshub-instance>/<route-path>?<parameters>

• Instance address: the domain of a running RSSHub deployment. The public demo instance is commonly used for testing, but for regular or heavy use you should run your own instance so you're not dependent on someone else's uptime and rate limits.
• Route path: copied from the docs, e.g. /github/issue/... style paths depending on the route.
• Parameters: some routes require them (a user ID, a channel name, a category). The docs page for each route lists which parameters are required and which are optional, along with their format.

Fill in the parameters exactly as the docs specify, then combine everything into one URL.

Step 3: Verify the feed works

Before subscribing, open the constructed URL in a browser.

• Expected result: you see XML/RSS content (a feed document), not an error page.
• If you get an error, the usual causes are: a missing or malformed required parameter, a typo in the route path, or the instance being down.
• Check the docs page again for the exact parameter names and order — small differences matter.

Step 4: Add the feed to your RSS reader

Once the URL returns valid feed content:

1. Copy the full feed URL.
2. In your RSS reader, choose "Add feed" / "Add subscription" and paste the URL.
3. The reader fetches the feed and displays the items. New items appear as the source site updates.

Most readers accept a pasted URL directly; some also let you search by keyword, but pasting the exact URL is the reliable method.

Common sticking points

Choosing an instance

The docs describe routes, not a guaranteed hosting service. For anything beyond occasional testing, self-hosting an RSSHub instance gives you control over availability and avoids overloading shared public instances. The route paths and parameters are the same regardless of which instance you point them at — only the domain in front changes.