Docs /Getting Started/Chatterbox

Chatterbox

English speech with an unnamed built-in voice and zero-shot reference cloning; generation controls are not exposed.

Identity

Featherless model ID: ResembleAI/chatterbox.

This is the original 500M English Chatterbox model. It has an unnamed built-in voice and supports reference-audio conditioning. It is separate from Chatterbox Multilingual and Chatterbox Turbo.

Use Chatterbox when

Choose base Chatterbox for English speech with its built-in voice or for zero-shot voice cloning after you have verified the reference workflow for your use case. Choose Chatterbox Turbo when its speed-oriented, lower-compute architecture and documented inline vocal-event tags are more important.

Voice behavior

Voice discovery for this model returns an empty voices array and default_voice: null: Chatterbox has no selectable named presets through Featherless. Omit voice to use its unnamed built-in voice, or send voice.clone with reference audio. Do not send a preset name or a custom voice ID.

Generate with the built-in voice

Every example on this page reads your key from the FEATHERLESS_API_KEY environment variable, so export it once before running any of them. The Python examples need pip install requests. The TypeScript examples use top-level await, so save each one with an .mjs extension, or set "type": "module" in package.json, and run it on Node 18 or newer, which supplies the built-in fetch they rely on.

Generate English speech

curl --fail-with-body https://api.featherless.ai/v1/audio/speech \
  --header "Authorization: Bearer $FEATHERLESS_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "model": "ResembleAI/chatterbox",
    "input": "Please leave the blue folder beside the window before seven tonight.",
    "response_format": "wav"
  }' \
  --output chatterbox-default.audio \
  --write-out "Content-Type: %{content_type}\n"

There is intentionally no voice property in this request. Passing a string voice produces an invalid-voice error because the model exposes no named inventory.

Zero-shot voice cloning

Chatterbox accepts WAV and MP3 reference clips; FLAC is rejected before synthesis.

Use a clean, single-speaker recording with little noise or reverberation and no music. Resemble AI, the team that created Chatterbox, recommends a 5–20 second reference clip. Only clone a voice when you have the speaker’s informed permission and the right to use the recording.

The snippets below read a WAV recording named reference.wav from the working directory and send it as bare base64. Put a clean single-speaker clip there first, then run the snippet.

Generate with reference audio

reference_audio=$(base64 < reference.wav | tr -d '\n')

curl --fail-with-body https://api.featherless.ai/v1/audio/speech \
  --header "Authorization: Bearer $FEATHERLESS_API_KEY" \
  --header "Content-Type: application/json" \
  --data-binary @- \
  --output chatterbox-clone.audio \
  --write-out "Content-Type: %{content_type}\n" <<JSON
{
  "model": "ResembleAI/chatterbox",
  "input": "Read this line using the supplied reference voice.",
  "voice": {
    "clone": {
      "audio": {
        "data": "$reference_audio",
        "format": "wav"
      }
    }
  },
  "response_format": "wav"
}
JSON

The audio.data value must contain bare base64, not a data-URL prefix. Convert MP4 or M4A recordings to WAV before sending them. Omit reference_text: it is accepted without error, but the reference workflow for this model is not documented to use it, and its effect is unspecified.

Parameter support

Use only the parameters listed under Supported and Best-effort. The request body does not reject unrecognized fields: anything not listed below is accepted, comes back as a normal 200 with audio, and is discarded before the model sees it. A successful response is therefore never evidence that a field was honored. The Unsupported list is split accordingly, into fields that fail with an error and fields that are accepted and ignored.

Supported

Parameter	Required	Behavior
`model`	yes	Use `ResembleAI/chatterbox`
`input`	yes	Target text, forwarded to Chatterbox as its prompt
`voice` omitted	no	Generates with the unnamed built-in voice
`voice.clone.audio.data`	no	Non-empty bare-base64 reference clip
`voice.clone.audio.format`	no	Clone container, `wav` or `mp3`
`delivery`	no	Delivery control, `stream`, `json`, or `bulk`
`stream_format`	no	Delivery control, `sse` or `audio`
`stream`	no	Delivery control, boolean
`encoding`	no	Delivery control, `binary` or `base64`

Send voice.clone.audio.data and voice.clone.audio.format together: that is the clone request shape this model accepts. delivery, stream_format, stream, and encoding are supported Featherless delivery controls; they do not change model generation. response_format is not listed here; it is covered under Best-effort below.

Unsupported

Rejected with an error. The request fails and no audio is produced.

Parameter	Result	Error code
`voice` as a named string	`400`	`invalid_voice`
`voice.clone.audio.format` set to `opus`, `aac`, `flac`, or `pcm`	`400`	`unsupported_clone_format`
`response_format` set to `opus`, `aac`, or `flac`	`400`	`unsupported_format`
`speed` outside the range `0.25` to `4.0`	`422`	`invalid_request_error`
Malformed `voice` objects, and reference clips whose format is not one of `mp3`, `opus`, `aac`, `flac`, `wav`, or `pcm`	`422`	`invalid_request_error`

This model exposes no named preset inventory, so any preset name is refused before any audio is produced. The accepted reference containers are wav and mp3, and the error lists that accepted set. The accepted response_format set for a speech model is its native container, anything reachable from that container by a lossless rewrap, plus mp3 and wav, which are always accepted; for this model that set is wav, pcm, and mp3, so opus, aac, and flac are refused. The speed range check and the malformed-shape failures are raised by schema validation before any audio is produced; the range check tests the field itself and is not a sign that the value changes the audio, as described below.

Accepted and ignored. These return 200 with normal audio, raise no error, and have no effect on what is generated.

Parameter	What happens
`exaggeration`	Returns `200`, no effect on output
`cfg_weight`	Returns `200`, no effect on output
`temperature`	Returns `200`, no effect on output
`seed`	Returns `200`, no effect on output
`repetition_penalty`	Returns `200`, no effect on output
`min_p`	Returns `200`, no effect on output
`top_p`	Returns `200`, no effect on output
`language`	Returns `200`, no effect on output
Any other field not listed under Supported or Best-effort	Returns `200`, no effect on output

The Featherless speech request carries no field for exaggeration, cfg_weight, temperature, seed, repetition_penalty, min_p, or top_p, so they are discarded at the API boundary and never reach the model. language is discarded the same way because this model ID is English-only. Any other field not listed under Supported or Best-effort is accepted, discarded, and never surfaced as an error.

Best-effort

These fields are read and carried with the request, but none of them is guaranteed to affect the output for this model. They are real fields in the Featherless speech request, not unrecognized fields discarded at the API boundary, so none of them is rejected; sending them will not produce an error, but the effect is unspecified and may change, so do not build on them. speed is accepted and range-checked, constrained to 0.25 to 4.0; omitting it substitutes 1.0, and a value outside the range fails schema validation with 422 before any audio is produced, which tests the field itself rather than showing that the value changes the audio. instructions and voice.clone.reference_text are accepted and carried with no documented effect for this model, and voice.id has nothing to address because this model publishes no voice inventory. Inline markup such as SSML or vocal-event tags sits in the same category: the input text is forwarded unchanged, with no parsing or stripping, so Featherless neither implements nor blocks it and this page makes no claim about how the model treats it.

response_format is a request, not a guarantee. The accepted values for this model are wav, pcm, and mp3. wav is native and pcm is reachable from it by a lossless rewrap; that rewrapping is the only conversion Featherless performs, and there is no codec transcoding, so an accepted mp3 request can still come back as wav. The response is labeled with what the bytes actually are, so read the Content-Type header on binary responses and the format field on JSON responses to learn which container you received. SSE events carry no format metadata.

Output and streaming

Live discovery currently reports mp3, pcm, and wav as accepted response-format selectors. Chatterbox’s native output is WAV. Featherless can convert WAV to raw PCM, but it does not currently transcode WAV to MP3. An MP3 request can therefore return WAV bytes with an honest WAV Content-Type for bulk binary responses. For JSON responses, inspect the format field. SSE events do not include audio-format metadata, so inspect the decoded bytes for a RIFF/WAVE signature before choosing a filename extension.

Request delivery: "stream" to receive SSE events. Chatterbox finishes generating before Featherless starts sending audio, so SSE is deferred delivery rather than live generation. Streaming does not guarantee a shorter wait for the first audio.

Watermark and limits

The official Chatterbox implementation applies Resemble’s PerTh watermark to generated audio. Featherless exposes no watermark switch and has not independently verified watermark detection on production output.

Featherless does not publish a stable model-specific character maximum for Chatterbox. The official demo labels its text box as 300 characters but does not enforce that value as a model limit. Keep requests moderate, split long passages, and test the exact workflow before production.

Sources

Official Chatterbox repository and official Chatterbox model documentation.

Last edited: Aug 27, 2026