Automate a media library with Sonarr and Radarr

UsenetShare can pretend to be two things your arr apps already know how to talk to: a Newznab indexer so they can search your published shares, and a SABnzbd download client so they can grab what they find.

The result is the normal arr workflow with UsenetShare underneath, and no .nzb files anywhere.

Setting these up currently means editing a configuration file. Unlike the S3 gateway and media streaming, the two shims have no Settings page yet — the app's own API documentation refers to one, and it is not there. Everything below works; it is just less convenient than it should be, and a Settings section is worth asking for.

The two pieces

Both are off by default.

The loop: Sonarr searches the Newznab shim → finds a match in a published public share → grabs it → the SABnzbd shim imports it → Sonarr imports the result into your library.

Only published public shares are indexed. Private and password-protected shares are not searchable, because an indexer cannot be handed a key.

Two ways to store what is grabbed

This is the decision worth making before you start.

Model A — download to disk (default)

The release is downloaded normally, and the arr imports it from disk like any other download. Ordinary local files afterwards.

Choose it when you want the files on your disk, or your player cannot cope with streaming.

Model B — stream in place, zero local storage

The release is imported but not downloaded. What the arr imports is a link into a mounted view of the share, and Plex or Jellyfin streams from Usenet on demand.

A library of any size fits on a small disk, because nothing is stored.

Requires the S3 gateway enabled and an rclone mount of it that the service can read. On Linux the mount needs --allow-other so the service user can see it — without it the shim sees an empty directory and the job fails.

Choose it when you want a large streamed library. It can be set per category, so TV streams while a small archive category downloads.

Enabling them

Both shims read config.json in your data folder, or environment variables. Stop the app, edit, start it again.

Your data folder:

Newznab indexer

{
  "newznab_enabled": true,
  "newznab_port": 8388,
  "newznab_public_url": "http://192.168.1.20:8388"
}

newznab_public_url is the address the arr will use, and it matters when the arr runs on a different machine or in another container. An API key is minted automatically on first start and written back into config.json as newznab_api_key — read it from there after starting.

SABnzbd download client

{
  "sab_enabled": true,
  "sab_port": 8385,
  "sab_storage_model": "download"
}

sab_api_key is likewise minted on first start and written back.

For Model B, instead:

{
  "sab_enabled": true,
  "sab_port": 8385,
  "sab_storage_model": "stream",
  "sab_stream_mount_dir": "/mnt/usenetshare"
}

Or per category, mixing the two:

{
  "sab_storage_model": "download",
  "sab_category_models": { "tv": "stream", "movies": "stream" },
  "sab_stream_mount_dir": "/mnt/usenetshare"
}

Every key has an environment variable equivalent — SAB_ENABLED, SAB_PORT, NEWZNAB_ENABLED, and so on — which is the better route for Docker, where you can set them on the container instead of editing a file inside it.

Check they came up

curl http://127.0.0.1:8385/api/sab/health
curl http://127.0.0.1:8388/api/newznab/health

If a shim is not listening, it is still disabled — the setting did not take. Check you edited the config.json the app actually uses, and that the JSON is valid.

Point Sonarr or Radarr at them

Indexer

Settings → Indexers → + → Newznab (Custom)

Test, then Save.

Download client

Settings → Download Clients → + → SABnzbd

Test, then Save.

That is the whole integration. Search from Sonarr and a match in a published public share appears alongside your other indexers' results.

What comes back is not an .nzb

Worth knowing so the behaviour is not surprising: what the indexer hands over is a UsenetShare share token, and the SABnzbd shim fetches and decodes it. The arr never sees an .nzb, and does not need to.

Everything else the arr does — quality profiles, renaming, importing — works normally.

When it goes wrong

Sonarr's indexer test fails. The shim is not running (check the health URL), the port is blocked, or the API key is wrong. In Docker, 127.0.0.1 inside Sonarr's container is not your host — use the host's address or the container name.

Search returns nothing. Only published public shares are indexed. A private or password-protected share cannot appear. Confirm you have at least one public share published.

Grabs fail immediately. The SABnzbd shim is not enabled, or its API key is wrong in Sonarr.

Model B jobs fail with a message about the mount. sab_stream_mount_dir is not set, or the mount is not there, or the service user cannot see it. That last one is the --allow-other case: the mount exists for your user and not for the service.

Files import but do not play. Model B, and your player cannot reach the mount. Plex and Jellyfin must see the same path the shim wrote.

Downloads go somewhere unexpected. Model A writes under sab_complete_dir, which defaults to a sab/complete folder in your data directory. Set it explicitly if you want it elsewhere, and make sure your arr can read it.

Next

• S3 object storage — needed for Model B
• Mount a share as a drive — the mount Model B uses
• /api-docs/sab and /api-docs/newznab in the app — full wire references