# Table of Contents
- [Documentation | ElevenLabs Documentation](#documentation-elevenlabs-documentation)
- [Models | ElevenLabs Documentation](#models-elevenlabs-documentation)
- [Text to Speech | ElevenLabs Documentation](#text-to-speech-elevenlabs-documentation)
- [Speech to Text | ElevenLabs Documentation](#speech-to-text-elevenlabs-documentation)
---
# Documentation | ElevenLabs Documentation
[\
\
### \
\
Creative Platform\
\
Learn how to use the ElevenLabs Creative Platform with step-by-step guides](https://elevenlabs.io/docs/creative-platform/overview)
[\
\
### \
\
Agents Platform\
\
Learn how to build, launch, and scale agents with ElevenLabs](https://elevenlabs.io/docs/agents-platform/overview)
[\
\
### \
\
Developers\
\
Learn how to integrate ElevenLabs with examples and tutorials](https://elevenlabs.io/docs/developers/quickstart)
Meet the models
---------------
[Eleven v3\
\
\
\
Our most emotionally rich, expressive speech synthesis model\
\
Dramatic delivery and performance\
\
70+ languages supported\
\
5,000 character limit\
\
Support for natural multi-speaker dialogue](https://elevenlabs.io/docs/overview/models#eleven-v3-alpha)
[Eleven Multilingual v2\
\
Lifelike, consistent quality speech synthesis model\
\
Natural-sounding output\
\
29 languages supported\
\
10,000 character limit\
\
Most stable on long-form generations](https://elevenlabs.io/docs/overview/models#multilingual-v2)
[Eleven Flash v2.5\
\
Our fast, affordable speech synthesis model\
\
Ultra-low latency (~75ms†)\
\
32 languages supported\
\
40,000 character limit\
\
Faster model, 50% lower price per character](https://elevenlabs.io/docs/overview/models#flash-v25)
[Eleven Turbo v2.5\
\
High quality, low-latency model with a good balance of quality and speed\
\
High quality voice generation\
\
32 languages supported\
\
40,000 character limit\
\
Low latency (~250ms-300ms†), 50% lower price per character](https://elevenlabs.io/docs/overview/models#turbo-v25)
[Scribe v1\
\
State-of-the-art speech recognition model\
\
Accurate transcription in 99 languages\
\
Precise word-level timestamps\
\
Speaker diarization\
\
Dynamic audio tagging](https://elevenlabs.io/docs/overview/models#scribe-v1)
[Scribe v2 Realtime\
\
Real-time speech recognition model\
\
Accurate transcription in 90 languages\
\
Real-time transcription\
\
Low latency (~150ms†)\
\
Precise word-level timestamps](https://elevenlabs.io/docs/overview/models#scribe-v2-realtime)
[Explore all](https://elevenlabs.io/docs/overview/models)
† Excluding application & network latency
Browse by capability
--------------------
[Text to Speech\
\
Convert text into lifelike speech](https://elevenlabs.io/docs/overview/capabilities/text-to-speech)
[Speech to Text\
\
Transcribe spoken audio into text](https://elevenlabs.io/docs/overview/capabilities/speech-to-text)
[Music\
\
Generate music from text](https://elevenlabs.io/docs/overview/capabilities/music)
[Text to Dialogue\
\
Create natural-sounding dialogue from text](https://elevenlabs.io/docs/overview/capabilities/text-to-dialogue)
[Image & Video\
\
Generate images and videos from text](https://elevenlabs.io/docs/overview/capabilities/image-video)
[Voice changer\
\
Modify and transform voices](https://elevenlabs.io/docs/overview/capabilities/voice-changer)
[Voice isolator\
\
Isolate voices from background noise](https://elevenlabs.io/docs/overview/capabilities/voice-isolator)
[Dubbing\
\
Dub audio and videos seamlessly](https://elevenlabs.io/docs/overview/capabilities/dubbing)
[Sound effects\
\
Create cinematic sound effects](https://elevenlabs.io/docs/overview/capabilities/sound-effects)
[Voices\
\
Clone and design custom voices](https://elevenlabs.io/docs/overview/capabilities/voices)
[Voice Remixing\
\
Transform and enhance existing voices](https://elevenlabs.io/docs/overview/capabilities/voice-remixing)
[Forced Alignment\
\
Align text to audio](https://elevenlabs.io/docs/overview/capabilities/forced-alignment)
[Agents Platform\
\
Deploy intelligent voice agents](https://elevenlabs.io/docs/agents-platform/overview)
Ask AI
Assistant
Hi, I'm an AI assistant with access to documentation and other content.
Tip: You can toggle this pane with
⌘
+
/
---
# Models | ElevenLabs Documentation
Flagship models
---------------
### Text to Speech
[Eleven v3\
\
\
\
Our most emotionally rich, expressive speech synthesis model\
\
Dramatic delivery and performance\
\
70+ languages supported\
\
5,000 character limit\
\
Support for natural multi-speaker dialogue](https://elevenlabs.io/docs/overview/models#eleven-v3-alpha)
[Eleven Multilingual v2\
\
Lifelike, consistent quality speech synthesis model\
\
Natural-sounding output\
\
29 languages supported\
\
10,000 character limit\
\
Most stable on long-form generations](https://elevenlabs.io/docs/overview/models#multilingual-v2)
[Eleven Flash v2.5\
\
Our fast, affordable speech synthesis model\
\
Ultra-low latency (~75ms†)\
\
32 languages supported\
\
40,000 character limit\
\
Faster model, 50% lower price per character](https://elevenlabs.io/docs/overview/models#flash-v25)
[Eleven Turbo v2.5\
\
High quality, low-latency model with a good balance of quality and speed\
\
High quality voice generation\
\
32 languages supported\
\
40,000 character limit\
\
Low latency (~250ms-300ms†), 50% lower price per character](https://elevenlabs.io/docs/overview/models#turbo-v25)
### Speech to Text
[Scribe v1\
\
State-of-the-art speech recognition model\
\
Accurate transcription in 99 languages\
\
Precise word-level timestamps\
\
Speaker diarization\
\
Dynamic audio tagging](https://elevenlabs.io/docs/overview/models#scribe-v1)
[Scribe v2 Realtime\
\
Real-time speech recognition model\
\
Accurate transcription in 90 languages\
\
Real-time transcription\
\
Low latency (~150ms†)\
\
Precise word-level timestamps](https://elevenlabs.io/docs/overview/models#scribe-v2-realtime)
### Music
[Eleven Music\
\
Studio-grade music with natural language prompts in any style\
\
Complete control over genre, style, and structure\
\
Vocals or just instrumental\
\
Multilingual, including English, Spanish, German, Japanese and more\
\
Edit the sound and lyrics of individual sections or the whole song](https://elevenlabs.io/docs/overview/models#eleven-music)
[Pricing](https://elevenlabs.io/pricing/api)
Models overview
---------------
The ElevenLabs API offers a range of audio models optimized for different use cases, quality levels, and performance requirements.
| Model ID | Description | Languages |
| --- | --- | --- |
| `eleven_v3` | Human-like and expressive speech generation | [70+ languages](https://elevenlabs.io/docs/overview/models#supported-languages) |
| `eleven_ttv_v3` | Human-like and expressive voice design model (Text to Voice) | [70+ languages](https://elevenlabs.io/docs/overview/models#supported-languages) |
| `eleven_multilingual_v2` | Our most lifelike model with rich emotional expression | `en`, `ja`, `zh`, `de`, `hi`, `fr`, `ko`, `pt`, `it`, `es`, `id`, `nl`, `tr`, `fil`, `pl`, `sv`, `bg`, `ro`, `ar`, `cs`, `el`, `fi`, `hr`, `ms`, `sk`, `da`, `ta`, `uk`, `ru` |
| `eleven_flash_v2_5` | Ultra-fast model optimized for real-time use (~75ms†) | All `eleven_multilingual_v2` languages plus: `hu`, `no`, `vi` |
| `eleven_flash_v2` | Ultra-fast model optimized for real-time use (~75ms†) | `en` |
| `eleven_turbo_v2_5` | High quality, low-latency model with a good balance of quality and speed (~250ms-300ms) | `en`, `ja`, `zh`, `de`, `hi`, `fr`, `ko`, `pt`, `it`, `es`, `id`, `nl`, `tr`, `fil`, `pl`, `sv`, `bg`, `ro`, `ar`, `cs`, `el`, `fi`, `hr`, `ms`, `sk`, `da`, `ta`, `uk`, `ru`, `hu`, `no`, `vi` |
| `eleven_turbo_v2` | High quality, low-latency model with a good balance of quality and speed (~250ms-300ms) | `en` |
| `eleven_multilingual_sts_v2` | State-of-the-art multilingual voice changer model (Speech to Speech) | `en`, `ja`, `zh`, `de`, `hi`, `fr`, `ko`, `pt`, `it`, `es`, `id`, `nl`, `tr`, `fil`, `pl`, `sv`, `bg`, `ro`, `ar`, `cs`, `el`, `fi`, `hr`, `ms`, `sk`, `da`, `ta`, `uk`, `ru` |
| `eleven_multilingual_ttv_v2` | State-of-the-art multilingual voice designer model (Text to Voice) | `en`, `ja`, `zh`, `de`, `hi`, `fr`, `ko`, `pt`, `it`, `es`, `id`, `nl`, `tr`, `fil`, `pl`, `sv`, `bg`, `ro`, `ar`, `cs`, `el`, `fi`, `hr`, `ms`, `sk`, `da`, `ta`, `uk`, `ru` |
| `eleven_english_sts_v2` | English-only voice changer model (Speech to Speech) | `en` |
| `scribe_v2_realtime` | Real-time speech recognition model | [99 languages](https://elevenlabs.io/docs/overview/capabilities/speech-to-text#supported-languages) |
| `scribe_v1` | State-of-the-art speech recognition. Outclassed by v2 models | [99 languages](https://elevenlabs.io/docs/overview/capabilities/speech-to-text#supported-languages) |
† Excluding application & network latency
### Deprecated models
The `eleven_monolingual_v1` and `eleven_multilingual_v1` models are deprecated and will be removed in the future. Please migrate to newer models for continued service.
| Model ID | Description | Languages | Replacement model suggestion |
| --- | --- | --- | --- |
| `eleven_monolingual_v1` | First generation TTS model (outclassed by v2 models) | `en` | `eleven_multilingual_v2` |
| `eleven_multilingual_v1` | First multilingual model (outclassed by v2 models) | `en`, `fr`, `de`, `hi`, `it`, `pl`, `pt`, `es` | `eleven_multilingual_v2` |
Eleven v3 (alpha)
-----------------
This model is currently in alpha and is subject to change. Eleven v3 is not made for real-time applications like Agents Platform. When integrating Eleven v3 into your application, consider generating several generations and allowing the user to select the best one.
Eleven v3 is our latest and most advanced speech synthesis model. It is a state-of-the-art model that produces natural, life-like speech with high emotional range and contextual understanding across multiple languages.
This model works well in the following scenarios:
* **Character Discussions**: Excellent for audio experiences with multiple characters that interact with each other.
* **Audiobook Production**: Perfect for long-form narration with complex emotional delivery.
* **Emotional Dialogue**: Generate natural, lifelike dialogue with high emotional range and contextual understanding.
With Eleven v3 comes a new Text to Dialogue API, which allows you to generate natural, lifelike dialogue with high emotional range and contextual understanding across multiple languages. Eleven v3 can also be used with the Text to Speech API to generate natural, lifelike speech with high emotional range and contextual understanding across multiple languages.
Read more about the Text to Dialogue API [here](https://elevenlabs.io/docs/overview/capabilities/text-to-dialogue)
.
### Supported languages
The Eleven v3 model supports 70+ languages, including:
_Afrikaans (afr), Arabic (ara), Armenian (hye), Assamese (asm), Azerbaijani (aze), Belarusian (bel), Bengali (ben), Bosnian (bos), Bulgarian (bul), Catalan (cat), Cebuano (ceb), Chichewa (nya), Croatian (hrv), Czech (ces), Danish (dan), Dutch (nld), English (eng), Estonian (est), Filipino (fil), Finnish (fin), French (fra), Galician (glg), Georgian (kat), German (deu), Greek (ell), Gujarati (guj), Hausa (hau), Hebrew (heb), Hindi (hin), Hungarian (hun), Icelandic (isl), Indonesian (ind), Irish (gle), Italian (ita), Japanese (jpn), Javanese (jav), Kannada (kan), Kazakh (kaz), Kirghiz (kir), Korean (kor), Latvian (lav), Lingala (lin), Lithuanian (lit), Luxembourgish (ltz), Macedonian (mkd), Malay (msa), Malayalam (mal), Mandarin Chinese (cmn), Marathi (mar), Nepali (nep), Norwegian (nor), Pashto (pus), Persian (fas), Polish (pol), Portuguese (por), Punjabi (pan), Romanian (ron), Russian (rus), Serbian (srp), Sindhi (snd), Slovak (slk), Slovenian (slv), Somali (som), Spanish (spa), Swahili (swa), Swedish (swe), Tamil (tam), Telugu (tel), Thai (tha), Turkish (tur), Ukrainian (ukr), Urdu (urd), Vietnamese (vie), Welsh (cym)._
Multilingual v2
---------------
Eleven Multilingual v2 is our most advanced, emotionally-aware speech synthesis model. It produces natural, lifelike speech with high emotional range and contextual understanding across multiple languages.
The model delivers consistent voice quality and personality across all supported languages while maintaining the speaker’s unique characteristics and accent.
This model excels in scenarios requiring high-quality, emotionally nuanced speech:
* **Character Voiceovers**: Ideal for gaming and animation due to its emotional range.
* **Professional Content**: Well-suited for corporate videos and e-learning materials.
* **Multilingual Projects**: Maintains consistent voice quality across language switches.
* **Stable Quality**: Produces consistent, high-quality audio output.
While it has a higher latency & cost per character than Flash models, it delivers superior quality for projects where lifelike speech is important.
Our multilingual v2 models support 29 languages:
_English (USA, UK, Australia, Canada), Japanese, Chinese, German, Hindi, French (France, Canada), Korean, Portuguese (Brazil, Portugal), Italian, Spanish (Spain, Mexico), Indonesian, Dutch, Turkish, Filipino, Polish, Swedish, Bulgarian, Romanian, Arabic (Saudi Arabia, UAE), Czech, Greek, Finnish, Croatian, Malay, Slovak, Danish, Tamil, Ukrainian & Russian._
Flash v2.5
----------
Eleven Flash v2.5 is our fastest speech synthesis model, designed for real-time applications and Agents Platform. It delivers high-quality speech with ultra-low latency (~75ms†) across 32 languages.
The model balances speed and quality, making it ideal for interactive applications while maintaining natural-sounding output and consistent voice characteristics across languages.
This model is particularly well-suited for:
* **Agents Platform**: Perfect for real-time voice agents and chatbots.
* **Interactive Applications**: Ideal for games and applications requiring immediate response.
* **Large-Scale Processing**: Efficient for bulk text-to-speech conversion.
With its lower price point and 75ms latency, Flash v2.5 is the cost-effective option for anyone needing fast, reliable speech synthesis across multiple languages.
Flash v2.5 supports 32 languages - all languages from v2 models plus:
_Hungarian, Norwegian & Vietnamese_
† Excluding application & network latency
### Considerations
###### Text normalization with numbers
When using Flash v2.5, numbers aren’t normalized by default in a way you might expect. For example, phone numbers might be read out in way that isn’t clear for the user. Dates and currencies are affected in a similar manner.
By default, normalization is disabled for Flash v2.5 to maintain the low latency. However, Enterprise customers can now enable text normalization for v2.5 models by setting the `apply_text_normalization` parameter to “on” in your request.
The Multilingual v2 model does a better job of normalizing numbers, so we recommend using it for phone numbers and other cases where number normalization is important.
For low-latency or Agents Platform applications, best practice is to have your LLM [normalize the text](https://elevenlabs.io/docs/overview/capabilities/text-to-speech/best-practices#text-normalization)
before passing it to the TTS model, or use the `apply_text_normalization` parameter (Enterprise plans only for v2.5 models).
Turbo v2.5
----------
Eleven Turbo v2.5 is our high-quality, low-latency model with a good balance of quality and speed.
This model is an ideal choice for all scenarios where you’d use Flash v2.5, but where you’re willing to trade off latency for higher quality voice generation.
Model selection guide
---------------------
###### Requirements
Quality
Use `eleven_multilingual_v2`
Best for high-fidelity audio output with rich emotional expression
Low-latency
Use Flash models
Optimized for real-time applications (~75ms latency)
Multilingual
Use either either `eleven_multilingual_v2` or `eleven_flash_v2_5`
Both support up to 32 languages
Balanced
Use `eleven_turbo_v2_5`
Good balance between quality and speed
###### Use case
Content creation
Use `eleven_multilingual_v2`
Ideal for professional content, audiobooks & video narration.
Agents Platform
Use `eleven_flash_v2_5`, `eleven_flash_v2`, `eleven_multilingual_v2`, `eleven_turbo_v2_5` or `eleven_turbo_v2`
Perfect for real-time conversational applications
Voice changer
Use `eleven_multilingual_sts_v2`
Specialized for Speech-to-Speech conversion
Character limits
----------------
The maximum number of characters supported in a single text-to-speech request varies by model.
| Model ID | Character limit | Approximate audio duration |
| --- | --- | --- |
| `eleven_v3` | 5,000 | ~5 minutes |
| `eleven_flash_v2_5` | 40,000 | ~40 minutes |
| `eleven_flash_v2` | 30,000 | ~30 minutes |
| `eleven_turbo_v2_5` | 40,000 | ~40 minutes |
| `eleven_turbo_v2` | 30,000 | ~30 minutes |
| `eleven_multilingual_v2` | 10,000 | ~10 minutes |
| `eleven_multilingual_v1` | 10,000 | ~10 minutes |
| `eleven_english_sts_v2` | 10,000 | ~10 minutes |
| `eleven_english_sts_v1` | 10,000 | ~10 minutes |
For longer content, consider splitting the input into multiple requests.
Scribe v1
---------
Scribe v1 is our state-of-the-art speech recognition model designed for accurate transcription across 99 languages. It provides precise word-level timestamps and advanced features like speaker diarization and dynamic audio tagging.
This model excels in scenarios requiring accurate speech-to-text conversion:
* **Transcription Services**: Perfect for converting audio/video content to text
* **Meeting Documentation**: Ideal for capturing and documenting conversations
* **Content Analysis**: Well-suited for audio content processing and analysis
* **Multilingual Recognition**: Supports accurate transcription across 99 languages
Key features:
* Accurate transcription with word-level timestamps
* Speaker diarization for multi-speaker audio
* Dynamic audio tagging for enhanced context
* Support for 99 languages
Read more about Scribe v1 [here](https://elevenlabs.io/docs/overview/capabilities/speech-to-text)
.
Scribe v2 Realtime
------------------
Scribe v2 Realtime, our fastest and most accurate live speech recognition model, delivers state-of-the-art accuracy in over 90 languages with an ultra-low 150ms of latency.
This model excels in conversational use cases:
* **Live meeting transcription**: Perfect for realtime transcription
* **AI Agents**: Ideal for live conversations
* **Multilingual Recognition**: Supports accurate transcription across 99 languages with automatic language recognition
Key features:
* Ultra-low latency: Get partial transcriptions in ~150 milliseconds
* Streaming support: Send audio in chunks while receiving transcripts in real-time
* Multiple audio formats: Support for PCM (8kHz to 48kHz) and μ-law encoding
* Voice Activity Detection (VAD): Automatic speech segmentation based on silence detection
* Manual commit control: Full control over when to finalize transcript segments
Read more about Scribe v2 Realtime [here](https://elevenlabs.io/docs/developers/guides/cookbooks/speech-to-text/streaming)
.
Eleven Music
------------
Eleven Music is our studio-grade music generation model. It allows you to generate music with natural language prompts in any style.
This model is excellent for the following scenarios:
* **Game Soundtracks**: Create immersive soundtracks for games
* **Podcast Backgrounds**: Enhance podcasts with professional music
* **Marketing**: Add background music to ad reels
Key features:
* Complete control over genre, style, and structure
* Vocals or just instrumental
* Multilingual, including English, Spanish, German, Japanese and more
* Edit the sound and lyrics of individual sections or the whole song
Read more about Eleven Music [here](https://elevenlabs.io/docs/overview/capabilities/music)
.
Concurrency and priority
------------------------
Your subscription plan determines how many requests can be processed simultaneously and the priority level of your requests in the queue. Speech to Text has an elevated concurrency limit. Once the concurrency limit is met, subsequent requests are processed in a queue alongside lower-priority requests. In practice this typically only adds ~50ms of latency.
| Plan | Concurrency Limit
(Multilingual v2) | Concurrency Limit
(Turbo & Flash) | STT Concurrency Limit | Realtime STT Concurrency limit | Music Concurrency limit | Priority level |
| --- | --- | --- | --- | --- | --- | --- |
| Free | 2 | 4 | 8 | 4 | 0 | 3 |
| Starter | 3 | 6 | 12 | 6 | 2 | 4 |
| Creator | 5 | 10 | 20 | 10 | 2 | 5 |
| Pro | 10 | 20 | 40 | 20 | 2 | 5 |
| Scale | 15 | 30 | 60 | 30 | 5 | 5 |
| Business | 15 | 30 | 60 | 30 | 5 | 5 |
| Enterprise | Elevated | Elevated | Elevated | Elevated | Highest | 5 |
Startup grants recipients receive Scale level benefits.
The response headers include `current-concurrent-requests` and `maximum-concurrent-requests` which you can use to monitor your concurrency.
### API requests per minute vs concurrent requests
It’s important to understand that **API requests per minute** and **concurrent requests** are different metrics that depend on your usage patterns.
API requests per minute can be different from concurrent requests since it depends on the length of time for each request and how the requests are batched.
**Example 1: Spaced requests** If you had 180 requests per minute that each took 1 second to complete and you sent them each 0.33 seconds apart, the max concurrent requests would be 3 and the average would be 3 since there would always be 3 in flight.
**Example 2: Batched requests** However, if you had a different usage pattern such as 180 requests per minute that each took 3 seconds to complete but all fired at once, the max concurrent requests would be 180 and the average would be 9 (first 3 seconds of the minute saw 180 requests at once, final 57 seconds saw 0 requests).
Since our system cares about concurrency, requests per minute matter less than how long each of the requests take and the pattern of when they are sent.
How endpoint requests are made impacts concurrency limits:
* With HTTP, each request counts individually toward your concurrency limit.
* With a WebSocket, only the time where our model is generating audio counts towards your concurrency limit, this means a for most of the time an open websocket doesn’t count towards your concurrency limit at all.
### Understanding concurrency limits
The concurrency limit associated with your plan should not be interpreted as the maximum number of simultaneous conversations, phone calls character voiceovers, etc that can be handled at once. The actual number depends on several factors, including the specific AI voices used and the characteristics of the use case.
As a general rule of thumb, a concurrency limit of 5 can typically support up to approximately 100 simultaneous audio broadcasts.
This is because of the speed it takes for audio to be generated relative to the time it takes for the TTS request to be processed. The diagram below is an example of how 4 concurrent calls with different users can be facilitated while only hitting 2 concurrent requests.
###### Building AI Voice Agents
Where TTS is used to facilitate dialogue, a concurrency limit of 5 can support about 100 broadcasts for balanced conversations between AI agents and human participants.
For use cases in which the AI agent speaks less frequently than the human, such as customer support interactions, more than 100 simultaneous conversations could be supported.
###### Character voiceovers
Generally, more than 100 simultaneous character voiceovers can be supported for a concurrency limit of 5.
The number can vary depending on the character’s dialogue frequency, the length of pauses, and in-game actions between lines.
###### Live Dubbing
Concurrent dubbing streams generally follow the provided heuristic.
If the broadcast involves periods of conversational pauses (e.g. because of a soundtrack, visual scenes, etc), more simultaneous dubbing streams than the suggestion may be possible.
If you exceed your plan’s concurrency limits at any point and you are on the Enterprise plan, model requests may still succeed, albeit slower, on a best efforts basis depending on available capacity.
To increase your concurrency limit & queue priority, [upgrade your subscription plan](https://elevenlabs.io/pricing/api)
.
Enterprise customers can request a higher concurrency limit by contacting their account manager.
### Scale testing concurrency limits
Scale testing can be useful to identify client side scaling issues and to verify concurrency limits are set correctly for your usecase.
It is heavily recommended to test end-to-end workflows as close to real world usage as possible, simulating and measuring how many users can be supported is the recommended methodology for achieving this. It is important to:
* Simulate users, not raw requests
* Simulate typical user behavior such as waiting for audio playback, user speaking or transcription to finish before making requests
* Ramp up the number of users slowly over a period of minutes
* Introduce randomness to request timings and to the size of requests
* Capture latency metrics and any returned error codes from the API
For example, to test an agent system designed to support 100 simultaneous conversations you would create up to 100 individual “users” each simulating a conversation. Conversations typically consist of a repeating cycle of ~10 seconds of user talking, followed by the TTS API call for ~150 characters, followed by ~10 seconds of audio playback to the user. Therefore, each user should follow the pattern of making a websocket Text-to-Speech API call for 150 characters of text every 20 seconds, with a small amount of randomness introduced to the wait period and the number of characters requested. The test would consist of spawning one user per second until 100 exist and then testing for 10 minutes in total to test overall stability.
###### Scale testing script example
This example uses [locust](https://locust.io/)
as the testing framework with direct API calls to the ElevenLabs API.
It follows the example listed above, testing a conversational agent system with each user sending 1 request every 20 seconds.
Python
` | | | | --- | --- | | 1 | import json | | 2 | import random | | 3 | import time | | 4 | import gevent | | 5 | import locust | | 6 | from locust import User, task, events, constant_throughput | | 7 | import websocket | | 8 | | | 9 | # Averages up to 10 seconds of audio when played, depends on the voice speed | | 10 | DEFAULT_TEXT = ( | | 11 | "Hello, this is a test message. I am testing if a long input will cause issues for the model " | | 12 | "like this sentence. " | | 13 | ) | | 14 | | | 15 | TEXT_ARRAY = [ | | 16 | "Hello.", | | 17 | "Hello, this is a test message.", | | 18 | DEFAULT_TEXT, | | 19 | DEFAULT_TEXT * 2, | | 20 | DEFAULT_TEXT * 3 | | 21 | ] | | 22 | | | 23 | # Custom command line arguments | | 24 | @events.init_command_line_parser.add_listener | | 25 | def on_parser_init(parser): | | 26 | parser.add_argument("--api-key", default="YOUR_API_KEY", help="API key for authentication") | | 27 | parser.add_argument("--encoding", default="mp3_22050_32", help="Encoding") | | 28 | parser.add_argument("--text", default=DEFAULT_TEXT, help="Text to use") | | 29 | parser.add_argument("--use-text-array", default="false", help="Text to use") | | 30 | parser.add_argument("--voice-id", default="aria", help="Text to use") | | 31 | | | 32 | | | 33 | class WebSocketTTSUser(User): | | 34 | # Each user will send a request every 20 seconds, regardless of how long each request takes | | 35 | wait_time = constant_throughput(0.05) | | 36 | | | 37 | def __init__(self, *args, **kwargs): | | 38 | super().__init__(*args, **kwargs) | | 39 | self.api_key = self.environment.parsed_options.api_key | | 40 | self.voice_id = self.environment.parsed_options.voice_id | | 41 | self.text = self.environment.parsed_options.text | | 42 | self.encoding = self.environment.parsed_options.encoding | | 43 | self.use_text_array = self.environment.parsed_options.use_text_array | | 44 | if self.use_text_array: | | 45 | self.text = random.choice(TEXT_ARRAY) | | 46 | self.all_recieved = False | | 47 | | | 48 | @task | | 49 | def tts_task(self): | | 50 | # Do jitter waiting of up to 1 second | | 51 | # Users appear to be spawned every second so this ensures requests are not aligned | | 52 | gevent.sleep(random.random()) | | 53 | | | 54 | max_wait_time = 10 | | 55 | | | 56 | # Connection details | | 57 | uri = f"{self.environment.host}/v1/text-to-speech/{self.voice_id}/stream-input?auto_mode=true&output_format={self.encoding}" | | 58 | headers = {"xi-api-key": self.api_key} | | 59 | | | 60 | ws = None | | 61 | self.all_recieved = False | | 62 | try: | | 63 | init_msg = {"text": " "} | | 64 | # Use proper header format for websocket - this is case sensitive! | | 65 | ws = websocket.create_connection(uri, header=headers) | | 66 | ws.send(json.dumps(init_msg)) | | 67 | | | 68 | # Start measuring after websocket initiated but before any messages are sent | | 69 | send_request_time = time.perf_counter() | | 70 | ws.send(json.dumps({"text": self.text})) | | 71 | | | 72 | # Send to flush and receive the audio | | 73 | ws.send(json.dumps({"text": ""})) | | 74 | | | 75 | def _receive(): | | 76 | t_first_response = None | | 77 | audio_size = 0 | | 78 | try: | | 79 | while True: | | 80 | # Wait up to 10 seconds for a response | | 81 | ws.settimeout(max_wait_time) | | 82 | response = ws.recv() | | 83 | response_data = json.loads(response) | | 84 | | | 85 | if "audio" in response_data and response_data["audio"]: | | 86 | audio_size = audio_size + len(response_data["audio"]) | | 87 | | | 88 | if t_first_response is None: | | 89 | t_first_response = time.perf_counter() | | 90 | first_byte_ms = ( | | 91 | t_first_response - send_request_time | | 92 | ) * 1000 | | 93 | if audio_size is None: | | 94 | # The first response should always have audio | | 95 | locust.events.request.fire( | | 96 | request_type="websocket", | | 97 | name="Bad Response (no audio)", | | 98 | response_time=first_byte_ms, | | 99 | response_length=audio_size, | | 100 | exception=Exception("Response has no audio"), | | 101 | ) | | 102 | break | | 103 | | | 104 | if "isFinal" in response_data and response_data["isFinal"]: | | 105 | # Fire this event once finished streaming, but report the important TTFB metric | | 106 | locust.events.request.fire( | | 107 | request_type="websocket", | | 108 | name="TTS Stream Success (First Byte)", | | 109 | response_time=first_byte_ms, | | 110 | response_length=audio_size, | | 111 | exception=None, | | 112 | ) | | 113 | break | | 114 | | | 115 | except websocket.WebSocketTimeoutException: | | 116 | locust.events.request.fire( | | 117 | request_type="websocket", | | 118 | name="TTS Stream Timeout", | | 119 | response_time=max_wait_time * 1000, | | 120 | response_length=audio_size, | | 121 | exception=Exception("Timeout waiting for response"), | | 122 | ) | | 123 | except Exception as e: | | 124 | # Typically JSON decode error if the server returns HTTP backoff error | | 125 | locust.events.request.fire( | | 126 | request_type="websocket", | | 127 | name="TTS Stream Failure", | | 128 | response_time=0, | | 129 | response_length=0, | | 130 | exception=e, | | 131 | ) | | 132 | finally: | | 133 | self.all_recieved = True | | 134 | | | 135 | gevent.spawn(_receive) | | 136 | | | 137 | # Sleep until recieved so new tasks aren't spawned | | 138 | while not self.all_recieved: | | 139 | gevent.sleep(1) | | 140 | | | 141 | except websocket.WebSocketTimeoutException: | | 142 | locust.events.request.fire( | | 143 | request_type="websocket", | | 144 | name="TTS Stream Timeout", | | 145 | response_time=max_wait_time * 1000, | | 146 | response_length=0, | | 147 | exception=Exception("Timeout waiting for response"), | | 148 | ) | | 149 | except Exception as e: | | 150 | locust.events.request.fire( | | 151 | request_type="websocket", | | 152 | name="TTS Stream Failure", | | 153 | response_time=0, | | 154 | response_length=0, | | 155 | exception=e, | | 156 | ) | | 157 | finally: | | 158 | # Try and close the websocket gracefully | | 159 | try: | | 160 | if ws: | | 161 | ws.close() | | 162 | except Exception: | | 163 | pass | `
[](https://elevenlabs.io/docs)
[Login](https://elevenlabs.io/docs/overview/models)
[Login](https://elevenlabs.io/docs/overview/models)
[Community](https://discord.gg/elevenlabs)
[Blog](https://elevenlabs.io/blog)
[Help Center](https://help.elevenlabs.io/)
[API Pricing](https://elevenlabs.io/pricing/api)
[Sign up](https://elevenlabs.io/sign-up)
---
# Text to Speech | ElevenLabs Documentation
Overview
--------
ElevenLabs [Text to Speech (TTS)](https://elevenlabs.io/docs/api-reference/text-to-speech)
API turns text into lifelike audio with nuanced intonation, pacing and emotional awareness. [Our models](https://elevenlabs.io/docs/overview/models)
adapt to textual cues across 32 languages and multiple voice styles and can be used to:
* Narrate global media campaigns & ads
* Produce audiobooks in multiple languages with complex emotional delivery
* Stream real-time audio from text
Listen to a sample:
Explore our [voice library](https://elevenlabs.io/app/voice-library)
to find the perfect voice for your project.
[Products\
\
Step-by-step guide for using text to speech in ElevenLabs.](https://elevenlabs.io/docs/creative-platform/playground/text-to-speech)
[Developers\
\
Learn how to integrate text to speech into your application.](https://elevenlabs.io/docs/developers/quickstart)
### Voice quality
For real-time applications, Flash v2.5 provides ultra-low 75ms latency, while Multilingual v2 delivers the highest quality audio with more nuanced expression.
[Eleven v3\
\
\
\
Our most emotionally rich, expressive speech synthesis model\
\
Dramatic delivery and performance\
\
70+ languages supported\
\
5,000 character limit\
\
Support for natural multi-speaker dialogue](https://elevenlabs.io/docs/overview/models#eleven-v3-alpha)
[Eleven Multilingual v2\
\
Lifelike, consistent quality speech synthesis model\
\
Natural-sounding output\
\
29 languages supported\
\
10,000 character limit\
\
Most stable on long-form generations](https://elevenlabs.io/docs/overview/models#multilingual-v2)
[Eleven Flash v2.5\
\
Our fast, affordable speech synthesis model\
\
Ultra-low latency (~75ms†)\
\
32 languages supported\
\
40,000 character limit\
\
Faster model, 50% lower price per character](https://elevenlabs.io/docs/overview/models#flash-v25)
[Eleven Turbo v2.5\
\
High quality, low-latency model with a good balance of quality and speed\
\
High quality voice generation\
\
32 languages supported\
\
40,000 character limit\
\
Low latency (~250ms-300ms†), 50% lower price per character](https://elevenlabs.io/docs/overview/models#turbo-v25)
[Explore all](https://elevenlabs.io/docs/overview/models)
### Voice options
ElevenLabs offers thousands of voices across 32 languages through multiple creation methods:
* [Voice library](https://elevenlabs.io/docs/overview/capabilities/voices)
with 3,000+ community-shared voices
* [Professional voice cloning](https://elevenlabs.io/docs/overview/capabilities/voices#cloned)
for highest-fidelity replicas
* [Instant voice cloning](https://elevenlabs.io/docs/overview/capabilities/voices#cloned)
for quick voice replication
* [Voice design](https://elevenlabs.io/docs/overview/capabilities/voices#voice-design)
to generate custom voices from text descriptions
Learn more about our [voice options](https://elevenlabs.io/docs/overview/capabilities/voices)
.
### Supported formats
The default response format is “mp3”, but other formats like “PCM”, & “μ-law” are available.
* **MP3**
* Sample rates: 22.05kHz - 44.1kHz
* Bitrates: 32kbps - 192kbps
* 22.05kHz @ 32kbps
* 44.1kHz @ 32kbps, 64kbps, 96kbps, 128kbps, 192kbps
* **PCM (S16LE)**
* Sample rates: 16kHz - 44.1kHz
* Bitrates: 8kHz, 16kHz, 22.05kHz, 24kHz, 44.1kHz, 48kHz
* 16-bit depth
* **μ-law**
* 8kHz sample rate
* Optimized for telephony applications
* **A-law**
* 8kHz sample rate
* Optimized for telephony applications
* **Opus**
* Sample rate: 48kHz
* Bitrates: 32kbps - 192kbps
Higher quality audio options are only available on paid tiers - see our [pricing page](https://elevenlabs.io/pricing/api)
for details.
### Supported languages
Our multilingual v2 models support 29 languages:
_English (USA, UK, Australia, Canada), Japanese, Chinese, German, Hindi, French (France, Canada), Korean, Portuguese (Brazil, Portugal), Italian, Spanish (Spain, Mexico), Indonesian, Dutch, Turkish, Filipino, Polish, Swedish, Bulgarian, Romanian, Arabic (Saudi Arabia, UAE), Czech, Greek, Finnish, Croatian, Malay, Slovak, Danish, Tamil, Ukrainian & Russian._
Flash v2.5 supports 32 languages - all languages from v2 models plus:
_Hungarian, Norwegian & Vietnamese_
Simply input text in any of our supported languages and select a matching voice from our [voice library](https://elevenlabs.io/app/voice-library)
. For the most natural results, choose a voice with an accent that matches your target language and region.
### Prompting
The models interpret emotional context directly from the text input. For example, adding descriptive text like “she said excitedly” or using exclamation marks will influence the speech emotion. Voice settings like Stability and Similarity help control the consistency, while the underlying emotion comes from textual cues.
Read the [prompting guide](https://elevenlabs.io/docs/overview/capabilities/text-to-speech/best-practices)
for more details.
Descriptive text will be spoken out by the model and must be manually trimmed or removed from the audio if desired.
FAQ
---
###### Can I clone my own voice?
Yes, you can create [instant voice clones](https://elevenlabs.io/docs/overview/capabilities/voices#cloned)
of your own voice from short audio clips. For high-fidelity clones, check out our [professional voice cloning](https://elevenlabs.io/docs/overview/capabilities/voices#cloned)
feature.
###### Do I own the audio output?
Yes. You retain ownership of any audio you generate. However, commercial usage rights are only available with paid plans. With a paid subscription, you may use generated audio for commercial purposes and monetize the outputs if you own the IP rights to the input content.
###### What qualifies as a free regeneration?
A free regeneration allows you to regenerate the same text to speech content without additional cost, subject to these conditions:
* You can regenerate each piece of content up to 2 times for free
* The content must be exactly the same as the previous generation. Any changes to the text, voice settings, or other parameters will require a new, paid generation
Free regenerations are useful in case there is a slight distortion in the audio output. According to ElevenLabs’ internal benchmarks, regenerations will solve roughly half of issues with quality, with remaining issues usually due to poor training data.
###### How do I reduce latency for real-time cases?
Use the low-latency Flash [models](https://elevenlabs.io/docs/overview/models)
(Flash v2 or v2.5) optimized for near real-time conversational or interactive scenarios. See our [latency optimization guide](https://elevenlabs.io/docs/developers/best-practices/latency-optimization)
for more details.
###### Why is my output sometimes inconsistent?
The models are nondeterministic. For consistency, use the optional [seed parameter](https://elevenlabs.io/docs/api-reference/text-to-speech/convert#request.body.seed)
, though subtle differences may still occur.
###### What's the best practice for large text conversions?
Split long text into segments and use streaming for real-time playback and efficient processing. To maintain natural prosody flow between chunks, include [previous/next text or previous/next request id parameters](https://elevenlabs.io/docs/api-reference/text-to-speech/convert#request.body.previous_text)
.
[](https://elevenlabs.io/docs)
[Login](https://elevenlabs.io/docs/overview/capabilities/text-to-speech)
[Login](https://elevenlabs.io/docs/overview/capabilities/text-to-speech)
[Community](https://discord.gg/elevenlabs)
[Blog](https://elevenlabs.io/blog)
[Help Center](https://help.elevenlabs.io/)
[API Pricing](https://elevenlabs.io/pricing/api)
[Sign up](https://elevenlabs.io/sign-up)
---
# Speech to Text | ElevenLabs Documentation
Overview
--------
The ElevenLabs [Speech to Text (STT)](https://elevenlabs.io/docs/api-reference/speech-to-text)
API turns spoken audio into text with state of the art accuracy. Our Scribe v1 [model](https://elevenlabs.io/docs/overview/models)
adapts to textual cues across 99 languages and multiple voice styles and can be used to:
* Transcribe podcasts, interviews, and other audio or video content
* Generate transcripts for meetings and other audio or video recordings
[Products\
\
Step-by-step guide for using speech to text in ElevenLabs.](https://elevenlabs.io/docs/creative-platform/playground/speech-to-text)
[Developers\
\
Learn how to integrate speech to text into your application.](https://elevenlabs.io/docs/developers/guides/cookbooks/speech-to-text/quickstart)
[Realtime speech to text\
\
Learn how to transcribe audio with ElevenLabs in realtime with WebSockets.](https://elevenlabs.io/docs/developers/guides/cookbooks/speech-to-text/streaming)
Companies requiring HIPAA compliance must contact [ElevenLabs Sales](https://elevenlabs.io/contact-sales)
to sign a Business Associate Agreement (BAA) agreement. Please ensure this step is completed before proceeding with any HIPAA-related integrations or deployments.
State of the art accuracy
-------------------------
The Scribe v1 model is capable of transcribing audio from up to 32 speakers with high accuracy. Optionally it can also transcribe audio events like laughter, applause, and other non-speech sounds.
The transcribed output supports exact timestamps for each word and audio event, plus diarization to identify the speaker for each word.
The Scribe v1 model is best used for when high-accuracy transcription is required rather than real-time transcription. A low-latency, real-time version will be released soon.
Pricing
-------
###### Scribe v1 Developer API
###### Scribe v2 Realtime Developer API
###### Product interface pricing
| Tier | Price/month | Hours included | Price per included hour | Price per additional hour |
| --- | --- | --- | --- | --- |
| Free | $0 | 2 hours 30 min | Unavailable | Unavailable |
| Starter | $5 | 12 hours 30 min | $0.4 | Unavailable |
| Creator | $22 | 62 hours 51 min | $0.35 | $0.48 |
| Pro | $99 | 300 hours | $0.33 | $0.4 |
| Scale | $330 | 1,100 hours | $0.3 | $0.33 |
| Business | $1,320 | 6,000 hours | $0.22 | $0.22 |
For reduced pricing at higher scale than 6,000 hours/month in addition to custom MSAs and DPAs, please [contact sales](https://elevenlabs.io/contact-sales)
.
**Note: The free tier requires attribution and does not have commercial licensing.**
Scribe has higher concurrency limits than other services from ElevenLabs. Please see other concurrency limits [here](https://elevenlabs.io/docs/overview/models#concurrency-and-priority)
| Plan | STT Concurrency Limit |
| --- | --- |
| Free | 8 |
| Starter | 12 |
| Creator | 20 |
| Pro | 40 |
| Scale | 60 |
| Business | 60 |
| Enterprise | Elevated |
Examples
--------
The following example shows the output of the Scribe v1 model for a sample audio file.
` | | | | --- | --- | | 1 | { | | 2 | "language_code": "en", | | 3 | "language_probability": 1, | | 4 | "text": "With a soft and whispery American accent, I'm the ideal choice for creating ASMR content, meditative guides, or adding an intimate feel to your narrative projects.", | | 5 | "words": [ | | 6 | { | | 7 | "text": "With", | | 8 | "start": 0.119, | | 9 | "end": 0.259, | | 10 | "type": "word", | | 11 | "speaker_id": "speaker_0" | | 12 | }, | | 13 | { | | 14 | "text": " ", | | 15 | "start": 0.239, | | 16 | "end": 0.299, | | 17 | "type": "spacing", | | 18 | "speaker_id": "speaker_0" | | 19 | }, | | 20 | { | | 21 | "text": "a", | | 22 | "start": 0.279, | | 23 | "end": 0.359, | | 24 | "type": "word", | | 25 | "speaker_id": "speaker_0" | | 26 | }, | | 27 | { | | 28 | "text": " ", | | 29 | "start": 0.339, | | 30 | "end": 0.499, | | 31 | "type": "spacing", | | 32 | "speaker_id": "speaker_0" | | 33 | }, | | 34 | { | | 35 | "text": "soft", | | 36 | "start": 0.479, | | 37 | "end": 1.039, | | 38 | "type": "word", | | 39 | "speaker_id": "speaker_0" | | 40 | }, | | 41 | { | | 42 | "text": " ", | | 43 | "start": 1.019, | | 44 | "end": 1.2, | | 45 | "type": "spacing", | | 46 | "speaker_id": "speaker_0" | | 47 | }, | | 48 | { | | 49 | "text": "and", | | 50 | "start": 1.18, | | 51 | "end": 1.359, | | 52 | "type": "word", | | 53 | "speaker_id": "speaker_0" | | 54 | }, | | 55 | { | | 56 | "text": " ", | | 57 | "start": 1.339, | | 58 | "end": 1.44, | | 59 | "type": "spacing", | | 60 | "speaker_id": "speaker_0" | | 61 | }, | | 62 | { | | 63 | "text": "whispery", | | 64 | "start": 1.419, | | 65 | "end": 1.979, | | 66 | "type": "word", | | 67 | "speaker_id": "speaker_0" | | 68 | }, | | 69 | { | | 70 | "text": " ", | | 71 | "start": 1.959, | | 72 | "end": 2.179, | | 73 | "type": "spacing", | | 74 | "speaker_id": "speaker_0" | | 75 | }, | | 76 | { | | 77 | "text": "American", | | 78 | "start": 2.159, | | 79 | "end": 2.719, | | 80 | "type": "word", | | 81 | "speaker_id": "speaker_0" | | 82 | }, | | 83 | { | | 84 | "text": " ", | | 85 | "start": 2.699, | | 86 | "end": 2.779, | | 87 | "type": "spacing", | | 88 | "speaker_id": "speaker_0" | | 89 | }, | | 90 | { | | 91 | "text": "accent,", | | 92 | "start": 2.759, | | 93 | "end": 3.389, | | 94 | "type": "word", | | 95 | "speaker_id": "speaker_0" | | 96 | }, | | 97 | { | | 98 | "text": " ", | | 99 | "start": 4.119, | | 100 | "end": 4.179, | | 101 | "type": "spacing", | | 102 | "speaker_id": "speaker_0" | | 103 | }, | | 104 | { | | 105 | "text": "I'm", | | 106 | "start": 4.159, | | 107 | "end": 4.459, | | 108 | "type": "word", | | 109 | "speaker_id": "speaker_0" | | 110 | }, | | 111 | { | | 112 | "text": " ", | | 113 | "start": 4.44, | | 114 | "end": 4.52, | | 115 | "type": "spacing", | | 116 | "speaker_id": "speaker_0" | | 117 | }, | | 118 | { | | 119 | "text": "the", | | 120 | "start": 4.5, | | 121 | "end": 4.599, | | 122 | "type": "word", | | 123 | "speaker_id": "speaker_0" | | 124 | }, | | 125 | { | | 126 | "text": " ", | | 127 | "start": 4.579, | | 128 | "end": 4.699, | | 129 | "type": "spacing", | | 130 | "speaker_id": "speaker_0" | | 131 | }, | | 132 | { | | 133 | "text": "ideal", | | 134 | "start": 4.679, | | 135 | "end": 5.099, | | 136 | "type": "word", | | 137 | "speaker_id": "speaker_0" | | 138 | }, | | 139 | { | | 140 | "text": " ", | | 141 | "start": 5.079, | | 142 | "end": 5.219, | | 143 | "type": "spacing", | | 144 | "speaker_id": "speaker_0" | | 145 | }, | | 146 | { | | 147 | "text": "choice", | | 148 | "start": 5.199, | | 149 | "end": 5.719, | | 150 | "type": "word", | | 151 | "speaker_id": "speaker_0" | | 152 | }, | | 153 | { | | 154 | "text": " ", | | 155 | "start": 5.699, | | 156 | "end": 6.099, | | 157 | "type": "spacing", | | 158 | "speaker_id": "speaker_0" | | 159 | }, | | 160 | { | | 161 | "text": "for", | | 162 | "start": 6.099, | | 163 | "end": 6.199, | | 164 | "type": "word", | | 165 | "speaker_id": "speaker_0" | | 166 | }, | | 167 | { | | 168 | "text": " ", | | 169 | "start": 6.179, | | 170 | "end": 6.279, | | 171 | "type": "spacing", | | 172 | "speaker_id": "speaker_0" | | 173 | }, | | 174 | { | | 175 | "text": "creating", | | 176 | "start": 6.259, | | 177 | "end": 6.799, | | 178 | "type": "word", | | 179 | "speaker_id": "speaker_0" | | 180 | }, | | 181 | { | | 182 | "text": " ", | | 183 | "start": 6.779, | | 184 | "end": 6.979, | | 185 | "type": "spacing", | | 186 | "speaker_id": "speaker_0" | | 187 | }, | | 188 | { | | 189 | "text": "ASMR", | | 190 | "start": 6.959, | | 191 | "end": 7.739, | | 192 | "type": "word", | | 193 | "speaker_id": "speaker_0" | | 194 | }, | | 195 | { | | 196 | "text": " ", | | 197 | "start": 7.719, | | 198 | "end": 7.859, | | 199 | "type": "spacing", | | 200 | "speaker_id": "speaker_0" | | 201 | }, | | 202 | { | | 203 | "text": "content,", | | 204 | "start": 7.839, | | 205 | "end": 8.45, | | 206 | "type": "word", | | 207 | "speaker_id": "speaker_0" | | 208 | }, | | 209 | { | | 210 | "text": " ", | | 211 | "start": 9, | | 212 | "end": 9.06, | | 213 | "type": "spacing", | | 214 | "speaker_id": "speaker_0" | | 215 | }, | | 216 | { | | 217 | "text": "meditative", | | 218 | "start": 9.04, | | 219 | "end": 9.64, | | 220 | "type": "word", | | 221 | "speaker_id": "speaker_0" | | 222 | }, | | 223 | { | | 224 | "text": " ", | | 225 | "start": 9.619, | | 226 | "end": 9.699, | | 227 | "type": "spacing", | | 228 | "speaker_id": "speaker_0" | | 229 | }, | | 230 | { | | 231 | "text": "guides,", | | 232 | "start": 9.679, | | 233 | "end": 10.359, | | 234 | "type": "word", | | 235 | "speaker_id": "speaker_0" | | 236 | }, | | 237 | { | | 238 | "text": " ", | | 239 | "start": 10.359, | | 240 | "end": 10.409, | | 241 | "type": "spacing", | | 242 | "speaker_id": "speaker_0" | | 243 | }, | | 244 | { | | 245 | "text": "or", | | 246 | "start": 11.319, | | 247 | "end": 11.439, | | 248 | "type": "word", | | 249 | "speaker_id": "speaker_0" | | 250 | }, | | 251 | { | | 252 | "text": " ", | | 253 | "start": 11.42, | | 254 | "end": 11.52, | | 255 | "type": "spacing", | | 256 | "speaker_id": "speaker_0" | | 257 | }, | | 258 | { | | 259 | "text": "adding", | | 260 | "start": 11.5, | | 261 | "end": 11.879, | | 262 | "type": "word", | | 263 | "speaker_id": "speaker_0" | | 264 | }, | | 265 | { | | 266 | "text": " ", | | 267 | "start": 11.859, | | 268 | "end": 12, | | 269 | "type": "spacing", | | 270 | "speaker_id": "speaker_0" | | 271 | }, | | 272 | { | | 273 | "text": "an", | | 274 | "start": 11.979, | | 275 | "end": 12.079, | | 276 | "type": "word", | | 277 | "speaker_id": "speaker_0" | | 278 | }, | | 279 | { | | 280 | "text": " ", | | 281 | "start": 12.059, | | 282 | "end": 12.179, | | 283 | "type": "spacing", | | 284 | "speaker_id": "speaker_0" | | 285 | }, | | 286 | { | | 287 | "text": "intimate", | | 288 | "start": 12.179, | | 289 | "end": 12.579, | | 290 | "type": "word", | | 291 | "speaker_id": "speaker_0" | | 292 | }, | | 293 | { | | 294 | "text": " ", | | 295 | "start": 12.559, | | 296 | "end": 12.699, | | 297 | "type": "spacing", | | 298 | "speaker_id": "speaker_0" | | 299 | }, | | 300 | { | | 301 | "text": "feel", | | 302 | "start": 12.679, | | 303 | "end": 13.159, | | 304 | "type": "word", | | 305 | "speaker_id": "speaker_0" | | 306 | }, | | 307 | { | | 308 | "text": " ", | | 309 | "start": 13.139, | | 310 | "end": 13.179, | | 311 | "type": "spacing", | | 312 | "speaker_id": "speaker_0" | | 313 | }, | | 314 | { | | 315 | "text": "to", | | 316 | "start": 13.159, | | 317 | "end": 13.26, | | 318 | "type": "word", | | 319 | "speaker_id": "speaker_0" | | 320 | }, | | 321 | { | | 322 | "text": " ", | | 323 | "start": 13.239, | | 324 | "end": 13.3, | | 325 | "type": "spacing", | | 326 | "speaker_id": "speaker_0" | | 327 | }, | | 328 | { | | 329 | "text": "your", | | 330 | "start": 13.299, | | 331 | "end": 13.399, | | 332 | "type": "word", | | 333 | "speaker_id": "speaker_0" | | 334 | }, | | 335 | { | | 336 | "text": " ", | | 337 | "start": 13.379, | | 338 | "end": 13.479, | | 339 | "type": "spacing", | | 340 | "speaker_id": "speaker_0" | | 341 | }, | | 342 | { | | 343 | "text": "narrative", | | 344 | "start": 13.479, | | 345 | "end": 13.889, | | 346 | "type": "word", | | 347 | "speaker_id": "speaker_0" | | 348 | }, | | 349 | { | | 350 | "text": " ", | | 351 | "start": 13.919, | | 352 | "end": 13.939, | | 353 | "type": "spacing", | | 354 | "speaker_id": "speaker_0" | | 355 | }, | | 356 | { | | 357 | "text": "projects.", | | 358 | "start": 13.919, | | 359 | "end": 14.779, | | 360 | "type": "word", | | 361 | "speaker_id": "speaker_0" | | 362 | } | | 363 | ] | | 364 | } | `
The output is classified in three category types:
* `word` - A word in the language of the audio
* `spacing` - The space between words, not applicable for languages that don’t use spaces like Japanese, Mandarin, Thai, Lao, Burmese and Cantonese
* `audio_event` - Non-speech sounds like laughter or applause
Models
------
[Scribe v1\
\
State-of-the-art speech recognition model\
\
Accurate transcription in 99 languages\
\
Precise word-level timestamps\
\
Speaker diarization\
\
Dynamic audio tagging](https://elevenlabs.io/docs/overview/models#scribe-v1)
[Scribe v2 Realtime\
\
Real-time speech recognition model\
\
Accurate transcription in 90 languages\
\
Real-time transcription\
\
Low latency (~150ms†)\
\
Precise word-level timestamps](https://elevenlabs.io/docs/overview/models#scribe-v2-realtime)
[Explore all](https://elevenlabs.io/docs/overview/models)
Concurrency and priority
------------------------
Concurrency is the concept of how many requests can be processed at the same time.
For Speech to Text, files that are over 8 minutes long are transcribed in parallel internally in order to speed up processing. The audio is chunked into four segments to be transcribed concurrently.
You can calculate the concurrency limit with the following calculation:
Concurrency\=min(4,round\_up(audio\_duration\_secs480))Concurrency = \\min(4, \\text{round\\\_up}(\\frac{\\text{audio\\\_duration\\\_secs}}{480}))Concurrency\=min(4,round\_up(480audio\_duration\_secs))
For example, a 15 minute audio file will be transcribed with a concurrency of 2, while a 120 minute audio file will be transcribed with a concurrency of 4.
The above calculation is only applicable to Scribe v1. For Scribe v2 Realtime, see the [concurrency limit chart](https://elevenlabs.io/docs/overview/models#concurrency-and-priority)
.
Supported languages
-------------------
The Scribe v1 model supports 99 languages, including:
_Afrikaans (afr), Amharic (amh), Arabic (ara), Armenian (hye), Assamese (asm), Asturian (ast), Azerbaijani (aze), Belarusian (bel), Bengali (ben), Bosnian (bos), Bulgarian (bul), Burmese (mya), Cantonese (yue), Catalan (cat), Cebuano (ceb), Chichewa (nya), Croatian (hrv), Czech (ces), Danish (dan), Dutch (nld), English (eng), Estonian (est), Filipino (fil), Finnish (fin), French (fra), Fulah (ful), Galician (glg), Ganda (lug), Georgian (kat), German (deu), Greek (ell), Gujarati (guj), Hausa (hau), Hebrew (heb), Hindi (hin), Hungarian (hun), Icelandic (isl), Igbo (ibo), Indonesian (ind), Irish (gle), Italian (ita), Japanese (jpn), Javanese (jav), Kabuverdianu (kea), Kannada (kan), Kazakh (kaz), Khmer (khm), Korean (kor), Kurdish (kur), Kyrgyz (kir), Lao (lao), Latvian (lav), Lingala (lin), Lithuanian (lit), Luo (luo), Luxembourgish (ltz), Macedonian (mkd), Malay (msa), Malayalam (mal), Maltese (mlt), Mandarin Chinese (zho), Māori (mri), Marathi (mar), Mongolian (mon), Nepali (nep), Northern Sotho (nso), Norwegian (nor), Occitan (oci), Odia (ori), Pashto (pus), Persian (fas), Polish (pol), Portuguese (por), Punjabi (pan), Romanian (ron), Russian (rus), Serbian (srp), Shona (sna), Sindhi (snd), Slovak (slk), Slovenian (slv), Somali (som), Spanish (spa), Swahili (swa), Swedish (swe), Tamil (tam), Tajik (tgk), Telugu (tel), Thai (tha), Turkish (tur), Ukrainian (ukr), Umbundu (umb), Urdu (urd), Uzbek (uzb), Vietnamese (vie), Welsh (cym), Wolof (wol), Xhosa (xho) and Zulu (zul)._
### Breakdown of language support
Word Error Rate (WER) is a key metric used to evaluate the accuracy of transcription systems. It measures how many errors are present in a transcript compared to a reference transcript. Below is a breakdown of the WER for each language that Scribe v1 supports.
###### Excellent (≤ 5% WER)
Bulgarian (bul), Catalan (cat), Czech (ces), Danish (dan), Dutch (nld), English (eng), Finnish (fin), French (fra), Galician (glg), German (deu), Greek (ell), Hindi (hin), Indonesian (ind), Italian (ita), Japanese (jpn), Kannada (kan), Malay (msa), Malayalam (mal), Macedonian (mkd), Norwegian (nor), Polish (pol), Portuguese (por), Romanian (ron), Russian (rus), Serbian (srp), Slovak (slk), Spanish (spa), Swedish (swe), Turkish (tur), Ukrainian (ukr) and Vietnamese (vie).
###### High Accuracy (>5% to ≤10% WER)
Bengali (ben), Belarusian (bel), Bosnian (bos), Cantonese (yue), Estonian (est), Filipino (fil), Gujarati (guj), Hungarian (hun), Kazakh (kaz), Latvian (lav), Lithuanian (lit), Mandarin (cmn), Marathi (mar), Nepali (nep), Odia (ori), Persian (fas), Slovenian (slv), Tamil (tam) and Telugu (tel)
###### Good (>10% to ≤25% WER)
Afrikaans (afr), Arabic (ara), Armenian (hye), Assamese (asm), Asturian (ast), Azerbaijani (aze), Burmese (mya), Cebuano (ceb), Croatian (hrv), Georgian (kat), Hausa (hau), Hebrew (heb), Icelandic (isl), Javanese (jav), Kabuverdianu (kea), Korean (kor), Kyrgyz (kir), Lingala (lin), Maltese (mlt), Mongolian (mon), Māori (mri), Occitan (oci), Punjabi (pan), Sindhi (snd), Swahili (swa), Tajik (tgk), Thai (tha), Urdu (urd), Uzbek (uzb) and Welsh (cym).
###### Moderate (>25% to ≤50% WER)
Amharic (amh), Chichewa (nya), Fulah (ful), Ganda (lug), Igbo (ibo), Irish (gle), Khmer (khm), Kurdish (kur), Lao (lao), Luxembourgish (ltz), Luo (luo), Northern Sotho (nso), Pashto (pus), Shona (sna), Somali (som), Umbundu (umb), Wolof (wol), Xhosa (xho) and Zulu (zul).
FAQ
---
###### Can I use speech to text with video files?
Yes, the API supports uploading both audio and video files for transcription.
###### What are the file size and duration limits?
Files up to 3 GB in size and up to 10 hours in duration are supported.
###### Which audio and video formats are supported?
The audio supported audio formats include:
* audio/aac
* audio/x-aac
* audio/x-aiff
* audio/ogg
* audio/mpeg
* audio/mp3
* audio/mpeg3
* audio/x-mpeg-3
* audio/opus
* audio/wav
* audio/x-wav
* audio/webm
* audio/flac
* audio/x-flac
* audio/mp4
* audio/aiff
* audio/x-m4a
Supported video formats include:
* video/mp4
* video/x-msvideo
* video/x-matroska
* video/quicktime
* video/x-ms-wmv
* video/x-flv
* video/webm
* video/mpeg
* video/3gpp
###### When will you support more languages?
ElevenLabs is constantly expanding the number of languages supported by our models. Please check back frequently for updates.
###### Does speech to text API support webhooks?
Yes, asynchronous transcription results can be sent to webhooks configured in webhook settings in the UI. Learn more in the [webhooks cookbook](https://elevenlabs.io/docs/developers/guides/cookbooks/speech-to-text/webhooks)
.
###### Is a multichannel transcription mode supported?
Yes, the multichannel STT feature allows you to transcribe audio where each channel is processed independently and assigned a speaker ID based on its channel number. This feature supports up to 5 channels. Learn more in the [multichannel transcription cookbook](https://elevenlabs.io/docs/developers/guides/cookbooks/speech-to-text/multichannel-transcription)
.
###### How does billing work for speech to text?
ElevenLabs charges for speech to text based on the duration of the audio sent for transcription. Billing is calculated per hour of audio, with rates varying by tier and model. See the [pricing section](https://elevenlabs.io/docs/overview/capabilities/speech-to-text#pricing)
above for detailed pricing information.
[](https://elevenlabs.io/docs)
[Login](https://elevenlabs.io/docs/overview/capabilities/speech-to-text)
[Login](https://elevenlabs.io/docs/overview/capabilities/speech-to-text)
[Community](https://discord.gg/elevenlabs)
[Blog](https://elevenlabs.io/blog)
[Help Center](https://help.elevenlabs.io/)
[API Pricing](https://elevenlabs.io/pricing/api)
[Sign up](https://elevenlabs.io/sign-up)
---