# Streaming text to speech over a WebSocket, explained (2026)

By Samuel Oram-Jones

Bland says a voice agent "that waits for a complete LLM response before starting synthesis adds the model's entire generation time to every reply." LLM is short for large language model, the software that writes an agent's answers, and it writes them in pieces, so an agent that waits for the last piece before asking for audio has already lost time the caller feels.

A WebSocket fixes that by staying open after it is made. A voice agent sends a speech model its language model's words a few tokens at a time, tokens being the small pieces of text a language model emits one after another, while audio comes back on the same connection.

## What is streaming text to speech, and why does a voice agent use a WebSocket?

Streaming text to speech returns audio while it is still being generated, and a WebSocket adds the other half by accepting text while it is still being written, which is what a voice agent needs because its language model produces a reply in pieces.

A plain HTTP request sends all the text and gets audio back. Chunked HTTP streaming, which OpenAI's speech endpoint and Bland's `POST /v2/tts` both offer, lets playback begin before the audio is finished, but the text has to be complete first. Server-sent events, or SSE, are a one-way stream from a server to a client, and Cartesia offers them on `/tts/sse` with the same limit. Cartesia says "If the full transcript is not known up front, use WebSocket with contexts, not bytes or SSE", and Bland says to use its WebSocket when "text arrives incrementally, such as tokens from an LLM."

Time to first audio is the delay between sending text and hearing the first sound. A WebSocket shortens it because synthesis can start on the first few words of a reply instead of the last.

## How does a WebSocket text to speech session work?

A WebSocket text to speech session is one open connection per conversation in which the client sends text in numbered turns and the server sends back audio, and Bland Speech's `/v2/tts/ws` is a documented example of the message flow.

1. The client opens the connection and sends `init` once, naming a voice, an audio format, and optional controls, and Bland replies `ready`.
2. The client sends `speak` messages, each carrying a `context_id` that names the turn and the next piece of text, kept verbatim with its leading spaces and punctuation.
3. Audio comes back as raw binary frames, with no JSON, base64, or container header, between an `utterance_start` and an `utterance_end` message for that turn.
4. When the language model finishes, the client sends `end_of_turn`, Bland synthesizes whatever text is still buffered, and `utterance_end` arrives with the reason `complete`.
5. When a caller interrupts, a `speak` with a new `context_id` preempts the active turn, or `cancel` stops it with no replacement.
6. `close` ends the session.

```json
{
  "type": "init",
  "voice": "29158307-9893-4149-8a75-bc9ce313d64e",
  "audio": {
    "encoding": "pcm_s16le",
    "sample_rate": 48000
  },
  "controls": {
    "expressiveness": 0.6,
    "stability": 0.5
  }
}
{ "type": "speak", "context_id": "turn-42", "text": "Hello" }
{ "type": "speak", "context_id": "turn-42", "text": ", how can I help?" }
{ "type": "end_of_turn", "context_id": "turn-42" }
```

Bland accumulates the text, finds speech boundaries, and releases it to synthesis once there is enough context for natural output, so a client sends tokens as the model produces them rather than re-wrapping them into sentences. Bland says one large `speak` message returns nothing until `end_of_turn`, while "The same words sent as deltas start playing about a second in." A connection holds one active turn at a time, a turn can hold at most 4,000 characters, and a voice is fixed for the life of a connection, so a different voice means a new connection.

Interruption is where a client has a job to do. Bland says "The server cannot retract audio frames that already reached your client", so a client discards any unplayed audio for the old `context_id` when a turn is preempted or cancelled.

## Which text to speech providers stream text in over a WebSocket?

As of November 2026, Bland Speech, Cartesia, ElevenLabs, and Deepgram each take streamed text over a WebSocket, Azure does through its Speech SDK, Google and Amazon Polly offer bidirectional streaming through their own calls, and OpenAI puts its WebSocket on a separate Realtime API.

| Provider | How text streams in |
| --- | --- |
| Bland Speech | `WSS /v2/tts/ws` takes text as an LLM writes it, with barge-in in the protocol; `POST /v2/tts` streams audio from complete text |
| Cartesia | WebSocket `/tts/websocket` takes partial text through contexts; `/tts/bytes` and `/tts/sse` stream audio from complete text |
| ElevenLabs | WebSocket `stream-input` for text to speech, which does not support the eleven_v3 or eleven_v4 models; Eleven v4 Turbo runs through the Text to Dialogue WebSocket |
| Deepgram | Flux TTS WebSocket and batch REST on `/v2/speak`; Aura on `/v1/speak` with REST and WebSocket |
| OpenAI | Chunked HTTP streaming on the speech endpoint; WebSocket and WebRTC on the Realtime API |
| Azure | Text streaming over WebSocket v2 in the Speech SDK for C#, C++, and Python |
| Google | Bidirectional streaming, text in and audio out, through its client library |
| Amazon Polly | Bidirectional streaming over HTTP/2 with `StartSpeechSynthesisStream`, on the Generative engine in the regions AWS names |

<details><summary>What these rows mean</summary>

- **How text streams in:** what each provider publishes for sending text while audio comes back. A WebSocket is the usual shape, and Google's and Amazon Polly's calls are bidirectional streams of their own.
- **Bland Speech and Cartesia:** both publish a plain streaming endpoint for complete text and a WebSocket for text that arrives in pieces.
- **ElevenLabs:** ElevenLabs states that its text to speech WebSocket does not take Eleven v3 or v4, and that v4 Turbo reaches a WebSocket through Text to Dialogue.
- **OpenAI:** the speech endpoint streams audio from complete text, and OpenAI's WebSocket belongs to the Realtime API, the replacement path for models that shut down on 6 January 2027.

</details>

## What are the catches with streaming text to speech?

The catches are that published latency numbers start each company's clock in its own place, that formats and features differ by endpoint, and that interrupting a turn changes what is billed.

### Latency numbers are each company's own

Bland publishes 199ms to first audio on a streamed request. Cartesia says Sonic has "first audio in under 90ms", Deepgram says Flux TTS responses start "in as low as 80ms at full 24kHz fidelity", ElevenLabs publishes a median of about 100ms for Eleven v4 Turbo and states that the figure excludes application and network latency, and Azure publishes less than 300 ms for its HD voices. Those are five companies' own numbers, and a team's own call adds its speech recognition, its language model, and its network on top.

### Formats and features differ by endpoint

Cartesia says its Bytes endpoint supports every container format and its SSE and WebSocket endpoints support raw audio only. Bland says a WAV is buffered before its first byte "since a valid header needs the final size", so a team that wants early audio streams raw. Google says SSML tags are not currently supported for Chirp 3: HD streaming requests.

### Interrupting a turn changes the bill

Bland bills for what it delivers: "A synthesis that fails before any bytes are written is not charged", and "A preempted or cancelled turn can therefore have a partial set of its text billed." A cut-off sentence can cost less than a finished one, and the amount follows whole chunks of synthesized text, because Bland does not map audio frames back to characters.

### A browser needs a short-lived token

Bland says a long-lived API key never belongs in browser code. A backend mints a five-minute stream token and the browser connects with it.

## Where does Bland Speech fit among WebSocket text to speech options?

Bland Speech fits a voice agent that needs a socket to take text as the language model writes it and to drop a turn cleanly when a caller interrupts, which Bland documents as part of the protocol, and the [text to speech API](/text-to-speech-api) page covers both endpoints.

Pipecat says its Bland service "Streams LLM tokens as they arrive and keeps its connection open across turns, with support for interruptions via Bland's `cancel` message", and LiveKit says of its Bland plugin: "By default it streams speech over a realtime WebSocket connection, so audio starts before a sentence finishes and interruptions cancel the current turn." The Pipecat service is maintained by the Pipecat team and the LiveKit plugin is for Python. For a phone line, `init` takes `mulaw` audio at 8 kHz, and the [sample rate explainer](/blog/tts-sample-rates-explained) covers what that means.

Cartesia and Deepgram publish lower first-audio numbers than Bland's 199ms, and a team comparing 80 or 90 milliseconds with 199 can set that gap against how each voice sounds. In Design Arena's [Audio Realism Bench results of 4 August 2026](https://notes.designarena.ai/audio-realism-benchmark-measuring-realism-in-audio-models/), Bland Speech v3 ranked first of 13 AI voices at 1365, against 1500 for the human recording. [Bland Speech](/speech) costs $0.04 per 1,000 characters, pay as you go with no monthly plan, and a new account gets 50,000 free characters once. The [best WebSocket text to speech APIs](/blog/best-websocket-tts-apis) page compares the options directly, and [latency explained](/blog/tts-latency-explained) covers the numbers. The [text to speech hub](/compare/text-to-speech) puts price and voice quality beside streaming, and the [guides](/compare/text-to-speech/guides) hold the other explainers.

<div class="cmp-usewhen"><div class="cmp-usewhen-own"><p><strong>Use Bland Speech when</strong></p><ul><li>A team will stream LLM tokens to `/v2/tts/ws` and discard unplayed audio when a caller interrupts</li><li>A voice agent will run on Pipecat, or on LiveKit in Python, and needs a Bland service or plugin</li></ul></div><div><p><strong>Use another provider when</strong></p><ul><li>A team will build on Azure's Speech SDK in C#, C++, or Python and use its WebSocket v2 text streaming</li><li>A team will take the lowest first-audio figure a provider publishes, as Cartesia and Deepgram do, and test how the voice sounds on its own script</li></ul></div></div>

<div class="cmp-proscons cmp-proscons-own"><div class="cmp-proscons-pros"><p><strong>Pros</strong></p><ul><li>A documented message flow with barge-in as part of the protocol</li><li>Raw audio over the socket, including 8 kHz mu-law for phone lines</li><li>A Pipecat service and a LiveKit Python plugin that use the WebSocket</li></ul></div><div class="cmp-proscons-cons"><p><strong>Cons</strong></p><ul><li>More than a hobby project needs, because Bland Speech is built for production calls</li></ul></div></div>

## Frequently asked questions

### What is the difference between HTTP streaming and a WebSocket for text to speech?

HTTP streaming sends complete text in one request and plays audio as it arrives, while a WebSocket stays open so text can arrive in pieces too. Bland Speech offers both: `POST /v2/tts` for complete text and `WSS /v2/tts/ws` for text from a language model.

### Why do voice agents need a WebSocket for text to speech?

A voice agent needs a WebSocket because its language model writes a reply in pieces, and a WebSocket lets synthesis start on the first pieces. Bland says an agent that waits for a complete LLM response adds the model's entire generation time to every reply.

### What is a context ID in WebSocket text to speech?

A context ID names one turn of speech. Bland's `speak` messages reuse one `context_id` for every piece of text in a turn, and sending a new one preempts the active turn, which makes barge-in part of the protocol.

### How does barge-in work with streaming text to speech?

Barge-in works by stopping the active turn when a caller speaks. On Bland Speech a `speak` with a new `context_id` preempts the turn, `cancel` stops it with no replacement, and the client discards unplayed audio for the old turn.

### Can a browser connect to a WebSocket text to speech API directly?

Yes, with a short-lived token. Bland says a backend mints a five-minute stream token and the browser connects with it, and a long-lived API key never goes in browser code.

### Do all text to speech providers take streamed text input?

No. OpenAI's speech endpoint streams audio from complete text and puts its WebSocket on the Realtime API, ElevenLabs says its text to speech WebSocket does not take Eleven v3 or v4, and Cartesia's bytes and SSE endpoints take complete text. Bland Speech, Cartesia's WebSocket, Deepgram's Flux TTS, and Azure's WebSocket v2 take text in pieces.

### What audio format does a WebSocket text to speech session return?

Raw binary audio in the format named in `init`. On Bland Speech that is `pcm_s16le` at 8, 16, 24, 44.1, or 48 kHz, or `mulaw` at 8 kHz, with 48 kHz the default.
