Text to speech API: open-weight models, one speech route
A text to speech API takes written text over HTTP and returns spoken audio. This page is the entry to the speech side of IronStratum: four open-weight models, Kokoro, Chatterbox, Pocket, and Audio8, answer a single speech endpoint, accept the same request shape, and bill the same way, by the characters you send.
Two things make this catalog different from the TTS vendors that own the search results today. The models are open-weight, with Apache 2.0 and MIT licenses, so the weights behind the endpoint are the same weights you could download and run yourself. And the billing unit is one thing, a character of input, against a market where TTS is quoted per thousand characters, per million, per minute, per credit, or per token depending on the vendor.
Last verified: 2026-09-11
What a text to speech API is
The request is three fields. You name the model, you pass the text, and you pick a voice from that model's catalog; the service converts the text to speech and returns audio bytes. The shape that most of the industry converged on is the one OpenAI documents for its speech endpoint: a model, an input string, and a voice, with a couple of optional fields for output format and speed. That convention is why speech integrations tend to be portable, and why this platform keeps it: a client library written against the OpenAI shape speaks to this route with its base URL changed.
Behind the request shape sit two very different kinds of catalog. The vendors that dominate the head terms serve proprietary models: the voice exists only while you rent it, the weights never leave their infrastructure, and the license terms can change with a price update. Open-weight catalogs run the other way. Kokoro shipped in January 2025 as an 82-million-parameter model under Apache 2.0, and per its card it delivers quality comparable to larger models. Pocket TTS came out of Kyutai as a model built to synthesize on a laptop CPU. Chatterbox comes from Resemble AI, open-sourced under MIT. Audio8 TTS is a 0.6-billion-parameter multilingual model with a cloning-capable architecture, also Apache 2.0. A hosted API built on these models is renting operations, not renting the model itself, which changes what you are buying and what you can fall back to.
The speech catalog
Four speech SKUs sit behind this route today, each wired to the gateway and measured on its serving lane. The serving card they run on is stopped during the specialty fleet rollout, so what follows is capability, not a traffic report. The model registry drives what the catalog table on this page renders, and each model page states its own measured caps, speeds, and ceilings.
- Kokoro is the volume engine: a small, fast model with a large fixed-voice catalog, at its best on steady English narration where the same reliable voices carry long sessions.
- Chatterbox is the expressive lane: a 0.5-billion-parameter model from a family known for controllable, dramatic delivery, suited to character voices and short-form quality-sensitive work.
- Pocket TTS is the everywhere model: a 100-million-parameter design that runs in real time on plain CPUs, with an ecosystem of community ports that has carried it well beyond its original Python home.
- Audio8 TTS is the reach model: a compact multilingual build whose card names eleven recommended languages, several of them ones that small TTS models usually skip.
The four are one family in the billing sense. One wallet funds them all, one key system governs them all, and switching between them is a model-id change in the request body, not a new integration.
Choosing a model
The fastest way to choose is to name the dominant job.
If the job is narration at volume, articles, documentation, e-learning, news digests, the weight goes to Kokoro. Fixed voices, a lane measured for throughput, and a bill you can compute before anything is sent: count the characters of the script and you have the number.
If the job is a voice with personality, product speech that should sound like a character rather than a reader, start with Chatterbox. Its family was built around expressiveness controls, and short scripts play to its strengths.
If the job is languages beyond English, Audio8 TTS is the starting point. Eleven languages sit in its card's recommended set, and its architecture was designed for zero-shot voice work.
If the job is a model you can also hold onto, something small enough to embed, port, or run on modest hardware when the hosted route is not the right tool, Pocket TTS is that class of model. The same weights that answer the endpoint run on laptops and, through community builds, on phones and single-board computers.
Many products end up using two: a volume lane for the steady stream and a second model for the edges, both drawing from the same wallet. The model pages carry the measured numbers, the voice catalogs, and the copy-paste code tabs for each.
Calling the route
One route serves all four models: POST /v1/audio/speech, authorized by a console-issued Bearer key. The body takes model, input, and voice as required fields, accepts response_format and speed, and rejects anything else with a named unknown-parameter error, because a silently ignored field is a debugging trap. There is no streaming switch to flip: the audio itself comes over chunked transfer, as wav, and the first bytes leave once synthesis has produced enough to send.
Voice ids are not guesswork. GET /v1/audio/voices with a model name returns that model's full catalog, costs nothing to call, and is the reference for every valid voice string.
Long scripts are a splitting problem, and the boundary lives with the model. Each model page states the request cap its lane was measured around, beside its code tabs in curl, Python, and the OpenAI SDK. The guide Long audio and long text, streaming and chunking done right, linked in the guides block, handles the patterns in depth.
How billing works
Speech on this platform is billed by the character, and only by the character. A completed request is charged for the characters it consumed. A request the gateway refuses before synthesis, an over-cap input, an unknown parameter, bills nothing. Nothing here bills by the month, by the seat, or by the request.
The ceiling on spend is structural rather than alerting-based. Every call is paid from the prepaid wallet, and a request arriving once the balance is empty is refused with a named error before any synthesis starts. The top organic result for text to speech API pricing on our September 2026 reads was a developer asking how to be sure of their costs. They were afraid of waking to a cloud bill in the thousands. A balance whose only possible breach is the single request already synthesizing answers that fear directly, and the guide How to avoid API bill shock, linked in the guides block, collects the operating habits around any metered endpoint.
Keys are revocable one at a time, effective immediately, so a compromised project key can be killed without disturbing anything else the wallet funds. Per-key spending limits are on the roadmap and not part of today's surface; the wallet balance is the bound that exists now.
Every rate is rendered from the model registry onto the pricing page, where the catalog table for all four speech models is generated at build time. This page and the model pages carry no hand-written prices anywhere, because a price typed by hand is a price that goes stale.
Running the models yourself
Every model in this catalog can be downloaded, and the licenses permit commercial use. If that is the whole appeal, the feeling is correct and the door is open: the model pages link each project's official repository and card, and the local road is a supported path, not a loophole.
Local wins when the properties you need only exist locally. Offline and on-device synthesis, cloning a voice from clips you supply, phoneme-level pronunciation control, or volume so high that any per-character fee would dwarf the cost of a machine you already run. The ecosystem is real: Pocket TTS alone has been ported to Rust, C++, and C#, wrapped for embedded boards, and extended with community-trained models in half a dozen languages.
The hosted route wins when the work you are skipping is the work you would otherwise do: keeping runtimes patched, sizing hardware for synthesis bursts, measuring lanes, and metering honestly. The same request shape reaches the same weights here, and your fallback never disappears, because the weights are yours to keep either way.
The break-even point is arithmetic, not a feeling: the guide Running TTS locally vs API, the real break-even math, works through machine cost against character volume for models in exactly this weight class.
Voices, rights, and disclosure
The hosted surface serves registered voice catalogs. Each model answers with the voices pinned to it, listed by the free voices read, and cloning from arbitrary reference audio is deliberately not part of this route. Three of the four models, Chatterbox, Pocket TTS, and Audio8 TTS, carry cloning-capable architectures upstream; Kokoro is the exception, speaking from the fixed voice packs it was trained with. That upstream capability lives on the self-host road, where the reference audio never has to leave your machine.
Two obligations travel with synthetic speech wherever it is made. Use voices whose owner consented to the use, which the upstream projects state in their own terms. And tell listeners what they are hearing: OpenAI's usage policies, for example, require clear disclosure that a TTS voice is AI-generated rather than a human voice. Disclosure is a sentence in your product, not a compliance program.
Getting started
- Open a console account. The console runs invite-only while the beta lasts; the wallet, the API keys, and the spend history sit there.
- Create a key. Give each project its own key, and retire a key the moment its project changes; revoking one never disturbs the others.
- Pick a model and take its tabs. Each model page carries curl, Python, and OpenAI SDK examples that run against this route as written; put your key in one of them and synthesize a single sentence.
- Read the rates once. The pricing page renders every speech rate from the registry, and the full catalog, chat, speech to text, embeddings, rerank, and document parsing on the same wallet, is laid out on the models index.