How to Split an M4B Into Chapters (Without Re-Encoding)

You have one M4B, fourteen hours long, chapters and all. But the car stereo sees one giant track, and the old player will not take a file that big. You need the book in pieces.

Do not convert it — the chapters are already in the file, and splitting is a copy job that loses nothing. AudioBo shows where every chapter starts, lets you fix the marks, and exports from there. The rest of the page is the same job by hand.

The rest of this page is the machinery: how to read the chapter table the book already carries, how to cut on its boundaries, and the three things that go quietly wrong while you do.

First: check whether you need to do this at all

If the app you are using can read embedded chapters, splitting makes your library worse. You trade one clean file with a chapter menu and a remembered position for thirty files that a player will happily treat as thirty separate items.

Apple Books reads chapters out of a single M4B and lets you move between them. A book that imports there without a chapter menu either never had chapters embedded, or carries them only as a Nero chpl list, which Apple’s frameworks do not read — and neither case is fixed by cutting the book up. If Books is where you listen, close this page and keep the file whole.

Splitting is worth it in three situations, and they are all “the target cannot read chapters, and never will”:

• A media server that indexes audiobooks as track lists. Cut the book into chapters and the track list becomes the chapter list — the workaround exists precisely because the chapter table is being ignored.
• A car stereo or a cheap player reading a USB stick, where “next track” is the only navigation that exists.
• An old iPod, where per-file length limits mean a long book has to arrive in parts regardless.

And if the chapters are missing from the file in the first place, splitting is not your problem yet — that is a diagnosis question, and it lives on why an M4B shows no chapters.

One boundary before the commands. If the book came from a store and is protected, none of this works: the file will not open for copying, and no tool on this page changes that. AudioBo does not remove DRM either. The M4B to MP3 guide covers what that means in practice.

Why splitting does not need re-encoding

Cutting a book up sounds like it ought to mean making the audio again from scratch, and that is where the quality loss in most people’s split files comes from. It does not have to work that way. The sound in an audiobook is stored as a long run of very short pieces, and the file keeps a record of where every one of them starts. A splitter reads that record, copies out the stretch you asked for, and never has to understand the sound at all. What comes out is the same audio that went in.

That is also why the cut lands where you asked rather than somewhere near it, and why it costs you nothing in sound quality.

An M4B is AAC audio inside an MPEG-4 container, and the container knows exactly where every audio frame begins. Frames are short, and there is no equivalent of a video keyframe you have to hunt backwards for. A splitter copies out the frames covering the range you asked for, writes them into a fresh container, and never decodes a thing.

Want the measured version? I checked this on a file I built for the purpose: a five-minute M4B with three chapters, a cover, and title and artist tags. Asking for the 60-to-180-second range produced a piece of 120.000998 seconds — one millisecond of overshoot, and the audio bits copied rather than re-encoded. Cutting the same book at every chapter boundary summed back to within a few hundredths of a second of the original duration, and the largest single overshoot I measured anywhere was 22 milliseconds, which is roughly the length of one AAC frame.

Chapter boundaries in an audiobook usually land in silence. Millisecond precision is far more than the material needs.

Read the chapter table before you cut anything

Every cut you are about to make comes out of the times the book is already carrying: where each chapter starts, where it ends, and what it is called. Everything downstream depends on those timings, so look at them before you touch anything. Reading the list changes nothing in the file — and if it comes back empty, you have a different problem than the one you came here with.

ffprobe ships with ffmpeg, and on a Mac Homebrew is the usual way to get both.

Check your own book:

ffprobe -v error -show_chapters -of 'csv=p=0:s=|' \
        -show_entries chapter=start_time,end_time:chapter_tags=title \
        "MyBook.m4b"

You get one line per chapter:

0.000000|60.000000|Chapter One
60.000000|180.000000|Chapter Two
180.000000|300.000000|Chapter Three

The s=| is not decoration. The default separator is a comma, and ffprobe quotes any title that contains one — so a chapter called Chapter Two, Revisited comes back wrapped in literal double quotes and lands in your filenames that way. Ask for pipes and the problem disappears.

If this command prints nothing, the file has no chapter table, and no splitter can invent one.

Split at the chapter boundaries

There are two jobs here, and from the outside they look like the same one. Pulling a single chapter out of a book is one instruction: start here, stop there, copy. Cutting a whole book into one file per chapter is that same instruction repeated once for every line of the list you just read, with the right title and the right number put on each piece as it comes out — which is work for a short script rather than for you and a calculator.

Start with the single chapter. It tells you whether the cut is landing where you asked, and if it is not, you have one wrong file to throw away instead of thirty.

Try one chapter first. The single-chapter case is one command. This pulls out the second chapter:

ffmpeg -ss 60 -to 180 -i "MyBook.m4b" -map_chapters -1 -c copy \
       -metadata title="Chapter Two" -metadata track=2 \
       "02 - Chapter Two.m4a"

The -to sits before -i, which makes it an input option — that is what keeps the cut accurate here on ffmpeg 8.0. Older builds treated input-side -to differently, so check the length of the first piece before you trust the rest.

Now do the whole book. Feed the chapter table into a loop. This is the version I ran against the test file — it handles titles with commas, keeps the cover art, and numbers the files so they sort correctly:

#!/bin/bash
book="$1"
mkdir -p chapters
i=0
ffprobe -v error -show_chapters -of 'csv=p=0:s=|' \
        -show_entries chapter=start_time,end_time:chapter_tags=title "$book" |
while IFS='|' read -r start end title; do
  i=$((i + 1))
  num=$(printf "%02d" "$i")
  ffmpeg -nostdin -loglevel error -ss "$start" -to "$end" -i "$book" \
         -map_chapters -1 -c copy \
         -metadata title="$title" -metadata track="$i" \
         "chapters/${num} - ${title//\//-}.m4a"
done

Save it as split-chapters.sh, run bash split-chapters.sh MyBook.m4b, and you get a chapters folder with one file per chapter, each carrying its own title, its track number, the book’s album tag, and the cover art.

The ${title//\//-} is there because a slash in a chapter title is a directory separator in a filename. The one other character worth knowing about is the pipe itself: ask for s=| and a title that contains a literal | comes back wrapped in double quotes, exactly the way a comma does under the default separator, and those quotes land in the filename.

For fixed-length pieces instead of chapters — an old device with a length ceiling, say — the segment muxer does it in one pass:

ffmpeg -i "MyBook.m4b" -c copy -map_chapters -1 \
       -f segment -segment_time 3600 -reset_timestamps 1 \
       "part%02d.m4a"

That gives you hour-long parts. Cutting by file size rather than duration has no direct equivalent here: you work out the duration that lands near your size target from the bitrate, and cut by time.

The three things that go wrong, and what they look like

None of these stops the commands from finishing. You get your files, they play, and the damage only shows up later in whatever you were feeding: every piece insisting it is the whole book, a chapter menu pointing at time the file does not contain, and — if you tidy up the wrong thing on the way through — the cover gone from all of them.

Every one of these came out of the test runs, and none of them announces itself.

The pieces inherit the whole book’s chapter list. Chapter data is metadata, and a plain -c copy brings metadata along. Cutting 60 to 180 seconds out of the three-chapter test file produced a two-minute piece that still claimed all three chapters — the first collapsed to zero length, and the last one ran to 240 seconds inside a file that ends at 120. A chapter table that points past the end of its own file is not something any player can do anything sensible with. -map_chapters -1 removes it, which is why it is in every command above.

Every piece claims to be the whole book. Title, artist, and album copy across untouched, so without the -metadata title= override you end up with thirty files all named after the book and sorted by luck. The track number matters as much as the title: track order is what a car stereo and a media server actually sort on. Fixing tags after the fact is a separate chore, and one worth doing in a proper M4B metadata editor rather than thirty times by hand.

The cover survives, unless you tell it not to. Cover art is a still-image stream inside the container, and a plain copy carries it. Add -map 0:a to be tidy about streams and you have quietly discarded the artwork from every piece. Leave the stream selection alone and it comes through.

There is a fourth, subtler one. Name your output .m4b and ffmpeg will still write M4A as the major brand in the ftyp atom — the first sixteen bytes of the file say so plainly under a hex dump. The extension does not set the brand, which is the same reason renaming an .m4a to .m4b was never a conversion. For per-chapter pieces this rarely matters, since the point of splitting is to feed something that ignores audiobook flags in the first place. Call them .m4a and move on. If the pieces need to behave as audiobooks, they need a container that declares the M4B brand — AudioBo writes it into the ftyp atom and shows the hex dump on its own page.

When you want MP3 pieces instead

The one thing you cannot do is both at once. Cut the book into pieces first, change the format afterwards — in that order, because the second step is the expensive one and you want it running on pieces you have already checked.

Splitting and converting are separate operations, and the order matters. A stream copy into an MP3 container is not possible — AAC cannot live there, so MP3 pieces mean re-encoding, with the quality and time cost that carries. Cut first, convert the pieces you kept, and read how to convert M4B to MP3 on a Mac before you pick a bitrate.

What AudioBo does here: checking the boundaries and cutting into parts

The commands above are correct and free, and if you are splitting one book you should use them. ffmpeg is doing something genuinely hard extremely well, and a GUI cannot make the cut more accurate — it is already frame-accurate.

What a script does not give you is a look at the result before you commit. You cannot hear whether a chapter boundary in the file actually sits where the narrator stops talking, and on books with fetched or hand-written chapter data it does not always — fetched chapters can come from a different edition, or from a copy split differently, or from one with extra audio at the front. You find out after thirty files exist.

This is where AudioBo fits, and it is worth being precise, because it is not a per-chapter splitter.

What it gives you is the listen. You open the book in the app, hear where the chapters actually begin, move the ones that are in the wrong place, and export once you are happy — instead of discovering the problem after the files exist. And when what you want is a long book in a few large pieces rather than one piece per chapter, it does that cutting for you — and there is a mode that puts every cut on a chapter start rather than on a clock reading, which is the part that is genuinely tedious to do by hand.

If you do want the mechanical version: it splits long books into parts — by duration or by file size, added in version 1.2.6, and the parts come out as M4B files.

Chapter-aligned splitting is a separate, automatic path: iPod Compatibility mode splits long books into parts of twelve hours or less, aligns those splits to chapter boundaries, and uses codec settings for 2007–2010 devices. That is the case where the manual route is genuinely annoying, because you have to compute the boundaries yourself and each one has to be a chapter start.

Ordinary exports can go out as M4A or MP3 alongside M4B when the destination is picky.

If what you need is literally one file per chapter, the loop above is the right tool. What it leaves you with is thirty files that all claim to be the whole book — and renaming, renumbering and retagging that pile in one pass is the app’s Batch Rename, not thirty rounds of typing.

Putting the book back together

Splitting is not one-way. A folder of per-chapter files is exactly the input a builder wants, and the file boundaries become the chapter boundaries — which is the whole workflow in converting MP3 files to a chaptered M4B on a Mac, running in reverse.

The practical habit: keep the single M4B as the master and treat split output as disposable. Anything you cut can be cut again in a minute. Anything you re-encode has lost something you cannot get back.