Chatterbox TTS: Resemble AI's open-source speech model as an API

Chatterbox is a family of open-source text to speech models from Resemble AI, released under the MIT license. It is known for two things. One is expressive, controllable speech. The other is voice cloning from seconds of reference audio. The repository now counts more than twenty-six thousand GitHub stars. The model behind it is a 0.5B-parameter design with a Llama-style backbone. It runs small enough for one consumer GPU.

This platform serves Chatterbox's multilingual model behind an OpenAI-compatible speech endpoint. One JSON request carries a model, a voice, and your text. It is metered per character from a prepaid wallet. One fact worth more than the rest of this paragraph. The lane serves the v2-generation multilingual checkpoint, the 23-language weights, pinned by content hash at build. The family's newest generation, v3, is a newer release from the project, which this lane does not serve. This page and the platform's own model data stay the truth on that.

What follows: what the model is, what it does well, and the exact call shape on this platform. Our own measurements from the hosted lane come with it. The self-host route is genuinely good. The comparison gets its own section instead of a dismissal.

Last verified: 2026-09-25

What it is

Resemble AI is a voice AI company that also builds audio detection and watermarking tools. It open-sourced Chatterbox in 2025. It has shipped generations since: the original English model, a 23-language multilingual model, and newer efficiency variants. The official repository documents the family. Its current headliner, Chatterbox Multilingual v3, keeps the same 0.5B size as v2 while improving speaker similarity and stability. Alongside it sit dedicated single-language finetunes and the smaller Turbo and Nano models for English.

Four facts from the official sources matter to an API buyer:

• Open weights, MIT license. Code and weights are downloadable, on GitHub and Hugging Face, for any commercial or non-commercial use. The weights cannot be revoked out from under you.
• Expressive control. Chatterbox was the first open-source TTS model with emotion exaggeration control, per Resemble's model page: a single dial that moves output from monotone to dramatic. The defaults most pipelines ship (exaggeration 0.5, cfg_weight 0.5) come from the repository's own tuning notes.
• Zero-shot cloning in the open-source release. A reference clip of a few seconds, five to ten across Resemble's pages, is enough for the model to speak in a new voice. The hosted surface starts from a fixed catalog instead; the FAQ gives the split.
• Watermarking by default. Every file the open-source pipeline emits carries Resemble's PerTh watermark. What this platform's output carries is a different answer, and it is in the FAQ with the measurement behind it.

On this platform, the model answers the chatterbox-tts alias on the speech route. The route follows the OpenAI /v1/audio/speech shape. It meters by input characters and serves wav audio from a catalog of 29 voices. Under the endpoint, the lane runs the model through the open-source Chatterbox TTS Server on a pinned, digest-verified image. The v2 multilingual checkpoint's weights are pinned by hash at build. The model answers calls today on this platform, measured 2026-09-09, metered per character from a prepaid wallet. The models index shows the catalog as it stands.

Use cases

The lane is a premium, serialized voice. That means expressive synthesis, 29 fixed voices, one request at a time, and 400 characters per request. That profile points at quality-sensitive short-form and mid-form speech. It does not point at bulk narration in single calls.

• Character and brand voice. The catalog's named voices, from Abigail to Thomas, give products a consistent speaker without a cloning setup. For expressive reads, this model's exaggeration heritage is the draw.
• Agents that talk. Spoken confirmations, summaries, and alerts are sentence-shaped, the exact fit for the cap. A prepaid wallet makes the worst case of a chatty agent a bounded number: past an empty balance, the next request is refused with a named error instead of billed.
• Prototyping before a GPU commitment. The local route wants an NVIDIA setup in practice; the community wrapper that leads the search results notes the project's code is broken for non-CUDA installs, and users report around 6.5 GB of VRAM in real use. The API route is one HTTP call. For deciding whether voice belongs in your product, that difference is the whole argument.
• Multilingual groundwork in English. Your roadmap may need Arabic, Chinese, or Hindi speech later. The model under this endpoint already speaks 23 languages when run yourself, so the migration path is a hosting question, not a model swap.
• Batch clips. Course lines, prompts, and short narration segments generate well in sequence. Split at sentence boundaries, concatenate at playback, and the wallet sees exactly the characters sent.
• Paired with a throughput model. When a project outgrows this lane, the same wallet and metering carry Kokoro on a lane measured at 7.0M characters per day against this lane's 0.73M. Character here, volume there.

Run it yourself or point here

Chatterbox is one of the friendlier models to self-host. The top result for this model's API query is itself a self-host wrapper. So the honest comparison matters, and here is the decision rule.

Run it yourself when the local capabilities are the point. That covers per-request cloning from your own reference clips, language selection per call, and offline operation. It also covers volume high enough that per-character billing would dominate your costs. The devnen server this platform also uses gives you the same OpenAI-shaped endpoint on your own hardware. A web UI, chunking, and voice management come on top.

Point at this API when you want the operations handled. The OpenAI-compatible shape means existing client libraries work unchanged. Spend is bounded by construction: the wallet is the limit. The lane is measured and pinned. The exact checkpoint, cap, and timeouts on this page are the ones the route enforces. And the parts you skip are not nothing. Keeping a CUDA stack patched is work. So are sidestepping the watermark library's import fragility and sizing VRAM around a 0.5B model that behaves like a bigger one.

Both roads pair well. Prototype and burst here. Keep a local copy for cloning and language work. Let the same model serve both.

API usage

The speech route is POST /v1/audio/speech, authorized with a Bearer key from the console. Three fields are required in the body: model (chatterbox-tts), input (the text), and voice (a catalog id; default on this model). Two optional fields also parse, response_format and speed. There is no stream parameter: the route rejects it as an unknown parameter. Audio always arrives by chunked transfer, and the lane emits wav, PCM 16-bit mono at 24 kHz.

Four route facts that save debugging time:

1. 400 characters per request. The gateway refuses longer input with a 400 before anything synthesizes, and refused requests are not billed. Split longer text client-side; the wav files concatenate in order at playback.
2. Respect the first byte. Synthesis runs at roughly 0.085 seconds per character on this lane: a short request answers in around 7 seconds warm, a full 400-character request synthesizes for around 41 seconds, and the first call after a cold boot can take half a minute while weights load. Give clients a read timeout of 120 seconds or better. Consume live with curl --no-buffer. A generation that dies mid-stream cuts the connection: the bytes already delivered stand, and the turn is not billed.
3. Retries re-bill. The Idempotency-Key header parses on this route but replays nothing: audio exceeds the replay budget, so a retried request executes and bills again. Inspect your client's retry defaults before you connect a production loop to this endpoint.
4. The voice catalog is a free read. GET /v1/audio/voices?model=chatterbox-tts returns the valid ids: default plus 28 named voices, each listed with its .wav suffix (Abigail.wav, Elena.wav, and so on). The bare string default works in the speech call itself.

A 1,200-character script becomes three requests split at sentence boundaries. The requests serialize on the lane: it serves one synthesis at a time. Concurrent requests queue rather than fail. That is why you should plan against the daily ceiling. Parallel speedup is not there to plan against.

curl

curl -X POST "https://api.ironstratum.com/v1/audio/speech" \
  -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "chatterbox-tts",
    "input": "Chatterbox gives this paragraph its dramatic side, and this endpoint meters it by the character.",
    "voice": "default"
  }' \
  --no-buffer \
  --output speech.wav

python

import os
import requests

resp = requests.post(
    "https://api.ironstratum.com/v1/audio/speech",
    headers={"Authorization": "Bearer " + os.environ["KEY"]},
    json={
        "model": "chatterbox-tts",
        "input": "Chatterbox gives this paragraph its dramatic side.",
        "voice": "default",
    },
    timeout=120,  # first byte can take tens of seconds near the cap
)
resp.raise_for_status()

with open("speech.wav", "wb") as f:
    for chunk in resp.iter_content(chunk_size=65536):
        f.write(chunk)

openai-sdk

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.ironstratum.com/v1",
    api_key=os.environ["KEY"],
)

with client.audio.speech.with_streaming_response.create(
    model="chatterbox-tts",
    voice="default",
    input="Chatterbox gives this paragraph its dramatic side.",
) as response:
    response.stream_to_file("speech.wav")

An existing OpenAI SDK integration therefore changes in exactly two places. They are the base URL and the model id.

Benchmarks

Two evidence layers, both dated. One is our measurements from the hosted lane. The other is the official record for the model itself.

Our hosted lane. Measured 2026-09-09 in the task-17 verification window, with the task-16 E5b corrected grid as the capacity basis. The records are the platform launch catalog, section D, and the measurement records for the hosted lane. The same numbers live as comments beside the model's row in the platform's data.

Read the ceiling as a planning bound for sustained load, not a per-request promise. The lane synthesizes one request at a time on purpose. When the underlying hardware was measured at four concurrent requests, one in twelve succeeded. The gateway serializes requests instead. A queue grows under burst load and drains at the curve's pace. That is the physics of a 0.5B model whose expressiveness costs real compute.

The model itself. The multilingual checkpoint lists 23 languages in the official repository, from Arabic and Danish to Chinese. Resemble's evaluation work describes gains with the newest generation. V3, announced June 2026, improved speaker similarity and hallucination rates over v2 at the same 0.5B size. For calibration on what bigger hardware does with the newer generation, look at Resemble's own v3 numbers. The company reports sub-300 ms time to first byte and roughly five-times-real-time synthesis for v3 on a single H100. Those numbers describe that model on that hardware, not this lane, and are labeled as such here. This lane trades that speed class for edge economics and a single metering plan.

Getting started

1. Create an account through the console's invite flow. The console is invite-only in beta; the wallet, the keys, and the spend history all live there.
2. Create an API key. Revoking a key takes effect immediately when its project changes. Every key spends from the prepaid wallet, and requests past an emptied balance are refused at the door.
3. Check the rate. With metering per character, the pricing page puts the whole cost picture in one place. There is no monthly fee and no per-request charge.
4. Make the first call. Take the curl tab, put your key in it, and synthesize one short line. If it plays, everything longer is a chunking exercise. The table above sets expectations while it renders.

The speech catalog holds the other TTS models on the same metering. The models index maps the whole catalog.