Pocket TTS: Kyutai's lightweight text to speech model as an API

Pocket TTS is a 100M-parameter text to speech model from Kyutai. It was released in January 2026 and open-sourced under the MIT license. It made its name running in real time on laptop CPUs, with voice cloning from a five-second sample. On this platform it sits 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.

This page covers what the model is, what it is good at, and exactly how to call it here. Our own measurements on the hosted lane come with it. If you are deciding between running it yourself and pointing at an API, the honest comparison is here too.

Last verified: 2026-09-25

What it is

Kyutai, the Paris lab behind the Moshi voice models, built Pocket TTS to answer one question. How small can a cloning-capable speech model get while still running faster than real time on a plain CPU? The answer is 100M parameters. On a MacBook Air M4 the reference implementation synthesizes about six times faster than real time using two CPU cores. The first audio chunk arrives in roughly 200 milliseconds. Both numbers come from the official repository.

The architecture is unusual for this size class. The model does not predict discrete audio tokens. It does not decode them through a vocoder, a separate decoder step. It predicts continuous audio representations directly, streaming as it goes. That design is why long text never blocks on a fixed synthesis pass locally. It is also why the first chunk arrives fast. Kyutai describes the method in its technical report and the underlying Continuous Audio Language Models paper.

Three capability facts matter for API buyers:

• Voice cloning. Give the model about five seconds of reference audio and it speaks in that voice, carrying over accent, cadence, and the acoustic character of the sample. This is the open-source release's capability; the platform paragraph below and the FAQ cover what the hosted surface includes.
• Six languages. English, French, German, Spanish, Portuguese, and Italian since the May 2026 multilingual release.
• Open weights, permissive code. MIT on the code; each voice in the voice repository carries its own listed license.

Cloning also carries consent and licensing obligations, and the project treats them as real rather than optional. Each voice in the repository carries its own listed license. The repository runs a voice-donation program for additions. And the README's prohibited-use section requires the explicit and lawful consent of a voice's owner before cloning it. A build of the model with voice cloning removed is published alongside the standard one. That is the clearest signal of where the project draws the line. This platform's answer is the fixed catalog: the 17 license-verified voices, all CC BY 4.0 or CC0. Every voice id on the route has a license trail. Cloning is not part of the hosted surface.

On this platform, the model answers the pocket-tts alias on the speech route. The route follows the OpenAI /v1/audio/speech shape. It meters by input characters and serves a fixed set of 17 license-verified voices, with alba as the default. The model answers calls today on this platform, measured 2026-09-09, metered per character from a prepaid wallet. The models index reflects the catalog as it stands.

Use cases

The model is small and fast, the hosted voices are English-first, and each request carries up to 2,500 characters. That profile points at short-form and mid-form speech rather than audiobook-length single calls.

• App speech and notifications. Spoken confirmations, read-aloud views, and UI narration are usually a sentence to a paragraph, exactly the shape the request cap is sized for.
• Agents that talk. Reading model output, summaries, or alerts aloud benefits from a per-character endpoint paid from a prepaid wallet: a chatty agent's worst case is the wallet balance plus at most the one request already synthesizing, not hope.
• Prototyping without a GPU. The local route needs Python, PyTorch, and on Linux either a CPU-only index setting or about 3 GB of CUDA wheels you will not use. The API route needs one HTTP call. For evaluating voice features before committing infrastructure, that difference is the whole argument.
• English-first products. The 17 hosted voices cover the day-one case. If your roadmap needs the other five languages later, the model underneath already speaks them, so the migration is a voice and content question, not a model swap.
• Batch clips. Course lines, product demos, IVR prompts, and short narration segments generate well in sequence; chunk anything longer than the cap and concatenate.

The broader text to speech catalog carries the other speech models. That includes Kokoro for throughput-heavy fixed-voice work.

Self-host it or call the API

Google's own AI summary for this model says it is free and local, which is true and incomplete. The model costs no money; running it in production costs setup and attention. Here is the honest decision rule.

Self-host when you need what only the local copy gives you. Offline or on-device operation. Per-request voice cloning from arbitrary samples. A language outside the hosted voice set. Or volume high enough that per-character billing would dominate your costs, and you already have a spare machine.

Use the API when you want the parts that are boring to build. The OpenAI-compatible shape means existing client libraries work as-is. The prepaid wallet bounds the cost of a runaway loop. After the balance empties, each further request is refused with a named error. Someone else owns the update cadence. When the project ships new languages or fixes a serving bug, the hosted lane picks it up on redeploy. Nothing in your repository changes. And the install path you skip is not nothing. On Linux a plain pip install pocket-tts pulls the CUDA build of PyTorch, roughly 3 GB of wheels the CPU model never touches. That happens unless you know to point the installer at the CPU-only index. Both of those facts come from the official repository. It documents them for people who choose the local road.

The two roads also pair well. The same weights that answer this endpoint ship as ONNX exports for phones and browsers. So the common shape is simple. Prototype and overflow on the API. Ship the on-device build for the offline cases.

API usage

The route is POST /v1/audio/speech with a Bearer key from the console. The body takes three required fields: model (pocket-tts), input (the text), and voice (a catalog id such as alba). Two optional fields are accepted, response_format and speed. There is no stream parameter. Audio always arrives by chunked transfer, and the lane emits wav.

Four laws of this route that save debugging time:

1. 2,500 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 and concatenate at playback.
2. Do not set tight read timeouts. The lane buffers synthesis before the first byte; a capped-size request can take tens of seconds to first audio. A 120-second client timeout is a sane floor.
3. Retries re-bill. The Idempotency-Key header is accepted on this route but carries no replay semantics: audio does not fit the replay budget, so a retried request executes and bills again. Check your client's retry defaults.
4. Voices are a free read. GET /v1/audio/voices?model=pocket-tts lists the valid ids for this model. It needs auth and meters nothing.

Chunking in practice: an 8,000-character article becomes four requests of at most 2,500 characters each. The wav files concatenate in order, and the wallet sees exactly the characters sent. Split on sentence boundaries where you can. A mid-sentence split is audible as a pause and nothing worse.

curl

curl -X POST "https://api.ironstratum.com/v1/audio/speech" \
  -H "Authorization: Bearer $KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "pocket-tts",
    "input": "Pocket TTS gives your CPU a voice, and this endpoint gives it a billing plan.",
    "voice": "alba"
  }' \
  --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": "pocket-tts",
        "input": "Pocket TTS gives your CPU a voice.",
        "voice": "alba",
    },
    timeout=120,  # first byte can take tens of seconds at 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="pocket-tts",
    voice="alba",
    input="Pocket TTS gives your CPU a voice.",
) as response:
    response.stream_to_file("speech.wav")

The OpenAI SDK sends the same shape the route parses. An existing integration changes by exactly two lines: the base URL and the model id.

Benchmarks

Two evidence layers, both dated. One is our measurements from the hosted lane. The other is Kyutai's published evaluation of the model.

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

Read the ceiling as a service-planning number for sustained load, not a per-request promise. Single requests are bounded by the synthesis curve. The concurrency-8 figure is where the measured day tops out before tails widen.

The model itself. From Kyutai's technical report, January 2026. Librispeech test-clean under the F5-TTS evaluation protocol. ELO columns are pairwise human ratings.

The row worth sitting on: intelligibility tied with a model 7.5 times its size. Quality sits above the F5-TTS baseline. And it is one of only two entries in the table that run faster than real time on a CPU. The speaker-similarity ELO sits under the large cloning models. That is the honest cost of the size. That trade is what lets modest hardware host the model at all, per character, without large-GPU economics underneath it.

Getting started

1. Create an account on the console. The console is where the wallet and keys live.
2. Create an API key. One key per project is the intended shape: each key can be revoked on its own, so a compromised project key never puts the other projects at risk, and every key draws from the prepaid wallet, whose emptied balance refuses the next request at the door.
3. Check the rate. Per-character metering means the pricing page is where the rate lives; nothing here is billed by the month or by the request.
4. Make the first call. Copy the curl tab, substitute your key, and synthesize something short. If it plays, every longer case is just chunking.

The models index lists the rest of the catalog. Speech models covers the other TTS models on the same metering.