Docs

Using Kokoro on Chutes

Kokoro (hexgrad/Kokoro-82M) is an 82-million-parameter open-weight text-to-speech model that trades a tiny footprint for speed and cost while staying competitive with much larger TTS systems. On Chutes it is one JSON POST: send text to /speak, get 24 kHz WAV bytes back.

Overview

Kokoro is built on the StyleTTS 2 architecture with an ISTFTNet vocoder, released decoder-only (no diffusion, no encoder). Text is converted to phonemes by the misaki G2P library before synthesis. The v1.0 checkpoint, published January 27, 2025, was trained on a few hundred hours of exclusively permissive or non-copyrighted audio for a total cost of roughly $1000 in A100 GPU-hours, a fact the model card documents in detail.

v1.0 ships 54 preset voices across 8 languages. Voice IDs follow a <language><gender>_<name> convention: af_heart is American English female, bm_george British English male, jf_alpha Japanese female, zm_yunxi Chinese male. Coverage spans American and British English, Spanish, French, Hindi, Italian, Japanese, Portuguese, and Chinese. There is no voice cloning and no instruction-based style control: you choose a preset voice and a playback speed. The weights are Apache-2.0, and the model card explicitly welcomes commercial deployment; it cites April 2025 market API pricing under $1 per million input characters (about $0.06 per hour of audio).

Model specifications

Property	Value
Parameters	82M
Architecture	StyleTTS 2 + ISTFTNet, decoder-only release
Voices	54 presets across 8 languages (v1.0)
Output	audio/wav, 24 kHz
License	Apache-2.0
Modalities	Text in, audio out
Release	v1.0, January 2025
Training data	A few hundred hours of permissive/non-copyrighted audio

Quick start

The chute exposes one endpoint, POST /speak, on its own host. Only text is required; the response body is the WAV file itself.

curl -X POST "https://chutes-kokoro.chutes.ai/speak" \
  -H "Authorization: Bearer $CHUTES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "text": "Hello from Kokoro on Chutes.",
  "voice": "af_heart",
  "speed": 1
}' \
  --output output.wav

import os
import requests

resp = requests.post(
    "https://chutes-kokoro.chutes.ai/speak",
    headers={"Authorization": f"Bearer {os.environ['CHUTES_API_KEY']}"},
    json={
        "text": "Hello from Kokoro on Chutes.",
        "voice": "af_heart",  # default; see llms.txt for all 54 voices
        "speed": 1,           # playback speed multiplier, default 1
    },
)
resp.raise_for_status()
with open("output.wav", "wb") as f:
    f.write(resp.content)  # raw audio/wav at 24 kHz

import { writeFile } from "node:fs/promises";

const resp = await fetch("https://chutes-kokoro.chutes.ai/speak", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.CHUTES_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    text: "Hello from Kokoro on Chutes.",
    voice: "af_heart",
    speed: 1,
  }),
});
const wav = Buffer.from(await resp.arrayBuffer());
await writeFile("output.wav", wav);

Parameters and tuning

The full request surface, from the chute's llms.txt:

text (string, required): the text to synthesize.
voice (string, optional, default af_heart): one of 54 preset voice IDs. The prefix encodes language and gender: af_/am_ American English female/male, bf_/bm_ British English, ef_/em_ Spanish, ff_ French, hf_/hm_ Hindi, if_/im_ Italian, jf_/jm_ Japanese, pf_/pm_ Portuguese, zf_/zm_ Chinese.
speed (number, optional, default 1): playback speed multiplier. Below 1 is slower, above 1 is faster.

That is the entire tuning surface; there are no sampling parameters, no seeds, and no style instructions. Match the voice's language to your text: sending French text to an American English voice produces heavily accented, often garbled output because the G2P step is language-specific.

What it's best at

Low-latency assistant voices. The 82M footprint keeps synthesis fast, which suits chat readback, notifications, and IVR prompts.
High-volume narration. Per-character economics are the model's headline: the card cites under $1 per million characters at market rates.
Multilingual product voices. Eight languages with multiple voices each, selectable per request.
Minimal integration surface. One required field in, WAV bytes out; no async job polling.

Not a fit: voice cloning or voice design (Kokoro has fixed presets only; on Chutes the AudioDojo chute adds Qwen3-TTS cloning and design endpoints, and its /speak is a drop-in replacement for this chute), fine-grained emotion control, and languages outside the 8 voice packs.

How Chutes serves this model

The chute runs on a dedicated host, https://chutes-kokoro.chutes.ai, with a single POST /speak endpoint. Requests are flat JSON (no input_args wrapper) authenticated with Authorization: Bearer $CHUTES_API_KEY, and responses are raw audio/wav bytes rather than JSON, so treat the body as binary. Defaults mirror the upstream project: voice af_heart, speed 1, 24 kHz output.

Related resources: the model page, the machine-readable llms.txt, and the callable OpenAPI spec.

FAQ

What audio format does the chute return?

Raw audio/wav bytes at 24 kHz, returned directly as the response body. There is no JSON envelope and no base64 encoding; save the body to a .wav file or pipe it into playback.

Which voices are available and how do I pick one?

54 preset voices, enumerated in the chute's llms.txt. IDs encode language and gender: af_/am_ American English female/male, bf_/bm_ British English, ef_/em_ Spanish, ff_ French, hf_/hm_ Hindi, if_/im_ Italian, jf_/jm_ Japanese, pf_/pm_ Portuguese, zf_/zm_ Chinese. The default is af_heart.

Can Kokoro clone my voice or follow style instructions?

No. Kokoro only offers fixed preset voices with a speed control. For zero-shot voice cloning, preset speakers with emotion instructions, or voice design from a text description on Chutes, use the AudioDojo chute's Qwen3-TTS endpoints; its /speak endpoint is also a drop-in replacement for this chute.

What does the speed parameter do?

It is a playback speed multiplier with a default of 1. Values below 1 slow the voice down, values above 1 speed it up. It is the only synthesis control besides voice selection.

What license is Kokoro under? Can I use the audio commercially?

The weights are Apache-2.0, per the hexgrad/Kokoro-82M Hugging Face repo. The model card explicitly welcomes deployment in commercial APIs and real use cases. Apache-2.0 permits commercial use with attribution and license notice.

How large is the model and why does that matter?

82 million parameters, tiny by TTS standards. That footprint is what makes it fast and cheap to serve; the model card cites market pricing under $1 per million characters of input, roughly $0.06 per hour of generated audio.

How do I call it from code?

POST flat JSON to https://chutes-kokoro.chutes.ai/speak with an Authorization: Bearer header carrying your Chutes API key, e.g. {"text": "Hello", "voice": "af_heart", "speed": 1}. Write the binary response body to a .wav file.