# RSSAid for Flutter: RSSHub Feed Discovery and Subscription

> RSSAid is a Flutter companion app for RSSHub that discovers feed sources from URLs, expands mobile links, applies common RSSHub parameters, and manages subscriptions. It is aimed at RSSHub users who want feed discovery outside a desktop workflow, with a key limitation around browser-style rules.

**LeetaoGoooo/RSSAid** — RSSAid is a complementary app for RSSHub built with Flutter | RSSAid 是一个由 Flutter 构建的 RSSHub 的辅助 App

- Repository: https://github.com/LeetaoGoooo/RSSAid
- Stars: 1,357 · Forks: 59
- Language: Dart
- License: MIT
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/leetaogoooo-rssaid

## Why RSSAid Exists Beside RSSHub

RSSAid addresses a specific gap around RSSHub: RSSHub can generate feeds, but users still need a convenient way to identify the correct feed route for a website, configure route parameters, and subscribe to the result. The README describes RSSAid as a complementary app rather than a replacement for RSSHub or RSSHub Radar. Its intended users are people who already understand RSS feeds or are willing to configure an RSSHub server and want a mobile interface for feed discovery.

The app is positioned as a Flutter-built application with support for Android and iOS-related project structure. It also links to F-Droid availability and Android releases. This matters because the application is not merely a static list of feed links. Its feature list includes RSSHub source detection from a URL, clipboard import, quick subscription, history, configurable RSSHub servers, and general RSSHub parameters.

The central design choice is to reuse the RSSHub Radar rules. According to the README, RSSAid uses the same rules as RSSHub Radar, and both support automatic updates. That reuse reduces duplication in route metadata, but it also creates a compatibility boundary. RSSAid is described as a URL parser and feed discovery client, not as a browser. As a result, rules that depend on browser document behavior cannot simply be treated as interchangeable.

## URL Discovery and RSSHub Rule Flow

The documented flow starts with a website URL and ends with an RSS subscription. RSSAid detects RSSHub sources from the URL using the same rule set as RSSHub Radar. The rules are associated with RSSHub's `assets/radar-rules.js`, and RSSAid is designed to support most rules available to RSSHub Radar. That makes the rule file the central lookup mechanism rather than a collection of feeds stored directly in the app.

The app also addresses URL shape differences. RSSAid supports mobile-only URLs and attempts automatic expansion for short links and mobile subdomains. This is useful when a page URL contains a mobile domain or a shortened link that does not match the PC-style URL expected by a route rule. The README also warns that some sites expose different mobile and PC URLs. If a URL works in RSSHub Radar but not in RSSAid, the project suggests trying the PC URL and reporting the issue.

After detecting a source, the app can present a quick subscription path. It supports clipboard imports, custom rules, RSS+ rules, history, and common RSSHub parameters for actions such as filtering and obtaining full text. The precise parameter UI is not documented in the README, so it would be unsafe to claim that every RSSHub route parameter is exposed. What can be confirmed is that RSSAid has configurable general parameters and a configurable RSSHub server. The app therefore acts as a client that turns a detected route into a usable subscription, while the selected RSSHub server handles the actual feed generation.

## Installing RSSAid and Completing a First Subscription

The README gives two installation paths. Android users can obtain the app through the linked F-Droid listing, and the latest Android build is linked from the repository's releases page. The README does not provide a direct APK command, so no download command is reproduced here.

For source builds, the project directs developers to Flutter's official Android deployment documentation. The repository includes Android and Flutter project files, including `pubspec.yaml`, `pubspec.lock`, `android/`, and the Dart source under `lib/`. The README does not give a complete build command or a minimum Flutter toolchain version for this repository, although the project badge displays Flutter 3.0.0. That badge should not be treated as a complete compatibility statement without checking the repository configuration and Flutter documentation.

A first use should follow this sequence. First install RSSAid and select or configure the RSSHub server that the app should use. Next, copy a supported website URL or paste it into the app. If the source is represented by a short link or mobile URL, allow the app to attempt its documented expansion. Review the detected RSSHub source, apply any common parameters required by that source, and use the quick subscription action. RSSAid can retain history and supports custom rules, so a subscription can be revisited without reconstructing the entire flow.

The expected result is an RSS subscription generated through the configured RSSHub server. The README does not document account login, browser cookie import, feed migration formats, or an API endpoint for headless subscription import, so those should not be assumed.

## Configuration Boundaries and Platform Constraints

RSSAid offers two configuration decisions that determine whether a detected source will work: the RSSHub server and the route parameters. The customizable server setting is important because the app is explicitly dependent on RSSHub. A route rule can identify the right RSSHub path without proving that a particular server deployment can access the target website. Server availability, route availability, and network access remain separate concerns.

The common parameter support is also narrower than the full RSSHub route surface may appear. The README names filtering and full text as examples of supported parameters, but it does not enumerate every parameter accepted by every route. Custom rules are listed as a feature, which suggests a path for cases not covered by the shared rules, yet the README does not document the custom rule file format, validation rules, or import workflow. Those details would need confirmation from the source files before relying on custom rules for a production subscription set.

Platform constraints are explicit in one important area. RSSAid is not a browser extension and simply gets and parses URLs. Any rule that uses `document` in `target` is therefore not applicable. This is not a minor UI difference. It defines the app's parsing model and excludes rules that rely on inspecting a rendered browser document. The project supports Android and iOS-related project directories, but the README provides installation information primarily for Android, including F-Droid and release builds.

## How RSSAid Differs from RSSHub Radar and RSSHub Itself

RSSAid, RSSHub Radar, and RSSHub occupy different layers. RSSHub is the feed-generation service and provides route documentation and server-side parameters. RSSHub Radar is the project whose rules RSSAid says it shares, with RSSAid presenting those rules through a mobile application. RSSAid then adds subscription discovery, clipboard import, history, customizable server settings, and an interface for common route parameters.

The main difference from RSSHub Radar is execution context. The README states that RSSAid is not a browser extension and only gets and parses URLs. A browser-oriented workflow may be able to use page document information during rule matching, while RSSAid cannot apply rules using `document` in `target`. The difference is therefore architectural, not simply a preference for one interface over another.

Compared with RSSHub itself, RSSAid is not the route host. It does not replace an RSSHub deployment or promise a standalone feed source. It depends on a configurable server and uses RSSHub's rules to help users construct subscriptions. This makes RSSAid suitable for people who want an RSSHub client experience on a phone. It is less suitable for operators who need to run RSSHub itself, inspect server logs, modify routes, or manage feed generation infrastructure.

## Maintenance Signals and MIT License Implications

The repository is not archived, and its last push was on 2026-08-28. The release list includes v3.0.9 on 2026-04-02, v3.0.8 on 2026-03-31, and v3.0.7 on 2026-03-31. These are repository and release facts, but they do not by themselves establish compatibility with every RSSHub deployment or every RSSHub Radar rule.

The README says RSSAid is licensed under the MIT license. That permits use and modification under the license's conditions, including preservation of its copyright and license notice. This review does not provide legal advice. Teams should read the repository's `LICENSE` file for the exact terms before redistributing modified builds or embedding the application in another product.

The project also points to F-Droid, Android releases, Flutter documentation, and RSSHub's rule contribution documentation. That gives users several routes for obtaining code or reporting rule problems, but the README does not document a compatibility matrix between RSSAid versions and RSSHub versions. Because RSSAid relies on external RSSHub routes and shared rules, upgrade planning should include checking the app release notes, the selected RSSHub server, and the affected route definitions separately.

## Conclusion

Adopt RSSAid if you already use RSSHub and want a mobile-oriented way to discover, configure, and subscribe to feeds, especially from Android. Do not choose it as a browser extension or as a complete RSSHub Radar replacement, because the README says rules using `document` in `target` do not apply. Before adoption, verify that your RSSHub server configuration, target URLs, mobile links, and required RSSHub parameters work with the rules you need.

## FAQ

### What is RSSAid used for?

RSSAid is a Flutter companion app for RSSHub. It detects RSSHub sources from URLs, supports subscription management, and offers controls for common RSSHub parameters.

### Can I install RSSAid on Android?

Yes. The README links an F-Droid listing and states that the latest Android build can be found in the repository's releases.

### Does RSSAid work with every RSSHub Radar rule?

No. The README says RSSAid supports almost all RSSHub Radar rules, but rules using `document` in `target` are not applicable because RSSAid is not a browser extension.

### Does RSSAid replace an RSSHub server?

No. RSSAid supports a customizable RSSHub server and is presented as a complementary app for discovering and subscribing to RSSHub feeds.

## Sources

- [Issues](https://github.com/LeetaoGoooo/RSSAid/issues)
- [LeetaoGoooo/RSSAid on GitHub](https://github.com/LeetaoGoooo/RSSAid)
- [License: MIT](https://github.com/LeetaoGoooo/RSSAid/blob/main/LICENSE)
- [README](https://github.com/LeetaoGoooo/RSSAid/blob/main/README.md)
- [Releases](https://github.com/LeetaoGoooo/RSSAid/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/leetaogoooo-rssaid