Modellen

Toonaangevende modellen

Text to Speech

Speech to Text

Muziek

Overzicht van modellen

De ElevenLabs API biedt een reeks audiomodellen die zijn geoptimaliseerd voor verschillende gebruikssituaties, kwaliteitsniveaus en prestatievereisten.

Verouderde modellen

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.

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).

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.

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).

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 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).

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 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).

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

Aandachtspunten

Handleiding voor modelselectie

Bekijk de handleiding voor modelselectie voor advies over welk model het beste past bij je vereisten en use case.

Tekenlimieten

Het maximale aantal tekens dat wordt ondersteund in één text-to-speech-request verschilt per model.

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 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 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.

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 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.

Lees hier 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 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.

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.

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.

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.

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 en Stream dialogue) 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 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.

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.

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