ElevenLabs V4 Text to Speech API

elevenlabs/tts/eleven-v4

ElevenLabs V4 Text to Speech turns written scripts into emotionally expressive narration with inline audio tags and support for 90+ languages. Tune stability and voice similarity for each scene, then choose MP3, PCM, Opus or telephony audio.

Input

Text

291/5000

Voice

Stability

Similarity Boost

Output Format

Language Code

Apply Text Normalization

Timestamps

Output

Explore more speech models

ElevenLabs V4 Turbo Text to Speech ElevenLabs V3 Text to Speech Gemini 3.8 Flash TTS Text to Speech

Examples

First pot at the mountain tea house

First pot at the mountain tea house — A warm Mandarin welcome with a soft laugh in the middle.

Spanish trail-shoe ad with timestamps

Spanish trail-shoe ad with timestamps — An upbeat Spanish ad read, returned with timing data.

ElevenLabs V4 Text to Speech API

Generate speech with the API

Submit a script, keep the returned task_id, and retrieve the completed audio through the task status endpoint.

Authenticate your request

Send your Vidgo API key in the Authorization header using Bearer authentication.

Endpoint: POSThttps://api.vidgo.ai/api/generate/submit
Authentication: Authorization: Bearer YOUR_API_KEY

Submit the script

Send model and input as JSON. The example below uses the same script and voice as the first audio sample.

Request example

REQUEST_BODY=$(cat <<'JSON'
{
  "model": "elevenlabs/tts/eleven-v4",
  "input": {
    "text": "[calm] Night three at the lighthouse. The fog rolled in early, thick as wool. [whispers] At midnight, something knocked on the door... three slow knocks. [nervous laugh] I told myself it was only the wind. [quietly] Then I found wet footprints on the stairs, leading up, and never back down.",
    "voice": "George",
    "stability": 0.45,
    "similarity_boost": 0.75,
    "output_format": "mp3_44100_128",
    "apply_text_normalization": "auto",
    "timestamps": false,
    "language_code": "en"
  }
}
JSON
)

RESPONSE=$(curl --silent --show-error --fail-with-body \
  --request POST \
  --url "https://api.vidgo.ai/api/generate/submit" \
  --header "Authorization: Bearer $VIDGO_API_KEY" \
  --header "Content-Type: application/json" \
  --data "$REQUEST_BODY")

CODE=$(printf '%s' "$RESPONSE" | jq -r '.code // empty')
if [ "$CODE" != "0" ] && [ "$CODE" != "200" ]; then
  printf 'API error: %s
' "$RESPONSE" >&2
  exit 1
fi
printf '%s
' "$RESPONSE"

Follow the task

Query the returned task_id until status is finished or failed.

Status endpoint

GET https://api.vidgo.ai/api/generate/status/{task_id}

Keep the task_id from submission. Check its status and read the generated files when it finishes.

not_startedrunningfinishedfailed

Submission response

{
  "code": 200,
  "data": {
    "task_id": "BAMMBL0SN12PBO8U",
    "status": "not_started",
    "created_time": "2026-11-05T07:13:33"
  }
}

Completed response

{
  "code": 200,
  "data": {
    "task_id": "BAMMBL0SN12PBO8U",
    "status": "finished",
    "files": [
      {
        "file_url": "https://cdn.vidgo.ai/apis/models/elevenlabs/tts/eleven-v4/v2/01/speech-01.mp3",
        "file_type": "audio",
        "file_name": "speech-01.mp3"
      }
    ],
    "created_time": "2026-11-05T07:13:33",
    "error_message": null,
    "progress": 100
  }
}

Read the audio files

Use the audio file_url for playback or download. With timestamps enabled, download the timing file from its separate files entry.

Read the audio files

set -euo pipefail
: "${VIDGO_API_KEY:?Set VIDGO_API_KEY in your environment}"

REQUEST_BODY=$(cat <<'JSON'
{
  "model": "elevenlabs/tts/eleven-v4",
  "input": {
    "text": "[calm] Night three at the lighthouse. The fog rolled in early, thick as wool. [whispers] At midnight, something knocked on the door... three slow knocks. [nervous laugh] I told myself it was only the wind. [quietly] Then I found wet footprints on the stairs, leading up, and never back down.",
    "voice": "George",
    "stability": 0.45,
    "similarity_boost": 0.75,
    "output_format": "mp3_44100_128",
    "apply_text_normalization": "auto",
    "timestamps": false,
    "language_code": "en"
  }
}
JSON
)

SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
  --request POST \
  --url "https://api.vidgo.ai/api/generate/submit" \
  --header "Authorization: Bearer $VIDGO_API_KEY" \
  --header "Content-Type: application/json" \
  --data "$REQUEST_BODY")

TASK_ID=$(printf '%s' "$SUBMIT_RESPONSE" | jq -r '.data.task_id // .task_id // empty')
BUSINESS_CODE=$(printf '%s' "$SUBMIT_RESPONSE" | jq -r '.code // empty')
if [ "$BUSINESS_CODE" != "0" ] && [ "$BUSINESS_CODE" != "200" ]; then
  printf 'Submit failed:
%s
' "$SUBMIT_RESPONSE" >&2
  exit 1
fi
if [ -z "$TASK_ID" ]; then
  printf 'Submit response did not include task_id:
%s
' "$SUBMIT_RESPONSE" >&2
  exit 1
fi

START_TIME=$(date +%s)
POLL_DELAY=2
while true; do
  if [ $(( $(date +%s) - START_TIME )) -ge 600 ]; then
    printf 'Timed out after 600 seconds
' >&2
    exit 1
  fi
  STATUS_RESPONSE=$(curl --silent --show-error --fail-with-body \
    --url "https://api.vidgo.ai/api/generate/status/$TASK_ID" \
    --header "Authorization: Bearer $VIDGO_API_KEY")
  STATUS=$(printf '%s' "$STATUS_RESPONSE" | jq -r '.data.status // .status // empty')
  BUSINESS_CODE=$(printf '%s' "$STATUS_RESPONSE" | jq -r '.code // empty')
  if [ "$BUSINESS_CODE" != "0" ] && [ "$BUSINESS_CODE" != "200" ]; then
    printf 'Status request failed:
%s
' "$STATUS_RESPONSE" >&2
    exit 1
  fi

  case "$STATUS" in
    finished)
      printf '%s' "$STATUS_RESPONSE" | jq -r '(.data.files // .files // [])[]?.file_url'
      break
      ;;
    failed)
      printf '%s' "$STATUS_RESPONSE" | jq -r '.data.error_message // .error_message // "Generation failed"' >&2
      exit 1
      ;;
    not_started|running)
      sleep "$POLL_DELAY"
      if [ "$POLL_DELAY" -lt 10 ]; then POLL_DELAY=$((POLL_DELAY + 1)); fi
      ;;
    *)
      printf 'Unexpected task status: %s
' "$STATUS" >&2
      exit 1
      ;;
  esac
done

Request parameters

Place speech controls inside input; keep model and callback_url at the top level.

Field	Type	Required	Default	Description
model	string	Yes	—	Use elevenlabs/tts/eleven-v4 to select this speech model.
input	object	Yes	—	Contains the script and the speech controls listed below.
input.text	string	Yes	—	The script to speak, 1–5,000 characters as sent, including spaces, line breaks and audio tags. Add tags such as [whispers] or [excited] where the delivery should change.
input.voice	string	No	Rachel	An ElevenLabs voice name or voice ID. Pick a suggested preset such as Rachel, George or Lily, or paste the ID of another ElevenLabs voice.
input.stability	number	No	0.5	A value from 0 to 1. Lower values allow more expressive variation; higher values keep the read steadier from line to line.
input.similarity_boost	number	No	0.75	A value from 0 to 1 that sets how closely the speech follows the character of the selected voice.
input.output_format	string	No	mp3_44100_128	Codec, sample rate and bitrate of the returned audio: MP3 at 22.05 or 44.1 kHz, raw PCM from 8 to 48 kHz, µ-law and A-law at 8 kHz for telephony, or Opus at 48 kHz. Values: mp3_22050_32, mp3_44100_32, mp3_44100_64, mp3_44100_96, mp3_44100_128, mp3_44100_192, pcm_8000, pcm_16000, pcm_22050, pcm_24000, pcm_44100, pcm_48000, ulaw_8000, alaw_8000, opus_48000_32, opus_48000_64, opus_48000_96, opus_48000_128, opus_48000_192.
input.apply_text_normalization	string	No	auto	auto decides when to spell out numbers, dates and symbols, on always normalizes them, and off reads text that you have already written out for speech.
input.timestamps	boolean	No	false	Set to true to receive timing data for the speech as an additional file next to the audio.
input.language_code	string	No	—	Optional ISO 639-1 code, such as en, zh or es, to name the spoken language. Leave it empty to let the model detect the language from the script.
callback_url	string	No	—	Optional HTTP or HTTPS URL for task notifications. Include it at the top level of the request.

Response fields

Submission identifies the task. Status responses report progress toward the completed audio.

Field	Type	Description
code	integer	Response code. A successful response uses 200 or 0.
data.task_id	string	Task identifier used to query status.
data.status	string	Task state: not_started, running, finished, or failed.
data.created_time	string	Task creation time returned by the service.
data.files	array	Generated files. Read audio entries for speech and other entries for requested attachments.
data.files[].file_url	string	URL used to play or download a generated file.
data.files[].file_type	string	audio for speech; other for attachments such as the timing file.
data.files[].file_name	string	File name, when returned.
data.error_message	string \| null	Error details when a task fails.

Task lifecycle

Use the task state to decide when to check again or read the result.

not_started
The task has been accepted and is waiting to start.
running
Speech generation is in progress. Continue checking the same task.
finished
Generation is complete. Read files for the audio and requested attachments.
failed
Generation failed. Read error_message before deciding whether to submit a new request.

Handle results and interruptions

Keep the current task identifierIf a status request is interrupted, query the same task_id again to recover its latest state.
Match each file to its purposeUse file_type to separate speech from attachments. Read the returned file_url and file_name for each download.
Inspect a failed taskWhen status is failed, read error_message and review the script and settings before submitting another generation.

Speech specifications

Item	Value	Description
Task	Text to Speech	Generate speech from a script and one voice.
Text length	1–5,000 characters	Counted as sent, including spaces and tags.
Languages	90+	Detected from the script or set with language_code.
Output formats	19	MP3, PCM, µ-law, A-law and Opus; default mp3_44100_128.
Price	$0.08 / 1K characters	16 credits per 1,000 characters.
Timing data	Optional	Returned as an extra file when timestamps is true.

View the ElevenLabs V4 Text to Speech API docs

ElevenLabs V4 Text to Speech

ElevenLabs V4 Text to Speech is an ElevenLabs model, released in September 2026, for expressive voiceovers and character performances. It reads inline audio tags together with punctuation and context, so a line can move from calm to a whisper or a laugh inside one passage. Stability, similarity boost, language hints and 19 output formats help you fit the result to video, audiobook or game pipelines.

Why choose ElevenLabs V4?

Direct the performance inside the scriptPut [whispers], [laughs] or [excited] where the delivery should change. One passage can carry several emotional beats without splitting the request.
Fit the voice to the characterUse any ElevenLabs voice name or voice ID, then balance stability and similarity boost to make a narrator steadier or a character more animated.
Deliver audio in the format your pipeline needsChoose from 19 output formats, from 192 kbps MP3 for video to raw PCM for editing and µ-law or A-law for phone systems.
Align captions with timing dataTurn on timestamps to receive a timing file next to the audio for subtitles, lip-sync or edit points.

Speech parameters

Parameter	Requirement	What it controls
text	Required	The script to speak, 1–5,000 characters as sent, including spaces, line breaks and audio tags. Add tags such as [whispers] or [excited] where the delivery should change.
voice	Optional	An ElevenLabs voice name or voice ID. Pick a suggested preset such as Rachel, George or Lily, or paste the ID of another ElevenLabs voice. Default`Rachel`
stability	Optional	A value from 0 to 1. Lower values allow more expressive variation; higher values keep the read steadier from line to line. Default`0.50–1`
similarity_boost	Optional	A value from 0 to 1 that sets how closely the speech follows the character of the selected voice. Default`0.750–1`
output_format	Optional	Codec, sample rate and bitrate of the returned audio: MP3 at 22.05 or 44.1 kHz, raw PCM from 8 to 48 kHz, µ-law and A-law at 8 kHz for telephony, or Opus at 48 kHz. Default`mp3_44100_128mp3_22050_32mp3_44100_32mp3_44100_64mp3_44100_96mp3_44100_192pcm_8000pcm_16000pcm_22050pcm_24000pcm_44100pcm_48000ulaw_8000alaw_8000opus_48000_32opus_48000_64opus_48000_96opus_48000_128opus_48000_192`
apply_text_normalization	Optional	auto decides when to spell out numbers, dates and symbols, on always normalizes them, and off reads text that you have already written out for speech. Default`autoonoff`
timestamps	Optional	Set to true to receive timing data for the speech as an additional file next to the audio. Default`falsetrue`
language_code	Optional	Optional ISO 639-1 code, such as en, zh or es, to name the spoken language. Leave it empty to let the model detect the language from the script.

Create speech in four steps

Write the scriptEnter up to 5,000 characters in Text and add an audio tag where the delivery changes.
Pick a voiceType or select a Voice, then start with Stability 0.5 and Similarity Boost 0.75.
Choose format and languageSet Output Format for your destination, add a Language Code if needed and enable Timestamps for captions.
Run and listenCheck the cost on the Run button, select Run and download the audio when the task finishes.

Character-based pricing

ElevenLabs V4 Text to Speech costs $0.08, or 16 credits, per 1,000 characters of text. Every character you send counts, including spaces, line breaks and audio tags; the other settings do not change the price.

Text length	Cost	Calculation
100 characters	$0.008 · 1.6 credits	100 × 16 / 1000 = 1.6 credits
1,000 characters	$0.08 · 16 credits	1000 × 16 / 1000 = 16 credits
5,000 characters	$0.40 · 80 credits	5000 × 16 / 1000 = 80 credits

Where it fits

YouTube and explainer voiceoversShape emphasis and pauses with tags so the narration follows the edit.
Audiobook chaptersSplit a chapter into passages of up to 5,000 characters and keep the same voice and settings across them.
Ad reads with emotional turnsMove from curiosity to excitement in a 30-second script and export 192 kbps MP3 for the final mix.
Localized voice tracksGenerate each translated script with a language code and the same voice for a consistent brand sound.

Pro tips

Place one clear tag before the words it should affect, for example [whispers] I can hear it too.
Compare stability 0.3 and 0.6 on the same line before settling on a narration style.
Write pronunciations you need to control, such as product names, the way they should sound, or test IPA between slashes.
Keep the same voice, stability and similarity boost when splitting a long script so passages join smoothly.
Use PCM when you plan to edit or mix the audio, and MP3 or Opus for direct playback.

Prepare audio for your workflow

PCM, µ-law and A-law files are raw audio without a WAV header. Wrap or convert them in your audio tool if a player needs a container.
With timestamps enabled, read every item in files: the audio and the timing file are returned as separate entries.

Explore more speech models

ElevenLabs V4 Turbo Text to Speech preview

ElevenLabs V4 Turbo Text to SpeechThe same V4 controls at half the rate for prompts and bulk audio.

ElevenLabs V3 Text to SpeechThe previous ElevenLabs expressive speech model with audio tags.

Gemini 3.8 Flash TTS Text to Speech preview

Gemini 3.8 Flash TTS Text to SpeechTwo-speaker dialogue and 30 preset voices with WAV output.

ElevenLabs V4 Text to Speech API frequently asked questions

What is the ElevenLabs V4 Text to Speech API?

ElevenLabs V4 Text to Speech is an ElevenLabs model for turning scripts into expressive speech. It generates narration and character lines in 90+ languages, with inline audio tags for emotion, pauses and reactions. It interprets tags together with punctuation and context while you keep control of the voice, stability, similarity and output format. You can call it programmatically or try it from the playground above.

How is ElevenLabs V4 different from ElevenLabs V3?

ElevenLabs V4 is the newer generation, released in September 2026, with support for 90+ languages compared with 70+ for V3. On Vidgo it also adds Similarity Boost, a choice of 19 output formats and voice IDs beyond the preset list, while the price stays at 16 credits ($0.08) per 1,000 characters.

How do audio tags work in ElevenLabs V4?

Write a direction in square brackets inside Text, such as [whispers], [laughs] or [excited], right before the words it should shape. Tags count toward the character total. Start with one tag per phrase and listen before adding more.

How long can a ElevenLabs V4 script be?

Each request accepts 1–5,000 characters, counted exactly as sent, including spaces, line breaks and tags. Split longer scripts at paragraph or scene breaks and reuse the same voice settings for every part.

Which output formats does ElevenLabs V4 return?

Output Format offers 19 values: MP3 at 22.05 or 44.1 kHz from 32 to 192 kbps, raw PCM from 8 to 48 kHz, µ-law and A-law at 8 kHz, and Opus at 48 kHz from 32 to 192 kbps. The default is mp3_44100_128.

Can I use my own ElevenLabs voice with ElevenLabs V4?

Voice accepts an ElevenLabs voice name or voice ID. Use a suggested preset such as Rachel or George, or paste the ID of another ElevenLabs voice and keep Stability and Similarity Boost fixed while you compare takes.

Can ElevenLabs V4 return timestamps for subtitles?

Yes. Set timestamps to true and the finished task includes a timing file as an additional item in files, next to the audio. Use it to place captions or align edits.

How much does ElevenLabs V4 cost per request?

ElevenLabs V4 costs 16 credits ($0.08) per 1,000 characters. A 1,000-character script costs 16 credits and a full 5,000-character request costs 80 credits ($0.40).