A subscription polls a source on its own schedule and feeds what it finds into the LinkGrabber through the ordinary intake — so routing rules, grouping, categories and the online check apply exactly as they do to a link you pasted yourself.

Open Subscriptions from the sidebar or with 4.

The form asks for the Type first, because the type decides which fields follow. Duplicate on a subscription makes a copy and opens it in the form to be changed.

Per subscription, with its own destination category and priority:

• Review first — hits wait in the LinkGrabber for you to decide.
• Queue automatically — accepted hits go straight into the download list.

Hits held for review live in a drawer over the LinkGrabber: one line under the link list names the open decisions, and a button opens the hits over the dimmed page. The line appears only when there is an indexer subscription and something to review.

Inside, the hits are grouped per subscription with its name and count. Each group has its own queue all and dismiss all, both behind a confirmation naming the search and the number; there is no action spanning every subscription. Dismissing deletes nothing — it only stops the hit being suggested again. Check all asks every indexer subscription to check now.

The drawer holds still while it is open. New hits from a check, a finished check or the reading after a decision do not move the rows under your hand: the hits on screen stay in place, and an alert at the top counts what arrived besides — 3 more hits — with Show to bring them in. A subscription whose first hit arrives meanwhile waits there too. What you start yourself — opening a group, turning a page, Show, closing the drawer — brings everything in.

Queue all and Dismiss all decide the whole list as it was last shown to you — every page of it, also in a folded group — and the confirmation counts exactly those. Hits behind the alert, or found after the list was shown, stay for the next decision; Show or opening the drawer again takes them into the list. A hit someone decided elsewhere meanwhile is not decided twice.

Each indexer subscription chooses how its hits appear in that drawer: set View in the LinkGrabber in the subscription's form to List or Cards.

• List is the default.
• Cards shows a slider of equally tall cards, one per hit, each headed by its release name: the cover, or a coloured tile with the initials where there is none (a series keeps its colour); the size, with a lock for a protected archive; release group, episode and year, and chips for IMDb, language, resolution, codec, genre and grabs. Each card has Queue, Details and Dismiss. Details opens one panel under the slider with the same details the list row expands to.

Both views offer the same actions and details; what an indexer did not send is left out. The slider pages with its arrows, the arrow keys, a swipe or the page dots, and holds every open hit, loading more as you near the end. Past ten pages the dots give way to a counter, Page 3 of 40. It stops at the last hit rather than starting over: the forward arrow is greyed out on the last page, the back arrow on the first. Under an open group, Queue all and Dismiss all repeat at its end in both views, with or without pages, so a long group needs no scrolling back to its header. The list view pages as described under How much is fetched. Show cover images switched off applies here too.

With Cards selected, two more options appear:

• Autoplay — off by default. The slider turns a page every six seconds and stops on the last one, with a pause button. It holds while the pointer or keyboard focus is in the slider, while the details panel is open and while the tab is hidden, and never runs when your system asks for reduced motion.
• Card aspect ratio — the shape of each card's picture: 1:1, 2:3, 3:2, 16:9, 4:3 or 2:1, the default. Square suits music covers, the upright 2:3 suits posters, wide suits series banners. The cover is cropped, not stretched.

All three settings are kept with the subscription, including in the settings backup and the subscriptions export.

Each subscription polls on an independent schedule with backoff, jitter and a bounded retry delay. A failing source blocks no other one: every poll is isolated and its error is stored on its own row.

Requests to one indexer are serialised with a quiet time between them, whether the schedule or the Check now button started them, so several subscriptions to one indexer (one per category, say) do not arrive at once. Different hosts never wait for each other.

Feeds are polled conditionally with the stored ETag/Last-Modified, so an unchanged feed costs a 304 rather than a full download.

A first check that fails — the source is down, or refuses for its rate limit — decides nothing: the next check still applies the backlog choice below.

Every item is acted on once, recognised by the source's own id, else its address, else its title and publication date — so a re-shared or renamed item, a reordered feed or a restart mid-poll brings nothing twice.

Switching a subscription on does not import its backlog. Everything present at activation is recorded as seen. You can deliberately collect the whole history for review instead, which never queues anything regardless of the subscription's mode.

A hit is marked queued only once the LinkGrabber has it. If rDownloader stops in between, or the LinkGrabber refuses the link, the hit stays in the review list, where you queue it by hand — it is neither lost nor queued twice.

Old skipped and dismissed items are compacted. Once a skipped or dismissed item is older than Keep skipped subscription entries whole under Settings → System → Logs & retention — 30 days by default, 0 keeps everything — the data folder clean-up drops its title, link and details and keeps only what the subscription recognises it by. It no longer appears in the archive or its counts and cannot be queued again, but a feed or indexer that still lists it brings nothing back. Open and queued items are never compacted. Clearing a subscription's history or deleting the subscription removes these keys too.

Items are filtered by:

• title inclusion and exclusion,
• duration bounds,
• publication date,
• language,
• minimum resolution.

A skipped item records which rule skipped it. Absent metadata never rejects, so a source that reports no durations is not silently emptied.

A title filter wrapped in slashes is a regular expression:

/^S0\d/

Anything else is matched as plain text. The regex editor from the routing rules is available on both fields.

A Release page subscription watches a listing — a series page, a category, a tag. At most every half hour the listing is fetched conditionally, the release pages on it that a site rule recognises become items, and each one enters the LinkGrabber through the ordinary intake, where the five hosters one episode was posted to become one row with mirrors.

An episode is identified by its release name — series, season and episode — not by its address. The same episode posted again by another group, in another quality, or three weeks later counts as already had.

Quality and language are read from the release name with a closed list of tokens — Show.2160.mkv is not 2160p — and feed the minimum-resolution, language and exclusion filters.

Keep every release is the explicit counter-choice for somebody who collects versions: with it set, identity is the address again and every further version enters the LinkGrabber.

An Own script subscription runs a script of yours on a schedule rDownloader keeps and takes the links it prints — for a source no other kind reads: a page behind a login you script yourself, an API of your own, a list somebody posts every morning.

1. Put the script into the scripts folder — the one post-processing scripts live in, scripts/ next to the database unless you changed it. Its name is letters, digits, ., _ and -, directly inside that folder. The ending picks the interpreter: .sh runs with sh, .py with Python, .ps1 with PowerShell. A .bat or .cmd is started as itself, and so is any other file, which then has to be executable.
2. Subscriptions → Add subscription, Type: Own script. Script is a list of the files in the scripts folder — the same list the automation offers. A script that has left the folder since it was chosen stays visible, marked no longer in the scripts folder.
3. Arguments, if the script takes any — see Arguments below.
4. Choose when it runs: Check every (minutes), or Schedule (cron) — five fields in the service's local time, 0 6 * * * for 06:00 every day. With a schedule the interval only sets how soon a failed run is tried again. A new or rescheduled subscription waits for its first time rather than running at once; Check now runs it immediately.
5. The mode decides where the links go — Review first into the subscription's list in the LinkGrabber, Queue automatically straight into the download list — with the subscription's category and priority.

Every line the script prints that is exactly one link is taken — HTTP(S), magnet, FTP, SFTP or WebDAV, the same links the LinkGrabber recognises in pasted text. Any other line is ignored. A link the subscription has already delivered is not taken again, so a script may print the whole day's list on every run. Unlike the other kinds, the first run is taken in full rather than recorded as backlog.

#!/bin/sh
# Prints today's links from a page; rDownloader takes each line that is one link.
curl -fsS https://example.org/today.txt | grep -Eo 'https://ddownload\.com/[A-Za-z0-9]+'

The script runs the way a post-processing script runs: without a shell in between, from the scripts folder as its working directory, and under the same time limit. It sees RD_KIND (subscription), RD_SCRIPT_DIR, RD_SUBSCRIPTION_ID and RD_SUBSCRIPTION_NAME. Its output may be at most 64 KiB; more fails the run rather than cutting the list. A non-zero exit status fails the run, and the run history shows the status and the end of the script's error output.

Only the administrator creates, changes, switches on or off, or runs a script subscription, because it starts a program on the machine the service runs on. Tools over MCP can read one but neither create, change, switch nor run it, whatever scopes their token holds. A subscriptions export leaves script subscriptions out and its import skips them; the full settings backup, an administrator's own action, carries them with their schedule.

Arguments is one line, handed to the script as its command-line arguments. It is split at spaces — "…" or '…' keep an argument with spaces together — and nothing else a shell does happens: $HOME, >, ; and & arrive unchanged. Under the field the form shows every argument as it will arrive, and says so when a quotation mark is not closed.

--list "Morning releases" --since 1d

reaches the script as --list, Morning releases, --since and 1d.

• At most 32 arguments of at most 1024 characters each, without line breaks.
• A .bat or .cmd script is started as itself, so every argument is escaped for cmd.exe. An argument that cannot be escaped safely fails the run with script.batch_arguments_refused rather than reaching the script altered.
• Arguments are not secret. They are stored in plain text — in the database, in backups, in the audit log and in the API — so a password or token never belongs in one. Have the script read it from a file of its own instead.

Creating or changing a script subscription is recorded in the audit log as Script subscription created or changed.

A script that runs on a scheduler of its own can hand its links over from outside instead: rdownloader links add takes --category, --package and --enqueue — see Command line client.

RSS, Atom and podcast feeds are supported. Podcast items are downloaded by their enclosure, not their show-notes page, with season, episode, duration and publication date carried through.

A feed with a DOCTYPE that declares entities is refused, and a truncated document fails the poll instead of being reported as a feed that emptied itself.

A GitHub/GitLab releases subscription follows a repository and downloads the files of every new release once. Enter the repository's address as you copy it from the browser:

https://github.com/owner/name
https://gitlab.com/group/subgroup/project

github.com and gitlab.com are recognised from the address. For a GitHub Enterprise Server or a self-hosted GitLab, choose the service under Service; rDownloader then asks the API at <server>/api/v3 (GitHub) or <server>/api/v4 (GitLab).

A release usually carries one file per system. Choose which of them you want:

Drafts are never downloaded (on GitLab: a release whose date has not come yet). The title filters below apply to the file names as well.

A file your choice leaves out is kept in the subscription's history as skipped with the reason File does not match the platforms, architectures or name patterns. A file added to a release that is already out is downloaded on its own; a file replaced on GitHub has a new id and is downloaded again.

When the release states a SHA-256 for a file — GitHub's own digest, a SHA256SUMS or checksums.txt list, or a <file>.sha256 next to it — the download is checked against it.

A public repository needs nothing. For a private one, enter a token under Token; it is stored encrypted in the vault and never shown again, never written to a log and never put in an address. The smallest rights are enough:

A private file is handed to the LinkGrabber at the short-lived address GitHub redirects to, which needs no token. A self-hosted GitLab that serves the file itself needs an authentication profile of type Bearer with the same token for its host (Settings → Accounts → Site logins), so the download carries it too.

GitHub answers sixty requests an hour to a caller without a token, counted per address. A check costs one request when nothing changed (the list is asked for with its ETag), and the shortest interval for this kind is 15 minutes. When the service refuses for its limit, the subscription waits until the time it names — the history says so once, and it is not counted as a failure. A token raises GitHub's limit to 5,000 an hour.

There is no webhook: rDownloader asks, it is never called, so it needs no public address.

Saved-search parameters in the configured address are preserved. Results carry size and category and are imported like any NZB or torrent.

An indexer defined once under Settings → Usenet (Indexers) can be taken over: choose it in Take over a defined indexer. When the subscription is saved it gets the indexer's address (leave the address field empty, or paste a saved search from the same server), its default categories, and a copy of its API key. It is a copy, not a link: editing or deleting the indexer later changes no subscription — take it over again to follow a new key. An address and a key entered in the subscription itself keep working as before.

An indexer subscription can send a search of its own:

Each is sent only when set, and only when the address does not already carry it: a saved search copied from the indexer's RSS button keeps what it says. The title filter below stays a local filter and is never sent as q — the indexer would search for something else than what the filter matches.

The key lives in the encrypted vault and is masked out of every address that reaches a log, an error or the interface. A key pasted into the address is replaced by the stored one.

An indexer that refuses the query — as HTTP 200 with an error document, as they do — is reported as a failure, not as an indexer with nothing new.

A check reads the indexer's newest results 100 at a time and pages on until it reaches a hit it already has — everything after that was there at the previous check — or a short page ends the list. A busy category therefore costs a request or two per check, and nothing that appeared in between is skipped. The first check of a new subscription reads five pages; later checks stop at 20 pages (2,000 results) at most. The local title filter runs on everything a check read.

A warning under the hits, This check paged through 2000 indexer results without reaching one it already knew, means a check reached that bound and every result was new: hits that appeared since the previous check further down may be missing. A narrower category or a shorter interval closes the gap. The warning does not appear on ordinary checks of a busy category.

When the indexer answers a page with a rate limit — HTTP 429, or "Request limit reached" — the check ends there and waits: until the time the indexer named, an hour for "Request limit reached". It counts as no failure, and since nothing from the refused check is kept, the next one starts from what the subscription already has and misses nothing the indexer still lists.

The archive is paged fifty hits at a time, with totals for open, queued, dismissed and skipped. Queue-all or dismiss-all covers every page; a hit that arrives meanwhile, or fails to queue, stays open. Each subscription can delete its settled hits and check records after a confirmation; open hits are never deleted.

A hit that was already decided can go back into the LinkGrabber from the subscription's archive: one dismissed by mistake — in the LinkGrabber's review too —, a skipped one, or a queued one whose download is gone. Queue again on its row does it for one; the checkboxes, with Shift+click for a range and the checkbox in the archive's header for the whole page, and Queue selected again do it for several. It takes the way the first queueing took — the subscription's category and the LinkGrabber's routing, naming and category rules — and the hit is queued afterwards. Every one is recorded in the audit log.

• A hit with no link or NZB to fetch has no checkbox, and its action is off; the button's tooltip says why.
• A hit whose address is still in the LinkGrabber or the download list is not doubled silently: you are asked once for all of them, and confirmed they arrive in the LinkGrabber marked as duplicates. A queued hit whose download was deleted is not asked about.
• A hit that could not be queued keeps its state and stays ticked; the line above the list says how many went and why the others did not.

The same is available to MCP clients as requeue_subscription_items.

t=caps fetches the category tree, the supported search types and the result limit. The same request is the connection test. Categories can be fetched while the subscription is still being written, before it is saved.

Which categories to fetch is its own field, sent as cat, so a subscription does not pull the indexer's whole feed. It is independent of the mapping below. An address that already names its categories — a saved search from an indexer's own RSS button — keeps them.

Mapping goes from an indexer's categories to rDownloader categories, picked from the discovered tree by name. An unmapped category falls back to the subscription's own, and the raw category is stored on each item, so a mapping added later still applies.

Cover image, IMDb id, score and plot, season and episode, resolution, video and audio codec, genre, grab count and size — read from the search answer itself, without a second request.

The row carries the thumbnail, the size, and — where the indexer sent them — the IMDb score, the language and the genre. The rest sits behind the chevron. Attributes without a known name are listed rather than dropped.

Attributes are filtered before they are stored:

• a value carrying the subscription's own API key is redacted,
• an attribute named like a credential is dropped whole,
• a cover address that is not absolute http/https is discarded rather than handed to the browser.

Loading the pictures is a setting — on by default. Switching it off leaves every written detail in place.

An archive password announced with a hit reaches the extractor, which tries it before the shared password list. Two sources:

• the SABnzbd {{secret}} marker in the title, which also applies to torrent hits;
• an indexer that writes a real password where Newznab specifies its 0/1/2 flag.

The flag itself is only shown as a lock, never used as a password.

Subscriptions, stream schedules and automations can each be written to a file and read back on another installation. The file references categories and targets by name and carries no credentials — so an indexer's API key or a repository's token has to be re-entered on the other side.

• The LinkGrabber — where hits land for review
• Video and audio downloads
• Image galleries
• Usenet and NZB — where indexer NZB hits go
• Storage, categories and rules