> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt. # Modellen > Learn about the models that power the ElevenLabs API. ## Toonaangevende modellen ### Text to Speech #### [Eleven v4](/docs/nl/overview/models#eleven-v4) Ons meest emotionele spraaksynthesemodel van hoge kwaliteit Uitzonderlijke mogelijkheden voor stemklonen Ondersteunt meer dan 90 talen Limiet van 10.000 tekens Ondersteuning voor natuurlijke dialogen met meerdere sprekers #### [Eleven v4 Turbo](/docs/nl/overview/models#eleven-v4-turbo) Ons meest emotionele spraaksynthesemodel voor realtime gebruik Ultralage latentie (mediane inferentielatentie van \~100 ms†) Uitzonderlijke mogelijkheden voor stemklonen Ondersteunt meer dan 90 talen Audiotags voor nauwkeurige controle #### [Eleven v3](/docs/nl/overview/models#eleven-v3) Ons emotioneel rijke, expressieve spraaksynthesemodel Dramatische voordracht en uitvoering Ondersteunt meer dan 70 talen Limiet van 5.000 tekens Ondersteuning voor natuurlijke dialogen met meerdere sprekers #### [Eleven v3 Conversational](/docs/nl/overview/models#eleven-v3-conversational) Ons expressieve spraaksynthesemodel voor realtime gebruik Lage latentie (\~280 ms) Dramatische voordracht en uitvoering Ondersteunt meer dan 70 talen Audiotags voor nauwkeurige controle #### [Eleven Multilingual v2](/docs/nl/overview/models#multilingual-v2) Levensecht spraaksynthesemodel met consistente kwaliteit Natuurlijk klinkende uitvoer Ondersteunt 29 talen Limiet van 10.000 tekens Meest stabiel bij lange generaties #### [Eleven Flash v2.5](/docs/nl/overview/models#flash-v25) Ons snelle, betaalbare spraaksynthesemodel Ultralage latentie (\~75 ms†) Ondersteunt 32 talen Limiet van 40.000 tekens Sneller model, 50% lagere prijs per teken voor API-generaties ### Speech to Text #### [Scribe v2](/docs/nl/overview/models#scribe-v2) Toonaangevend model voor spraakherkenning Nauwkeurige transcriptie in meer dan 90 talen Keyterm-prompting, tot 1000 termen Entiteitsdetectie, 65 entiteitstypen Transcript bewerken met instructies in natuurlijke taal Nauwkeurige tijdstempels op woordniveau Sprekerdiarisatie, tot 32 sprekers Dynamische audiotagging Slimme taaldetectie #### [Scribe v2 Realtime](/docs/nl/overview/models#scribe-v2-realtime) Realtime model voor spraakherkenning Nauwkeurige transcriptie in meer dan 90 talen Transscriptie in realtime Lage latentie (\~150ms†) Nauwkeurige tijdstempels op woordniveau Entiteitsdetectie, 65 entiteitstypen Transcript bewerken met instructies in natuurlijke taal #### [Scribe v2 Medical](/docs/nl/overview/models#scribe-v2-medical) Spraakherkenning gefinetuned voor klinische audio 35% minder transcriptiefouten bij klinische audio dan Scribe v2 Dezelfde nauwkeurigheid bij alledaagse spraak als Scribe v2 Dezelfde functies, talen, prijzen en API als Scribe v2 ### Muziek #### [Eleven Music v2.5](/docs/nl/overview/models#eleven-music) Ons meest geavanceerde მუსiekmodel Verbeterde kwaliteit en nauwkeurigere opvolging van prompts Rijkere melodieën, diepere arrangementen en meer gelaagde instrumenten. Dezelfde workflows en ondersteuning: compositieplannen, audioreferentie en inpainting #### [Eleven Music v2](/docs/nl/overview/models#eleven-music) Muziek van studiokwaliteit met prompts in natuurlijke taal, in elke stijl Volledige controle over genre, stijl en structuur Zang of alleen instrumentaal Meertalig, waaronder Engels, Spaans, Duits, Japans en meer Bewerk het geluid en de songtekst van afzonderlijke delen of het hele nummer [Prijzen](https://elevenlabs.io/pricing/api) ## Overzicht van modellen De ElevenLabs API biedt een reeks audiomodellen die zijn geoptimaliseerd voor verschillende gebruikssituaties, kwaliteitsniveaus en prestatievereisten. | Model-ID | Beschrijving | Talen | | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `eleven_v4` | Ons spraaksynthesemodel met de rijkste emotionele expressie | [Meer dan 90 talen](/docs/nl/overview/models#supported-languages) | | `eleven_v4_turbo` | Ons meest expressieve spraaksynthesemodel voor realtimegebruik (\~100ms†) | [Meer dan 90 talen](/docs/nl/overview/models#supported-languages) | | `eleven_v3` | Mensachtige en expressieve spraakgeneratie | [Meer dan 70 talen](/docs/nl/overview/models#supported-languages-2) | | `eleven_v3_conversational` | Ons meest expressieve spraaksynthesemodel voor realtimegebruik (\~280ms†) | [Meer dan 70 talen](/docs/nl/overview/models#supported-languages-2) | | `eleven_ttv_v3` | Mensachtig en expressief stemontwerpmodel (Text to Voice) | [Meer dan 70 talen](/docs/nl/overview/models#supported-languages-2) | | `eleven_multilingual_v2` | Ons levensechte model met rijke emotionele expressie | `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` | Ultrasnel model geoptimaliseerd voor realtimegebruik (\~75ms†) | Alle talen van `eleven_multilingual_v2` plus: `hu`, `no`, `vi` | | `eleven_flash_v2` | Ultrasnel model geoptimaliseerd voor realtimegebruik (\~75ms†) | `en` | | `eleven_multilingual_sts_v2` | Toonaangevend meertalig 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` | Toonaangevend meertalig stemontwerpmodel (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` | Voice Changer-model alleen voor Engels (Speech to Speech) | `en` | | `scribe_v2_realtime` | Spraakherkenningsmodel voor realtimegebruik | [Meer dan 90 talen](/docs/nl/overview/capabilities/speech-to-text#supported-languages) | | `scribe_v2_medical` | Spraakherkenning gefinetuned voor klinische audio | [Meer dan 90 talen](/docs/nl/overview/capabilities/speech-to-text#supported-languages) | | `scribe_v2` | Toonaangevend spraakherkenningsmodel | [Meer dan 90 talen](/docs/nl/overview/capabilities/speech-to-text#supported-languages) | | `scribe_v2_medical` | Spraakherkenningsmodel gespecialiseerd in medische en klinische audio | [Meer dan 90 talen](/docs/nl/overview/capabilities/speech-to-text#supported-languages) | | `eleven_text_to_sound_v2` | Geluidseffecten genereren op basis van tekstprompts | N.v.t. | | `music_v2_5` | Ons meest geavanceerde muziekmodel. Generatie van studiokwaliteit op basis van tekstprompts, compositieplannen en eerder gegenereerde nummers, met betere kwaliteit en promptnauwkeurigheid dan `music_v2` | `en`, `es`, `de`, `ja` en meer | | `music_v2` | Muziekgeneratie van studiokwaliteit op basis van tekstprompts, compositieplannen en eerder gegenereerde nummers | `en`, `es`, `de`, `ja` en meer | | `music_v1` | Muziekgeneratie van studiokwaliteit op basis van tekstprompts. Overtroffen door `music_v2` en `music_v2_5` | `en`, `es`, `de`, `ja` en meer | † Exclusief applicatie- en netwerklatentie ### Verouderde modellen > **Warning** > > De modellen `eleven_turbo_v2_5` en `eleven_turbo_v2` zijn functioneel gelijk aan respectievelijk > de modellen `eleven_flash_v2_5` en `eleven_flash_v2`, behalve dat de latentie van de Flash- > modellen gemiddeld lager is. We raden aan om in alle gebruikssituaties Flash-modellen te gebruiken > in plaats van Turbo-modellen. | Model-ID | Beschrijving | Talen | Voorgesteld vervangend model | | ------------------- | -------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | | `eleven_turbo_v2_5` | Low-latencymodel van de eerste generatie (overtroffen door Flash-modellen) | `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_flash_v2_5` | | `eleven_turbo_v2` | Low-latencymodel van de eerste generatie (overtroffen door Flash-modellen) | `en` | `eleven_flash_v2` | | `scribe_v1` | Spraakherkenning van de eerste generatie (overtroffen door v2-modellen) | [Meer dan 90 talen](/docs/nl/overview/capabilities/speech-to-text#supported-languages) | `scribe_v2` | ## Eleven v4 Eleven v4 is ons toonaangevende spraaksynthesemodel en levert audio van onze hoogste kwaliteit, expressiviteit en controle over de manier waarop stemmen worden uitgevoerd. Eleven v4 ondersteunt stemklonen met hoge natuurgetrouwheid en behoudt de spreker betrouwbaar bij het genereren van lange teksten. Dit model werkt goed in de volgende scenario's: * **Character voice-overs**: Ideaal voor games en animatie dankzij het emotionele bereik. * **Emotionele dialogen**: Genereer natuurlijke, levensechte dialogen met een groot emotioneel bereik en contextueel begrip. * **Luisterboekproductie**: Perfect voor lange vertelteksten met complexe emotionele uitvoering. * **Meertalige projecten**: Behoudt consistente stemkwaliteit bij het wisselen van taal. Eleven v4 is beschikbaar via de [Text to Dialogue API](/docs/nl/api-reference/text-to-dialogue/convert). ### Ondersteunde talen De Eleven v4-modelfamilie ondersteunt meer dan 90 talen, waaronder: *Afrikaans (af), Arabisch (ar), Armeens (hy), Assamees (as), Asturisch (ast), Azerbeidzjaans (az), Belarussisch (be), Bengaals (bn), Bosnisch (bs), Bulgaars (bg), Birmaans (my), Kantonees (yue), Catalaans (ca), Cebuano (ceb), Kroatisch (hr), Tsjechisch (cs), Deens (da), Nederlands (nl), Engels (en), Estisch (et), Filipijns (fil), Fins (fi), Frans (fr), Galicisch (gl), Georgisch (ka), Duits (de), Grieks (el), Gujarati (gu), Hausa (ha), Hebreeuws (he), Hindi (hi), Hongaars (hu), IJslands (is), Indonesisch (id), Iers (ga), Italiaans (it), Japans (ja), Javaans (jv), Kannada (kn), Kazachs (kk), Koreaans (ko), Kirgizisch (ky), Lets (lv), Lingala (ln), Litouws (lt), Luxemburgs (lb), Macedonisch (mk), Maleis (ms), Malayalam (ml), Maltees (mt), Mandarijn-Chinees (zh), Māori (mi), Marathi (mr), Mongools (mn), Nepalees (ne), Noors (no), Occitaans (oc), Odia (or), Pasjtoe (ps), Perzisch (fa), Pools (pl), Portugees (pt), Punjabi (pa), Roemeens (ro), Russisch (ru), Servisch (sr), Sindhi (sd), Slowaaks (sk), Sloveens (sl), Somalisch (so), Spaans (es), Swahili (sw), Zweeds (sv), Tadzjieks (tg), Tamil (ta), Telugu (te), Thais (th), Turks (tr), Oekraïens (uk), Urdu (ur), Oezbeeks (uz), Vietnamees (vi), Welsh (cy), Yoruba (yo).* > **Note** > > De parameter `language_code` accepteert [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1)- > codes van twee letters voor de meeste talen. Talen zonder een ISO 639-1-code gebruiken [ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3)-codes van drie letters: Asturisch (`ast`), Kantonees > (`yue`), Cebuano (`ceb`) en Filipijns (`fil`). ## Eleven v4 Turbo Eleven v4 Turbo is ons toonaangevende model voor realtime spraaksynthese en levert audio van hoge kwaliteit, expressiviteit en controle over de manier waarop stemmen worden uitgevoerd. Eleven v4 Turbo ondersteunt stemklonen met hoge natuurgetrouwheid en levert resultaten met een mediane inferentielatentie van \~100 ms. Dit model werkt goed in de volgende scenario's: * **Supportagents**: Voorzie stemagents die klantvragen in realtime oplossen van spraak. * **AI-assistenten**: Genereer natuurlijke, levensechte dialogen met een groot emotioneel bereik en contextueel begrip. * **Interactieve personages**: Uitstekend voor audio-ervaringen met expressieve personages. Eleven v4 Turbo is beschikbaar via de [Text to Dialogue websocket](/docs/nl/eleven-api/guides/how-to/websockets/realtime-tdd). ### Ondersteunde talen De Eleven v4-modelfamilie ondersteunt meer dan 90 talen, waaronder: *Afrikaans (af), Arabisch (ar), Armeens (hy), Assamees (as), Asturisch (ast), Azerbeidzjaans (az), Belarussisch (be), Bengaals (bn), Bosnisch (bs), Bulgaars (bg), Birmaans (my), Kantonees (yue), Catalaans (ca), Cebuano (ceb), Kroatisch (hr), Tsjechisch (cs), Deens (da), Nederlands (nl), Engels (en), Estisch (et), Filipijns (fil), Fins (fi), Frans (fr), Galicisch (gl), Georgisch (ka), Duits (de), Grieks (el), Gujarati (gu), Hausa (ha), Hebreeuws (he), Hindi (hi), Hongaars (hu), IJslands (is), Indonesisch (id), Iers (ga), Italiaans (it), Japans (ja), Javaans (jv), Kannada (kn), Kazachs (kk), Koreaans (ko), Kirgizisch (ky), Lets (lv), Lingala (ln), Litouws (lt), Luxemburgs (lb), Macedonisch (mk), Maleis (ms), Malayalam (ml), Maltees (mt), Mandarijn-Chinees (zh), Māori (mi), Marathi (mr), Mongools (mn), Nepalees (ne), Noors (no), Occitaans (oc), Odia (or), Pasjtoe (ps), Perzisch (fa), Pools (pl), Portugees (pt), Punjabi (pa), Roemeens (ro), Russisch (ru), Servisch (sr), Sindhi (sd), Slowaaks (sk), Sloveens (sl), Somalisch (so), Spaans (es), Swahili (sw), Zweeds (sv), Tadzjieks (tg), Tamil (ta), Telugu (te), Thais (th), Turks (tr), Oekraïens (uk), Urdu (ur), Oezbeeks (uz), Vietnamees (vi), Welsh (cy), Yoruba (yo).* > **Note** > > De parameter `language_code` accepteert [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1)- > codes van twee letters voor de meeste talen. Talen zonder een ISO 639-1-code gebruiken [ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3)-codes van drie letters: Asturisch (`ast`), Kantonees > (`yue`), Cebuano (`ceb`) en Filipijns (`fil`). ## Eleven v3 Eleven v3 is ons spraaksynthesemodel van de vorige generatie dat natuurlijke, levensechte spraak produceert met een groot emotioneel bereik en contextueel begrip in meerdere talen. Met Eleven v3 komt een nieuwe Text to Dialogue API, waarmee je natuurlijke, levensechte dialogen kunt genereren met een groot emotioneel bereik en contextueel begrip in meerdere talen. Je kunt Eleven v3 ook gebruiken met de Text to Speech API om natuurlijke, levensechte spraak te genereren met een groot emotioneel bereik en contextueel begrip in meerdere talen. Lees [hier](/docs/nl/overview/capabilities/text-to-dialogue) meer over de Text to Dialogue API. ### Ondersteunde talen Het Eleven v3-model ondersteunt meer dan 70 talen, waaronder: *Afrikaans (af), Arabisch (ar), Armeens (hy), Assamees (as), Asturisch (ast), Azerbeidzjaans (az), Belarussisch (be), Bengaals (bn), Bosnisch (bs), Bulgaars (bg), Birmaans (my), Kantonees (yue), Catalaans (ca), Cebuano (ceb), Chichewa (ny), Kroatisch (hr), Tsjechisch (cs), Deens (da), Nederlands (nl), Engels (en), Estisch (et), Filipijns (fil), Fins (fi), Frans (fr), Galicisch (gl), Georgisch (ka), Duits (de), Grieks (el), Gujarati (gu), Hausa (ha), Hebreeuws (he), Hindi (hi), Hongaars (hu), IJslands (is), Indonesisch (id), Iers (ga), Italiaans (it), Japans (ja), Javaans (jv), Kannada (kn), Kazachs (kk), Kirgizisch (ky), Koreaans (ko), Lets (lv), Lingala (ln), Litouws (lt), Luxemburgs (lb), Macedonisch (mk), Maleis (ms), Malayalam (ml), Maltees (mt), Mandarijn-Chinees (zh), Māori (mi), Marathi (mr), Mongools (mn), Nepalees (ne), Noors (no), Occitaans (oc), Odia (or), Pasjtoe (ps), Perzisch (fa), Pools (pl), Portugees (pt), Punjabi (pa), Roemeens (ro), Russisch (ru), Servisch (sr), Sindhi (sd), Slowaaks (sk), Sloveens (sl), Somalisch (so), Spaans (es), Swahili (sw), Zweeds (sv), Tadzjieks (tg), Tamil (ta), Telugu (te), Thais (th), Turks (tr), Oekraïens (uk), Urdu (ur), Oezbeeks (uz), Vietnamees (vi), Welsh (cy), Yoruba (yo).* > **Note** > > De parameter `language_code` accepteert [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1)- > codes van twee letters voor de meeste talen. Talen zonder een ISO 639-1-code gebruiken [ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3)-codes van drie letters: Asturisch (`ast`), Kantonees > (`yue`), Cebuano (`ceb`) en Filipijns (`fil`). ## Eleven v3 Conversational Eleven v3 Conversational is ons model van de vorige generatie voor realtime spraaksynthese. Het produceert natuurlijke, levensechte spraak met een groot emotioneel bereik en contextueel begrip in meerdere talen. Met Eleven v3 Conversational komt een nieuwe Text to Dialogue WebSocket, waarmee je natuurlijke, levensechte dialogen kunt genereren met een groot emotioneel bereik en contextueel begrip in meerdere talen. Met Eleven v3 Conversational komt een nieuwe Text to Dialogue WebSocket, waarmee je natuurlijke, levensechte dialogen kunt genereren met een groot emotioneel bereik en contextueel begrip in meerdere talen. Lees [hier](/docs/nl/eleven-api/guides/how-to/websockets/realtime-tdd) meer over de Text to Dialogue WebSocket. ### Ondersteunde talen Het Eleven v3-model ondersteunt meer dan 70 talen, waaronder: *Afrikaans (af), Arabisch (ar), Armeens (hy), Assamees (as), Asturisch (ast), Azerbeidzjaans (az), Belarussisch (be), Bengaals (bn), Bosnisch (bs), Bulgaars (bg), Birmaans (my), Kantonees (yue), Catalaans (ca), Cebuano (ceb), Chichewa (ny), Kroatisch (hr), Tsjechisch (cs), Deens (da), Nederlands (nl), Engels (en), Estisch (et), Filipijns (fil), Fins (fi), Frans (fr), Galicisch (gl), Georgisch (ka), Duits (de), Grieks (el), Gujarati (gu), Hausa (ha), Hebreeuws (he), Hindi (hi), Hongaars (hu), IJslands (is), Indonesisch (id), Iers (ga), Italiaans (it), Japans (ja), Javaans (jv), Kannada (kn), Kazachs (kk), Kirgizisch (ky), Koreaans (ko), Lets (lv), Lingala (ln), Litouws (lt), Luxemburgs (lb), Macedonisch (mk), Maleis (ms), Malayalam (ml), Maltees (mt), Mandarijn-Chinees (zh), Māori (mi), Marathi (mr), Mongools (mn), Nepalees (ne), Noors (no), Occitaans (oc), Odia (or), Pasjtoe (ps), Perzisch (fa), Pools (pl), Portugees (pt), Punjabi (pa), Roemeens (ro), Russisch (ru), Servisch (sr), Sindhi (sd), Slowaaks (sk), Sloveens (sl), Somalisch (so), Spaans (es), Swahili (sw), Zweeds (sv), Tadzjieks (tg), Tamil (ta), Telugu (te), Thais (th), Turks (tr), Oekraïens (uk), Urdu (ur), Oezbeeks (uz), Vietnamees (vi), Welsh (cy), Yoruba (yo).* > **Note** > > De parameter `language_code` accepteert [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1)- > codes van twee letters voor de meeste talen. Talen zonder een ISO 639-1-code gebruiken [ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3)-codes van drie letters: Asturisch (`ast`), Kantonees > (`yue`), Cebuano (`ceb`) en Filipijns (`fil`). ## Multilingual v2 Eleven Multilingual v2 is een emotiebewust spraaksynthesemodel van de vorige generatie. Het produceert natuurlijke, levensechte spraak met een groot emotioneel bereik en contextueel begrip in meerdere talen. Het model levert consistente stemkwaliteit en persoonlijkheid in alle ondersteunde talen, terwijl de unieke kenmerken en het accent van de spreker behouden blijven. Dit model blinkt uit in scenario's die hoogwaardige, emotioneel genuanceerde spraak vereisen: * **Character voice-overs**: Ideaal voor games en animatie dankzij het emotionele bereik. * **Professionele content**: Zeer geschikt voor bedrijfsvideo's en e-learningmateriaal. * **Meertalige projecten**: Behoudt consistente stemkwaliteit bij het wisselen van taal. * **Stabiele kwaliteit**: Produceert consistente audio-output van hoge kwaliteit. Hoewel de latentie en kosten per teken hoger zijn dan bij Flash-modellen, levert dit model superieure kwaliteit voor projecten waarin levensechte spraak belangrijk is. Onze meertalige v2-modellen ondersteunen 29 talen: *Engels (VS, VK, Australië, Canada), Japans, Chinees, Duits, Hindi, Frans (Frankrijk, Canada), Koreaans, Portugees (Brazilië, Portugal), Italiaans, Spaans (Spanje, Mexico), Indonesisch, Nederlands, Turks, Filipijns, Pools, Zweeds, Bulgaars, Roemeens, Arabisch (Saoedi-Arabië, VAE), Tsjechisch, Grieks, Fins, Kroatisch, Maleis, Slowaaks, Deens, Tamil, Oekraïens & Russisch.* ## Flash v2.5 Eleven Flash v2.5 is ons snelste spraaksynthesemodel, ontworpen voor realtime applicaties en Agents Platform. Het levert hoogwaardige spraak met ultralage latentie (\~75ms†) in 32 talen. Het model combineert snelheid en kwaliteit, waardoor het ideaal is voor interactieve applicaties. Daarbij behoudt het natuurlijk klinkende output en consistente stemkenmerken in verschillende talen. Dit model is bijzonder geschikt voor: * **Agents Platform**: Perfect voor realtime stemagents en chatbots. * **Interactieve applicaties**: Ideaal voor games en applicaties die direct moeten reageren. * **Verwerking op grote schaal**: Efficiënt voor conversie van grote hoeveelheden tekst naar spraak. Met de lagere prijs voor API-generaties en een latentie van 75 ms is Flash v2.5 de kosteneffectieve optie voor iedereen die snelle, betrouwbare spraaksynthese in meerdere talen nodig heeft. Flash v2.5 ondersteunt 32 talen: alle talen van v2-modellen plus: *Hongaars, Noors & Vietnamees* † Exclusief applicatie- en netwerklatentie ### Aandachtspunten #### Tekstnormalisatie met getallen Wanneer je Flash v2.5 gebruikt, worden getallen standaard mogelijk niet genormaliseerd zoals je verwacht. Telefoonnummers kunnen bijvoorbeeld op een manier worden voorgelezen die niet duidelijk is voor de gebruiker. Datums en valuta worden op vergelijkbare wijze beïnvloed. Standaard is normalisatie uitgeschakeld voor Flash v2.5 om de lage latentie te behouden. Enterprise-klanten kunnen tekstnormalisatie voor v2.5-modellen nu echter inschakelen door de parameter `apply_text_normalization` in je request in te stellen op "on". Het model Multilingual v2 normaliseert getallen beter. Daarom raden we aan dit model te gebruiken voor telefoonnummers en andere gevallen waarin getalnormalisatie belangrijk is. Voor applicaties met lage latentie of voor Agents Platform is het een best practice om je LLM de [tekst te laten normaliseren](/docs/nl/overview/capabilities/text-to-speech/best-practices#text-normalization) voordat je deze doorgeeft aan het TTS-model, of om de parameter `apply_text_normalization` te gebruiken (alleen voor Enterprise-abonnementen bij v2.5-modellen). ## Handleiding voor modelselectie Bekijk de [handleiding voor modelselectie](/docs/nl/eleven-api/choosing-the-right-model) voor advies over welk model het beste past bij je vereisten en use case. #### Vereisten #### Kwaliteit Gebruik `eleven_v4` of `eleven_multilingual_v2` Het beste voor hifi-audio-output met rijke emotionele expressie #### Lage latentie Gebruik `eleven_v4_turbo` Geoptimaliseerd voor realtime-applicaties (\~100 ms latentie) #### Use case #### Contentcreatie Gebruik `eleven_v4` of `eleven_multilingual_v2` Ideaal voor professionele content, luisterboeken en videovoice-overs. #### Agents Platform Gebruik `eleven_v4_turbo`, `eleven_flash_v2_5`, `eleven_flash_v2` of `eleven_multilingual_v2` Perfect voor realtime conversationele applicaties. Gebruik `eleven_v4_turbo` voor de meest expressieve voordracht. #### Voice Changer Gebruik `eleven_multilingual_sts_v2` Gespecialiseerd in Speech-to-Speech-conversie ## Tekenlimieten Het maximale aantal tekens dat wordt ondersteund in één text-to-speech-request verschilt per model. | Model-ID | Tekenlimiet | Geschatte audioduur | | ------------------------ | ----------- | ------------------- | | `eleven_v4` | 10,000 | \~10 minuten | | `eleven_v3` | 5,000 | \~5 minuten | | `eleven_flash_v2_5` | 40,000 | \~40 minuten | | `eleven_flash_v2` | 30,000 | \~30 minuten | | `eleven_multilingual_v2` | 10,000 | \~10 minuten | | `eleven_multilingual_v1` | 10,000 | \~10 minuten | | `eleven_english_sts_v2` | 10,000 | \~10 minuten | | `eleven_english_sts_v1` | 10,000 | \~10 minuten | > **Note** > > Overweeg bij langere content de invoer over meerdere requests te verdelen. ## Scribe v2 Scribe v2 is ons geavanceerde spraakherkenningsmodel, ontworpen voor nauwkeurige transcriptie in meer dan 90 talen. Het biedt nauwkeurige timestamps op woordniveau en geavanceerde functies zoals sprekersdiarisatie en dynamische audiotagging. Dit model blinkt uit in scenario's die nauwkeurige speech-to-text-conversie vereisen: * **Transcriptieservices**: Perfect om audio-/video-content naar tekst om te zetten * **Vergaderdocumentatie**: Ideaal voor het vastleggen en documenteren van gesprekken * **Contentanalyse**: Zeer geschikt voor het verwerken en analyseren van audio-content * **Meertalige herkenning**: Ondersteunt nauwkeurige transcriptie in meer dan 90 talen Belangrijkste functies: * Nauwkeurige transcriptie met timestamps op woordniveau * Sprekersdiarisatie voor audio met meerdere sprekers * Dynamische audiotagging voor extra context * Ondersteuning voor meer dan 90 talen * Entiteitsdetectie * Keyterm prompting * Transcriptbewerking Lees [hier](/docs/nl/overview/capabilities/speech-to-text) meer over Scribe v2. ## Scribe v2 Realtime Scribe v2 Realtime, ons snelste en nauwkeurigste model voor live spraakherkenning, levert geavanceerde nauwkeurigheid in meer dan 90 talen met een ultralage latentie van 150 ms. Dit model blinkt uit in conversationele use cases: * **Live transcriptie van vergaderingen**: Perfect voor realtime transcriptie * **AI-agents**: Ideaal voor live gesprekken * **Meertalige herkenning**: Ondersteunt nauwkeurige transcriptie in meer dan 90 talen met automatische taalherkenning Belangrijkste functies: * Ultralage latentie: ontvang gedeeltelijke transcripties in \~150 milliseconden * Ondersteuning voor streaming: verstuur audio in delen terwijl je transcripties in realtime ontvangt * Meerdere audioformaten: ondersteuning voor PCM (8 kHz tot 48 kHz) en μ-law-codering * Voice Activity Detection (VAD): automatische spraaksegmentatie op basis van stiltedetectie * Handmatige commitcontrole: volledige controle over wanneer transcriptsegmenten worden afgerond * Entiteitsdetectie * Transcriptbewerking Lees [hier](/docs/nl/overview/capabilities/speech-to-text) meer over Scribe v2 Realtime. ## Scribe v2 Medical Scribe v2 Medical is een batch-spraakherkenningsmodel dat is gespecialiseerd in medische en klinische audio. Het is een finetune van Scribe v2 die de herkenning van medicijnnamen, anatomie, pathologie en klinische dicteeropnamen verbetert, terwijl de nauwkeurigheid van Scribe v2 voor alledaagse spraak behouden blijft. Het gebruikt dezelfde Speech to Text API als Scribe v2 en wordt tegen hetzelfde tarief gefactureerd. Geef `scribe_v2_medical` door als `model_id`. > **Note** > > ### Beoogd gebruik > > Scribe v2 Medical is een batchmodel voor de Speech-to-Text API, bedoeld voor ontwikkelaars en > organisaties om te integreren in applicaties die klinische audio, waaronder > zorgverlener-patiëntgesprekken, dicteeropnamen, intake- en zorgcoördinatiegesprekken, omzetten in concept- > transcripten voor documentatie en gerelateerde administratieve workflows. De resulterende tekst is bedoeld > om vóór gebruik te worden beoordeeld en gecorrigeerd door een zorgprofessional of andere geautoriseerde gebruiker. Scribe > v2 Medical is niet bedoeld om klinische informatie te interpreteren of diagnoses, behandelings- > aanbevelingen, klinische beslissingen of andere klinische richtlijnen te geven. Dit model is zeer geschikt voor: * **Klinische documentatie**: Ambient encounters en notities waarin medische termen midden in het gesprek voorkomen * **Dicteren**: Dichte reeksen van medicatie, doseringen en bevindingen * **Intake- en coördinatiegesprekken**: Patiënten die hun eigen aandoeningen beschrijven, vaak telefonisch * **Complianceworkflows**: Combineer met [entiteitsdetectie](/docs/nl/eleven-api/guides/how-to/speech-to-text/batch/entity-detection) voor PHI-categorieën Belangrijkste functies: * Dezelfde requeststructuur als Scribe v2 (`keyterms`, `entity_detection`, `no_verbatim`, diarisatie, timestamps) * Betere herkenning van medicijnnamen en anatomie- en pathologietermen * Geen achteruitgang bij alledaagse spraak ten opzichte van Scribe v2 * Ondersteuning voor meer dan 90 talen * Sprekersdiarisatie voor audio met meerdere sprekers * Dynamische audiotagging * Entiteitsdetectie, waaronder PHI-categorieën Scribe v2 Medical is een batchmodel. Gebruik Scribe v2 Realtime voor live transcriptie. Scribe v2 Medical komt in aanmerking voor HIPAA, met Business Associate Agreements voor Enterprise-klanten en Zero Retention Mode (ZRM). Als ZRM is ingeschakeld, worden audio-invoer en tekstuitvoer direct verwijderd nadat elke request is voltooid. ElevenLabs bewaart niets en je applicatie ontvangt de volledige API-response en bewaart transcripties onder je eigen beheer. > **Info** > > Bedrijven die HIPAA-compliance vereisen, moeten contact opnemen met [ElevenLabs Sales](https://elevenlabs.io/contact-sales) om een Business Associate Agreement (BAA) te ondertekenen voordat > ze beschermde gezondheidsinformatie versturen. Lees [hier](/docs/nl/overview/capabilities/speech-to-text) meer over Speech to Text. ## Eleven Music Eleven Music is ons model voor muziekgeneratie van studiokwaliteit. Hiermee kun je muziek in elke stijl genereren met prompts in natuurlijke taal. Dit model is uitstekend voor de volgende scenario's: * **Gamesoundtracks**: Maak meeslepende soundtracks voor games * **Podcastachtergronden**: Verrijk podcasts met professionele muziek * **Marketing**: Voeg achtergrondmuziek toe aan reclamevideo's Belangrijkste functies: * Volledige controle over genre, stijl en structuur * Zang of alleen instrumentaal * Meertalig, waaronder Engels, Spaans, Duits, Japans en meer * Bewerk het geluid en de songtekst van afzonderlijke delen of het hele nummer Lees [hier](/docs/nl/overview/capabilities/music) meer over Eleven Music. ## Concurrency en prioriteit Je abonnement bepaalt hoeveel requests gelijktijdig kunnen worden verwerkt en het prioriteitsniveau van je requests in de wachtrij. Speech to Text heeft een hogere concurrencylimiet. Zodra de concurrencylimiet is bereikt, worden volgende requests in een wachtrij verwerkt naast requests met een lagere prioriteit. In de praktijk voegt dit doorgaans slechts \~50 ms latentie toe. | Abonnement | Concurrencylimiet (Multilingual v2) | Concurrencylimiet (Flash) | STT-concurrencylimiet | Realtime STT-concurrencylimiet | Music-concurrencylimiet | Prioriteitsniveau | | ---------- | ------------------------------------ | -------------------------- | --------------------- | ------------------------------ | ----------------------- | ----------------- | | Free | 2 | 4 | 8 | 6 | 0 | 3 | | Starter | 3 | 6 | 12 | 9 | 2 | 4 | | Creator | 5 | 10 | 20 | 15 | 2 | 5 | | Pro | 10 | 20 | 40 | 30 | 2 | 5 | | Scale | 15 | 30 | 60 | 45 | 5 | 5 | | Business | 15 | 30 | 60 | 45 | 5 | 5 | | Enterprise | Verhoogd | Verhoogd | Verhoogd | Verhoogd | Hoogste | 6 | > **Note** > > Ontvangers van startup grants krijgen voordelen op Scale-niveau. De responseheaders bevatten `current-concurrent-requests` en `maximum-concurrent-requests`, waarmee je je concurrency kunt monitoren. ### API-requests per minuut versus gelijktijdige requests Het is belangrijk om te begrijpen dat **API-requests per minuut** en **gelijktijdige requests** verschillende statistieken zijn die afhangen van je gebruikspatronen. API-requests per minuut kunnen verschillen van gelijktijdige requests, omdat dit afhangt van de duur van elke request en hoe de requests worden gebundeld. **Voorbeeld 1: Gespreide requests** Als je 180 requests per minuut had die elk 1 seconde duurden en je ze met telkens 0,33 seconde ertussen verstuurde, zouden er maximaal 3 gelijktijdige requests zijn en gemiddeld ook 3, omdat er altijd 3 actief zouden zijn. **Voorbeeld 2: Gebundelde requests** Als je echter een ander gebruikspatroon had, zoals 180 requests per minuut die elk 3 seconden duurden maar allemaal tegelijk werden verstuurd, zouden er maximaal 180 gelijktijdige requests zijn en gemiddeld 9 (in de eerste 3 seconden van de minuut waren er 180 requests tegelijk, in de laatste 57 seconden 0 requests). Omdat ons systeem kijkt naar concurrency, zijn requests per minuut minder belangrijk dan hoe lang elke request duurt en het patroon waarmee ze worden verstuurd. De manier waarop endpointrequests worden gedaan, heeft invloed op concurrencylimieten: * Bij HTTP telt elke request afzonderlijk mee voor je concurrencylimiet. * Bij de Text to Speech WebSocket telt alleen de tijd waarin ons model audio genereert mee voor je concurrencylimiet. Dit betekent dat een open websocket meestal helemaal niet meetelt voor je concurrencylimiet. * De Text to Dialogue WebSockets werken anders: elke open verbinding reserveert één dialoogsessie uit een aparte pool zolang deze open blijft, en audio die via de verbinding wordt gegenereerd telt niet mee voor je standaardconcurrencylimiet. Dit is bedoeld om eenvoudiger te begrijpen: één verbinding is één sessie, en je limieten voor dialoogsessies zijn afgestemd op deze nieuwe methodiek voor concurrency. Zie [Text to Dialogue-concurrency](#text-to-dialogue-concurrency). ### Concurrencylimieten begrijpen De concurrencylimiet van je abonnement moet niet worden geïnterpreteerd als het maximale aantal gelijktijdige gesprekken, telefoongesprekken, voice-overs voor personages enzovoort dat tegelijk kan worden afgehandeld. Het werkelijke aantal hangt af van verschillende factoren, waaronder de specifieke gebruikte AI-stemmen en de kenmerken van de use case. Als algemene vuistregel kan een concurrencylimiet van 5 doorgaans tot ongeveer 100 gelijktijdige audio-uitzendingen ondersteunen. Dit komt door de snelheid waarmee audio wordt gegenereerd ten opzichte van de tijd die nodig is om de TTS-request te verwerken. Het onderstaande diagram is een voorbeeld van hoe 4 gelijktijdige gesprekken met verschillende gebruikers kunnen worden gefaciliteerd terwijl slechts 2 gelijktijdige requests worden gebruikt. ![Concurrencylimieten](/docs/_fern-img/dcc5e3bd18993a9f862bd526f3dc1b32cfa89003a58ded6f4f6a7bda1bd5a2ea.webp) #### AI-spraakagents bouwen Wanneer TTS wordt gebruikt om dialoog mogelijk te maken, kan een concurrencylimiet van 5 ongeveer 100 uitzendingen ondersteunen voor evenwichtige gesprekken tussen AI-agents en menselijke deelnemers. Voor use cases waarin de AI-agent minder vaak spreekt dan de mens, zoals interacties met de klantenservice, kunnen meer dan 100 gelijktijdige gesprekken worden ondersteund. #### Voice-overs voor personages Over het algemeen kunnen meer dan 100 gelijktijdige voice-overs voor personages worden ondersteund met een concurrencylimiet van 5. Het aantal kan variëren afhankelijk van hoe vaak het personage spreekt, de duur van pauzes en acties in de game tussen zinnen. #### Live nasynchronisatie Gelijktijdige nasynchronisatiestreams volgen doorgaans de gegeven vuistregel. Als de uitzending periodes met pauzes in gesprekken bevat (bijvoorbeeld door een soundtrack, visuele scènes enzovoort), zijn mogelijk meer gelijktijdige nasynchronisatiestreams mogelijk dan de aanbeveling aangeeft. Als je op enig moment de concurrencylimieten van je abonnement overschrijdt en je het Enterprise-abonnement hebt, kunnen modelrequests mogelijk nog steeds slagen, zij het langzamer, op basis van best effort en afhankelijk van de beschikbare capaciteit. > **Note** > > Verhoog je concurrencylimiet en wachtrijprioriteit door [je abonnement te upgraden](https://elevenlabs.io/pricing/api). > > Enterprise-klanten kunnen via hun accountmanager een hogere concurrencylimiet aanvragen. ### Text to Dialogue-concurrency Text to Dialogue-requests worden op twee verschillende manieren gemeten, afhankelijk van hoe je de API aanroept: * **HTTP-endpoints** ([Create dialogue](/docs/nl/api-reference/text-to-dialogue/convert) en [Stream dialogue](/docs/nl/api-reference/text-to-dialogue/stream)) tellen mee voor de standaardconcurrencylimiet van je abonnement terwijl audio wordt gegenereerd, net als elke andere Text to Speech-request. * **WebSocket-endpoints** zoals de [Text to Dialogue WebSocket](/docs/nl/api-reference/text-to-dialogue/ttd-websocket) worden gemeten als **dialoogsessies**. Een open verbinding houdt een dialoogsessie bezet zolang deze open blijft, ongeacht of er op dat moment audio wordt gegenereerd. Meting op basis van sessies houdt capaciteitsplanning eenvoudig: één verbinding is één sessie, dus je gebruik fluctueert niet met generatieactiviteit. Omdat een sessie gedurende de hele verbinding bezet blijft in plaats van alleen tijdens het genereren van audio, zijn je limieten voor dialoogsessies afgestemd op deze nieuwe methodiek voor concurrency. | Abonnement | WebSocket-sessies | | ---------- | ----------------- | | Free | 14 | | Starter | 21 | | Creator | 35 | | Pro | 70 | | Scale | 105 | | Business | 105 | | Enterprise | Verhoogd | Als je een verbinding opent terwijl alle dialoogsessies van je workspace in gebruik zijn, wordt de nieuwe verbinding geweigerd met een `too_many_concurrent_requests`-fout. Sluit verbindingen die je niet meer nodig hebt om sessies vrij te maken — een verbinding sluit ook automatisch na 20 seconden inactiviteit, tenzij je `keep_alive`-berichten verstuurt. Om dialoogsessies te monitoren, open je **Developers** onderaan de zijbalk van het dashboard, selecteer je het tabblad **Analytics** en bekijk je de statistiek **Concurrent requests** in de gebruiksweergave. Dialoogsessies worden gerapporteerd als een eigen reeks, **TTD Websocket Sessions**, apart van je andere gelijktijdige requests. ### Concurrencylimieten op schaal testen Testen op schaal kan nuttig zijn om schaalbaarheidsproblemen aan de clientzijde te identificeren en te controleren of concurrencylimieten correct zijn ingesteld voor je use case. Het wordt sterk aanbevolen om end-to-end-workflows zo dicht mogelijk bij werkelijk gebruik te testen. Het simuleren en meten van hoeveel gebruikers kunnen worden ondersteund, is hiervoor de aanbevolen methode. Het is belangrijk om: * Gebruikers te simuleren, niet losse requests * Typisch gebruikersgedrag te simuleren, zoals wachten tot het afspelen van audio, spreken door een gebruiker of transcriptie is voltooid voordat je requests doet * Het aantal gebruikers langzaam op te bouwen over een periode van enkele minuten * Variatie aan te brengen in requesttimings en de omvang van requests * Latentiestatistieken en eventuele foutcodes die door de API worden teruggestuurd vast te leggen Om bijvoorbeeld een agentsysteem te testen dat is ontworpen voor 100 gelijktijdige gesprekken, maak je maximaal 100 afzonderlijke "gebruikers" die elk een gesprek simuleren. Gesprekken bestaan doorgaans uit een herhalende cyclus van \~10 seconden waarin de gebruiker spreekt, gevolgd door een TTS API-call voor \~150 tekens, gevolgd door \~10 seconden waarin audio voor de gebruiker wordt afgespeeld. Daarom moet elke gebruiker het patroon volgen om elke 20 seconden een WebSocket Text-to-Speech API-call te doen voor 150 tekens tekst, met een kleine hoeveelheid variatie in de wachttijd en het aantal aangevraagde tekens. De test bestaat uit het starten van één gebruiker per seconde totdat er 100 zijn, en vervolgens in totaal 10 minuten testen om de algehele stabiliteit te testen. #### Voorbeeld van een testscript voor schaal Dit voorbeeld gebruikt [locust](https://locust.io/) als testframework met directe API-calls naar de ElevenLabs API. Het volgt het hierboven genoemde voorbeeld en test een conversationeel agentsysteem waarbij elke gebruiker elke 20 seconden 1 request verstuurt. **`Python`** ```python title="Python" {12} import json import random import time import gevent import locust from locust import User, task, events, constant_throughput import websocket # Averages up to 10 seconds of audio when played, depends on the voice speed DEFAULT_TEXT = ( "Hello, this is a test message. I am testing if a long input will cause issues for the model " "like this sentence. " ) TEXT_ARRAY = [ "Hello.", "Hello, this is a test message.", DEFAULT_TEXT, DEFAULT_TEXT * 2, DEFAULT_TEXT * 3 ] # Custom command line arguments @events.init_command_line_parser.add_listener def on_parser_init(parser): parser.add_argument("--api-key", default="YOUR_API_KEY", help="API key for authentication") parser.add_argument("--encoding", default="mp3_22050_32", help="Encoding") parser.add_argument("--text", default=DEFAULT_TEXT, help="Text to use") parser.add_argument("--use-text-array", default="false", help="Text to use") parser.add_argument("--voice-id", default="aria", help="Text to use") class WebSocketTTSUser(User): # Each user will send a request every 20 seconds, regardless of how long each request takes wait_time = constant_throughput(0.05) def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.api_key = self.environment.parsed_options.api_key self.voice_id = self.environment.parsed_options.voice_id self.text = self.environment.parsed_options.text self.encoding = self.environment.parsed_options.encoding self.use_text_array = self.environment.parsed_options.use_text_array if self.use_text_array: self.text = random.choice(TEXT_ARRAY) self.all_recieved = False @task def tts_task(self): # Do jitter waiting of up to 1 second # Users appear to be spawned every second so this ensures requests are not aligned gevent.sleep(random.random()) max_wait_time = 10 # Connection details uri = f"{self.environment.host}/v1/text-to-speech/{self.voice_id}/stream-input?auto_mode=true&output_format={self.encoding}" headers = {"xi-api-key": self.api_key} ws = None self.all_recieved = False try: init_msg = {"text": " "} # Use proper header format for websocket - this is case sensitive! ws = websocket.create_connection(uri, header=headers) ws.send(json.dumps(init_msg)) # Start measuring after websocket initiated but before any messages are sent send_request_time = time.perf_counter() ws.send(json.dumps({"text": self.text})) # Send to flush and receive the audio ws.send(json.dumps({"text": ""})) def _receive(): t_first_response = None audio_size = 0 try: while True: # Wait up to 10 seconds for a response ws.settimeout(max_wait_time) response = ws.recv() response_data = json.loads(response) if "audio" in response_data and response_data["audio"]: audio_size = audio_size + len(response_data["audio"]) if t_first_response is None: t_first_response = time.perf_counter() first_byte_ms = ( t_first_response - send_request_time ) * 1000 if audio_size is None: # The first response should always have audio locust.events.request.fire( request_type="websocket", name="Bad Response (no audio)", response_time=first_byte_ms, response_length=audio_size, exception=Exception("Response has no audio"), ) break if "isFinal" in response_data and response_data["isFinal"]: # Fire this event once finished streaming, but report the important TTFB metric locust.events.request.fire( request_type="websocket", name="TTS Stream Success (First Byte)", response_time=first_byte_ms, response_length=audio_size, exception=None, ) break except websocket.WebSocketTimeoutException: locust.events.request.fire( request_type="websocket", name="TTS Stream Timeout", response_time=max_wait_time * 1000, response_length=audio_size, exception=Exception("Timeout waiting for response"), ) except Exception as e: # Typically JSON decode error if the server returns HTTP backoff error locust.events.request.fire( request_type="websocket", name="TTS Stream Failure", response_time=0, response_length=0, exception=e, ) finally: self.all_recieved = True gevent.spawn(_receive) # Sleep until recieved so new tasks aren't spawned while not self.all_recieved: gevent.sleep(1) except websocket.WebSocketTimeoutException: locust.events.request.fire( request_type="websocket", name="TTS Stream Timeout", response_time=max_wait_time * 1000, response_length=0, exception=Exception("Timeout waiting for response"), ) except Exception as e: locust.events.request.fire( request_type="websocket", name="TTS Stream Failure", response_time=0, response_length=0, exception=e, ) finally: # Try and close the websocket gracefully try: if ws: ws.close() except Exception: pass ```