Streaming TTS 2026: Kokoro vs ElevenLabs, Cartesia, OpenAI

Updated October 2026: ElevenLabs deprecated Turbo v2.5 (Flash v2.5 replaces it) and launched v4 Turbo, new Coval latency medians (Flash v2.5 188 ms, v4 Turbo 192 ms, Cartesia Sonic 3.6 289 ms), and current ElevenLabs and Cartesia prices.

Why This Matters

If your product talks back — a meeting assistant that reads a summary aloud, a language tutor, a customer-support voice agent, a video dub, or an accessibility narrator — you will choose a text-to-speech engine, and that one choice sets your latency, your bill, and your privacy posture all at once. This article is for the product manager, founder, or engineering lead deciding between hosting an open-source voice model and paying for a hosted API. By the end you will understand why "first audio in under 300 milliseconds" is the metric that matters, how the four leading 2026 options compare on speed and cost, the trap of measuring the wrong kind of latency, and a clear rule for when free-but-self-hosted beats paid-but-managed. The goal is that you can walk into a vendor conversation and ask the right questions instead of being sold on a single headline number.

The short answer, October 2026: for a live voice agent, ElevenLabs Flash v2.5 or the new v4 Turbo give the fastest and steadiest first audio (about 190 ms in independent tests, $0.04 per 1,000 characters); Cartesia Sonic 3.6 is about 100 ms slower but has the lowest error rate and 44 languages; Kokoro is the free, self-hosted choice when audio must stay in your network or volume is very high; OpenAI's TTS endpoint is a batch tool, not a real-time one (Coval, October 2026).

What "Streaming" Actually Means For Speech

Streaming TTS means the engine sends speech back in small audio chunks as it generates them, so playback starts before the whole sentence has been synthesised. Start with the problem streaming solves. A text-to-speech engine — the software that turns written words into a spoken audio recording, abbreviated TTS — can work in two ways. The simple way is to take your whole sentence, generate the entire audio clip, and hand it back when it is done. The streaming way is to start sending out sound as soon as the first few words are ready, while the rest is still being made.

Think of the difference like a kettle versus a tap. The non-streaming engine is a kettle: you wait for the whole thing to boil, then you pour. The streaming engine is a tap: water starts flowing the instant you turn it, and keeps flowing. For a pre-recorded audiobook, the kettle is fine — nobody is waiting live. For a back-and-forth conversation, the kettle's wait feels like the line went dead, and you need the tap.

Why does this matter so much? Because human conversation has a rhythm. When one person stops talking, the other normally starts within about two-tenths of a second (Gradium, 2026). That gap — roughly 200 milliseconds, where a millisecond is one-thousandth of a second — is so consistent across languages that our ears treat anything much longer as a hesitation. If a voice agent takes a full second to start replying, the conversation stops feeling like a conversation and starts feeling like a phone menu.

Streaming buys back that time. Instead of waiting for the engine to finish the whole reply, the listener hears the opening words while the engine is still working on the end of the sentence. The audio plays at its own natural pace — about 150 words a minute — and as long as the engine can generate faster than the ear consumes, the listener never hears a gap.

Figure 1. Batch waits for the whole clip; streaming delivers first audio while the rest is still being made — which is the delay the listener actually feels.

Time-To-First-Audio Is The Number That Counts

There is one metric that decides whether a streaming voice feels responsive, and it is easy to get wrong. The right metric is time-to-first-audio, abbreviated TTFA: the time between sending your text and hearing the first playable piece of sound (Gradium, 2026). It is the part of the delay the listener actually feels, because once the first chunk arrives, playback begins and the engine races to stay ahead of the ear.

The metric people often quote instead is time-to-first-byte, abbreviated TTFB: the time until the first piece of data comes back. The trap is that the first bytes are frequently not sound at all. Audio files start with a header — a small block of bookkeeping data that says "this is a WAV file, here is its sample rate" — and that header carries no speech. A service can return its header in a few milliseconds and look lightning-fast on a TTFB chart, while the first actual audible sample arrives much later (Gradium, 2026). Leading silence is the second trap: some engines send their first real audio frames as near-silent padding. In June 2026 the independent Coval benchmark switched to perceived TTFA — arrival time plus the leading silence before the first audible sample — and one engine's reported figure jumped from 172 ms to 430 ms with no change to the model (Coval, September 2026). Measuring TTFB rewards the wrong thing. Always insist on time-to-first-audio, measured after the header and any leading silence are stripped.

Figure 2. The first byte is often just a file header. Measure time-to-first-audio, not time-to-first-byte.

How fast is fast enough? The 2026 benchmarks, vendor and independent, converge on a simple rule. Under 300 milliseconds of TTFA feels conversational; under 200 milliseconds is excellent; above 400 milliseconds starts to feel like waiting (Gradium, 2026). And remember that TTS sits at the end of a chain: in a voice agent, the system first listens (speech-to-text), then thinks (a language model), then speaks (TTS). Every millisecond the voice engine adds lands directly on top of everything before it, so a tight TTS budget leaves room for the rest.

Why Consistency Matters As Much As Speed

A median speed hides a second problem: how steady that speed is. Engineers measure the typical case with the median, written P50 — the value half of all requests beat. But they also watch the spread, often summarized as the interquartile range, abbreviated IQR: the gap between the fast quarter and the slow quarter of requests. A low median with a wide spread means most calls feel snappy but a meaningful fraction feel broken — and at the scale of thousands of concurrent calls, "a fraction" is a lot of unhappy users.

The October 2026 data makes the point. Over the 30 days to 16 October 2026, ElevenLabs Flash v2.5 posts a 188-millisecond median with a 27-millisecond spread (175–202 ms), and the new Eleven v4 Turbo is almost identical at 192 milliseconds with a 31-millisecond spread (Coval, October 2026). Over the 30 days to 21 October 2026, Cartesia Sonic 3.6 sits at 289 milliseconds with a 59-millisecond spread (261–320 ms), so its slower quarter of requests crosses the 300-millisecond line (Coval, October 2026). Speed and steadiness are two different questions. Ask both.

Figure 3. Median time-to-first-audio for the hosted engines (Coval, 30 days to 16–21 October 2026). The whiskers show the spread; OpenAI's gpt-4o-mini-tts averages over two and a half seconds, so treat it as a batch tool.

The Two Ways To Get A Voice: Host It Or Rent It

Every streaming-TTS decision comes down to one fork. You can host an open-weights model — download the model file, run it on your own hardware, pay only for that hardware — or you can rent a hosted API, where the vendor runs everything and bills you per character of text. The four options in this article line up neatly on that fork: Kokoro is the host-it option; ElevenLabs, Cartesia, and OpenAI are the rent-it options.

"Open-weights" means the trained model file is published for anyone to download and run. Kokoro goes further: its weights carry the Apache 2.0 licence, a permissive open-source licence that allows commercial use with no per-use fee and no requirement to share your own code (hexgrad, 2026). That is the heart of its appeal. Once the model runs on your server, generating a million characters of speech costs only the electricity and the rented GPU time, not a metered fee to a vendor.

Renting flips the trade. You write no infrastructure, you get the vendor's newest model automatically, and you start in an afternoon. In return you pay per character, your users' text leaves your network and travels to the vendor, and you live with whatever latency the vendor's servers and your distance from them produce. For many teams that is the right trade — until the volume gets large enough that the per-character bill dwarfs the cost of a GPU.

Figure 4. The host-vs-rent fork, row by row. Each tinted cell is the option that usually wins that criterion.

Meet The Four Engines

Kokoro — the free model you host yourself

Kokoro is an open-weights TTS model with 82 million internal parameters — the adjustable numbers a model learns during training (hexgrad, 2026). Eighty-two million sounds large, but in model terms it is tiny: many rival voice models are ten to a hundred times bigger. That smallness is the whole point. A small model runs fast on cheap hardware: the community Kokoro-FastAPI server reports 35–100 times real-time on a single RTX 4060 Ti, about 300 milliseconds to first audio on a GPU and under a second on an Apple M3 Pro CPU (Kokoro-FastAPI, 2026).

Under the hood, Kokoro is built on two published research designs: StyleTTS 2 for shaping the voice and ISTFTNet for turning the model's internal representation into a sound wave (Li et al., 2023; Kaneko et al., 2022). Crucially, at speaking time it runs as a single forward pass with no slow iterative "diffusion" step, which is what keeps it quick (hexgrad, 2026). Version 1.0, released in January 2025, ships 54 voices across 8 languages and outputs 24-kilohertz audio — broadcast-adjacent quality from a model that fits on a laptop (hexgrad, 2026).

The economics are the headline. Served through a cloud API, Kokoro runs at under one dollar per million characters of text, or under six cents per hour of audio produced (hexgrad, 2026). Host it yourself at volume and the marginal cost falls further still. The catch is everything a managed vendor would otherwise handle: you run the servers, you scale them, you keep them up, and you accept that an 82-million-parameter model, while excellent, will not match the very top of the expressive-quality range on emotional nuance.

ElevenLabs Flash and v4 Turbo — the fast, broad, paid pair

ElevenLabs is the most widely used commercial voice vendor, and for streaming it now offers two fast models. Flash v2.5 is the speed specialist: about 75 milliseconds of model inference time, 32 languages, $0.04 per thousand characters on the API (ElevenLabs, October 2026). Eleven v4 Turbo, released on 28 September 2026, is the expressive real-time option: about 100 milliseconds of median inference, 90+ languages, the same $0.04 per thousand characters, streamed over the Text to Dialogue WebSocket (ElevenLabs, October 2026). The older Turbo v2.5 is now on ElevenLabs' deprecated list, with Flash v2.5 named as its replacement — if your code still calls eleven_turbo_v2_5, plan the switch. Note the gap between the marketing number and the measured one: the 75 and 100 milliseconds are inference time only, and real end-to-end TTFA, after network travel and server queuing, lands at about 190 milliseconds for both in independent tests (Coval, October 2026).

What you are buying with ElevenLabs is breadth and steadiness. Flash covers 32 languages and v4 Turbo 90+, both latency spreads are tight (27–31 milliseconds), and the API is mature: it offers a regular endpoint, a streaming endpoint that returns audio over chunked HTTP as it is generated, and a bidirectional WebSocket endpoint designed for feeding in text as a language model produces it (ElevenLabs, 2026). One of this article's secondary topics, the ElevenLabs voice isolator, is a sibling tool on the same platform: it strips background noise out of a recording to leave clean speech, billed at 1,000 characters per minute of audio, for files up to 500 MB and one hour long (ElevenLabs, October 2026). It is not a TTS engine, but teams building voice features often need both.

Cartesia Sonic — the accuracy leader among fast engines

Cartesia's Sonic line is built for low-latency real-time streaming. It uses a state-space model architecture — a newer alternative to the transformer designs most AI models use, tuned for streaming a continuous signal smoothly (Cartesia, 2026). The current model, Sonic 3.6, became generally available on 27 August 2026 with 44 languages; pin the snapshot sonic-3.6-2026-08-27 in production (Cartesia, 2026). On the independent Coval benchmark it has the lowest word error rate of all 32 TTS models tested, 1.5 %, with a 289-millisecond median time-to-first-audio (Coval, October 2026). Pricing starts free with 20,000 monthly credits (one credit is one character), then climbs through a $5 Pro tier, a $49 Startup tier with 1.25 million credits, and a $299 Scale tier with 8 million credits, with instant voice cloning from Pro and professional cloning from Startup (Cartesia, October 2026).

The honest caveat, visible only in the independent data, is speed. In May 2026 an earlier Sonic posted the fastest median in the field; under Coval's perceived-TTFA method, Sonic 3.6 now trails ElevenLabs by about 100 milliseconds at the median and has twice the spread (59 vs 27–31 ms), partly because more of its first audio is leading silence (Coval, September and October 2026). Choose Cartesia when pronunciation accuracy and 44 languages matter more than the last 100 milliseconds.

OpenAI TTS — convenient if you already live there

OpenAI's text-to-speech is the easy default for teams already building on OpenAI. The cost-optimized model, gpt-4o-mini-tts, runs at roughly 1.5 cents per minute of audio; the older tts-1 is $15 per million characters and tts-1-hd is $30 (OpenAI, 2026). It supports streaming and a useful range of output formats, including the low-latency Opus codec (OpenAI, 2026). OpenAI's May 2026 voice launch — GPT-Realtime-2, GPT-Realtime-Translate and GPT-Realtime-Whisper — added no new standalone TTS model; for a live agent inside OpenAI, the speech-to-speech Realtime API is the path, not the TTS endpoint (OpenAI, May 2026).

But the independent benchmarks are blunt about its place: over the 30 days to 21 October 2026, gpt-4o-mini-tts averaged 2,567 milliseconds to first audio — last of 32 models on Coval — which rules it out for live conversation and marks it as a batch tool, excellent for pre-rendering narration or dubbing where nobody is waiting (Coval, October 2026). OpenAI also offers no WebSocket TTS endpoint, only HTTP-based delivery, which adds a small per-turn cost in multi-turn conversations (Gradium, 2026). If you need conversational speed, look to the other three; if you need convenient batch narration inside an existing OpenAI stack, it fits.

The 2026 Comparison, Side By Side

The table below collects the numbers that decide most choices. Latency figures are independent perceived time-to-first-audio medians from the Coval benchmark over the 30 days to 16–21 October 2026, not vendor marketing claims; prices and language counts are read from each vendor's own pages on 21 October 2026. The "winner" of each column is not a single product — it depends on which column your product cares about most.

*Kokoro's first-audio latency depends entirely on your own hardware and chunk size; the Kokoro-FastAPI server reports about 300 ms to first audio on a GPU and under one second on an Apple M3 Pro CPU (Kokoro-FastAPI, 2026).

Read the table as a set of trade-offs, not a leaderboard. ElevenLabs now wins both median speed and steadiness, and v4 Turbo adds the widest language list. Cartesia wins pronunciation accuracy at about 100 milliseconds more latency. Kokoro wins long-run cost and privacy but hands you the operations bill. OpenAI's TTS endpoint is a convenience play for batch work, not a real-time engine.

A Worked Example — What A Voice Agent Costs Per Month

Numbers in a pricing table feel abstract until you run them against real usage, so let us cost a concrete product: a customer-support voice agent that speaks 200 hours of generated audio a month.

First, convert hours of speech to characters of text, because that is what hosted APIs bill. Speech runs at about 150 words a minute, and English words average about 6 characters including the trailing space. So one minute of audio is roughly:

150 words × 6 characters = 900 characters per minute

Two hundred hours is 12,000 minutes, so the monthly text volume is:

12,000 minutes × 900 characters = 10,800,000 characters ≈ 10.8 million characters

Now price that 10.8 million characters against each option:

ElevenLabs Flash v2.5   : 10.8M × $0.04 / 1,000   = $432 / month
ElevenLabs v4 Turbo     : 10.8M × $0.04 / 1,000   = $432 / month
Cartesia Sonic 3.6      : 10.8M × ~$0.037 / 1,000 = ~$404 / month (Scale per-credit rate; Scale includes 8M, the rest is overage or a higher plan)
OpenAI gpt-4o-mini-tts  : 12,000 min × ~$0.015    = ~$180 / month (batch only)
Kokoro via a hosted API : ~$1 per million served  = ~$11 / month
Kokoro self-hosted      : one GPU kept running all month, a fixed cost that does not grow with characters, + your ops time

The spread is the lesson. At 200 hours a month, the real-time hosted options run around $400–$430 (October 2026 list prices), Kokoro rented from a cloud API costs around eleven dollars, and Kokoro on your own GPU costs a fixed monthly server bill plus the salary cost of the engineer who keeps it running — whatever the character count. Below a few dozen hours a month, the hosted bill is trivial and self-hosting is not worth the operational burden. Somewhere as volume climbs, the per-character bill passes the fixed GPU bill, and the open model's near-zero marginal cost wins decisively. The break-even point is not a fixed number — it depends on your engineering cost and uptime needs — but every team at scale should know roughly where their line sits.

Kokoro vs ElevenLabs — Which One Should You Use?

Use Kokoro when volume is high, the audio must stay in your network, and 8 languages and 54 preset voices are enough; use ElevenLabs when you need voice cloning, 32–90+ languages and a managed real-time API with a measured ~190 ms time-to-first-audio. Kokoro is free under Apache 2.0 and costs only compute — about $11 a month through a hosted Kokoro API in the worked example above against $432 for ElevenLabs Flash or v4 Turbo, or a fixed GPU bill if you run it yourself (hexgrad, 2026; ElevenLabs, October 2026). Kokoro ships no voice cloning and its first-audio latency is whatever your hardware delivers; ElevenLabs bills per character and sends your text to its servers.

For Kokoro TTS streaming, the model itself is a single forward pass, so streaming comes from the server you put around it: the open-source Kokoro-FastAPI wraps it in an OpenAI-compatible /v1/audio/speech endpoint that streams audio chunks, which lets you swap it in for a hosted API without rewriting the client (Kokoro-FastAPI, 2026). Many teams run both: Kokoro for high-volume, fixed-voice narration and ElevenLabs for the branded or cloned voice in live calls.

How Streaming Is Wired — Chunks, Sentences, And Sockets

To get the low latency the benchmarks promise, the text has to be fed to the engine the right way, and the audio has to be carried back over the right kind of connection. Both choices are within your control, and getting them wrong can erase a fast model's advantage.

On the input side, the engine cannot start until it has enough text to say something natural. Read a single word and the engine has no idea how to inflect it; wait for a whole paragraph and you have reintroduced the kettle delay. The fix is chunking: feeding text in small batches sized so the engine can begin without stalling. ElevenLabs exposes this directly through a setting called the chunk-length schedule, a list of character counts at which it commits to generating — for example, generate after 120 characters, then 160, then 250 (ElevenLabs, 2026). It also offers an auto mode that picks those boundaries for you by reading the incoming text, and a flush command to force out whatever is buffered when you reach the end (ElevenLabs, 2026). When the text comes from a language model that emits words one at a time, this matters a great deal: chunk too eagerly and prosody suffers; chunk too late and latency suffers.

On the transport side, there are three ways to carry the audio back, and they suit different situations. A regular request returns the whole clip at once — simplest, slowest to first sound. An HTTP stream — plain chunked transfer, or a server-sent-events stream defined in the web's HTML standard — pushes audio chunks down a one-way channel as they are made, which lowers time-to-first-audio and is ideal when you already have the full text up front (WHATWG, 2026; ElevenLabs, 2026). A WebSocket, the two-way persistent connection standardized as RFC 6455, lets you keep feeding text in while audio streams back out, which is exactly the shape of a live agent reading a language model's output as it is generated (IETF, 2011; ElevenLabs, 2026). The WebSocket pays a small one-time setup cost to open the connection, but reusing one open connection across many turns saves 50 to 100 milliseconds per turn versus reopening an HTTP request each time (Gradium, 2026). For a chat-style agent, keep one socket open.

Figure 5. Choose the transport by how the text arrives: SSE when you have it all up front, a reused WebSocket when it streams from a language model.

One more knob worth knowing: geography. ElevenLabs serves its fast models from regional data centers, and its own latency table gives 100–150 milliseconds from North America or Europe and 150–200 milliseconds from parts of Asia — model-side figures that exclude your network, so the gap is regional serving, and your users' own network distance adds on top (ElevenLabs, 2026). If your users cluster in one region, pick a vendor with a server near them, or self-host close to your audience.

A Common Mistake — Optimizing The Model And Ignoring The Pipeline

The single most frequent error teams make is to pick the model with the lowest advertised inference number and then wonder why the live product still feels sluggish. The advertised "75 milliseconds" is the model's thinking time in isolation. The number your user feels is the sum of four things: the network trip to the server, any queue wait when the service is busy, the model's generation time, and the network trip back (ElevenLabs, 2026). A 75-millisecond model reached over a slow connection, behind a busy queue, with a fresh HTTP handshake every turn, can easily feel like half a second.

The fix is to measure the whole pipeline, end to end, from your own users' locations, using time-to-first-audio and not time-to-first-byte. Open one persistent WebSocket and reuse it. Choose a server region near your users. Tune your chunk schedule against real language-model output, not a static test sentence. A mid-pack model wired correctly beats a benchmark champion wired carelessly, every time.

How To Choose — Five Questions

Work through these in order; each one narrows the field.

1. Is this real-time or batch? If nobody is waiting live (pre-rendered narration, overnight dubbing), latency is irrelevant — pick on quality and price, and ElevenLabs v4 or Multilingual v2, or OpenAI's tts-1-hd, are fine. If it is conversational, latency rules everything below.
2. What is your monthly volume in hours? Convert to characters (≈900 per minute). Under a few dozen hours, rent. Above a few hundred, model the self-host break-even seriously.
3. How many languages, and which? Need broad coverage? ElevenLabs v4 Turbo (90+), Cartesia Sonic 3.6 (44) or ElevenLabs Flash (32). English-heavy and cost-sensitive? Kokoro's 8 languages may be enough.
4. Can the audio leave your network? If privacy or regulation says no, self-host Kokoro. If yes, the hosted APIs are open to you.
5. Does the worst case matter as much as the average? If a slow tail call breaks the experience at scale, weigh the latency spread, not just the median — favour the tighter spread (ElevenLabs Flash or v4 Turbo, 27–31 ms in October 2026) over the wider one (Cartesia Sonic 3.6, 59 ms).

Where Fora Soft Fits In

We build the products that consume streaming TTS — video conferencing tools with spoken meeting summaries, telemedicine platforms with voice-driven intake, e-learning systems with narrated lessons, and OTT services with automated dubbing. In that work the engine choice is rarely about the single fastest model; it is about matching the engine to the product's real constraints. A privacy-sensitive telemedicine deployment often points toward a self-hosted open model so audio never leaves the customer's environment, while a multilingual conferencing feature usually favours a hosted API for its language breadth and zero operations burden. The pattern we apply is to fix the latency budget first, then the privacy and language requirements, and only then compare prices — because a cheaper engine that misses the latency budget is not cheaper, it is unusable. Our custom text-to-speech development team wires Kokoro, ElevenLabs, Cartesia or OpenAI TTS into products under that budget, and our LiveKit AI agent development work uses streaming TTS for voice agents that answer in under half a second. If the voice sits inside a support bot or an in-app assistant rather than a call, our AI chatbot and voice assistant development team builds it on ElevenLabs, Cartesia or OpenAI with the same latency-first approach.

The book

AI for Video: A Complete Guide to Intelligence in Video Products: From Models and Inference to Computer Vision, Speech, Search, and Generative Video

This article picks a TTS engine by time-to-first-audio, price and privacy; volume 6 of the Fora Soft Video Engineering Handbook takes the whole speech stack apart — text-to-speech next to speech recognition and diarization, the models and inference behind them, and the deployment topologies that decide whether you host a model or rent an API. Volume 7 puts that voice inside a live call: the latency budget of a WebRTC pipeline, voice agents, and the cost per stream-hour at thousands of concurrent calls. Both sit inside a seven-volume series that takes the video stack from the pixel to production. Written by Nikolay Sapunov, CEO at Fora Soft.

Read it on Amazon →Kindle & paperback · Fora Soft Video Engineering Handbook

See our case studies

References

1. hexgrad. Kokoro-82M (model card), Hugging Face, accessed 2026-10-21. https://huggingface.co/hexgrad/Kokoro-82M. First-party source for the model's facts: 82 million parameters, Apache 2.0 licence (commercial use permitted), decoder-only StyleTTS 2 + ISTFTNet architecture with no diffusion or encoder at inference, v1.0 released 27 January 2025 with 54 voices across 8 languages and 24 kHz output, ~$1,000 total training cost on ~1,000 A100 GPU-hours over a few hundred hours of permissively licensed audio, and the served market rate of under $1 per million characters (≈$0.06 per hour of audio, ≈1,000 characters per minute).
2. Li, Y., Han, C., Raghavan, V., Mischler, G., Mesgarani, N. StyleTTS 2: Towards Human-Level Text-to-Speech through Style Diffusion and Adversarial Training with Large Speech Language Models, arXiv:2306.07691, 2023, accessed 2026-05-31. https://arxiv.org/abs/2306.07691. Primary academic source for the voice-modelling architecture Kokoro builds on — style diffusion as a latent variable and adversarial training with a speech language model. Original algorithm paper, the source of truth for the design rather than any vendor summary.
3. Kaneko, T., Tanaka, K., Kameoka, H., Seki, S. iSTFTNet: Fast and Lightweight Mel-Spectrogram Vocoder Incorporating Inverse Short-Time Fourier Transform, arXiv:2203.02395, 2022, accessed 2026-05-31. https://arxiv.org/abs/2203.02395. Primary academic source for the vocoder Kokoro uses to convert the model's internal representation into a sound wave quickly using an inverse short-time Fourier transform rather than a slow neural upsampler.
4. ElevenLabs. Models and Latency optimization, ElevenLabs Documentation, accessed 2026-10-21. https://elevenlabs.io/docs/overview/models and https://elevenlabs.io/docs/eleven-api/guides/how-to/best-practices/latency-optimization. First-party source for Flash v2.5 ~75 ms inference time and 32 languages, Eleven v4 Turbo ~100 ms median inference and 90+ languages, the deprecation of Turbo v2.5 with Flash v2.5 as replacement, the endpoint types (regular / server-sent-events streaming / WebSocket), the chunk-length schedule, auto-mode and flush controls, and the regional latency table (100–150 ms in North America / Europe, 150–200 ms in parts of Asia). Latency figures exclude network and application latency.
5. ElevenLabs. ElevenAPI Pricing, accessed 2026-10-21. https://elevenlabs.io/pricing/api. First-party source for the per-character API rates used in the worked example: Flash/Turbo and v4 Turbo $0.04 per 1,000 characters; v4, v3 and Multilingual v2 $0.08 per 1,000 characters. Eleven v4 and v4 Turbo were released on 28 September 2026.
6. ElevenLabs. Voice isolator (capability guide), accessed 2026-10-21. https://elevenlabs.io/docs/overview/capabilities/voice-isolator. First-party source for the voice-isolator secondary topic: a background-noise-removal tool costing 1,000 characters per minute of audio, accepting audio and video files up to 500 MB and one hour — distinct from text-to-speech.
7. Cartesia. Pricing, Sonic 3.6 and Changelog 2026, accessed 2026-10-21. https://www.cartesia.ai/pricing, https://docs.cartesia.ai/build-with-cartesia/tts-models/latest and https://docs.cartesia.ai/changelog/2026. First-party source for the self-serve plans (Free 20,000 credits; Pro $5 / 100,000 credits; Startup $49 / 1.25 M credits with professional voice cloning; Scale $299 / 8 M credits; 1 credit = 1 character), instant voice cloning from Pro, Sonic 3.5 GA in May 2026, Sonic 3.6 GA on 27 August 2026 with 44 languages, and the state-space-model architecture.
8. Gradium. TTS Latency Benchmark 2026: TTFA Compared Across Gradium, ElevenLabs, Cartesia and Deepgram, 5 May 2026, accessed 2026-05-31. https://gradium.ai/content/tts-latency-benchmark-2026. Source for the TTFA-vs-TTFB distinction (container headers carry no audio), the ~200 ms human turn-taking gap and ~300 ms conversational threshold, the absence of an OpenAI WebSocket TTS endpoint, and the 50–100 ms per-turn saving from WebSocket reuse. Its May 2026 latency medians are superseded by the October 2026 Coval figures (reference 9).
9. Coval. TTS Benchmark (model pages for Flash v2.5, Eleven v4 Turbo, Sonic 3.6 and GPT-4o mini TTS), accessed 2026-10-21, and Time to First Audio, Measured Right, 8 September 2026. https://benchmarks.coval.ai/tts and https://www.coval.ai/blog/time-to-first-audio-ttfa-benchmark/. Independent voice-AI evaluation platform, not affiliated with any TTS provider. Source for the 30-day perceived-TTFA figures: Flash v2.5 median 188 ms (IQR 175–202), Eleven v4 Turbo 192 ms (176–207), Sonic 3.6 289 ms (261–320) with the lowest WER of 32 models (1.5 %), GPT-4o mini TTS mean 2,567 ms; and for the June 2026 switch to perceived TTFA (arrival plus leading silence).
10. OpenAI. Text-to-speech models and API pricing (gpt-4o-mini-tts, tts-1, tts-1-hd), accessed 2026-10-21. https://platform.openai.com/docs/guides/text-to-speech and https://openai.com/api/pricing/. First-party source for OpenAI's TTS pricing (tts-1 $15 / M chars, tts-1-hd $30 / M chars, gpt-4o-mini-tts ~$0.015 per minute of audio), the voice line-ups (9 voices on tts-1/-hd, 13 on gpt-4o-mini-tts), streaming support, the output formats including low-latency Opus, and the absence of a WebSocket TTS endpoint. OpenAI, Advancing voice intelligence with new models in the API, 7 May 2026, https://openai.com/index/advancing-voice-intelligence-with-new-models-in-the-api/: GPT-Realtime-2, GPT-Realtime-Translate and GPT-Realtime-Whisper, with no new standalone TTS model.
11. IETF. RFC 6455 — The WebSocket Protocol, December 2011, accessed 2026-05-31. https://www.rfc-editor.org/rfc/rfc6455. Primary standards source for the bidirectional persistent-connection protocol used for real-time text-in / audio-out TTS streaming.
12. WHATWG. HTML Living Standard — Server-sent events, accessed 2026-05-31. https://html.spec.whatwg.org/multipage/server-sent-events.html. Primary standards source for the one-way server-push mechanism (server-sent events / EventSource) that the HTTP streaming TTS endpoints are built on.
13. remsky. Kokoro-FastAPI (README), GitHub, accessed 2026-10-21. https://github.com/remsky/Kokoro-FastAPI. Open-source server for Kokoro-82M: OpenAI-compatible /v1/audio/speech endpoint with streaming, ~300 ms first audio on a GPU at chunk size 400, under 1 s on an Apple M3 Pro CPU, 35–100× real-time on an RTX 4060 Ti.