audiobooker-ai 3.0.0

English | 日本語 | 中文 | Español | Français | हिन्दी | Italiano | Português (BR)

Turn EPUB / TXT / PDF / DOCX books into professionally narrated, multi-voice audiobooks — M4B / MP3 / Opus / FLAC / WAV, with chapter markers, cover art, and mastering to the ACX audio spec. From one command.

npx @mcptoolshop/audiobooker make mybook.epub --acx

Audiobooker detects dialogue, casts a distinct voice to each character, infers emotion, lets you review and correct everything before a single second is rendered, then masters the result to the ACX audio spec — so the output is a finished audiobook, not just generated audio.

Install

Zero-install (Node):

npx @mcptoolshop/audiobooker --help

Python (CLI):

pipx install audiobooker-ai            # isolated CLI
uvx audiobooker --help                 # zero-install trial
pip install "audiobooker-ai[render]"   # with the TTS voice engine

Docker — ffmpeg already inside, published to GHCR on every release:

docker run --rm -v "$(pwd):/data" ghcr.io/mcp-tool-shop-org/audiobooker \
  make /data/mybook.epub --acx

That one mount is enough, and --rm is safe: the render cache lives beside the project file, not in a home directory, so a re-run resumes instead of re-synthesizing the book.

Rendering audio needs the voice-soundboard TTS engine (the [render] extra) and FFmpeg on PATH (winget install ffmpeg · brew install ffmpeg · apt install ffmpeg). Everything up to render — parse, cast, compile, review — works without them. Run audiobooker diagnose to check your setup.

git clone https://github.com/mcp-tool-shop-org/audiobooker
cd audiobooker
pip install -e '.[render]'

Quick start

# One command: parse -> auto-cast -> compile -> render -> master
audiobooker make mybook.epub --acx

# ...or the staged workflow, with control at each step:
audiobooker new mybook.epub            # parse into chapters (EPUB/PDF/TXT/MD/DOCX, or a folder)
audiobooker cast --interactive         # guided per-character casting
audiobooker audition Sarah --render    # A/B candidate voices for one character
audiobooker compile                    # detect dialogue, attribute speakers, infer emotion
audiobooker speakers                   # who did compile find?
audiobooker speakers --suggest-aliases # Dr. Merrin / Merrin / The Doctor?
audiobooker speakers merge "Dr. Merrin" Merrin   # fold those slots into one voice
audiobooker report                     # what's weak? unattributed + guessed rates, top lines
audiobooker review-export              # human-editable script — fix attributions
audiobooker review-import mybook_review.txt
audiobooker render --acx               # render + master to ACX spec
audiobooker master-check mybook.m4b    # PASS/FAIL vs ACX loudness/peak/noise-floor

Features

Input & structure

• EPUB, TXT, Markdown, PDF, DOCX, or a folder of per-chapter files (Scrivener/Obsidian/serialized fiction).
• TOC-driven EPUB splitting — chapter boundaries and titles from the book's own table of contents.
• DOCX splits on Word Heading 1/2/Title styles; PDF detects headings (with a scanned-PDF guard); custom --chapter-delimiter.
• Smart text cleaning, Markdown-aware stripping, footnote handling, and a reusable pronunciation lexicon (pronunciation import/export, CSV/JSON, with phoneme passthrough).

Casting & attribution

• Multi-voice synthesis with explainable, ranked voice suggestions and an audition command to A/B candidates per character.
• Interactive casting, bulk cast-fill by gender/role, named cast presets reusable across a series, and CSV cast sheets for collaborators.
• Dialogue detection + speaker attribution (optional BookNLP co-reference), alias auto-discovery, and emotion inference with adjustable intensity, scene-level mood, and genre preset packs.
• Attribution you can audit. Every line records how its speaker was decided — a speech tag, an inline override, co-reference, your own correction, or a bare alternating-turn guess — and report counts the guesses separately from the lines it could not attribute at all. A guess cannot improve the score, so the number goes down when the attribution gets worse, which is the only direction that is useful.

Rendering & output

• M4B (chapter markers + embedded cover + series metadata), MP3, Opus, FLAC, WAV; per-chapter export; podcast/RSS feed export. WAV has no chapter atom, so a WAV render says so plainly rather than reporting a failed chapter mux — reach for it when the audio is going into an editor.
• ACX-spec mastering (--acx) + a master-check that reports PASS/FAIL on RMS loudness, peak, and noise floor; retail sample clips.
• Parallel rendering, a persistent render cache with resume, dynamic progress + ETA, and structured failure reports. The cache key covers everything that changes the audio — text, cast, voices, engine and version, profile, emotion preset and intensity — so a re-render that says "Cached" means it. An opt-in per-utterance cache (utterance_cache) narrows a re-render to the lines you actually edited.

Workflow & ecosystem

• make one-shot pipeline · config file (.audiobookerrc / [tool.audiobooker]) · --watch mode · manifest-driven batch · shell completion.
• 7 language profiles (en/fr/de/es/ja/it/pt) · pluggable TTS engines (--engine, entry-points — bring Piper/Coqui/ElevenLabs) · scriptable --json on most commands · structured exit codes.

Mastering to the ACX audio spec

ACX publishes a precise, measurable audio target. It is the closest thing the audiobook world has to a mastering standard, and it is worth hitting whatever you do with the file afterwards.

audiobooker render --acx --format mp3 --bitrate 192k
audiobooker master-check book.mp3      # PASS/FAIL against the three measured limits
audiobooker sample --duration 180      # a mastered retail sample clip

Two things the numbers above deserve:

master-check measures unweighted RMS, not LUFS. They are different quantities and ACX gates on the former. The −20 LUFS figure is how the mastering pass gets there — it is what ffmpeg loudnorm can target — not what is checked afterwards.

The noise floor is measured, not corrected. It is the requirement that most often fails, and it comes from the source audio. A tool that quietly gated it would be hiding the one number you need to see.

Where an AI-narrated audiobook can actually go

Meeting the spec is not the same as being accepted, and this is worth being plain about: ACX's standard submission flow is for human narration. Its April 2026 requirements list unauthorised text-to-speech and AI recordings among the things it does not accept, so an AI-narrated title needs prior authorisation from ACX rather than an ordinary submission.

Routes that do accept AI narration, generally with disclosure, include Amazon's Virtual Voice through KDP (Amazon-only distribution) and aggregators such as Spotify Audiobooks for Authors, Author's Republic and Kobo Writing Life. Retailer policy in this area moves quickly — check the current terms yourself rather than trusting this paragraph.

So: --acx is about the audio. Whether a retailer accepts an AI-narrated title is their decision, not a property of the file you just produced.

CLI commands

Every command supports -h/--help. Global flags: --silent, --debug. Exit codes: 0 ok · 1 user error (including a book that would not compile, or a render refused because attribution failed) · 2 runtime · 3 partial (batch).

Configuration

Set defaults once instead of re-passing flags — .audiobookerrc (TOML) next to your book, or [tool.audiobooker] in pyproject.toml. Precedence is CLI flag > project config > user config (~/.audiobookerrc) > built-in defaults.

# .audiobookerrc
output_format = "m4b"
output_profile = "acx"
lang = "en"
jobs = 4
booknlp_mode = "auto"

Pluggable TTS engines

The default engine is voice-soundboard, but the synthesis backend is swappable via setuptools entry-points (audiobooker.tts_engines):

audiobooker render --engine piper      # or set AUDIOBOOKER_ENGINE=piper

A plugin (pip install audiobooker-piper) registers itself; no fork required.

Python API

from audiobooker import AudiobookProject

project = AudiobookProject.from_epub("mybook.epub")   # or from_docx / from_pdf / from_folder / from_string
project.cast("narrator", "bm_george", emotion="calm")
project.cast("Alice", "af_bella", emotion="warm")
project.compile()                                     # dialogue, speakers, emotion
project.render("mybook.m4b")                          # resumes from cache on re-run
project.save("mybook.audiobooker")

render(...) and compile(...) accept an injected engine= (any object implementing the TTSEngine protocol) and a progress callback — embed audiobooker in a GUI or service.

Architecture

audiobooker/
├── parser/      # EPUB, PDF, TXT/MD, DOCX, folder, language-aware splitting
├── language/    # 7 language profiles (quotes, speaker verbs, chapter patterns)
├── casting/     # dialogue detection, voice suggestion, presets, cast-fill
├── nlp/         # BookNLP adapter, emotion inference, speaker/alias resolution
├── renderer/    # synthesis, chapter+utterance cache, mastering, assembly, RSS
├── config_file.py · review.py · project.py · cli.py

Source (EPUB/PDF/DOCX/TXT/folder) -> Parser -> Chapters -> Dialogue & Emotion ->
Casting -> Review/Edit -> TTS (pluggable) -> cached audio -> FFmpeg master -> M4B/MP3/Opus/FLAC/WAV

Security & data scope

• Network: none — no telemetry, no data storage, no credentials. Reads your book files, writes audio + cache to your output dirs.
• Permissions: read access to inputs, write access to outputs; optional FFmpeg + a TTS engine on PATH.
• See SECURITY.md.

Scorecard

License

MIT

Built by MCP Tool Shop