Guide · Open source

How to use Chatterbox: install and generate speech with voice cloning

Updated 2026-10-29 · written with AI from the project's own documentation and checked against our catalogue data

Chatterbox is a family of open-source text-to-speech models from Resemble AI. You give it text and, for voice cloning, a short reference audio clip, and it generates spoken audio in that voice. This guide walks through installing the Python package, generating your first WAV file, and choosing between the Turbo, Nano, Multilingual V3 and original models.

Chatterboxresemble-ai/chatterbox · ★ 27.5k · MIT Install options & downloads

Quick start

1Check Python 3.11. Confirm you have Python 3.11, the version the authors tested on.
2Install the package. Run pip install chatterbox-tts, or clone the repository and run pip install -e . for a source install.
3Pick a model. Use Turbo for English voice agents, Nano for CPU, or Multilingual V3 for many languages.
4Prepare a reference clip. Record or choose a short clip of the voice you want to clone; the README example uses a file called your_10s_ref_clip.wav.
5Load the model. Call from_pretrained with your device, for example device="cuda" or device="cpu" where supported.
6Generate and save audio. Call model.generate with your text and audio_prompt_path, then save the result with torchaudio using model.sr.

What do you need before you install Chatterbox?

Chatterbox is a Python package. The authors developed and tested it on Python 3.11 on Debian 11, so 3.11 is the version to start with. The README's usage examples are Python code, so you will need to be comfortable running a short script.

The examples also load models with device settings such as "cuda", "cpu" or "mps", and voice cloning needs a reference audio clip of the voice you want to copy. The README's Turbo example uses a file named your_10s_ref_clip.wav, which suggests a clip of about 10 seconds.

Python 3.11 (the version the authors tested on)
A reference audio clip for voice cloning
A device for inference: CUDA GPU, CPU or Apple MPS, depending on the model

Install Chatterbox with pip

The simplest route is the PyPI package. If you want to modify the code or its dependencies, install from source in editable mode instead. The README notes that dependency versions are pinned in pyproject.toml to keep installs consistent.

pip install chatterbox-tts

Install Chatterbox from source for development

To work on the code itself, clone the repository and install it in editable mode. The README suggests creating a conda environment with Python 3.11 first (the lines are commented out in the README, so run them yourself if you want them).

Clone the repository from GitHub
Change into the chatterbox folder
Run the editable install

git clone https://github.com/resemble-ai/chatterbox.git
cd chatterbox
pip install -e .

Generate your first speech file with Chatterbox-Turbo

Turbo is the English model for low-latency voice agents. Load it with ChatterboxTurboTTS, pass your text to generate(), and pass a reference clip with audio_prompt_path to clone a voice. Then save the output with torchaudio using the model's sample rate. Turbo supports paralinguistic tags such as [chuckle] and [laugh] directly inside the text.

Use device="cuda" in the README example; the Nano example also shows device="cpu"
Tags like [cough], [laugh] and [chuckle] go inside the text string

import torchaudio as ta
import torch
from chatterbox.tts_turbo import ChatterboxTurboTTS

# Load the Turbo model
model = ChatterboxTurboTTS.from_pretrained(device="cuda")

# Generate with Paralinguistic Tags
text = "Hi there, Sarah here from MochaFone calling you back [chuckle], have you got one minute to chat about the billing issue?"

# Generate audio (requires a reference clip for voice cloning)
wav = model.generate(text, audio_prompt_path="your_10s_ref_clip.wav")

ta.save("test-turbo.wav", wav, model.sr)

Run Chatterbox-Nano on CPU or limited hardware

Nano shares Turbo's architecture in a smaller 110M parameter package and is aimed at on-device and CPU inference. The README says it runs at 3x realtime on 8 CPU cores. You load it through the same ChatterboxTurboTTS class by passing nano=True. The README's comment shows device="cpu" as an option, and the example below uses cuda.

import torchaudio as ta
import torch
from chatterbox.tts_turbo import ChatterboxTurboTTS

# Load the Nano model (also runs on CPU: device="cpu")
model = ChatterboxTurboTTS.from_pretrained(device="cuda", nano=True)

# Generate with Paralinguistic Tags
text = "Hi there, Sarah here from MochaFone calling you back [chuckle], have you got one minute to chat about the billing issue?"

# Generate audio (requires a reference clip for voice cloning)
wav = model.generate(text, audio_prompt_path="your_10s_ref_clip.wav")

ta.save("test-nano.wav", wav, model.sr)

Choose a model: Turbo, Nano, Multilingual V3 or original Chatterbox

Pick the model based on language and hardware. Turbo and Nano are English-only. Multilingual V3 is the recommended model when you need one voice cloning model across many languages, and the README lists 23+ languages without giving the full list in the excerpt. The original Chatterbox model is English and offers CFG and exaggeration tuning. Multilingual V3 is loaded with ChatterboxMultilingualTTS and t3_model="v3"; the README says the legacy V2 checkpoint is used by omitting t3_model or passing t3_model="v2".

Turbo (350M, English): low-latency voice agents and narration
Nano (110M, English): CPU and tight memory or latency budgets
Multilingual V3 (500M, 23+ languages): cross-language voice cloning
Original Chatterbox (500M, English): CFG and exaggeration tuning

from chatterbox.tts import ChatterboxTTS
from chatterbox.mtl_tts import ChatterboxMultilingualTTS

multilingual_model = ChatterboxMultilingualTTS.from_pretrained(device="cuda", t3_model="v3")

What people use it for

Voice agents that need low-latency English speech, using Chatterbox-Turbo
Narration with paralinguistic tags such as [laugh] or [chuckle] in the text
Speech generation on a CPU or limited hardware with Chatterbox-Nano
Cross-language voice cloning across many languages with Multilingual V3

Frequently asked questions

Is Chatterbox free to use?

Chatterbox is open-source and its license is MIT, according to this directory's listing. The README also mentions a paid Resemble AI TTS service for scaling and higher accuracy tuning, which is separate from the open models.

What are the requirements to run Chatterbox?

The authors tested on Python 3.11 on Debian 11. You also need a reference audio clip for voice cloning and a device such as a CUDA GPU, CPU or Apple MPS, depending on the model you load.

How do I install Chatterbox?

Run pip install chatterbox-tts to install from PyPI. To install from source, clone the GitHub repository and run pip install -e . inside the chatterbox folder.

Can Chatterbox run without a GPU?

Yes. The README says Chatterbox-Nano targets on-device and CPU inference and runs at 3x realtime on 8 CPU cores. You pass device="cpu" when loading the model.

What is the difference between Chatterbox and Coqui TTS, Piper or Bark?

This listing names Coqui TTS, Piper, Bark and XTTS as comparable projects but does not compare them in the source. Check each project's documentation to decide which fits your language, hardware and voice cloning needs.

Is there a no-code version of Chatterbox?

Not in the README excerpt. It only shows Python code examples, so the Hugging Face demo spaces linked from the README are the place to try it without coding.

New agent skills, repos and AI tools — every week

The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.

Our verdict

Chatterbox suits developers who are comfortable with Python and want an open model for English voice agents, CPU speech generation, or cross-language voice cloning. If you need a no-code tool, guaranteed production-scale hosting, or a language outside the listed coverage, pick another option or look at the paid service the README mentions.

Install options & downloads