Speech to Text API-integratie: handleiding voor ontwikkelaars

Met een Speech to Text API kunnen ontwikkelaars spraakherkenning en transcriptiemogelijkheden rechtstreeks in hun applicaties integreren. Voordat je de STT API koppelt, moet je echter eerst een paar architecturale beslissingen nemen.

Welke transcriptiemodus gebruik je? Hoe ga je om met lange audiobestanden? En hoe zorg je ervoor dat productnamen of eigennamen correct worden gespeld? Met een beetje vooruitdenken en planning kun je een schaalbare Speech to Text API-integratie maken in je applicaties voor ontwikkelaars.

Deze handleiding behandelt alles wat je nodig hebt voor een ElevenLabs Speech to Text API-integratie, met duidelijke codevoorbeelden die je rechtstreeks naar productie kunt kopiëren. Houd als referentie de ElevenLabs Speech to Text-snelstartgids en de API-handleiding in een ander venster open.

Samenvatting

• ElevenLabs Speech to Text heeft twee modi: batch (voor vooraf opgenomen audio) en realtime (voor live audiostreams via WebSocket).
• Scribe v2 verwerkt batchtranscripties in meer dan 90 talen met sprekerdiarisatie, keyterm prompting, entiteitsdetectie, tijdstempels op woordniveau en ondersteuning voor meerdere kanalen.
• Scribe v2 Realtime verwerkt live streaming met een latentie van ongeveer 150 ms, met gedeeltelijke transcripties terwijl je spreekt en definitieve transcripties zodra een spraaksegment is voltooid.
• Voor bestanden langer dan 8 minuten splitst en transcribeert Scribe v2 automatisch parallel. Gebruik voor langdurige taken webhooks in plaats van te wachten op het synchrone antwoord.
• Keyterm prompting stuurt het model met context naar specifieke termen. Dit is betrouwbaarder dan trefwoordenlijsten voor productnamen, technisch jargon of ongebruikelijke eigennamen.

Speech to Text API-integratie: batch versus realtime

Elke ElevenLabs STT API-integratie begint met een architecturale keuze: batch of realtime. Beide leveren een krachtig STT-model voor je ontwikkelomgeving, maar je keuze heeft invloed op alles, van de functies die je kunt gebruiken tot de end-to-endlatentie.

Zo vergelijken de twee modi zich:

• Batch (Scribe v2): Neemt een volledig audio- of videobestand, transcribeert het en retourneert het volledige transcript in één antwoord. Ondersteunt de meeste functies: maximaal 1.000 keyterms, maximaal 32 sprekers voor diarisatie, entiteitsdetectie, multichannelmodus en webhooks voor asynchrone levering. In de standaardmodus worden bestanden tot 3 GB en 10 uur ondersteund.
• Realtime (Scribe v2 Realtime): Accepteert een live audiostream via een WebSocket en retourneert gedeeltelijke en definitieve transcripties zodra de audio binnenkomt, met een latentie van ongeveer 150 ms. Ondersteunt maximaal 50 keyterms en tijdstempels op woordniveau, en is de juiste keuze voor spraakassistenten, live ondertiteling of elke applicatie waarin een gebruiker spreekt en een antwoord verwacht.

Laten we de verschillen verder uitsplitsen.

Als vuistregel: gebruik batch wanneer de audio compleet is voordat de transcriptie begint, en realtime wanneer je audio transcribeert terwijl deze wordt geproduceerd.

Wanneer kies je Scribe v2 of Scribe v2 Realtime

Batch en realtime zijn bedoeld voor verschillende taken. Als je vroeg de verkeerde kiest, leidt dat later vaak tot extra werk.

Zo koppel je het model aan je use case:

• Scribe v2 is de juiste keuze voor alles waarbij de audio compleet is voordat de verwerking begint, zoals vergaderopnamen, podcasttranscripties, mediabestanden of alles wat je offline verwerkt. Het ondersteunt de volledige set functies, waaronder diarisatie, entiteitsdetectie en maximaal 1.000 keyterms.
• Scribe v2 Realtime is gemaakt voor live audio. Het accepteert een WebSocket-stream en retourneert transcripties zodra de audio binnenkomt. Daardoor is het de juiste keuze voor spraakassistenten of elk scenario waarin een gebruiker spreekt en je applicatie moet reageren voordat diegene is uitgesproken.

Een aanvullende factor is dat de nauwkeurigheid ook per taal verschilt. Controleer daarom de word error rate van transcripties voordat je kiest voor een talenmix. Scribe v2 publiceert Word Error Rate (WER)-niveaus voor alle meer dan 90 ondersteunde talen.

Uitstekende nauwkeurigheid (≤5% WER) geldt onder andere voor de belangrijkste Europese talen, Japans, Indonesisch en Vietnamees. Hoge nauwkeurigheid (5-10% WER) geldt onder andere voor Hindi, Bengaals, Mandarijn, Koreaans en Georgisch. Bekijk de categorie-indeling in de documentatie over taalondersteuning voor alle details.

De ElevenLabs Speech to Text API instellen

Voor een werkende client zijn slechts twee eenvoudige stappen nodig. Eerst installeer je de SDK. Daarna sla je je gegevens veilig op.

Zo doe je beide voordat je je eerste transcriptieverzoek schrijft.

Installeer de SDK en sla je API-sleutel als beheerd geheim op met een .env-bestand of de secrets manager van je platform. Hardcode je API-sleutel nooit in je applicatie.

Python

pip install elevenlabs
pip install python-dotenv

TypeScript

npm install @elevenlabs/elevenlabs-js

Maak een .env-bestand:

ELEVENLABS_API_KEY=<your_api_key_here>

Initialiseer de client:

Python

import os
from dotenv import load_dotenv
from elevenlabs.client import ElevenLabs

load_dotenv()

elevenlabs = ElevenLabs(
    api_key=os.getenv("ELEVENLABS_API_KEY"),
)

TypeScript

import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

const elevenlabs = new ElevenLabsClient({
  apiKey: process.env.ELEVENLABS_API_KEY,
});

Je eerste batchtranscriptie met de ElevenLabs STT API

Nu je je client hebt geïnitialiseerd, kun je je eerste bestand versturen.

De batch API neemt een bestand, transcribeert het en retourneert het volledige resultaat synchroon. Het onderstaande voorbeeld transcribeert een extern audiobestand met sprekerdiarisatie en tagging van audio-events ingeschakeld.

Python

# example.py
import os
from dotenv import load_dotenv
from io import BytesIO
import requests
from elevenlabs.client import ElevenLabs

load_dotenv()

elevenlabs = ElevenLabs(
    api_key=os.getenv("ELEVENLABS_API_KEY"),
)

audio_url = (
    "https://storage.googleapis.com/eleven-public-cdn/audio/marketing/nicole.mp3"
)
response = requests.get(audio_url)
audio_data = BytesIO(response.content)

transcription = elevenlabs.speech_to_text.convert(
    file=audio_data,
    model_id="scribe_v2",          # Model to use
    tag_audio_events=True,          # Tag audio events like laughter, applause, etc.
    language_code="eng",            # Language of the audio file. If set to None, the model will detect the language automatically.
    diarize=True,                   # Whether to annotate who is speaking
)

print(transcription)

Voer het uit:

python example.py

Het responseobject bevat de volledige transcriptietekst, items op woordniveau met tijdstempels en spreker-ID's, en gedetecteerde audio-events.

Elk woorditem heeft een typeveld met een van drie waarden:

• word: Voor getranscribeerde woorden in de audio.
• spacing: Spaties tussen woorden in talen die spaties gebruiken. Dit type is niet van toepassing op verschillende talen, zoals Japans, Kantonees en Birmaans.
• audio_event: Een tag voor elk geluid dat geen spraak is, zoals lachen of hoesten.

Zo ziet de responsstructuur eruit:

{
  "language_code": "en",
  "language_probability": 1,
  "text": "With a soft and whispery American accent, I'm the ideal choice for creating ASMR content, meditative guides, or adding an intimate feel to your narrative projects.",
  "words": [
    {
      "text": "With",
      "start": 0.119,
      "end": 0.259,
      "type": "word",
      "speaker_id": "speaker_0"
    },
    {
      "text": " ",
      "start": 0.239,
      "end": 0.299,
      "type": "spacing",
      "speaker_id": "speaker_0"
    },
    {
      "text": "a",
      "start": 0.279,
      "end": 0.359,
      "type": "word",
      "speaker_id": "speaker_0"
    }
  ]
}

Het veld language_probability geeft aan hoe zeker het model is van de taaldetectie, op een schaal van 0,00 tot 1,00.

STT API Realtime-integratie

Realtime STT API-integratie volgt een iets ander patroon. In plaats van één request en één response open je een WebSocket-verbinding en lees je transcripties zodra ze binnenkomen.

De realtime API gebruikt een WebSocket om een live audiostream te accepteren en transcripties te retourneren zodra de audio binnenkomt. Deze levert twee typen transcripties:

• Gedeeltelijke transcripties: Tussentijdse resultaten die worden bijgewerkt terwijl het model inkomende audio verwerkt. Deze kunnen veranderen.
• Definitieve transcripties: Definitieve resultaten voor een voltooid spraaksegment. Deze veranderen niet. Ze kunnen ook tijdstempels op woordniveau bevatten als je de optie "include timestamps" op true zet.

De implementatie aan clientzijde gebruikt een token voor eenmalig gebruik in plaats van rechtstreeks je API-sleutel. Dit is een tijdelijke credential die na 15 minuten verloopt en server-side wordt gegenereerd, zodat je API-sleutel nooit aan de browser wordt blootgesteld.

Stap 1: Genereer een token voor eenmalig gebruik (server-side)

// Node.js server
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

const elevenlabs = new ElevenLabsClient({
  apiKey: process.env.ELEVENLABS_API_KEY,
});

app.get("/scribe-token", yourAuthMiddleware, async (req, res) => {
  const token = await elevenlabs.tokens.singleUse.create("realtime_scribe");

  res.json(token);
});

Stap 2: Verbinden en transcriberen (client-side, React)

import { useScribe } from "@elevenlabs/react";

function MyComponent() {
  const scribe = useScribe({
    modelId: "scribe_v2_realtime",
    onPartialTranscript: (data) => {
      console.log("Partial:", data.text);
    },
    onCommittedTranscript: (data) => {
      console.log("Committed:", data.text);
    },
    onCommittedTranscriptWithTimestamps: (data) => {
      console.log("Committed with timestamps:", data.text);
      console.log("Timestamps:", data.words);
    },
  });

  const handleStart = async () => {
    // Fetch a single use token from the server
    const token = await fetchTokenFromServer();

    await scribe.connect({
      token,
      microphone: {
        echoCancellation: true,
        noiseSuppression: true,
      },
    });
  };

  return (
    <div>
      <button onClick={handleStart} disabled={scribe.isConnected}>
        Start Recording
      </button>
      <button onClick={scribe.disconnect} disabled={!scribe.isConnected}>
        Stop
      </button>

      {scribe.partialTranscript && <p>Live: {scribe.partialTranscript}</p>}

      <div>
        {scribe.committedTranscripts.map((t) => (
          <p key={t.id}>{t.text}</p>
        ))}
      </div>
    </div>
  );
}

De useScribe-hook beheert de levenscyclus van de WebSocket-verbinding, microfoontoegang en de transcriptiestatus. partialTranscript bevat de huidige tekst die nog wordt verwerkt; committedTranscripts is de groeiende array met definitieve segmenten.

Zie voor server-side streaming (audio transcriberen vanuit een URL of bestandsstream in plaats van een microfoon) de handleiding voor server-side streaming.

Concurrency en het schalen van lange bestanden

Lange bestanden hebben een ander schaalmodel nodig dan de meeste API's gebruiken. Het is goed om dit te begrijpen voordat je eromheen bouwt.

Concurrency voor batchtranscriptie werkt anders dan bij de meeste API's. In plaats van te beperken hoeveel requests je tegelijk kunt versturen, verwerkt Scribe v2 lange bestanden door ze intern automatisch parallel uit te voeren.

Bestanden langer dan 8 minuten worden in segmenten gesplitst en gelijktijdig getranscribeerd. Het aantal gebruikte gelijktijdige segmenten wordt als volgt berekend:

Concurrency = min(4, round_up(audio_duration_secs / 480))

Concreet:

• Een bestand van 15 minuten gebruikt een concurrency van 2
• Een bestand van 120 minuten gebruikt een concurrency van 4 (het maximum)

In de standaardmodus worden bestanden tot 10 uur en 3 GB ondersteund. Let op: de multichannelmodus heeft een lagere tijdslimiet. Zie de sectie Multichanneltranscriptie hieronder.

Wat ondersteunde formaten betreft, accepteert de STT API de meest gangbare audio- en videoformaten:

• Audio: AAC, AIFF, OGG, MP3, OPUS, WAV, FLAC, M4A, WebM.
• Video: MP4, AVI, MKV, MOV, WMV, FLV, WebM, MPEG, 3GPP.

Je kunt een videobestand rechtstreeks doorgeven en een transcript van de audiotrack ontvangen zonder voorbewerking.

Keyterm prompting

Generieke modellen transcriberen merknamen en technisch jargon vaak verkeerd. Keyterm prompting is bedoeld om dat op te lossen.

Keyterm prompting stuurt het model tijdens het transcriberen naar specifieke woorden of zinnen. Het is de juiste tool wanneer je audio productnamen, technische termen of eigennamen met ongebruikelijke spellingen bevat.

Keyterm prompting gebruikt context, waardoor het betrouwbaarder is dan een eenvoudige lijst met trefwoorden. Als je "ElevenLabs" als keyterm opgeeft, transcribeert het model dit correct wanneer de spreker de bedrijfsnaam noemt. Zonder deze context kan het model "I've worked at eleven labs for a year" nog steeds onjuist transcriberen.

Zonder keyterm prompting:

I work at eleven labs.

Met keyterms=["ElevenLabs"]:

I work at ElevenLabs.

Batch ondersteunt maximaal 1.000 keyterms (elk 50 tekens). Realtime ondersteunt maximaal 50 keyterms (elk 20 tekens).

Batchtranscriptie met keyterms

Python

import os
from dotenv import load_dotenv
from io import BytesIO
import requests
from elevenlabs.client import ElevenLabs

load_dotenv()

elevenlabs = ElevenLabs(
    api_key=os.getenv("ELEVENLABS_API_KEY"),
)

audio_url = (
    "https://storage.googleapis.com/eleven-public-cdn/documentation_assets/audio/stt-keyterm-prompting.mp3"
)
response = requests.get(audio_url)
audio_data = BytesIO(response.content)

transcription = elevenlabs.speech_to_text.convert(
    file=audio_data,
    model_id="scribe_v2",
    # Keyterms to prompt the model with.
    # Up to 1,000 keyterms can be provided, with a maximum length of 50 characters each
    keyterms=["ElevenLabs"],
)

print(transcription)

Realtime streaming met keyterms

Geef keyterms door wanneer je verbinding maakt met de realtime WebSocket:

Python

connection = await elevenlabs.speech_to_text.realtime.connect(RealtimeUrlOptions(
    model_id="scribe_v2_realtime",
    keyterms=["ElevenLabs"],
))

Of geef ze als queryparameters rechtstreeks door aan de WebSocket-URL:

wss://api.elevenlabs.io/v1/speech-to-text/realtime?model_id=scribe_v2_realtime&keyterms=ElevenLabs&keyterms=AnotherTerm

Keyterm prompting brengt extra kosten met zich mee. Bekijk de API-prijspagina voor meer informatie.

Geavanceerde functies

Hoewel de stappen hierboven de kernstroom voor transcriptie met de STT API behandelen, zijn er verschillende functies die de eindresultaten verrijken. Dit zijn enkele geavanceerde functies die je in je Speech to Text API kunt gebruiken:

• Sprekerdiarisatie om te identificeren wie spreekt
• No-verbatimmodus om transcripties op te schonen
• Entiteitsdetectie om gevoelige gegevens te markeren
• Multichanneltranscriptie om audiokanalen te scheiden

Laten we deze verder toelichten.

Sprekerdiarisatie

Schakel diarize=True in je batchrequest in om aan te geven wie spreekt. Scribe v2 ondersteunt maximaal 32 sprekers. Elk woord in het antwoord bevat een speaker_id-veld (bijvoorbeeld speaker_0, speaker_1) waarmee je transcriptsegmenten per spreker kunt scheiden.

Diarisatie is nuttig voor vergadertranscripties, verwerking van interviews of andere opnamen met meerdere sprekers waarbij het belangrijk is om woorden aan de juiste spreker toe te wijzen.

No-verbatimmodus

Wanneer no_verbatim=True, verwijdert het model stopwoorden, valse starts en haperingen uit het transcript. "Eh, M-misschien moeten we, uh, voor optie A gaan" wordt "Misschien moeten we voor optie A gaan."

Dit levert schonere output op voor ondertiteling, samenvattingen of elke use case waarin leesbaarheid belangrijker is dan elk uitgesproken geluid vastleggen. Het is beschikbaar voor zowel batch (scribe_v2) als realtime (scribe_v2_realtime).

Entiteitsdetectie en redactie

Scribe v2 kan entiteiten in het transcript detecteren en labelen, met exacte tijdstempels voor elke gedetecteerde entiteit. Categorieën zijn onder meer PII (namen, creditcardnummers, burgerservicenummers), PHI (medische aandoeningen) en PCI (betaalkaartgegevens). Bekijk voor de volledige lijst met ondersteunde entiteitstypen de documentatie over entiteitsdetectie.

Dit is vooral nuttig voor compliance-use cases, omdat je hiermee gevoelige informatie in een transcript kunt identificeren en automatisch redigeren voordat je het opslaat of weergeeft.

Entiteitsdetectie kost aanvullend $0.070 per uur boven op de basiskosten voor transcriptie. Bekijk de API-prijspagina voor meer informatie.

Multichanneltranscriptie

Wanneer use_multi_channel=True, wordt elk audiokanaal onafhankelijk getranscribeerd en krijgt het een spreker-ID op basis van het kanaalnummer. Maximaal 5 kanalen worden ondersteund. De maximale bestandsduur in de multichannelmodus is 1 uur.

De multichannelmodus is nuttig als je afzonderlijke audiotracks per spreker hebt, bijvoorbeeld een opname van een telefoongesprek waarin elke deelnemer een eigen kanaal heeft. Dit levert een nauwkeurigere sprekerstoewijzing op dan diarisatie van een gemixt monobestand.

Asynchrone levering met webhooks

Pollen op een resultaat werkt prima bij lage volumes, maar schaalt niet zodra je met lange bestanden of een pipeline met hoge doorvoer werkt. Webhooks lossen dit op door het resultaat naar je toe te sturen.

Voor lange bestanden of transcriptiepipelines met hoge volumes is wachten op het synchrone antwoord niet altijd praktisch. Met webhooks kun je een transcriptierequest indienen en het resultaat op je endpoint ontvangen zodra de verwerking is voltooid, zonder te pollen.

Een webhook instellen

Ga in het ElevenLabs-dashboard naar Developers > Webhooks, klik op Create webhook, en configureer:

• Naam: Geef je webhook een beschrijvende en herkenbare naam.
• Callback-URL: Voeg een openbaar toegankelijk HTTPS-endpoint aan de webhook toe.
• Webhook Auth Method: Selecteer HMAC of OAuth (optioneel, maar sterk aanbevolen voor de veiligheid).
• Events: Selecteer Transcription completed uit de opties.

Een transcriptie indienen met levering via webhook

Python

from dotenv import load_dotenv
from elevenlabs.client import ElevenLabs

load_dotenv()

elevenlabs = ElevenLabs(
    api_key=os.getenv("ELEVENLABS_API_KEY"),
)

def transcribe_with_webhook(audio_file):
    try:
        result = elevenlabs.speech_to_text.convert(
            file=audio_file,
            model_id="scribe_v2",
            webhook=True,
        )
        print(f"Transcription started: {result.request_id}")
        return result
    except Exception as e:
        print(f"Error starting transcription: {e}")
        raise e

Wanneer webhook=True, retourneert de request vroegtijdig zonder het transcript. Het voltooide transcript wordt als POST-request naar je endpoint gestuurd wanneer de verwerking is afgerond.

Je webhook-endpoint implementeren

import { ElevenLabsClient } from '@elevenlabs/elevenlabs-js';
import 'dotenv/config';
import express from 'express';

const elevenlabs = new ElevenLabsClient();
const app = express();
app.use(express.json());

const WEBHOOK_SECRET = process.env.WEBHOOK_SECRET;

app.post('/webhook/speech-to-text', (req, res) => {
  try {
    const signature = req.headers['elevenlabs-signature'];
    const payload = JSON.stringify(req.body);
    let event;

    try {
      // Verify the webhook signature.
      event = await elevenlabs.webhooks.constructEvent(payload, signature, WEBHOOK_SECRET);
    } catch (error) {
      return res.status(401).json({ error: 'Invalid signature' });
    }

    if (event.type === 'speech_to_text.completed') {
      const { requestId, status, text, language_code } = event.data;

      console.log(`Transcription ${requestId} completed`);
      console.log(`Language: ${language_code}`);
      console.log(`Text: ${text}`);

      processTranscription(requestId, text, language_code);
    } else if (status === 'failed') {
      console.error(`Transcription ${requestId} failed`);
      handleTranscriptionError(requestId);
    }

    res.status(200).json({ received: true });
  } catch (error) {
    console.error('Webhook error:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

app.listen(3000, () => {
  console.log('Webhook server listening on port 3000');
});

Structuur van de webhook-payload

Je endpoint ontvangt een POST met de volgende structuur:

{
  "type": "speech_to_text_transcription",
  "data": {
    "request_id": "some-request-id-123",
    "webhook_metadata": {},
    "transcription": {
      "language_code": "en",
      "language_probability": 0.98,
      "text": "Hello world!",
      "words": [
        {
          "text": "Hello",
          "start": 0.0,
          "end": 0.5,
          "type": "word",
          "speaker_id": "speaker_1"
        }
      ]
    }
  }
}

Best practices voor webhookbeveiliging

Wanneer je met webhooks bouwt, kun je enkele beveiligingsmaatregelen nemen om ervoor te zorgen dat events correct worden afgeleverd en verwerkt.

• Webhookhandtekeningen verifiëren: Verifieer webhookhandtekeningen altijd met elevenlabs.webhooks.constructEvent() om te bevestigen dat ze van ElevenLabs afkomstig zijn.
• HTTPS-endpoints gebruiken: Webhook-URL's moeten HTTPS gebruiken om gegevens tijdens verzending tegen manipulatie te beschermen.
• De juiste HTTP-statuscode retourneren: Retourneer 200-299 bij succesvolle verwerking, 400-499 bij clientfouten (deze worden niet opnieuw geprobeerd) en 500-599 bij serverfouten (deze worden opnieuw geprobeerd).
• Een tunnelingtool gebruiken voor lokale ontwikkeling: Gebruik voor lokale ontwikkeling een tunnelingtool zoals ngrok om je lokale server beschikbaar te maken via een openbare HTTPS-URL.

Met deze strategieën kun je webhooks met vertrouwen gebruiken.

Belangrijkste punten voor je Speech to Text API-integratie

Een Speech to Text API-integratie voor productie draait om een handvol beslissingen.

Maak de juiste keuzes en de rest volgt:

• Kies de modus op basis van je use case: Gebruik batch (scribe_v2) wanneer de audio compleet is voordat de verwerking begint. Gebruik realtime (scribe_v2_realtime) wanneer je moet transcriberen terwijl audio wordt geproduceerd, bijvoorbeeld voor agents, spraakassistenten of live ondertiteling.
• Gebruik keyterms voor nauwkeurigheid bij specifieke woordenschat: Geef productnamen, technische termen of ongebruikelijke eigennamen door als keyterms. Het model gebruikt context om ze correct toe te passen zonder ze te vaak te triggeren.
• Laat de API lange bestanden verwerken: Bestanden langer dan 8 minuten worden automatisch parallel verwerkt, dus je hoeft ze niet zelf op te splitsen. In de standaardmodus worden bestanden tot 10 uur en 3 GB ondersteund.
• Gebruik webhooks voor asynchrone pipelines: Voor langdurige taken of verwerking met hoge volumes kun je met webhook=True een request indienen en verdergaan. Verifieer de handtekening van elke binnenkomende webhook-payload.
• Schakel de no-verbatimmodus in voor schone output: Als je use case ondertiteling, samenvattingen of downstream NLP-verwerking is, verwijdert no_verbatim=True automatisch stopwoorden en haperingen.
• Gebruik de multichannelmodus voor gescheiden audiotracks: Als je opname één kanaal per spreker heeft (opnamen van een callcenter, interviewopstellingen), levert multichanneltranscriptie een nauwkeurigere sprekerstoewijzing op dan diarisatie van een gemixt bestand. Let op de tijdslimiet van 1 uur in deze modus.

Als je nog meer informatie wilt, bekijk dan de volledige API-referentie als startpunt.

Bouw je Speech to Text-integratie met ElevenAPI

Na het lezen van deze handleiding beschik je over alle patronen die je nodig hebt voor een Speech to Text API-integratie voor productie. Met batch- en realtimetranscriptie, plus geavanceerde functies zoals keyterm prompting en asynchrone levering, kun je je app lanceren met STT gekoppeld.

Ga aan de slag door meer te lezen over de Speech to Text API of registreren om vandaag je eerste request te doen met ElevenAPI.

Veelgestelde vragen over STT API-integratie