Eleven v4 API: Streaming TTS and Cost Checks

Start with the first audio your player can use. For an Eleven v4 API rollout, I would send one fixed script and record first audio, completion, retries, and credits. I have not run that request, so this Eleven v4 API guide is a test plan, not a benchmark.

Which Eleven v4 Model Fits One Streaming Workflow?

Choose eleven_v4 for expression and eleven_v4_turbo for interactive response. The ElevenLabs model directory lists both IDs, but they use different delivery paths.

Use Eleven v4 When Expressive Rendering Is the Priority

Use eleven_v4 when the full line is ready and expression matters more than response time. ElevenLabs gives it a 10,000-character request limit.

My acceptance sample would include a direction tag, proper noun, number, and emotional sentence. Keep the voice, script, language, settings, and format fixed. Score pronunciation, pacing, identity, clipping, and editorial approval.

Use Eleven v4 Turbo When Response Time Is the Priority

Use eleven_v4_turbo when text arrives incrementally. ElevenLabs reports roughly 100 ms median inference latency, excluding network and application delay. That is not first audible output.

The Eleven v4 Turbo API route is the Text-to-Dialogue WebSocket. The older Text-to-Speech WebSocket does not support v3 or v4. Turbo permits one registered voice per connection.

Make One Streaming Text-to-Speech Request

For a complete script, make one HTTP request with eleven_v4. The streaming API reference shows the ElevenLabs TTS API client returning progressive chunks.

Authenticate and Use the Exact Model ID

Keep the key server-side in an environment variable. The authentication guidance supports endpoint scopes, credit quotas, and IP allowlists. Never expose it in browser code.

import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

const client = new ElevenLabsClient({
  apiKey: process.env.ELEVENLABS_API_KEY,
});
const started = performance.now();
let firstAudio;

const audio = await client.textToSpeech.stream(
  process.env.ELEVENLABS_VOICE_ID,
  { text: "Your fixed acceptance line.", modelId: "eleven_v4" }
);

for await (const chunk of audio) {
  if (!firstAudio) firstAudio = performance.now();
  // Enqueue this chunk in your audio player.
}

console.log({
  firstAudioMs: firstAudio - started,
  completionMs: performance.now() - started,
});

This measures received bytes, not playback. Add a player callback if the SLA starts at the speaker.

Choose HTTP Streaming or WebSocket Input

Use HTTP for complete text. Use /v1/text-to-dialogue/stream-input when text arrives progressively. ElevenLabs’ audio-streaming explanation says smaller commitments may reduce delay but weaken phrasing because the model sees less context.

HTTP streams output; WebSocket input streams text and output.

Measure Latency and Usable Cost

This cannot be judged by feel. Test from the deployment region and production network path.

Track Time to First Audio and Completion Time

Record first response byte, decodable chunk, audible sample, and final chunk separately. Save model, voice, protocol, format, script length, region, network route, SDK version, date, and retries.

Run enough repetitions to expose slow and failed requests. Report the median and a high percentile. For WebSockets, include connection setup and buffering.

Count Credits, Retries, and Usable Responses

Eleven v4 cost should mean cost per approved response. Capture character-cost, request-id, and x-trace-id headers, then reconcile them with usage history. Include retries and discarded takes.

Use this operating formula:

usable cost = total credits charged for the test / responses that passed review

At my production gate, a response counts as usable only when it begins within the target window, plays without gaps, preserves the voice, and passes pronunciation review. A fast first chunk followed by a broken stream counts as a failed run.

Check the ElevenLabs pricing page on the test date. Its limited v4 promotion is for web and mobile apps, not API forecasts. Store the published rate and actual debit because terms can change.

Check Production Limits Before Switching Traffic

Do not move traffic until the account, model, and protocol pass a load test. One response proves little.

Character Limits, Concurrency, and Fallback Behavior

eleven_v4 has a published 10,000-character limit; the v4 Turbo WebSocket page does not publish an equivalent whole-session limit. WebSockets use plan-specific session capacity, and 20 seconds of inactivity closes a connection without keep-alive. HTTP uses standard concurrency.

Handle concurrency errors, busy responses, timeouts, and partial audio separately. Use bounded retries and idempotent logging. Never switch models silently; approve fallback with the same script first.

WaveSpeed lists Eleven v4 and v4 Turbo, but its schema describes submission, polling, and a returned file. I treat that as a separate route, not an Eleven v4 streaming substitute.

FAQ

Which v4 output formats require a paid ElevenLabs plan?

MP3 at 192 kbps requires Creator or higher, while 44.1 kHz PCM requires Pro or higher. Confirm the selected format against the current account because output access can change.

Can an ElevenLabs API key be limited to text-to-speech requests?

Yes. ElevenLabs supports endpoint-level scope restrictions, including Text to Speech, plus a custom credit quota and IP allowlisting. Use a production service-account key where your workspace plan supports it.

Do Eleven v4 usage records include a request-level identifier?

Yes. Raw responses can expose request-id and x-trace-id, and history records include a request ID when logging and history are enabled. Store them beside your internal job ID.

Can Eleven v4 estimate credits before a streaming request starts?

No documented v4 TTS preflight endpoint currently returns a guaranteed charge. Estimate from input characters and the current rate, then use the actual response metadata and account usage as the billing record.

Can v4 streaming responses include alignment data with the audio?

Yes, through supported timing routes. HTTP offers a stream-with-timestamps response, while the v4 dialogue WebSocket can request synchronized alignment. Plain raw-audio streaming does not automatically provide those timing objects.

Conclusion

A production Eleven v4 API decision needs one controlled path today. Use eleven_v4 with HTTP output streaming for a complete expressive script, or eleven_v4_turbo with the dialogue WebSocket for incremental input. Measure audible latency and charged credits yourself. The lowest quoted latency is irrelevant if retries, buffering, or rejected takes make each usable response slower and more expensive.

Previous posts: