*The missing arr for books. Self-hosted book, audiobook, and manga search and download manager -- like Sonarr/Radarr but for your reading library.

Librarr searches all configured indexers in parallel, scores results by confidence, and auto-imports into your Calibre, Audiobookshelf, Kavita, or Komga library. Single ~17MB Go binary, no runtime dependencies — ~14MB RSS idle in a real homelab¹, typically 10-20× lower than the .NET-based *arr apps.

Search	Library

Wishlist	Settings

• Import your Goodreads or StoryGraph library via CSV and bulk-download everything
• Request workflow -- users request books, admins approve, downloads happen automatically (like Jellyseerr for books)
• Quality profiles -- rank formats (EPUB > PDF > MOBI), auto-upgrade when a better version appears
• Author monitoring -- follow authors and get notified when new releases are found
• Series auto-complete -- detects gaps in series and searches for missing volumes
• Torznab API -- add Librarr as an indexer in Prowlarr or Readarr (it works both ways)
• OPDS 1.2 feed -- browse your library from any e-reader app
• Tiny footprint -- ~14MB idle RSS, runs comfortably on a Pi or any thermally-constrained mini-PC

• Pluggable indexer registry -- driver kinds listed below; default endpoints are fetched at startup from the librarr-sources companion repo and overrideable at runtime via LIBRARR_SOURCES_URL / LIBRARR_SOURCES_PATH
• Confidence scoring -- 0-100 score with breakdown (title match, author match, format, seeders, file size)
• Quality profiles -- define format ranking and preferred attributes, auto-upgrade existing downloads
• Release profiles -- preferred and excluded words for fine-grained filtering
• Blocklist -- failed downloads are auto-blocked to prevent retries; manual entries supported

• Multiple download clients -- qBittorrent or Transmission for torrents, plus SABnzbd for Usenet
• Request/approval workflow -- pending, approved, searching, downloading, completed states with per-request notifications
• Scheduled wishlist searches -- background scheduler auto-searches and downloads wishlist items on a configurable interval
• Torrent completion watcher -- polls download client, auto-imports completed downloads
• Dead letter retry -- failed jobs can be retried individually or in bulk

• Auto-import pipeline -- organize files by author/title, rename on import (configurable pattern), scan into Calibre/Audiobookshelf/Kavita/Komga
• Series auto-complete -- detect gaps in series, search for and download missing books
• Author monitoring -- follow authors, periodically check for new releases, auto-notify
• Reading history -- track what you've read with stats (books per month, pages, completion rate)
• Tags -- organize library items with custom tags for filtering and grouping
• Series grouping -- groups related books/volumes in the library view
• EPUB verification -- checks title word overlap to detect wrong-book downloads

• In-app notifications -- persistent alerts for downloads, requests, failures, and author releases
• Discord webhooks -- rich embeds for download events, request updates, and errors
• Generic webhooks -- JSON payloads for any webhook-compatible service
• Configurable events -- choose which events trigger notifications

• Goodreads CSV import -- import your shelves, auto-download "to-read" books
• StoryGraph CSV import -- import your reading list
• Library export -- JSON and CSV export for library, wishlist, and requests
• Backup and restore -- full database backup with one-click restore

• Torznab/Newznab API at /torznab/api -- add as indexer in Prowlarr, Readarr, or any compatible app
• OPDS 1.2 feed at /opds -- browse and download from e-readers (KOReader, Moon+ Reader, Librera)
• Prometheus metrics at /metrics -- request counts, download stats, source health, library size
• REST API -- full JSON API for all operations (see API section below)

• Multi-user auth -- session login with bcrypt passwords and admin/user roles
• TOTP 2FA -- RFC 6238 time-based one-time passwords with QR code setup
• OIDC / SSO -- OpenID Connect for Authelia, Keycloak, Authentik, and others
• API key auth -- X-Api-Key header or ?apikey= parameter for programmatic access
• Rate limiting -- per-endpoint rate limits with configurable thresholds
• Security headers -- X-Content-Type-Options, X-Frame-Options, CORS, request size limits

• Modern dark UI -- Tailwind CSS, mobile-responsive, single-page app
• Admin dashboard -- library stats, source health, activity log, system info
• Bulk operations -- retry or cancel multiple downloads at once
• File uploads -- drag and drop ebooks/audiobooks, auto-organize and library scan
• Connection tests -- verify Prowlarr, qBittorrent, SABnzbd, Audiobookshelf, Kavita connectivity

• Single static binary -- ~17MB, zero CGO, pure-Go SQLite (modernc.org/sqlite)
• Docker-ready -- minimal Alpine image, runs as non-root user
• Cross-platform -- Linux, macOS, Windows; amd64, arm64, armv7

Librarr ships with driver implementations -- the protocols it can speak. The list of active indexers, their endpoints, mirrors, and enabled flags lives in a JSON registry, hosted in the librarr-sources companion repo and fetched at startup (similar to how Prowlarr syncs its indexer definitions). The binary itself ships no embedded registry. After the first successful fetch the registry is cached on disk so subsequent restarts work offline. To use a different registry, set LIBRARR_SOURCES_URL (another HTTP source) or LIBRARR_SOURCES_PATH (a local file).

To add or remove a specific indexer endpoint, edit the registry -- no code changes required.

services:
  librarr:
    image: ghcr.io/jeremiahm37/librarr:latest
    ports:
      - "5050:5050"
    volumes:
      - ./data:/data
      - /path/to/ebooks:/books/ebooks
      - /path/to/audiobooks:/books/audiobooks
      - /path/to/manga:/books/manga
    environment:
      - AUTH_USERNAME=admin
      - AUTH_PASSWORD=changeme
      - API_KEY=your-api-key-here
      - QB_URL=http://qbittorrent:8080
      - QB_USER=admin
      - QB_PASS=changeme
      - PROWLARR_URL=http://prowlarr:9696
      - PROWLARR_API_KEY=your-prowlarr-api-key
    restart: unless-stopped

docker compose up -d

# Download from releases
curl -LO https://github.com/JeremiahM37/librarr/releases/latest/download/librarr_linux_amd64.tar.gz
tar xzf librarr_linux_amd64.tar.gz

# Configure
export AUTH_USERNAME=admin
export AUTH_PASSWORD=changeme
export QB_URL=http://localhost:8080
# ... set other env vars as needed

# Run
./librarr

Open http://localhost:5050 in your browser.

All configuration is via environment variables. Every variable has a sensible default.

When OIDC_PROXY_HEADERS_ENABLED=true and Librarr sits behind a trusted reverse proxy that injects Authentik headers like X-Authentik-Username, it will treat those requests as an authenticated SSO session, auto-provision the local user if needed, and skip the manual "Login with SSO" click. Enable this only for proxy-gated deployments. Local logout only clears Librarr's session cookie; if the proxy keeps sending the identity header, the next request will sign the browser back in.

Librarr sends torrents to either qBittorrent or Transmission. Configure one, or configure both and choose with TORRENT_CLIENT. The category/save-path settings below apply to both (Transmission uses the category as a torrent label, which requires Transmission 3.0+).

Resolution order on startup: LIBRARR_SOURCES_PATH → LIBRARR_SOURCES_URL → built-in default URL → on-disk cache (<LIBRARR_DB_PATH dir>/sources-cache.json) → empty registry. Successful URL fetches are cached so subsequent restarts work offline. If you set LIBRARR_SOURCES_URL, your value replaces the default — it does not stack on top of it.

Legacy per-source env vars (e.g. PROWLARR_URL and other per-driver overrides) continue to be honored and override values loaded from the registry.

Librarr exposes a standard Torznab API at /torznab/api that can be added as an indexer in Prowlarr, Readarr, or any Torznab-compatible application.

Setup in Prowlarr / Readarr:

1. Go to Settings > Indexers > Add
2. Select "Generic Torznab" (or "Generic Newznab")
3. Set the URL to http://your-librarr-host:5050/torznab/api
4. Set the API Key to your TORZNAB_API_KEY value
5. Test and save

Capabilities: GET /torznab/api?t=caps returns the supported search categories and capabilities.

Librarr serves an OPDS 1.2 catalog at /opds for e-reader apps (KOReader, Moon+ Reader, Librera, etc.).

Setup: Add http://your-librarr-host:5050/opds as an OPDS catalog in your e-reader. If auth is enabled, enter your Librarr username and password.

Librarr's REST API is the integration surface, so any Model Context Protocol server can expose Librarr's search, download, and library tools to an LLM (Claude Desktop, Claude Code, Open WebUI, Cursor, etc.). There's no built-in MCP server in Librarr — you wire it into the MCP server you already run.

Auth: every endpoint accepts an X-Api-Key header or ?apikey= query param. Set API_KEY in your docker-compose.yml and reuse it from your MCP server.

Minimal Python example using fastmcp:

# librarr_mcp.py — run as: fastmcp run librarr_mcp.py
import os, httpx
from fastmcp import FastMCP

LIBRARR = os.environ["LIBRARR_URL"]       # e.g. http://librarr.lan:5050
API_KEY = os.environ["LIBRARR_API_KEY"]
HEADERS = {"X-Api-Key": API_KEY}

mcp = FastMCP("librarr")

@mcp.tool()
async def search_books(query: str) -> list[dict]:
    """Search for an ebook across all configured sources."""
    async with httpx.AsyncClient() as c:
        r = await c.get(f"{LIBRARR}/api/search", params={"q": query}, headers=HEADERS)
        return r.json()

@mcp.tool()
async def download_book(result: dict) -> dict:
    """Queue an ebook download. Pass a result object returned by search_books — it
    already contains `source`, `title`, and the source-specific URL field
    (`download_url` / `magnet_url` / `md5` / etc.)."""
    async with httpx.AsyncClient() as c:
        r = await c.post(f"{LIBRARR}/api/download", json=result, headers=HEADERS)
        return r.json()

@mcp.tool()
async def list_downloads() -> list[dict]:
    """List active and recent download jobs with status."""
    async with httpx.AsyncClient() as c:
        r = await c.get(f"{LIBRARR}/api/downloads", headers=HEADERS)
        return r.json()

Register with Claude Desktop / Claude Code (~/.claude.json or claude_desktop_config.json):

{
  "mcpServers": {
    "librarr": {
      "command": "fastmcp",
      "args": ["run", "/path/to/librarr_mcp.py"],
      "env": {
        "LIBRARR_URL": "http://librarr.lan:5050",
        "LIBRARR_API_KEY": "your-api-key-here"
      }
    }
  }
}

The same pattern works for audiobooks (/api/search/audiobooks, /api/download/audiobook) and manga (/api/search/manga, /api/download/torrent). Wrap whichever subset of the API Endpoints above is useful to your assistant.

Single static binary, zero CGO dependencies, pure-Go SQLite via modernc.org/sqlite.

cmd/librarr/main.go            Entry point
internal/
  config/config.go              Env var configuration
  db/                           SQLite persistence + migrations
  models/                       Core types (books, downloads, wishlist, requests, etc.)
  api/                          HTTP handlers, router, middleware
    auth.go                     Session auth + bcrypt
    totp.go                     TOTP 2FA (RFC 6238)
    oidc.go                     OpenID Connect / SSO
    search.go                   Search endpoint handlers
    download.go                 Download management
    library.go                  Library CRUD
    requests.go                 Request workflow
    notifications.go            In-app notifications
    qualityprofile.go           Quality profiles
    releaseprofile.go           Release profiles
    blocklist.go                Blocklist management
    tags.go                     Tag management
    history.go                  Reading history
    series.go                   Series detection + auto-complete
    importexport.go             Import/export (JSON, CSV, Goodreads, StoryGraph)
    backup.go                   Database backup/restore
    webhook.go                  Webhook configuration
    opds.go                     OPDS 1.2 feed
    admin.go                    Admin dashboard
    metrics.go                  Prometheus metrics
    csv.go                      CSV bulk import
    ratelimit.go                Per-source rate limiting
    router.go                   Route registration
  search/                       Search source implementations
  download/                     Download manager (qBit, Transmission, Deluge, SABnzbd)
  organize/                     Post-download file organization + library import
  metadata/                     Open Library metadata enrichment
  scheduler/                    Background scheduler, series detector, author monitor
  webhook/                      Webhook sender (Discord + generic)
  torznab/                      Torznab/Newznab API handler
web/
  index.html                    Single-page web UI (Tailwind CSS)
Dockerfile                      Multi-stage Alpine build
.goreleaser.yml                 Cross-platform release builds

MIT

This software is provided for educational and personal use only. Users are responsible for ensuring their use complies with all applicable laws and regulations in their jurisdiction. The developers do not condone or encourage copyright infringement or any illegal activity. This tool does not host, store, or distribute any copyrighted content, and ships with no built-in catalog of indexers -- the list of endpoints to query comes from a user-supplied registry.