Chatterbox TTS Setup: Free ElevenLabs Killer (MIT, 2026)

Chatterbox TTS is Resemble AI's open-source, MIT-licensed text-to-speech model that you install with pip install chatterbox-tts, clones a voice from roughly 5 seconds of reference audio, and was preferred over ElevenLabs 63.75% of the time in blind listening tests (run on Podonos). It ships in three flavors — the original 0.5B English model, a 23-language Multilingual version, and a leaner 350M "Turbo" build — and it is the first open-source TTS with an emotion exaggeration knob you can dial from calm to dramatic. You can run it as a Python library or stand it up behind a self-hosted, OpenAI-compatible API on your own GPU.

If you have been paying ElevenLabs by the character and want a local model that sounds close (and sometimes better) for free, this is the one to try first. Below is the honest setup: what to install, how the variants differ, what the emotion control actually does, and how to self-host it as a drop-in API.

What is Chatterbox TTS?

Chatterbox is a production-grade open-source TTS model from Resemble AI. The original model is built on a 0.5B-parameter Llama backbone trained on roughly 0.5M hours of cleaned speech data, and Resemble released it under a permissive MIT license — so you can use it in commercial products, modify it, and redistribute it without paying per character.

Two things make it stand out from the older open-source crowd (Coqui XTTS, Piper, Bark):

1. Emotion exaggeration control. Resemble bills it as the first open-source TTS to expose an explicit emotion-exaggeration parameter. You pass an exaggeration value (0.5 is neutral) to push the delivery from flat-and-clean toward expressive-and-dramatic.
2. It actually competes with the paid leader. In blind A/B tests where listeners compared identical text and reference clips, Chatterbox was preferred over ElevenLabs 63.75% of the time. That is the headline claim, and it comes from Resemble's own evaluation suite — treat it as "very competitive," not gospel, but it matches what most reviewers report.

Every Chatterbox output also carries Resemble's PerTh (Perceptual Threshold) watermark — an inaudible neural signal baked into the audio so synthetic speech stays traceable. That is a responsible-AI feature, not a limiter; the audio quality is unaffected.

How do you install Chatterbox TTS? (the 2-minute version)

The fastest path is the pip package. You need Python 3.10+ and, ideally, an NVIDIA GPU with CUDA (it runs on CPU and Apple Silicon too, just slower).

# 1. Create a clean environment (recommended)
python -m venv chatterbox-env
source chatterbox-env/bin/activate    # Windows: chatterbox-env\Scripts\activate

# 2. Install the package (pulls in PyTorch + model loader)
pip install chatterbox-tts

Then generate speech in a few lines of Python. Weights download automatically from Hugging Face on first run:

import torchaudio as ta
from chatterbox.tts import ChatterboxTTS

model = ChatterboxTTS.from_pretrained(device="cuda")   # "cpu" or "mps" also work

text = "Chatterbox runs entirely on my own machine — no API key, no per-character bill."
wav = model.generate(text)
ta.save("output.wav", wav, model.sr)

That is the whole "hello world." To clone a voice, point the same call at a short reference clip (more on that next).

How does 5-second voice cloning work?

Chatterbox does zero-shot voice cloning: you give it a short sample of a target voice and it speaks new text in that voice without any fine-tuning. Resemble's guidance is that around 5 seconds of clean reference audio is enough — a clear, single-speaker clip with no music or background noise works best.

from chatterbox.tts import ChatterboxTTS

model = ChatterboxTTS.from_pretrained(device="cuda")

wav = model.generate(
    "This sentence is read in the cloned voice.",
    audio_prompt_path="reference_voice.wav",   # ~5 seconds, clean, one speaker
)

Reference quality matters more than reference length, and the reason is mechanical: zero-shot cloning conditions generation on a speaker embedding extracted from that one clip. Background music, room echo or a second voice gets encoded into the embedding alongside the target voice, and the model then faithfully reproduces all of it. A pristine 5-second clip beats a noisy 30-second one. If a clone sounds off, re-record the reference before you touch any parameters. (For a deeper, dedicated walkthrough of cloning workflows, see our local AI voice clone guide.)

What does the emotion (exaggeration) parameter do?

This is Chatterbox's signature feature. Two knobs shape the delivery:

• exaggeration controls expressiveness. The neutral default is 0.5; raising it adds emphasis and emotion, lowering it flattens the read. Values around 0.7+ push toward dramatic, performance-style delivery.
• cfg_weight controls pacing and adherence; the default is 0.5. Lowering it (toward ~0.3) tends to speed up delivery and pairs well with a higher exaggeration for emotional speech.

# Calm, steady narration
wav = model.generate(text, exaggeration=0.4, cfg_weight=0.5)

# Lively, expressive read (good for ads or characters)
wav = model.generate(text, exaggeration=0.8, cfg_weight=0.3)

In practice these two interact: very high exaggeration with a high cfg_weight can rush the cadence, so Resemble suggests dropping cfg_weight when you crank exaggeration. Start at the defaults, change one knob at a time, and you will dial in a voice quickly.

The three Chatterbox variants compared

Chatterbox is a small family, not a single model. Pick by language need and hardware budget. All three are MIT-licensed and carry the PerTh watermark.

The Multilingual model supports 23 languages out of the box: Arabic, Danish, German, Greek, English, Spanish, Finnish, French, Hebrew, Hindi, Italian, Japanese, Korean, Malay, Dutch, Norwegian, Polish, Portuguese, Russian, Swedish, Swahili, Turkish, and Chinese.

Turbo is the speed-and-efficiency pick. At 350M parameters it is meant to "run anywhere," and Resemble quotes roughly 75ms latency and about 6x-faster-than-real-time inference on a single GPU — i.e. it can generate audio well ahead of playback, which is what you want for streaming or interactive apps. The original 0.5B model is still the quality benchmark for English; Turbo trades a little fidelity for a much lighter footprint.

How fast and heavy is it, really?

The figures below are Resemble's own published claims, repeated as vendor claims. Treat them as approximate and hardware-dependent.

You can sanity-check those claims with arithmetic instead of trusting them. Two numbers decide how Chatterbox behaves on your machine.

Memory. Weight bytes are parameters × bytes per parameter: the 0.5B model at FP16 is about 1GB, and the 350M Turbo build about 0.7GB. Activations, the vocoder and framework overhead ride on top, which is why the working set lands in the low single-digit GB. For scale, a 14B language model at Q4_K_M needs roughly 8.4GB for weights alone — eight times more. VRAM is almost never the constraint with Chatterbox; an 8-12GB card has room to spare.

Bandwidth. Chatterbox's backbone is autoregressive, so it emits audio tokens one at a time and every token re-reads the full weight set from memory. The arithmetic ceiling on forward passes per second is therefore memory bandwidth ÷ weight bytes: roughly 900/s on a 936 GB/s RTX 3090, 500/s on a 504 GB/s RTX 4070, 270/s on a 272 GB/s RTX 4060, and 150/s on a 150 GB/s Apple Silicon chip. Those are arithmetic upper bounds, not measured rates — real throughput is lower — but they show where the headroom behind Resemble's real-time claims comes from, and why the practical rule reduces to "keep the model on the GPU." System RAM bandwidth is roughly an order of magnitude below a discrete card's, so plan CPU-only generation as a batch job rather than an interactive one.

How do you self-host Chatterbox as an OpenAI-compatible API?

If you want to swap Chatterbox in wherever your app already calls a TTS API, the community Chatterbox-TTS-Server project wraps the model in a server with a web UI and OpenAI-compatible endpoints. It exposes /v1/audio/speech and /v1/audio/voices (drop-in for OpenAI's TTS API) plus a richer native /tts endpoint, and it can hot-swap between the Original, Multilingual (23 languages), and Turbo models.

# Clone and run the self-hosted server
git clone https://github.com/devnen/Chatterbox-TTS-Server.git
cd Chatterbox-TTS-Server
pip install -r requirements.txt
python server.py
# Web UI + API default to http://localhost:8004

It runs accelerated on NVIDIA (CUDA), AMD (ROCm), Apple Silicon (MPS), or CPU fallback, handles audiobook-scale text by splitting and concatenating chunks, and supports voice cloning from uploaded reference clips plus a folder of predefined voices. Once it is up, point any OpenAI-TTS client at http://localhost:8004/v1/audio/speech and you have replaced a paid API with a local one.

Chatterbox vs the other open-source TTS options

Chatterbox is excellent, but it is not the only good local TTS in 2026, and the right pick depends on the job:

• Want the best English clone quality and an emotion knob? Chatterbox (original 0.5B) is the pick.
• Need a specific non-English language? Use Chatterbox Multilingual, or compare against XTTS v2, which has long been the go-to multilingual cloner.
• Need the lowest latency / smallest footprint? Chatterbox Turbo (350M), or a fixed-voice model like Kokoro if you do not need cloning at all.

For a side-by-side look at how Chatterbox stacks up against XTTS v2 and the other cloners, our local AI voice clone guide walks through the trade-offs with audio in mind.

Key Takeaways

1. Chatterbox TTS is free, MIT-licensed, and competitive with ElevenLabs — preferred 63.75% of the time in blind tests, with no per-character billing.
2. Setup is one command: pip install chatterbox-tts, then a few lines of Python. Weights download on first run.
3. Voice cloning needs only ~5 seconds of clean, single-speaker reference audio — clip quality matters more than length.
4. The emotion exaggeration knob is the differentiator. Start at exaggeration=0.5 / cfg_weight=0.5 and adjust one at a time.
5. Three variants: original 0.5B (best English), Multilingual (23 languages), and Turbo (350M, ~75ms latency, ~6x real-time) for low-VRAM/streaming.
6. You can self-host it as an OpenAI-compatible API via Chatterbox-TTS-Server (/v1/audio/speech) on NVIDIA, AMD, Apple Silicon, or CPU.

Next Steps

• New to local TTS? Compare cloners head to head in our local AI voice clone guide before you settle on one.
• Need strong multilingual cloning? Read the XTTS v2 voice cloning guide to see where it still beats (and loses to) Chatterbox.
• Confirm the official details and license on the Resemble AI Chatterbox GitHub repo before deploying to production.