LazyLibrarian + Readarr: Automating Your Book Library

Your Ebook Library Is a Crime Scene

You know the folder. Somewhere on your NAS there’s a directory called Books/ that started innocently enough and turned into this:

Books/
  Brandon Sanderson - The Way of Kings.epub
  way-of-kings-part2-final.mobi
  Mistborn (1).epub
  Mistborn_-_The_Final_Empire_unabridged.m4b
  BRANDON SANDERSON - WORDS OF RADIANCE.EPUB
  sanderson_stormlight_3_oathbringer.epub
  tmp_download_452.azw3
  unknown_author_2024-11-03.epub

No series ordering. Duplicate formats. Filenames that look like they were named by a cat walking across a keyboard. Metadata? What metadata? Half these files open in your reader with “Unknown Author” and a gray square where the cover should be.

The *arr ecosystem solved this for movies and TV years ago. Books got there too — just a bit more chaotically. In 2026, you’ve got two serious options: LazyLibrarian and Readarr. They solve the same problem differently, and one of them has had a rougher 2024/2025 than the other. Let’s talk about it.

The Contenders

LazyLibrarian

LazyLibrarian is a Python-based, all-in-one book manager that handles ebooks, audiobooks, and comics. It’s been around for ages, survived multiple GitHub ownership transfers, and despite its “is this project dead?” vibes from the outside, it’s actively maintained by the DobyTang fork.

It does its own thing — different UI paradigm from the *arr stack, but it works, it’s stable, and when Goodreads’ API breaks (and it does), LazyLibrarian has fallback metadata sources like Open Library and GoogleBooks baked in.

Readarr

Readarr is the official *arr-family book manager. If you’re already running Sonarr and Radarr, the UI, concepts, and quality profile system will feel instantly familiar. The trade-off: Readarr has been in an extended alpha/maintenance phase. The original dev team went quiet in late 2024, and the community has been holding it together with forks, PRs, and increasingly desperate Discord messages.

There are at least two active forks worth knowing about: Readarr-development (community patches backported) and early-stage experiments like ReadarrV2. The metadata server — which Readarr phones home to for book information — has had reliability issues. When it goes down, your queue freezes and auto-import stops. That’s not hypothetical; it’s happened multiple times.

Setting Up LazyLibrarian

Compose Stack

LazyLibrarian pairs well with Prowlarr for indexer management. Here’s a minimal stack:

services:
  lazylibrarian:
    image: lscr.io/linuxserver/lazylibrarian:latest
    container_name: lazylibrarian
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
      - DOCKER_MODS=linuxserver/mods:lazylibrarian-ffmpeg
    volumes:
      - ./config/lazylibrarian:/config
      - /mnt/media/books:/books
      - /mnt/media/audiobooks:/audiobooks
      - /mnt/downloads:/downloads
    ports:
      - "5299:5299"
    restart: unless-stopped

  prowlarr:
    image: lscr.io/linuxserver/prowlarr:latest
    container_name: prowlarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
    volumes:
      - ./config/prowlarr:/config
    ports:
      - "9696:9696"
    restart: unless-stopped

  calibre-web:
    image: lscr.io/linuxserver/calibre-web:latest
    container_name: calibre-web
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
      - DOCKER_MODS=linuxserver/mods:calibre-web-calibre
    volumes:
      - ./config/calibre-web:/config
      - /mnt/media/books:/books
    ports:
      - "8083:8083"
    restart: unless-stopped

Note: The linuxserver/mods:lazylibrarian-ffmpeg Docker mod adds FFmpeg for audiobook processing. Skip it if you’re ebooks-only.

Initial Configuration

LazyLibrarian’s config lives in config.ini but you’ll mostly drive it through the web UI at port 5299. The key settings to hit first:

[General]
# Where processed books land
ebook_dir = /books
audiobook_dir = /audiobooks
mag_dir = /books/magazines

[Downloaders]
# NZBGet or SABnzbd for usenet
nzbget_host = nzbget
nzbget_port = 6789

# qBittorrent for torrents
qbittorrent_host = qbittorrent
qbittorrent_port = 8080

[Providers]
# Prowlarr as your indexer aggregator
prowlarr_url = http://prowlarr:9696
prowlarr_apikey = your-api-key-here

Metadata Sources

This is where LazyLibrarian earns its keep. Under Config → Searching, you configure metadata sources in priority order:

• Goodreads — best coverage, worst reliability. Set up an API key, but don’t depend on it exclusively.
• GoogleBooks — solid fallback, missing some niche titles.
• Open Library — fully open, no API key needed, sparse on newer releases.
• ISBN-DB — needs a paid API key for bulk lookups, excellent accuracy when you have an ISBN.

LazyLibrarian will try each source in order and use the first one that returns a result. When Goodreads is having a day, your other imports keep working. That’s the key difference from Readarr — no single point of failure.

Author Follow Workflow

The killer feature: add an author, LazyLibrarian monitors for new releases and grabs them automatically.

1. Go to Authors → Add Author
2. Search for the author name — LazyLibrarian queries your configured metadata sources
3. Set Status: Wanted (for everything) or select individual books
4. Hit Save — it’ll kick off a search across your indexers immediately

For series management, LazyLibrarian pulls series data from Goodreads when available. Books get tagged with series name and position, so your Calibre library actually shows “The Stormlight Archive #1” instead of “The Way of Kings (Sanderson, Brandon).”

Quality Profiles

LazyLibrarian calls these “Preferred Extensions.” Under Config → Processing:

[Processing]
# Ebook format priority (first match wins)
ebook_type = epub,mobi,azw3,pdf
# Audiobook format priority
audiobook_type = m4b,mp3,flac
# Reject these formats entirely
reject_words = sample,partial,excerpt

EPUB is the right call for ebooks — universal support, reflowable, works with Calibre, KOBOs, Kindles via conversion. AZW3 is fine if you’re Amazon-only. PDF is a last resort for anything that isn’t a scanned technical manual.

For audiobooks, M4B (AAC in MPEG-4 container) is the gold standard — chapters, cover art, proper metadata. MP3 works everywhere but you lose chapter support. FLAC audiobooks exist but you’re looking at 3-4x the file size for marginal quality gains on spoken word. Your call.

Setting Up Readarr

Compose Stack

services:
  readarr:
    image: lscr.io/linuxserver/readarr:develop
    container_name: readarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
    volumes:
      - ./config/readarr:/config
      - /mnt/media/books:/books
      - /mnt/downloads:/downloads
    ports:
      - "8787:8787"
    restart: unless-stopped

  prowlarr:
    image: lscr.io/linuxserver/prowlarr:latest
    container_name: prowlarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=America/New_York
    volumes:
      - ./config/prowlarr:/config
    ports:
      - "9696:9696"
    restart: unless-stopped

  audiobookshelf:
    image: ghcr.io/advplyr/audiobookshelf:latest
    container_name: audiobookshelf
    environment:
      - TZ=America/New_York
    volumes:
      - ./config/audiobookshelf:/config
      - ./config/audiobookshelf/metadata:/metadata
      - /mnt/media/audiobooks:/audiobooks
      - /mnt/media/books:/ebooks
    ports:
      - "13378:80"
    restart: unless-stopped

Use the develop tag. Readarr’s nightly and master channels have been inconsistently maintained. The develop image from linuxserver gets community patches faster.

Quality Profiles

This is where Readarr’s *arr heritage shines. The quality profile system is identical to Sonarr/Radarr:

1. Settings → Quality — define your acceptable formats
2. Create a profile: “Ebooks” with EPUB preferred, MOBI acceptable, PDF cutoff
3. Create a profile: “Audiobooks” with M4B preferred, MP3 acceptable

You can set minimum size thresholds to avoid grabbing 50KB “ebooks” that are actually just sample chapters. Set a floor — anything under 500KB for an ebook is suspicious.

Author and Book Search

The *arr-family workflow is familiar: search for an author, monitor them, set a quality profile. Readarr queries its central metadata server (built on Goodreads data, with some additional sources) and populates series information automatically.

One-off book searches work through the Add Book interface — search by title, ISBN, or author. Readarr handles the import and rename on download.

The Metadata Server Problem

Here’s the honest part. Readarr’s metadata API (api.readarr.com) is a community-run service. When it goes down — and it has, multiple times — here’s what breaks:

• New author/book searches return nothing — the lookup fails silently or with a vague error
• Automatic monitoring stops working — Readarr can’t check for new releases it doesn’t know about
• Already-monitored items still download — if a book was already in your library, existing monitored grabs will continue

Coping strategies:

1. Check the Readarr Discord #help channel immediately — if it's a server-side issue,
   someone will have posted about it within 20 minutes.

2. For books you need NOW: grab manually via your usenet/torrent client and
   use Readarr's manual import. The import/rename logic still works without
   the metadata server.

3. Keep a Calibre library as your ground truth. Even when Readarr is broken,
   Calibre's fetch metadata function (which queries its own sources) still works.

4. Consider running a local Goodreads API proxy cache. Overkill for most people,
   but if you're adding 50 authors at once, it's worth it.

Audiobookshelf: The Playback Layer

Neither LazyLibrarian nor Readarr plays your audiobooks — they just download and organize them. That’s where Audiobookshelf comes in.

Point it at your audiobook directory, and it:

• Reads chapter data from M4B files
• Syncs your playback position across devices (iOS, Android apps available)
• Streams to browser with a clean player UI
• Manages per-book and per-series progress

After LazyLibrarian or Readarr drops an audiobook into /mnt/media/audiobooks/, Audiobookshelf picks it up on its next library scan (or trigger a manual scan from the UI). No extra configuration needed — just make sure the volume mounts point to the same physical directory.

Calibre Integration

For ebooks, Calibre is the industry-standard library manager and format converter. Calibre-Web sits in front of it to give you a browser-readable interface and OPDS server for e-readers.

The key integration point: tell LazyLibrarian (or Readarr) to use your Calibre library directory as the root, and let Calibre’s calibredb binary handle adding books and metadata.

In LazyLibrarian:

[Calibre]
# Use calibredb for adding books (gets you proper metadata, covers)
use_calibre = 1
calibre_dir = /books
# calibredb binary path inside calibre-web container with the mod
calibredb = /usr/bin/calibredb

With this setup, downloaded ebooks get passed through calibredb add before landing in your library. You get:

• Automatic cover fetching
• Metadata normalization
• Format conversion on-the-fly (MOBI → EPUB if you configure it)
• Series/author tagging that plays nicely with Calibre-Web’s UI

Side-by-Side: Which One

When to Pick LazyLibrarian

• You want audiobooks AND ebooks in one tool
• You’re not already invested in the *arr ecosystem
• You want metadata reliability — multiple fallback sources matter to you
• You read comics or manga alongside books
• You need Calibre deep integration today

When to Pick Readarr

• You’re already running Sonarr/Radarr and want a consistent UX across your media stack
• You only care about ebooks (audiobooks need a separate tool regardless)
• You’re comfortable with alpha software and checking Discord when things break
• Quality profile granularity matters to you — Readarr’s cutoff/upgrade logic is more powerful

The Bottom Line

Your ebook library Frankenstein situation is fixable in an afternoon. Both tools will get you there — the question is how much alpha-software babysitting you’re willing to do.

LazyLibrarian is the pragmatic choice in mid-2026. It handles ebooks, audiobooks, and comics, has real metadata fallbacks when Goodreads acts up, and the linuxserver image is actively maintained. It’s not as pretty as Readarr, but it doesn’t ghost you when the metadata server is having an existential crisis.

Readarr is the right call if you’re already deep in the *arr ecosystem and want UX consistency across your entire media stack. Just go in with eyes open: it’s alpha software with a community-maintained metadata API. Have a manual import workflow ready, keep Calibre as your safety net, and bookmark the Readarr Discord.

Either way: pair your book manager with Audiobookshelf for audiobook playback, Calibre-Web for ebook serving, and Prowlarr for indexers. That four-container stack — book manager + Audiobookshelf + Calibre-Web + Prowlarr — covers everything from automated downloading through polished playback.

Your 2 AM self, staring at an unread 14-book fantasy series that’s currently scattered across six directories in three formats, will appreciate the effort.