Most text-to-speech models give you a menu of pre-baked voices and a speed slider. chatterbox gives you something more useful: a voice you bring yourself. It's the open-weights TTS released by Resemble AI, a company that has been building commercial voice-cloning infrastructure for years, and it packages their production experience into a model anyone can run or call. Feed it a short reference clip of a speaker, hand it some text, and it reads that text back in the speaker's voice. Not a vague impression of the voice — the timbre, the pacing habits, the tonal fingerprint.
That capability puts it in a different category from the stock-voice narrators. When the voice itself is the product — a character, a brand, a narrator whose identity has to stay consistent across fifty episodes — you don't browse a voice library. You clone the one voice that matters, and you keep it. That's the job Chatterbox was built for, and it's the reason it sits in our catalog next to cheaper, faster TTS options that don't even attempt cloning.
This post is the honest tour: what it's genuinely good at, where it falls short, how it stacks up against kokoro-82m and orpheus-3b, what it costs, and how to call it through the API.
Voice cloning from a reference sample
This is the headline feature and the reason to pay Chatterbox prices instead of Kokoro prices. The cloning is zero-shot: you don't fine-tune anything, you don't collect a dataset, you don't wait for a training job. You provide a reference audio sample of the target speaker, and the model conditions its generation on that sample. In practice, somewhere in the five-to-fifteen-second range of clean speech is enough to lock onto a voice. Longer and cleaner references give the model more to work with, but you're not recording studio sessions.
The clone quality tracks the reference quality almost one-to-one, which is worth understanding before you blame the model. A clip recorded on a decent USB mic in a quiet room clones well. A clip ripped from a podcast with intro music bleeding under the speech, or compressed to death over a video call, will clone the artifacts along with the voice. Garbage in, karaoke out. If you're building anything serious on this, spend your effort budget on the reference sample, not on retry loops.
Concrete use cases where this earns its keep:
- Character voices for games and audio fiction. Record your voice actor once, then generate every line, retake, and pickup without booking another session. Rewrites stop being a scheduling problem.
- A consistent host voice for a serialized show or channel. One narrator identity across hundreds of episodes, even when the actual recording happens in batches weeks apart.
- Your own voice, scaled. Course creators and newsletter authors clone themselves and turn written drafts into audio versions without reading every word into a mic.
- Localization of an existing voice persona. Keep the brand voice while regenerating lines for new scripts, trailers, or announcements.
One line that shouldn't need saying but does: clone voices you have the right to clone. Your own voice, your paid actors, voices with signed releases. The model doesn't check, and the platform doesn't editorialize, which means the responsibility is yours.
Recording the reference is worth doing deliberately. Speak at the pace and energy you want the clone to default to, because the model treats the reference's delivery as the baseline. Leave a beat of silence at the start and end of the clip so the edges don't clip mid-phoneme. Avoid references with long pauses, laughter, or music beds. And keep a few alternate takes: if a generation comes back slightly off, swapping in a different take of the same speaker often fixes what parameter-tweaking can't.
Expressive delivery control
Cloning gets you the right voice. The next problem is getting the right read. Flat, neutral narration is fine for documentation; it's death for dialogue, ads, or anything with emotional stakes. Chatterbox exposes generation controls — an exaggeration parameter and a classifier-free guidance weight — that let you push the delivery around. Dial the exaggeration up and the same line comes out hotter: more emphasis, wider dynamic range, more theatrical stress patterns. Pull it down and the read flattens toward a careful, even narrator.
This matters more than it sounds. With stock-voice TTS, "expressiveness" is usually a label on a dropdown — pick the "excited" variant of Voice #7 and hope. Here you're steering a continuous control on top of a cloned voice, so the emotion stays in-character. A villain's menacing whisper and the same villain shouting a reveal are recognizably the same person, because the underlying speaker identity doesn't change when the delivery does.
The practical workflow is a calibration pass, not a guessing game. Take a handful of representative lines from your script — one quiet, one heated, one expository — and sweep the exaggeration control until each read lands. Write those values down. Voice settings behave like presets: once you know that your narrator lives at a moderate setting and your antagonist needs the top third of the range, every future generation in that project starts from a known-good point instead of a cold start.
Open weights from a team that ships voice for a living
Provenance matters in TTS because the space is full of anonymous checkpoints with unclear training data and license traps. Chatterbox is neither: it's a public release from Resemble AI, a company whose entire business is voice synthesis, released as open weights you can actually inspect and, if you want, self-host. The people who built it sell voice cloning to production customers; the open model is the same lineage, not a research demo that happened to leak.
For you as an API consumer, that translates to predictability. The model's failure modes are documented in the open, the community has mapped its quirks — how it handles numbers, abbreviations, long pauses, reference length — and the behavior you test against today is the behavior you get next month. There's no silent model swap because a vendor decided to retrain. When a line comes back wrong, you can reproduce it, report it, and engineer around it.
It also means the model has a real ecosystem. Fine-tunes, reference-sample recipes, pronunciation workarounds, chunking strategies for long documents: all of it exists in the open because the weights are in the open. When you hit an edge case, the odds are decent that someone else hit it first and posted the fix.
There's a quieter benefit too: the open release sets a floor under the whole voice-cloning market. Hosted cloning services compete against a model anyone can run, which keeps every vendor in the space honest on both price and capability. Calling it through an API instead of self-hosting is the convenience trade — you skip the GPU bill and the dependency wrangling, and you pay per character only for what you actually render.
Long-form consistency across a production
A single cloned line is a party trick. The real test is hour six of an audiobook or episode forty of a podcast: does the voice still sound like the same person? This is where Chatterbox earns the "production-grade" label. Because the speaker identity is anchored to your reference sample rather than to some internal voice slot that might get retrained, the timbre stays put. Generate a thousand lines across a month of sessions and they cut together.
The workflow that works: keep your reference clip and your generation settings under version control next to your scripts. Treat them like assets, because they are. Then chunk your long texts at natural boundaries — paragraphs, scene breaks, dialogue turns — rather than character counts, so prosody resets where a human reader would breathe anyway. Stitching paragraph-sized chunks is boring engineering, and boring is exactly what you want in a pipeline that produces billable audio.
Pair it with a cheap text model upstream and the whole pipeline closes: draft the chapter with euryale-l3.3-70b-uncensored or bulk-generate episode scripts with mythomax-l2-13b-uncensored, then voice them with your cloned narrator. One account, one API shape, text in and audio out.
No content referee in the audio path
Mainstream TTS APIs run your script through a moderation layer before a single phoneme is generated, and the filters are not subtle. Dark fiction, horror narration, mature audiobook content, profanity-heavy dialogue — all of it can bounce off a safety classifier that was tuned for corporate explainer videos. Chatterbox itself is an open model with no moralizing layer, and we serve it the way we serve everything else in the catalog: your text goes in, your audio comes out.
If you write thrillers, war fiction, or anything where the dialogue isn't rated for a general audience, this is the difference between a tool and a negotiation. The model reads what's on the page, in the voice you gave it, with the delivery you dialed in. Whether that content should exist is a question for you and your audience, not for an API's terms-of-service bot.
Where it falls short
Honesty section, because every model has one and pretending otherwise is how you end up with a burned afternoon.
- It's English-first. The released model is trained for English. Other languages will produce audio, but accent and pronunciation drift fast. If your project is multilingual narration, this is the wrong tool today.
- Cloning quality is reference-bound. Noisy, reverberant, or over-compressed references clone the noise along with the voice. There is no setting that rescues a bad sample; re-record or clean the audio first.
- It's not the cheap option. At ten times Kokoro's per-character price, using Chatterbox for generic narration where any competent voice would do is setting money on fire.
- It's not the fastest option. Cloning models are heavier than tiny stock-voice models. For high-throughput, latency-sensitive jobs — live captioning, real-time chatbots — the size tax is real.
- Long generations need chunking. Past a certain length, prosody drifts and artifacts creep in. You must split long documents yourself; the model won't manage a three-hour chapter in one shot.
- Numbers and odd tokens can stumble. Dates, currencies, and strange abbreviations sometimes read literally. Spell out what matters, or pre-process your script.
None of these are deal-breakers for the use cases the model is actually for. They're deal-breakers for the use cases it's not for, which is the entire point of knowing them.
Chatterbox vs kokoro-82m vs orpheus-3b
Three TTS models in the lineup, three different jobs. kokoro-82m is the workhorse: tiny, fast, and absurdly cheap at $0.99 per million characters upstream, with a set of solid stock voices. If you're voicing documentation, generating article-to-audio versions, or prototyping a voice feature, Kokoro is the default answer and it's not close. What it won't do is become a specific person. Its voices are its voices.
orpheus-3b sits in the middle at $7 per million characters upstream, and its game is emotional delivery: guided affect, naturalistic emphasis, speech that sounds performed rather than read. When the script is dramatic but the voice can be anyone, Orpheus is the pick. When the voice must be a particular someone, it isn't.
chatterbox is the specialist at $10 per million characters upstream. It trades Kokoro's price and Orpheus's out-of-box theatrics for the one thing neither offers: zero-shot cloning of a voice you supply, plus enough delivery control to keep that cloned voice expressive. The decision tree is short. Need any decent voice, cheap? Kokoro. Need an emotional read of a dramatic script? Orpheus. Need *that* voice, specifically? Chatterbox. Plenty of productions use two of them: Kokoro for scratch tracks and previews while the script is still moving, Chatterbox for the final render once lines are locked.
The comparison also clarifies what "expensive" means in context. Chatterbox costs ten times Kokoro per character, which sounds steep until you remember the absolute numbers: even at full retail, an entire audiobook is a lunch-money purchase. You're not choosing between cheap and ruinous; you're choosing between very cheap and slightly less cheap, and paying the difference only on the projects where voice identity is the point.
What it costs
Upstream, Chatterbox runs $10 per million characters. At the standard retail rate — upstream cost × 2.5 — you pay $25 per million characters. Rate cuts are permanent and based on your largest single deposit: one deposit of $50 drops your multiplier to 2.25× ($22.50 per million), $100 to 2.10× ($21 per million), and $200 to 2.00× ($20 per million, flat double upstream). Every character of every model bills at your rate, and credits never expire. Prices move with upstream providers, so check /pricing for the live numbers before you budget a big render.
In concrete units: a typical audiobook chapter of 3,000 words is around 18,000 characters, which lands near forty-five cents at the standard rate. A full 80,000-word novel voiced in a cloned narrator runs roughly $12 at retail. That's the whole book, not a monthly fee. Deposits are crypto, from $5 up, via NOWPayments — no card on file, no subscription quietly renewing.
How to call it
The API is OpenAI-compatible, so if you've ever called OpenAI's speech endpoint you already know the shape. Signup gives you an anonymous account key — a BAM-XXXX-XXXX-XXXX string — plus a password; no email, no KYC, and your API key (sk-bam-...) comes from the dashboard. Swap the base URL and the key, point the SDK at chatterbox, and you're generating.
import OpenAI from "openai";
import { writeFileSync } from "node:fs";
const client = new OpenAI({
baseURL: "https://badassmodel.com/v1",
apiKey: process.env.BAM_API_KEY, // sk-bam-...
});
const speech = await client.audio.speech.create({
model: "chatterbox",
voice: "clone", // your cloned voice / reference config
input: "The door was locked from the inside. That was the first problem.",
});
writeFileSync("chapter-one.mp3", Buffer.from(await speech.arrayBuffer()));
console.log("saved chapter-one.mp3");For anything longer than a paragraph, loop over your chunks, pass your reference and delivery settings consistently on every call, and concatenate the audio. Keep the reference clip and parameters in your repo so a render six months from now matches today's.
Who it's for
Chatterbox is for builders whose audio has a name attached. Indie game devs keeping a cast of character voices consistent through two years of patches and DLC. Audiobook and fiction podcast producers who need one narrator identity across a catalog. Course creators and newsletter writers turning their own voice into a scalable output format. Anyone shipping fiction with teeth who got tired of moderation layers rejecting their own scripts.
It's not for generic narration at scale — that's kokoro-82m — and it's not for theatrical one-off reads where any voice will do — that's orpheus-3b. But when the spec says "it has to sound like *this person*, every time, forever," Chatterbox is the model in the lineup that answers. Bring a clean reference, dial in your delivery once, and the voice is yours.