Text to speech API for real-time voice

Bland Speech is the text to speech API built for live conversation. POST text over HTTP or stream LLM tokens into a WebSocket, and humanlike audio starts in 199ms. One flat rate of $0.04 per 1,000 characters, with 50k characters free.

The verdict: In blind listening tests, Bland Speech ranked first among every AI voice model. Only recordings of real people scored higher.

Hear every voice for yourself on Bland Speech, or read what makes text to speech sound realistic.

Realism
#1 AI model, Audio Realism Bench
First audio
199ms
Streaming
HTTP chunked · WebSocket
Endpoints
POST /v2/tts · WSS /v2/tts/ws
Output
PCM16 at 8 to 48 kHz · mu-law
Price
$0.04 per 1,000 characters

The most human TTS API in blind tests

On Audio Realism Bench, intelligence.ai's blind listening benchmark, Bland Speech v3 ranked first among every AI voice model, 147 points clear of the next. It finished ahead of models from Microsoft, xAI, OpenAI, Google, MiniMax, Cartesia and ElevenLabs. Only real human recordings scored higher.

Audio Realism Bench

Elo rating
  1. 1,501Human speech
  2. 1,384Bland Speech v3
  3. 1,237MAI-Voice-2
  4. 1,177Grok TTS
  5. 1,154GPT Realtime 2
  6. 1,126Gemini 2.5 Pro TTS
  7. 1,105Speech-02 HD
  8. 1,098Sonic 3.5
  9. 1,048Gemini 3.1 Flash TTS
  10. 1,011GPT-4o Mini TTS
  11. 1,003Gemini 2.5 Flash TTS
  12. 968Lightning v3.1 Pro
  13. 956Eleven v3
  14. 785TTS-1.5 Max

Each trial plays two models reading the same script, unlabelled, and vetted native listeners pick which sounds like a real person. Results compound into Elo ratings, with real human recordings in the pool as the control. Bars start at 600, not zero.

What is a text to speech API?

A text to speech API is a web service that converts written text into spoken audio. Your code sends text, a voice ID and an output format. The API returns audio bytes, either as a finished file or as a stream that starts playing before the rest has rendered.

Developers use TTS APIs to voice AI agents, phone prompts, narration and accessibility features. The TTS engine decides how human the result sounds; the API decides how fast it arrives. Bland Speech was built for phone calls, where both matter on every turn.

How to choose a TTS API: the checklist

Hold every TTS API to eight standards: realism, latency, streaming, compatibility, direction, cloning, pricing and a free start. Bland Speech meets all eight, and on the one listeners notice first, how human it sounds, it ranks above every other AI model.

StandardWhat to demandBland Speech
RealismIndependent blind listening results, not a curated demo reel.Ranked first among AI voice models on Audio Realism Bench, second only to real human recordings.
LatencyFirst audio fast enough for a live conversation.199ms to first audio, inside the pause a person leaves before replying.
StreamingHTTP streaming plus a WebSocket that handles interruptions.Chunked HTTP streaming on POST /v2/tts and WSS /v2/tts/ws, where a new context_id interrupts the active turn immediately.
Drop-in compatibilityWorks with the SDK you already ship.POST /v2/audio/speech speaks the OpenAI audio speech contract. Change the base URL, key and model.
DirectionControl over how a line is performed, not just what it says.Performance tags like [laughs] and [say warmly], expressiveness and stability controls, and a director that writes the performance.
CloningA fast clone from a short sample, plus a studio-grade tier.Instant clones from about 10 seconds of audio. Professional clones trained on 30 minutes or more.
PricingOne predictable rate you can forecast.One flat rate, $0.04 per 1,000 characters, in the studio or the API, directed or not.
Free startEnough free usage to ship a prototype.50k characters free, nearly an hour of speech.

199ms to first audio.

Audio streams back before a person would have started their reply.

Bland Speech

A person replying

An awkward pause

the human gap
199ms
200ms
~1s

Measured to first audio on /v1/speak with streaming enabled, not to the finished file. The first chunk plays while the rest renders. People take about 200ms to begin a reply in conversation, and a pause near a second is where listeners start to notice.

Streaming TTS API: HTTP chunks or WebSocket?

Bland Speech streams both ways, so you never pick a vendor by transport. Complete text streams back over HTTP chunks. LLM tokens stream into a WebSocket, so audio starts before the sentence is finished and callers can interrupt at any word.

HTTP streaming with POST /v2/tts

Send the text, read the body as it arrives, and playback starts while the rest renders. Ask for a WAV container and the same call returns a finished file. Every response reports its own cost and time to first audio in its headers.

Realtime streaming with WSS /v2/tts/ws

One socket per conversation. Send each LLM token as a speak message with a context_id, and audio returns as binary frames before the turn is complete. A new context_id interrupts the active turn immediately, so barge-in is built into the protocol.

Already on an OpenAI SDK? POST /v2/audio/speech is a drop-in: change the base URL, key and model, and keep your code. Browser apps connect with a five-minute stream token minted on your backend, so API keys stay on the server.

Text to speech API quickstart

You can hear Bland Speech with one curl command. Create an account, copy an API key, pick a voice UUID, and POST your text to /v2/tts with the container set to wav. The response is a playable file. Omit the container to stream it.

  1. 1

    Get an API key

    Create a free account and copy an API key from your dashboard. New accounts include 50k characters of speech, so every step below is free to try.

  2. 2

    Pick a voice

    Every request names a voice by UUID. List what your account can use, or start with Karen, one of three built-in voices.

    List voices

    curl "https://api.bland.ai/v1/voices" \
      -H "Authorization: Bearer $BLAND_API_KEY"
  3. 3

    Generate a WAV file

    Text and voice are all you need. The pause marker adds 0.4 seconds of silence, and the two controls shape the read.

    cURL

    curl -X POST "https://api.bland.ai/v2/tts" \
      -H "Authorization: Bearer $BLAND_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "text": "Thanks for calling. <|0.4|> How can I help you today?",
        "voice": "29158307-9893-4149-8a75-bc9ce313d64e",
        "controls": { "expressiveness": 0.8, "stability": 0.4 },
        "audio": { "container": "wav" }
      }' \
      --output hello.wav
  4. 4

    Stream it

    Without a container, the response is 48 kHz PCM you can play as it lands, the rate the model renders natively. For LLM output, stream tokens into the WebSocket.

    HTTP streaming

    curl -N -X POST "https://api.bland.ai/v2/tts" \
      -H "Authorization: Bearer $BLAND_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "text": "Your appointment is confirmed for Tuesday at three.",
        "voice": "29158307-9893-4149-8a75-bc9ce313d64e",
        "audio": { "encoding": "pcm_s16le", "sample_rate": 48000 }
      }' > out.pcm

    WebSocket (Node)

    // npm install ws. llmTextStream is your model's token stream,
    // playback is your audio queue.
    import WebSocket from "ws";
    
    const ws = new WebSocket("wss://api.bland.ai/v2/tts/ws", {
      headers: { Authorization: "Bearer YOUR_API_KEY" },
    });
    const turn = crypto.randomUUID();
    
    ws.on("open", () => {
      ws.send(JSON.stringify({
        type: "init",
        voice: "29158307-9893-4149-8a75-bc9ce313d64e",
        audio: { encoding: "pcm_s16le", sample_rate: 48000 },
      }));
    });
    
    ws.on("message", async (data, isBinary) => {
      if (isBinary) return playback.enqueue(data); // raw PCM frames
    
      const msg = JSON.parse(data.toString());
      if (msg.type === "ready") {
        for await (const token of llmTextStream) {
          ws.send(JSON.stringify({ type: "speak", context_id: turn, text: token }));
        }
        ws.send(JSON.stringify({ type: "end_of_turn", context_id: turn }));
      }
      if (msg.type === "utterance_end") ws.send(JSON.stringify({ type: "close" }));
    });

The speech quickstart covers telephony formats, every field, and the full realtime example.

Voices, cloning and performance tags

Bland Speech gives you built-in voices on day one, clones from seconds of audio, and three ways to direct a read: two numeric controls, timed pauses, and performance tags written inline with your text.

Which voices can I use?

Every organization gets three built-in voices: Karen, Matthew and River. Listing voices returns those plus anything you have cloned or saved from the public library. Voices are addressed by UUID, so the voice you test is the voice you ship.

How does voice cloning work?

An instant clone takes one clean sample of about 10 seconds. A professional clone trains on 30 minutes or more of verified audio. Clones are private to your organization, and you confirm every voice is yours to use.

How do I direct the delivery?

Expressiveness and stability run from 0.0 to 1.0. Pause markers like <|0.8|> add timed silence. Tags such as [laughs] or [say warmly] sit right before the words they shape, and the model performs them. Or let the Bland Speech director write the performance.

TTS API pricing per character

Bland Speech charges one flat rate: $0.04 per 1,000 characters, pay as you go. No tiers and no plans to compare. The price is the same in the studio and the API, directed or not, and credits never expire.

60-second note$0.04
10-minute narration$0.36
1 million characters$40

Free to start

50k characters free, nearly an hour of speech, at the same rate in the studio and the API.

Scale with one top-up

A one-time $5 top-up adds professional voice cloning and five concurrent generations.

Text to speech API FAQ

A text to speech API is a web service that converts written text into spoken audio. You send text and a voice ID over HTTP or a WebSocket, and it returns audio as a file or a stream. Bland Speech is a TTS API built for real-time voice.

Bland Speech. On Audio Realism Bench, intelligence.ai's blind listening benchmark, Bland Speech v3 ranked first among every AI voice model, ahead of models from OpenAI, Google, ElevenLabs and Cartesia. Only recordings of real people scored higher.

Bland Speech returns first audio in 199ms on a streamed request, measured to the first audio chunk rather than the finished file. That is inside the roughly 200ms pause a person leaves before replying, so the conversation never stalls.

Bland Speech supports both. Use POST /v2/tts when the full text is ready: it streams raw audio or returns a WAV file. Use WSS /v2/tts/ws when text arrives token by token from an LLM, with interruptions built into the protocol.

Bland Speech costs one flat rate of $0.04 per 1,000 characters, pay as you go, in the studio or the API. New accounts get 50k characters free, nearly an hour of speech, and credits never expire.

Yes. An instant clone takes one clean sample of about 10 seconds, and a professional clone trains on 30 minutes or more of verified audio. A one-time $5 top-up adds professional cloning, and you confirm every voice is yours to use.

Performance tags are directions in square brackets, like [laughs], [sighs] or [say warmly], placed right before the words they shape. Bland Speech performs them instead of reading them aloud, so one line of text carries the whole delivery.

Yes. POST /v2/audio/speech implements the OpenAI audio speech contract. Point an existing OpenAI SDK at the Bland base URL, use a Bland API key, and set the model to btts-3. The rest of your request code stays the same.

Start building with the Bland text to speech API

The verdict: Bland Speech is the TTS API to build on: the most human voice in blind tests, 199ms to first audio, HTTP and WebSocket streaming, and one flat rate.

Your first 50k characters are free. Send one request and listen to the file. Then hear every voice on the Bland Speech page or see Bland vs ElevenLabs.