> 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. # Modelle > Learn about the models that power the ElevenLabs API. ## Flaggschiffmodelle ### Text to Speech #### [Eleven v4](/docs/de/overview/models#eleven-v4) Unser ausdrucksstärkstes Sprachsynthesemodell mit höchster Qualität Herausragende Funktionen zum Klonen von Stimmen Unterstützt über 90 Sprachen Zeichenlimit von 10.000 Unterstützt natürliche Dialoge mit mehreren Sprechern #### [Eleven v4 Turbo](/docs/de/overview/models#eleven-v4-turbo) Unser ausdrucksstärkstes Sprachsynthesemodell für Echtzeit Extrem niedrige Latenz (mittlere Inferenzlatenz von \~100 ms†) Herausragende Funktionen zum Klonen von Stimmen Unterstützt über 90 Sprachen Audiotags für präzise Steuerung #### [Eleven v3](/docs/de/overview/models#eleven-v3) Unser emotionales, ausdrucksstarkes Sprachsynthesemodell Dramatische Vortragsweise und Darbietung Unterstützt über 70 Sprachen Zeichenlimit von 5.000 Unterstützt natürliche Dialoge mit mehreren Sprechern #### [Eleven v3 Conversational](/docs/de/overview/models#eleven-v3-conversational) Unser ausdrucksstarkes Sprachsynthesemodell für Echtzeit Niedrige Latenz (\~280 ms) Dramatische Vortragsweise und Darbietung Unterstützt über 70 Sprachen Audiotags für präzise Steuerung #### [Eleven Multilingual v2](/docs/de/overview/models#multilingual-v2) Lebensechtes Sprachsynthesemodell mit gleichbleibender Qualität Natürlich klingende Ausgabe Unterstützt 29 Sprachen Zeichenlimit von 10.000 Besonders stabil bei langen Generierungen #### [Eleven Flash v2.5](/docs/de/overview/models#flash-v25) Unser schnelles, kostengünstiges Sprachsynthesemodell Extrem niedrige Latenz (\~75 ms†) Unterstützt 32 Sprachen Zeichenlimit von 40.000 Schnelleres Modell, 50 % niedrigerer Preis pro Zeichen für API-Generierungen ### Speech to Text #### [Scribe v2](/docs/de/overview/models#scribe-v2) Modernstes Spracherkennungsmodell Präzise Transkription in über 90 Sprachen Keyterm-Prompting mit bis zu 1000 Begriffen Entitätserkennung mit 65 Entitätstypen Transkriptbearbeitung mit Anweisungen in natürlicher Sprache Präzise Zeitstempel auf Wortebene Sprecherdiarisierung mit bis zu 32 Sprechern Dynamische Audio-Tagging Intelligente Spracherkennung #### [Scribe v2 Realtime](/docs/de/overview/models#scribe-v2-realtime) Spracherkennungsmodell in Echtzeit Präzise Transkription in über 90 Sprachen Transkription in Echtzeit Geringe Latenz (\~150ms†) Präzise Zeitstempel auf Wortebene Entitätserkennung mit 65 Entitätstypen Transkriptbearbeitung mit Anweisungen in natürlicher Sprache #### [Scribe v2 Medical](/docs/de/overview/models#scribe-v2-medical) Für klinische Audiodaten finetunierte Spracherkennung 35 % weniger Transkriptionsfehler bei klinischen Audiodaten als Scribe v2 Gleiche Genauigkeit bei Alltagssprache wie Scribe v2 Gleiche Funktionen, Sprachen, Preise und API wie Scribe v2 ### Musik #### [Eleven Music v2.5](/docs/de/overview/models#eleven-music) Unser fortschrittlichstes Musikmodell Verbesserte Qualität und Prompt-Treue Reichere Melodien, tiefere Arrangements und mehrschichtige Instrumente. Gleiche Workflows und Unterstützung: Kompositionspläne, Audio-Referenz und Inpainting #### [Eleven Music v2](/docs/de/overview/models#eleven-music) Musik in Studioqualität mit Prompts in natürlicher Sprache in jedem Stil Volle Kontrolle über Genre, Stil und Struktur Gesang oder nur Instrumental Mehrsprachig, einschließlich Englisch, Spanisch, Deutsch, Japanisch und mehr Bearbeiten Sie Sound und Liedtext einzelner Abschnitte oder des ganzen Songs [Preise](https://elevenlabs.io/pricing/api) ## Modellübersicht Die ElevenLabs API bietet eine Reihe von Audiomodellen, die für unterschiedliche Anwendungsfälle, Qualitätsstufen und Leistungsanforderungen optimiert sind. | Modell-ID | Beschreibung | Sprachen | | ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `eleven_v4` | Unser Modell für Sprachsynthese mit dem reichhaltigsten emotionalen Ausdruck | [Über 90 Sprachen](/docs/de/overview/models#supported-languages) | | `eleven_v4_turbo` | Unser ausdrucksstärkstes Modell für Echtzeit-Sprachsynthese (\~100 ms†) | [Über 90 Sprachen](/docs/de/overview/models#supported-languages) | | `eleven_v3` | Menschenähnliche und ausdrucksstarke Sprachgenerierung | [Über 70 Sprachen](/docs/de/overview/models#supported-languages-2) | | `eleven_v3_conversational` | Unser ausdrucksstärkstes Modell für Echtzeit-Sprachsynthese (\~280 ms†) | [Über 70 Sprachen](/docs/de/overview/models#supported-languages-2) | | `eleven_ttv_v3` | Menschenähnliches und ausdrucksstarkes Stimmendesign-Modell (Text to Voice) | [Über 70 Sprachen](/docs/de/overview/models#supported-languages-2) | | `eleven_multilingual_v2` | Unser lebensechtes Modell mit reichhaltigem emotionalem Ausdruck | `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` | Ultraschnelles, für die Echtzeitnutzung optimiertes Modell (\~75 ms†) | Alle Sprachen von `eleven_multilingual_v2` plus: `hu`, `no`, `vi` | | `eleven_flash_v2` | Ultraschnelles, für die Echtzeitnutzung optimiertes Modell (\~75 ms†) | `en` | | `eleven_multilingual_sts_v2` | Modernstes mehrsprachiges Stimmenverzerrer-Modell (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` | Modernstes mehrsprachiges Stimmendesign-Modell (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` | Stimmenverzerrer-Modell nur für Englisch (Speech to Speech) | `en` | | `scribe_v2_realtime` | Modell für Echtzeit-Spracherkennung | [Über 90 Sprachen](/docs/de/overview/capabilities/speech-to-text#supported-languages) | | `scribe_v2_medical` | Für klinische Audiodaten feinabgestimmte Spracherkennung | [Über 90 Sprachen](/docs/de/overview/capabilities/speech-to-text#supported-languages) | | `scribe_v2` | Modernstes Spracherkennungsmodell | [Über 90 Sprachen](/docs/de/overview/capabilities/speech-to-text#supported-languages) | | `scribe_v2_medical` | Auf medizinische und klinische Audiodaten spezialisiertes Spracherkennungsmodell | [Über 90 Sprachen](/docs/de/overview/capabilities/speech-to-text#supported-languages) | | `eleven_text_to_sound_v2` | Generierung von Soundeffekten aus Text-Prompts | Nicht verfügbar | | `music_v2_5` | Unser fortschrittlichstes Musikmodell. Generierung in Studioqualität aus Text-Prompts, Kompositionsplänen und zuvor generierten Songs, mit besserer Qualität und Prompt-Treue als `music_v2` | `en`, `es`, `de`, `ja` und weitere | | `music_v2` | Musikgenerierung in Studioqualität aus Text-Prompts, Kompositionsplänen und zuvor generierten Songs | `en`, `es`, `de`, `ja` und weitere | | `music_v1` | Musikgenerierung in Studioqualität aus Text-Prompts. Überholt von `music_v2` und `music_v2_5` | `en`, `es`, `de`, `ja` und weitere | † Ohne Anwendungs- und Netzwerklatenz ### Veraltete Modelle > **Warning** > > Die Modelle `eleven_turbo_v2_5` und `eleven_turbo_v2` entsprechen funktional den > Modellen `eleven_flash_v2_5` bzw. `eleven_flash_v2`, mit Ausnahme der im Durchschnitt > niedrigeren Latenz der Flash-Modelle. Wir empfehlen, in allen Anwendungsfällen Flash- statt Turbo-Modelle > zu verwenden. | Modell-ID | Beschreibung | Sprachen | Vorgeschlagenes Ersatzmodell | | ------------------- | ---------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | | `eleven_turbo_v2_5` | Modell der ersten Generation mit niedriger Latenz (von Flash-Modellen übertroffen) | `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` | Modell der ersten Generation mit niedriger Latenz (von Flash-Modellen übertroffen) | `en` | `eleven_flash_v2` | | `scribe_v1` | Spracherkennung der ersten Generation (von v2-Modellen übertroffen) | [Über 90 Sprachen](/docs/de/overview/capabilities/speech-to-text#supported-languages) | `scribe_v2` | ## Eleven v4 Eleven v4 ist unser modernstes Modell für Sprachsynthese und liefert Audio in höchster Qualität, Ausdrucksstärke und Kontrolle über die Stimmwiedergabe. Eleven v4 unterstützt hochpräzises KI-Stimme klonen mit zuverlässigem Sprechererhalt bei langen Textgenerierungen. Dieses Modell eignet sich gut für folgende Szenarien: * **Charakter-Voiceovers**: Ideal für Spiele und Animationen dank seiner emotionalen Bandbreite. * **Emotionale Dialoge**: Generieren Sie natürliche, lebensechte Dialoge mit großer emotionaler Bandbreite und Kontextverständnis. * **Hörbuchproduktion**: Perfekt für lange Erzählungen mit komplexem emotionalem Ausdruck. * **Mehrsprachige Projekte**: Bewahrt eine konsistente Stimmqualität bei Sprachwechseln. Eleven v4 ist über die [Text to Dialogue API](/docs/de/api-reference/text-to-dialogue/convert) verfügbar. ### Unterstützte Sprachen Die Modellfamilie Eleven v4 unterstützt über 90 Sprachen, darunter: *Afrikaans (af), Arabisch (ar), Armenisch (hy), Assamesisch (as), Asturisch (ast), Aserbaidschanisch (az), Belarussisch (be), Bengalisch (bn), Bosnisch (bs), Bulgarisch (bg), Birmanisch (my), Kantonesisch (yue), Katalanisch (ca), Cebuano (ceb), Kroatisch (hr), Tschechisch (cs), Dänisch (da), Niederländisch (nl), Englisch (en), Estnisch (et), Filipino (fil), Finnisch (fi), Französisch (fr), Galicisch (gl), Georgisch (ka), Deutsch (de), Griechisch (el), Gujarati (gu), Hausa (ha), Hebräisch (he), Hindi (hi), Ungarisch (hu), Isländisch (is), Indonesisch (id), Irisch (ga), Italienisch (it), Japanisch (ja), Javanisch (jv), Kannada (kn), Kasachisch (kk), Koreanisch (ko), Kirgisisch (ky), Lettisch (lv), Lingala (ln), Litauisch (lt), Luxemburgisch (lb), Mazedonisch (mk), Malaiisch (ms), Malayalam (ml), Maltesisch (mt), Mandarin-Chinesisch (zh), Māori (mi), Marathi (mr), Mongolisch (mn), Nepali (ne), Norwegisch (no), Okzitanisch (oc), Odia (or), Paschtunisch (ps), Persisch (fa), Polnisch (pl), Portugiesisch (pt), Punjabi (pa), Rumänisch (ro), Russisch (ru), Serbisch (sr), Sindhi (sd), Slowakisch (sk), Slowenisch (sl), Somali (so), Spanisch (es), Suaheli (sw), Schwedisch (sv), Tadschikisch (tg), Tamil (ta), Telugu (te), Thailändisch (th), Türkisch (tr), Ukrainisch (uk), Urdu (ur), Usbekisch (uz), Vietnamesisch (vi), Walisisch (cy), Yoruba (yo).* > **Note** > > Der Parameter `language_code` akzeptiert für die meisten Sprachen zweistellige Codes nach [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1). > Sprachen ohne ISO-639-1-Code verwenden dreistellige Codes nach [ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3): Asturisch (`ast`), Kantonesisch > (`yue`), Cebuano (`ceb`) und Filipino (`fil`). ## Eleven v4 Turbo Eleven v4 Turbo ist unser modernstes Modell für Echtzeit-Sprachsynthese und liefert Audio in hoher Qualität, Ausdrucksstärke und Kontrolle über die Stimmwiedergabe. Eleven v4 Turbo unterstützt hochpräzises KI-Stimme klonen und liefert Ergebnisse mit einer medianen Inferenzlatenz von \~100 ms. Dieses Modell eignet sich gut für folgende Szenarien: * **Support-Agenten**: Betreiben Sie Sprachagenten, die Kundenanfragen in Echtzeit lösen. * **KI-Assistenten**: Generieren Sie natürliche, lebensechte Dialoge mit großer emotionaler Bandbreite und Kontextverständnis. * **Interaktive Charaktere**: Ausgezeichnet für Audioerlebnisse mit ausdrucksstarken Charakteren. Eleven v4 Turbo ist über den [Text to Dialogue WebSocket](/docs/de/eleven-api/guides/how-to/websockets/realtime-tdd) verfügbar. ### Unterstützte Sprachen Die Modellfamilie Eleven v4 unterstützt über 90 Sprachen, darunter: *Afrikaans (af), Arabisch (ar), Armenisch (hy), Assamesisch (as), Asturisch (ast), Aserbaidschanisch (az), Belarussisch (be), Bengalisch (bn), Bosnisch (bs), Bulgarisch (bg), Birmanisch (my), Kantonesisch (yue), Katalanisch (ca), Cebuano (ceb), Kroatisch (hr), Tschechisch (cs), Dänisch (da), Niederländisch (nl), Englisch (en), Estnisch (et), Filipino (fil), Finnisch (fi), Französisch (fr), Galicisch (gl), Georgisch (ka), Deutsch (de), Griechisch (el), Gujarati (gu), Hausa (ha), Hebräisch (he), Hindi (hi), Ungarisch (hu), Isländisch (is), Indonesisch (id), Irisch (ga), Italienisch (it), Japanisch (ja), Javanisch (jv), Kannada (kn), Kasachisch (kk), Koreanisch (ko), Kirgisisch (ky), Lettisch (lv), Lingala (ln), Litauisch (lt), Luxemburgisch (lb), Mazedonisch (mk), Malaiisch (ms), Malayalam (ml), Maltesisch (mt), Mandarin-Chinesisch (zh), Māori (mi), Marathi (mr), Mongolisch (mn), Nepali (ne), Norwegisch (no), Okzitanisch (oc), Odia (or), Paschtunisch (ps), Persisch (fa), Polnisch (pl), Portugiesisch (pt), Punjabi (pa), Rumänisch (ro), Russisch (ru), Serbisch (sr), Sindhi (sd), Slowakisch (sk), Slowenisch (sl), Somali (so), Spanisch (es), Suaheli (sw), Schwedisch (sv), Tadschikisch (tg), Tamil (ta), Telugu (te), Thailändisch (th), Türkisch (tr), Ukrainisch (uk), Urdu (ur), Usbekisch (uz), Vietnamesisch (vi), Walisisch (cy), Yoruba (yo).* > **Note** > > Der Parameter `language_code` akzeptiert für die meisten Sprachen zweistellige Codes nach [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1). > Sprachen ohne ISO-639-1-Code verwenden dreistellige Codes nach [ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3): Asturisch (`ast`), Kantonesisch > (`yue`), Cebuano (`ceb`) und Filipino (`fil`). ## Eleven v3 Eleven v3 ist unser Sprachsynthesemodell der vorherigen Generation. Es erzeugt natürliche, lebensechte Sprache mit großer emotionaler Bandbreite und Kontextverständnis in mehreren Sprachen. Mit Eleven v3 gibt es eine neue Text to Dialogue API, mit der Sie natürliche, lebensechte Dialoge mit großer emotionaler Bandbreite und Kontextverständnis in mehreren Sprachen generieren können. Eleven v3 kann auch mit der Text to Speech API verwendet werden, um natürliche, lebensechte Sprache mit großer emotionaler Bandbreite und Kontextverständnis in mehreren Sprachen zu generieren. Lesen Sie [hier](/docs/de/overview/capabilities/text-to-dialogue) mehr über die Text to Dialogue API. ### Unterstützte Sprachen Das Modell Eleven v3 unterstützt über 70 Sprachen, darunter: *Afrikaans (af), Arabisch (ar), Armenisch (hy), Assamesisch (as), Asturisch (ast), Aserbaidschanisch (az), Belarussisch (be), Bengalisch (bn), Bosnisch (bs), Bulgarisch (bg), Birmanisch (my), Kantonesisch (yue), Katalanisch (ca), Cebuano (ceb), Chichewa (ny), Kroatisch (hr), Tschechisch (cs), Dänisch (da), Niederländisch (nl), Englisch (en), Estnisch (et), Filipino (fil), Finnisch (fi), Französisch (fr), Galicisch (gl), Georgisch (ka), Deutsch (de), Griechisch (el), Gujarati (gu), Hausa (ha), Hebräisch (he), Hindi (hi), Ungarisch (hu), Isländisch (is), Indonesisch (id), Irisch (ga), Italienisch (it), Japanisch (ja), Javanisch (jv), Kannada (kn), Kasachisch (kk), Kirgisisch (ky), Koreanisch (ko), Lettisch (lv), Lingala (ln), Litauisch (lt), Luxemburgisch (lb), Mazedonisch (mk), Malaiisch (ms), Malayalam (ml), Maltesisch (mt), Mandarin-Chinesisch (zh), Māori (mi), Marathi (mr), Mongolisch (mn), Nepali (ne), Norwegisch (no), Okzitanisch (oc), Odia (or), Paschtunisch (ps), Persisch (fa), Polnisch (pl), Portugiesisch (pt), Punjabi (pa), Rumänisch (ro), Russisch (ru), Serbisch (sr), Sindhi (sd), Slowakisch (sk), Slowenisch (sl), Somali (so), Spanisch (es), Suaheli (sw), Schwedisch (sv), Tadschikisch (tg), Tamil (ta), Telugu (te), Thailändisch (th), Türkisch (tr), Ukrainisch (uk), Urdu (ur), Usbekisch (uz), Vietnamesisch (vi), Walisisch (cy), Yoruba (yo).* > **Note** > > Der Parameter `language_code` akzeptiert für die meisten Sprachen zweistellige Codes nach [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1). > Sprachen ohne ISO-639-1-Code verwenden dreistellige Codes nach [ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3): Asturisch (`ast`), Kantonesisch > (`yue`), Cebuano (`ceb`) und Filipino (`fil`). ## Eleven v3 Conversational Eleven v3 Conversational ist unser Modell der vorherigen Generation für Echtzeit-Sprachsynthese. Es erzeugt natürliche, lebensechte Sprache mit großer emotionaler Bandbreite und Kontextverständnis in mehreren Sprachen. Mit Eleven v3 Conversational gibt es einen neuen Text to Dialogue WebSocket, mit dem Sie natürliche, lebensechte Dialoge mit großer emotionaler Bandbreite und Kontextverständnis in mehreren Sprachen generieren können. Mit Eleven v3 Conversational gibt es einen neuen Text to Dialogue WebSocket, mit dem Sie natürliche, lebensechte Dialoge mit großer emotionaler Bandbreite und Kontextverständnis in mehreren Sprachen generieren können. Lesen Sie [hier](/docs/de/eleven-api/guides/how-to/websockets/realtime-tdd) mehr über den Text to Dialogue WebSocket. ### Unterstützte Sprachen Das Modell Eleven v3 unterstützt über 70 Sprachen, darunter: *Afrikaans (af), Arabisch (ar), Armenisch (hy), Assamesisch (as), Asturisch (ast), Aserbaidschanisch (az), Belarussisch (be), Bengalisch (bn), Bosnisch (bs), Bulgarisch (bg), Birmanisch (my), Kantonesisch (yue), Katalanisch (ca), Cebuano (ceb), Chichewa (ny), Kroatisch (hr), Tschechisch (cs), Dänisch (da), Niederländisch (nl), Englisch (en), Estnisch (et), Filipino (fil), Finnisch (fi), Französisch (fr), Galicisch (gl), Georgisch (ka), Deutsch (de), Griechisch (el), Gujarati (gu), Hausa (ha), Hebräisch (he), Hindi (hi), Ungarisch (hu), Isländisch (is), Indonesisch (id), Irisch (ga), Italienisch (it), Japanisch (ja), Javanisch (jv), Kannada (kn), Kasachisch (kk), Kirgisisch (ky), Koreanisch (ko), Lettisch (lv), Lingala (ln), Litauisch (lt), Luxemburgisch (lb), Mazedonisch (mk), Malaiisch (ms), Malayalam (ml), Maltesisch (mt), Mandarin-Chinesisch (zh), Māori (mi), Marathi (mr), Mongolisch (mn), Nepali (ne), Norwegisch (no), Okzitanisch (oc), Odia (or), Paschtunisch (ps), Persisch (fa), Polnisch (pl), Portugiesisch (pt), Punjabi (pa), Rumänisch (ro), Russisch (ru), Serbisch (sr), Sindhi (sd), Slowakisch (sk), Slowenisch (sl), Somali (so), Spanisch (es), Suaheli (sw), Schwedisch (sv), Tadschikisch (tg), Tamil (ta), Telugu (te), Thailändisch (th), Türkisch (tr), Ukrainisch (uk), Urdu (ur), Usbekisch (uz), Vietnamesisch (vi), Walisisch (cy), Yoruba (yo).* > **Note** > > Der Parameter `language_code` akzeptiert für die meisten Sprachen zweistellige Codes nach [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1). > Sprachen ohne ISO-639-1-Code verwenden dreistellige Codes nach [ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3): Asturisch (`ast`), Kantonesisch > (`yue`), Cebuano (`ceb`) und Filipino (`fil`). ## Multilingual v2 Eleven Multilingual v2 ist ein emotional sensibles Sprachsynthesemodell der vorherigen Generation. Es erzeugt natürliche, lebensechte Sprache mit großer emotionaler Bandbreite und Kontextverständnis in mehreren Sprachen. Das Modell liefert in allen unterstützten Sprachen eine konsistente Stimmqualität und Persönlichkeit und bewahrt dabei die einzigartigen Merkmale und den Akzent des Sprechers. Dieses Modell überzeugt besonders in Szenarien, die hochwertige, emotional nuancierte Sprache erfordern: * **Charakter-Voiceovers**: Ideal für Spiele und Animationen dank seiner emotionalen Bandbreite. * **Professionelle Inhalte**: Gut geeignet für Unternehmensvideos und E-Learning-Materialien. * **Mehrsprachige Projekte**: Bewahrt eine konsistente Stimmqualität bei Sprachwechseln. * **Stabile Qualität**: Erzeugt konsistente Audioausgaben in hoher Qualität. Es hat zwar eine höhere Latenz und höhere Kosten pro Zeichen als Flash-Modelle, liefert jedoch eine überlegene Qualität für Projekte, bei denen lebensechte Sprache wichtig ist. Unsere mehrsprachigen v2-Modelle unterstützen 29 Sprachen: *Englisch (USA, UK, Australien, Kanada), Japanisch, Chinesisch, Deutsch, Hindi, Französisch (Frankreich, Kanada), Koreanisch, Portugiesisch (Brasilien, Portugal), Italienisch, Spanisch (Spanien, Mexiko), Indonesisch, Niederländisch, Türkisch, Filipino, Polnisch, Schwedisch, Bulgarisch, Rumänisch, Arabisch (Saudi-Arabien, VAE), Tschechisch, Griechisch, Finnisch, Kroatisch, Malaiisch, Slowakisch, Dänisch, Tamil, Ukrainisch & Russisch.* ## Flash v2.5 Eleven Flash v2.5 ist unser schnellstes Sprachsynthesemodell, entwickelt für Echtzeitanwendungen und die Agents Platform. Es liefert hochwertige Sprache mit extrem niedriger Latenz (\~75 ms†) in 32 Sprachen. Das Modell vereint Geschwindigkeit und Qualität. Dadurch eignet es sich ideal für interaktive Anwendungen und bewahrt gleichzeitig eine natürlich klingende Ausgabe sowie konsistente Stimmmerkmale über alle Sprachen hinweg. Dieses Modell eignet sich besonders für: * **Agents Platform**: Perfekt für Sprachagenten und Chatbots in Echtzeit. * **Interaktive Anwendungen**: Ideal für Spiele und Anwendungen, die eine sofortige Reaktion erfordern. * **Verarbeitung im großen Maßstab**: Effizient für die Text-to-Speech-Konvertierung großer Mengen. Mit seinem niedrigeren Preis für API-Generierungen und einer Latenz von 75 ms ist Flash v2.5 die kosteneffiziente Option für alle, die schnelle, zuverlässige Sprachsynthese in mehreren Sprachen benötigen. Flash v2.5 unterstützt 32 Sprachen – alle Sprachen der v2-Modelle sowie: *Ungarisch, Norwegisch & Vietnamesisch* † Ohne Anwendungs- und Netzwerklatenz ### Hinweise #### Textnormalisierung mit Zahlen Bei Flash v2.5 werden Zahlen standardmäßig möglicherweise nicht so normalisiert, wie Sie es erwarten. Telefonnummern könnten beispielsweise so vorgelesen werden, dass sie für Nutzer nicht eindeutig verständlich sind. Datumsangaben und Währungen sind ähnlich betroffen. Standardmäßig ist die Normalisierung für Flash v2.5 deaktiviert, um die niedrige Latenz beizubehalten. Enterprise-Kunden können die Textnormalisierung für v2.5-Modelle jedoch aktivieren, indem sie in ihrer Anfrage den Parameter `apply_text_normalization` auf "on" setzen. Das Modell Multilingual v2 normalisiert Zahlen besser. Daher empfehlen wir es für Telefonnummern und andere Fälle, in denen die Zahlennormalisierung wichtig ist. Bei Anwendungen mit niedriger Latenz oder für die Agents Platform empfiehlt es sich, dass Ihr LLM [den Text normalisiert](/docs/de/overview/capabilities/text-to-speech/best-practices#text-normalization), bevor er an das TTS-Modell übergeben wird, oder den Parameter `apply_text_normalization` zu verwenden (bei v2.5-Modellen nur für Enterprise-Pläne). ## Leitfaden zur Modellauswahl Hinweise dazu, welches Modell am besten zu Ihren Anforderungen und Ihrem Anwendungsfall passt, finden Sie im [Leitfaden zur Modellauswahl](/docs/de/eleven-api/choosing-the-right-model). #### Anforderungen #### Qualität Verwenden Sie `eleven_v4` oder `eleven_multilingual_v2` Ideal für hochwertige Audioausgabe mit ausdrucksstarken Emotionen #### Niedrige Latenz Verwenden Sie `eleven_v4_turbo` Optimiert für Echtzeitanwendungen (\~100 ms Latenz) #### Anwendungsfall #### Content-Erstellung Verwenden Sie `eleven_v4` oder `eleven_multilingual_v2` Ideal für professionelle Inhalte, Hörbücher und Videokommentare. #### Agents Platform Verwenden Sie `eleven_v4_turbo`, `eleven_flash_v2_5`, `eleven_flash_v2` oder `eleven_multilingual_v2` Perfekt für dialogbasierte Echtzeitanwendungen. Verwenden Sie `eleven_v4_turbo` für die ausdrucksstärkste Wiedergabe. #### Stimmenverzerrer Verwenden Sie `eleven_multilingual_sts_v2` Spezialisiert auf Speech-to-Speech-Konvertierung ## Zeichenlimits Die maximale Zeichenanzahl in einer einzelnen Text-to-Speech-Anfrage variiert je nach Modell. | Modell-ID | Zeichenlimit | Ungefähre Audiodauer | | ------------------------ | ------------ | -------------------- | | `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** > > Für längere Inhalte sollten Sie die Eingabe auf mehrere Anfragen aufteilen. ## Scribe v2 Scribe v2 ist unser modernes Spracherkennungsmodell für präzise Transkriptionen in über 90 Sprachen. Es liefert genaue Zeitstempel auf Wortebene sowie erweiterte Funktionen wie Sprecherdiarisierung und dynamische Audio-Tags. Dieses Modell eignet sich besonders für Szenarien, die eine präzise Speech-to-Text-Konvertierung erfordern: * **Transkriptionsdienste**: Perfekt für die Umwandlung von Audio- und Videoinhalten in Text * **Meeting-Dokumentation**: Ideal zum Erfassen und Dokumentieren von Gesprächen * **Inhaltsanalyse**: Gut geeignet für die Verarbeitung und Analyse von Audioinhalten * **Mehrsprachige Erkennung**: Unterstützt präzise Transkriptionen in über 90 Sprachen Wichtige Funktionen: * Präzise Transkription mit Zeitstempeln auf Wortebene * Sprecherdiarisierung für Audio mit mehreren Sprechern * Dynamische Audio-Tags für mehr Kontext * Unterstützung für über 90 Sprachen * Entitätserkennung * Keyterm-Prompting * Transkriptbearbeitung Weitere Informationen zu Scribe v2 finden Sie [hier](/docs/de/overview/capabilities/speech-to-text). ## Scribe v2 Realtime Scribe v2 Realtime, unser schnellstes und präzisestes Modell für Live-Spracherkennung, bietet modernste Genauigkeit in über 90 Sprachen bei einer extrem niedrigen Latenz von 150 ms. Dieses Modell eignet sich besonders für dialogbasierte Anwendungsfälle: * **Live-Meeting-Transkription**: Perfekt für Transkriptionen in Echtzeit * **KI-Agenten**: Ideal für Live-Gespräche * **Mehrsprachige Erkennung**: Unterstützt präzise Transkriptionen in über 90 Sprachen mit automatischer Spracherkennung Wichtige Funktionen: * Extrem niedrige Latenz: Erhalten Sie Teiltranskriptionen in \~150 Millisekunden * Streaming-Unterstützung: Senden Sie Audio in Abschnitten und empfangen Sie Transkripte in Echtzeit * Mehrere Audioformate: Unterstützung für PCM (8 kHz bis 48 kHz) und μ-law-Codierung * Voice Activity Detection (VAD): Automatische Sprachsegmentierung anhand von Stilleerkennung * Manuelle Commit-Steuerung: Volle Kontrolle darüber, wann Transkriptsegmente abgeschlossen werden * Entitätserkennung * Transkriptbearbeitung Weitere Informationen zu Scribe v2 Realtime finden Sie [hier](/docs/de/overview/capabilities/speech-to-text). ## Scribe v2 Medical Scribe v2 Medical ist ein Batch-Spracherkennungsmodell, das auf medizinisches und klinisches Audio spezialisiert ist. Es ist ein Finetune von Scribe v2 und verbessert die Erkennung von Medikamentennamen, Anatomie, Pathologie und klinischen Diktaten, bei gleichbleibender Genauigkeit von Scribe v2 für Alltagssprache. Es verwendet dieselbe Speech-to-Text-API wie Scribe v2 und wird zum gleichen Preis abgerechnet. Übergeben Sie `scribe_v2_medical` als `model_id`. > **Note** > > ### Zweckbestimmung > > Scribe v2 Medical ist ein Batch-Speech-to-Text-API-Modell für Entwickler und > Organisationen zur Integration in Anwendungen, die klinisches Audio, einschließlich > Gesprächen zwischen medizinischem Fachpersonal und Patienten, Diktaten, Erstaufnahme- und Versorgungskoordinationsanrufen, in Entwürfe von > Transkripten für die Dokumentation und zugehörige administrative Workflows umwandeln. Der resultierende Text ist > zur Überprüfung und Korrektur durch medizinisches Fachpersonal oder andere autorisierte Nutzer vor der Verwendung bestimmt. Scribe > v2 Medical ist nicht zur Interpretation klinischer Informationen oder zur Bereitstellung von Diagnosen, > Behandlungsempfehlungen, klinischen Entscheidungen oder anderen klinischen Hinweisen bestimmt. Dieses Modell eignet sich besonders für: * **Klinische Dokumentation**: Gespräche und Notizen, in denen medizinische Begriffe mitten im Gespräch auftauchen * **Diktate**: Dichte Abfolgen von Medikamenten, Dosierungen und Befunden * **Erstaufnahme- und Koordinationsanrufe**: Patienten beschreiben ihre eigenen Beschwerden, oft telefonisch * **Compliance-Workflows**: Kombinieren Sie es mit der [Entitätserkennung](/docs/de/eleven-api/guides/how-to/speech-to-text/batch/entity-detection) für PHI-Kategorien Wichtige Funktionen: * Gleiches Anfrageformat wie Scribe v2 (`keyterms`, `entity_detection`, `no_verbatim`, Diarisierung, Zeitstempel) * Verbesserte Erkennung von Medikamentennamen sowie Begriffen aus Anatomie und Pathologie * Keine Verschlechterung bei Alltagssprache im Vergleich zu Scribe v2 * Unterstützung für über 90 Sprachen * Sprecherdiarisierung für Audio mit mehreren Sprechern * Dynamische Audio-Tags * Entitätserkennung, einschließlich PHI-Kategorien Scribe v2 Medical ist ein Batch-Modell. Verwenden Sie für Live-Transkriptionen Scribe v2 Realtime. Scribe v2 Medical ist HIPAA-konform nutzbar. Business Associate Agreements sind für Enterprise-Kunden verfügbar, ebenso der Zero Retention Mode (ZRM). Bei aktiviertem ZRM werden Audioeingaben und Textausgaben unmittelbar nach Abschluss jeder Anfrage gelöscht. ElevenLabs speichert nichts, und Ihre Anwendung erhält die vollständige API-Antwort und verwaltet Transkripte unter Ihrer eigenen Kontrolle. > **Info** > > Unternehmen, die HIPAA-Konformität benötigen, müssen [ElevenLabs Sales](https://elevenlabs.io/contact-sales) kontaktieren, um vor dem > Senden geschützter Gesundheitsinformationen ein Business Associate Agreement (BAA) zu unterzeichnen. Weitere Informationen zu Speech to Text finden Sie [hier](/docs/de/overview/capabilities/speech-to-text). ## Eleven Music Eleven Music ist unser Musikgenerierungsmodell in Studioqualität. Damit können Sie Musik jeder Stilrichtung mit Prompts in natürlicher Sprache generieren. Dieses Modell eignet sich hervorragend für folgende Szenarien: * **Game-Soundtracks**: Erstellen Sie immersive Soundtracks für Spiele * **Podcast-Hintergründe**: Werten Sie Podcasts mit professioneller Musik auf * **Marketing**: Fügen Sie Werbe-Reels Hintergrundmusik hinzu Wichtige Funktionen: * Vollständige Kontrolle über Genre, Stil und Struktur * Gesang oder nur Instrumental * Mehrsprachig, einschließlich Englisch, Spanisch, Deutsch, Japanisch und weiteren Sprachen * Bearbeiten Sie Sound und Liedtext einzelner Abschnitte oder des gesamten Songs Weitere Informationen zu Eleven Music finden Sie [hier](/docs/de/overview/capabilities/music). ## Parallelität und Priorität Ihr Abonnement bestimmt, wie viele Anfragen gleichzeitig verarbeitet werden können und welche Prioritätsstufe Ihre Anfragen in der Warteschlange haben. Speech to Text hat ein erhöhtes Parallelitätslimit. Sobald das Parallelitätslimit erreicht ist, werden weitere Anfragen zusammen mit Anfragen niedrigerer Priorität in einer Warteschlange verarbeitet. In der Praxis erhöht dies die Latenz typischerweise nur um etwa 50 ms. | Tarif | Parallelitätslimit (Multilingual v2) | Parallelitätslimit (Flash) | STT-Parallelitätslimit | Echtzeit-STT-Parallelitätslimit | Musik-Parallelitätslimit | Prioritätsstufe | | ---------- | ------------------------------------- | --------------------------- | ---------------------- | ------------------------------- | ------------------------ | --------------- | | 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 | Erhöht | Erhöht | Erhöht | Erhöht | Höchste | 6 | > **Note** > > Empfänger von Startup-Grants erhalten die Vorteile der Stufe Scale. Die Response-Header enthalten `current-concurrent-requests` und `maximum-concurrent-requests`, mit denen Sie Ihre Parallelität überwachen können. ### API-Anfragen pro Minute im Vergleich zu parallelen Anfragen Es ist wichtig zu verstehen, dass **API-Anfragen pro Minute** und **parallele Anfragen** unterschiedliche Kennzahlen sind, die von Ihren Nutzungsmustern abhängen. API-Anfragen pro Minute können von parallelen Anfragen abweichen, da sie von der Dauer jeder Anfrage und der Bündelung der Anfragen abhängen. **Beispiel 1: Zeitlich versetzte Anfragen** Wenn Sie 180 Anfragen pro Minute hätten, die jeweils 1 Sekunde zur Verarbeitung benötigen, und diese im Abstand von jeweils 0,33 Sekunden senden würden, läge die maximale Anzahl paralleler Anfragen bei 3 und der Durchschnitt ebenfalls bei 3, da stets 3 Anfragen gleichzeitig verarbeitet würden. **Beispiel 2: Gebündelte Anfragen** Bei einem anderen Nutzungsmuster, etwa 180 Anfragen pro Minute, die jeweils 3 Sekunden zur Verarbeitung benötigen, aber alle gleichzeitig ausgelöst werden, läge die maximale Anzahl paralleler Anfragen bei 180 und der Durchschnitt bei 9 (in den ersten 3 Sekunden der Minute würden 180 Anfragen gleichzeitig eingehen, in den letzten 57 Sekunden 0 Anfragen). Da unser System auf Parallelität achtet, sind Anfragen pro Minute weniger wichtig als die Dauer der einzelnen Anfragen und das Muster, wann sie gesendet werden. Die Art, wie Endpoint-Anfragen gestellt werden, beeinflusst die Parallelitätslimits: * Bei HTTP zählt jede Anfrage einzeln für Ihr Parallelitätslimit. * Beim Text to Speech WebSocket zählt nur die Zeit, in der unser Modell Audio generiert, für Ihr Parallelitätslimit. Das bedeutet, dass ein offener WebSocket die meiste Zeit überhaupt nicht für Ihr Parallelitätslimit zählt. * Die Text to Dialogue WebSockets funktionieren anders: Jede offene Verbindung reserviert eine Dialogsitzung aus einem separaten Pool, solange sie geöffnet bleibt. Über die Verbindung generiertes Audio zählt nicht für Ihr Standard-Parallelitätslimit. Dies vereinfacht die Planung, da eine Verbindung einer Sitzung entspricht. Ihre Dialogsitzungslimits sind auf diese neue Parallelitätsmethode ausgelegt. Siehe [Text to Dialogue-Parallelität](#text-to-dialogue-concurrency). ### Parallelitätslimits verstehen Das mit Ihrem Tarif verbundene Parallelitätslimit sollte nicht als maximale Anzahl gleichzeitig möglicher Gespräche, Telefonanrufe, Charakter-Voiceovers usw. interpretiert werden. Die tatsächliche Anzahl hängt von mehreren Faktoren ab, darunter den verwendeten KI-Stimmen und den Merkmalen des Anwendungsfalls. Als Faustregel gilt: Ein Parallelitätslimit von 5 kann typischerweise bis zu etwa 100 gleichzeitige Audioübertragungen unterstützen. Das liegt an der Geschwindigkeit, mit der Audio im Verhältnis zur Verarbeitungszeit der TTS-Anfrage generiert wird. Das folgende Diagramm zeigt beispielhaft, wie 4 parallele Anrufe mit verschiedenen Nutzern bei nur 2 parallelen Anfragen ermöglicht werden können. ![Parallelitätslimits](/docs/_fern-img/dcc5e3bd18993a9f862bd526f3dc1b32cfa89003a58ded6f4f6a7bda1bd5a2ea.webp) #### KI-Sprachagenten entwickeln Wenn TTS für Dialoge eingesetzt wird, kann ein Parallelitätslimit von 5 etwa 100 Übertragungen für ausgewogene Gespräche zwischen KI-Agenten und menschlichen Teilnehmern unterstützen. Bei Anwendungsfällen, in denen der KI-Agent seltener spricht als der Mensch, etwa im Kundensupport, können mehr als 100 gleichzeitige Gespräche unterstützt werden. #### Charakter-Voiceovers Im Allgemeinen können mit einem Parallelitätslimit von 5 mehr als 100 gleichzeitige Charakter-Voiceovers unterstützt werden. Die Anzahl kann je nach Dialoghäufigkeit der Figur, Länge der Pausen und In-Game-Aktionen zwischen den Zeilen variieren. #### Live-Synchronisation Gleichzeitige Synchronisationsstreams folgen im Allgemeinen der angegebenen Faustregel. Wenn die Übertragung Phasen mit Gesprächspausen enthält, etwa aufgrund eines Soundtracks oder visueller Szenen, sind möglicherweise mehr gleichzeitige Synchronisationsstreams als angegeben möglich. Wenn Sie die Parallelitätslimits Ihres Tarifs überschreiten und den Enterprise-Tarif nutzen, können Modellanfragen abhängig von der verfügbaren Kapazität nach bestem Bemühen weiterhin erfolgreich sein, allerdings langsamer. > **Note** > > Um Ihr Parallelitätslimit und Ihre Warteschlangenpriorität zu erhöhen, [upgraden Sie Ihren Abonnementtarif](https://elevenlabs.io/pricing/api). > > Enterprise-Kunden können über ihren Account Manager ein höheres Parallelitätslimit anfordern. ### Text to Dialogue-Parallelität Text to Dialogue-Anfragen werden abhängig davon, wie Sie die API aufrufen, auf zwei unterschiedliche Arten gemessen: * **HTTP-Endpoints** ([Dialog erstellen](/docs/de/api-reference/text-to-dialogue/convert) und [Dialog streamen](/docs/de/api-reference/text-to-dialogue/stream)) zählen während der Audiogenerierung wie jede andere Text to Speech-Anfrage für das Standard-Parallelitätslimit Ihres Tarifs. * **WebSocket-Endpoints** wie der [Text to Dialogue WebSocket](/docs/de/api-reference/text-to-dialogue/ttd-websocket) werden als **Dialogsitzungen** gemessen. Eine offene Verbindung belegt eine Dialogsitzung, solange sie geöffnet bleibt, unabhängig davon, ob aktuell Audio generiert wird. Sitzungsbasierte Messung vereinfacht die Kapazitätsplanung: Eine Verbindung entspricht einer Sitzung, sodass Ihre Nutzung nicht mit der Generierungsaktivität schwankt. Da eine Sitzung für die gesamte Verbindung belegt wird und nicht nur während der Audiogenerierung, sind Ihre Dialogsitzungslimits auf diese neue Parallelitätsmethode ausgelegt. | Tarif | WebSocket-Sitzungen | | ---------- | ------------------- | | Free | 14 | | Starter | 21 | | Creator | 35 | | Pro | 70 | | Scale | 105 | | Business | 105 | | Enterprise | Erhöht | Wenn Sie eine Verbindung öffnen, während alle Dialogsitzungen Ihres Workspace belegt sind, wird die neue Verbindung mit einem `too_many_concurrent_requests`-Fehler abgelehnt. Um Sitzungen freizugeben, schließen Sie nicht mehr benötigte Verbindungen. Eine Verbindung wird auch nach 20 Sekunden Inaktivität automatisch geschlossen, sofern Sie keine `keep_alive`-Nachrichten senden. Um Dialogsitzungen zu überwachen, öffnen Sie unten in der Dashboard-Seitenleiste **Developers**, wählen Sie den Tab **Analytics** und rufen Sie in der Nutzungsansicht die Kennzahl **Concurrent requests** auf. Dialogsitzungen werden als eigene Reihe **TTD Websocket Sessions** angezeigt, getrennt von Ihren anderen parallelen Anfragen. ### Parallelitätslimits mit Skalierungstests prüfen Skalierungstests können helfen, clientseitige Skalierungsprobleme zu erkennen und zu prüfen, ob Parallelitätslimits für Ihren Anwendungsfall korrekt festgelegt sind. Es wird dringend empfohlen, End-to-End-Workflows möglichst nah an der realen Nutzung zu testen. Die empfohlene Methode dafür besteht darin, zu simulieren und zu messen, wie viele Nutzer unterstützt werden können. Dabei ist wichtig: * Simulieren Sie Nutzer, nicht rohe Anfragen. * Simulieren Sie typisches Nutzerverhalten, etwa das Warten auf die Audiowiedergabe, darauf, dass Nutzer sprechen, oder auf den Abschluss der Transkription, bevor Anfragen gestellt werden. * Erhöhen Sie die Anzahl der Nutzer über mehrere Minuten hinweg langsam. * Variieren Sie die Zeitpunkte und die Größe der Anfragen zufällig. * Erfassen Sie Latenzkennzahlen und alle von der API zurückgegebenen Fehlercodes. Um beispielsweise ein Agentensystem zu testen, das für 100 gleichzeitige Gespräche ausgelegt ist, würden Sie bis zu 100 einzelne „Nutzer“ erstellen, die jeweils ein Gespräch simulieren. Gespräche bestehen typischerweise aus einem sich wiederholenden Zyklus von etwa 10 Sekunden, in denen der Nutzer spricht, gefolgt von einem TTS-API-Aufruf für etwa 150 Zeichen und anschließend etwa 10 Sekunden Audiowiedergabe für den Nutzer. Daher sollte jeder Nutzer alle 20 Sekunden einen WebSocket-Text-to-Speech-API-Aufruf für 150 Textzeichen durchführen, wobei die Wartezeit und die Anzahl der angeforderten Zeichen leicht zufällig variiert werden. Der Test würde darin bestehen, eine Minute lang pro Sekunde einen Nutzer zu starten, bis 100 vorhanden sind, und anschließend insgesamt 10 Minuten lang die Gesamtstabilität zu testen. #### Beispiel für ein Skalierungstest-Skript Dieses Beispiel verwendet [locust](https://locust.io/) als Test-Framework mit direkten API-Aufrufen an die ElevenLabs API. Es folgt dem oben genannten Beispiel und testet ein dialogorientiertes Agentensystem, bei dem jeder Nutzer alle 20 Sekunden eine Anfrage sendet. **`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 ```