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

# Transcripten en commitstrategieën

> **Note**
>
> **Handleiding** · Hierbij wordt ervan uitgegaan dat je de gids voor
> [client-side](/docs/nl/eleven-api/guides/how-to/speech-to-text/realtime/client-side-streaming) of
> [server-side streaming](/docs/nl/eleven-api/guides/how-to/speech-to-text/realtime/server-side-streaming) hebt voltooid.

## Overzicht

Tijdens het transcriberen van audio ontvang je gedeeltelijke en vastgelegde transcripten.

* **Gedeeltelijke transcripten** - de tussentijdse resultaten van de transcriptie
* **Vastgelegde transcripten** - de definitieve resultaten van het transcriptiesegment die worden verzonden wanneer een "commit"-bericht wordt ontvangen. Een sessie kan meerdere vastgelegde transcripten hebben.

Het vastgelegde transcript kan optioneel tijdstempels op woordniveau bevatten. Dit ontvang je alleen als de optie "include timestamps" is ingesteld op `true`.

```python
# Initialize the connection
connection = await elevenlabs.speech_to_text.realtime.connect(RealtimeUrlOptions(
  model_id="scribe_v2_realtime",
  include_timestamps=True, # Include this to receive the RealtimeEvents.COMMITTED_TRANSCRIPT_WITH_TIMESTAMPS event with word-level timestamps
))
```

```typescript
// Initialize the connection
const connection = await elevenlabs.speechToText.realtime.connect({
  modelId: "scribe_v2_realtime",
  includeTimestamps: true, // Include this to receive the RealtimeEvents.COMMITTED_TRANSCRIPT_WITH_TIMESTAMPS event with word-level timestamps
});
```

**`React`**

```typescript title="React"
const connection = useScribe({
  modelId: "scribe_v2_realtime",
  // Configuring this callback will automatically set the `includeTimestamps` option to `true`
  onCommittedTranscriptWithTimestamps: (data) => {
    console.log("Committed with timestamps:", data.text);
    console.log("Timestamps:", data.words);
  },
});
```

**`JavaScript`**

```typescript title="JavaScript"
const connection = Scribe.connect({
  modelId: "scribe_v2_realtime",
  includeTimestamps: true, // Include this to receive the RealtimeEvents.COMMITTED_TRANSCRIPT_WITH_TIMESTAMPS event with word-level timestamps
});
```

## Commitstrategieën

Wanneer je audioblokken via de WebSocket verstuurt, kunnen transcriptsegmenten op twee manieren worden vastgelegd: handmatige commit of Voice Activity Detection (VAD).

### Handmatige commit

Met de handmatige commitstrategie bepaal je zelf wanneer je transcriptsegmenten vastlegt. Dit is de standaardstrategie. Door een segment vast te leggen, wordt het verwerkte verzamelde transcript gewist en begint een nieuw segment zonder context te verliezen. Om de latentie te verbeteren, kun je het beste elke 20 tot 30 seconden vastleggen. Ook als je niet handmatig vastlegt, legt het model automatisch vast na ongeveer 36 seconden verzamelde audio.

Voor de beste resultaten leg je vast tijdens stiltes of op een ander logisch moment, zoals een beurtwisseling.

> **Info**
>
> Transcriptverwerking begint nadat de eerste 2 seconden audio zijn verzonden.

```python
await connection.send({
  "audio_base_64": audio_base_64,
  "sample_rate": 16000,
})

# When ready to finalize the segment
await connection.commit()
```

```typescript
connection.send({
  audioBase64: audioBase64,
  sampleRate: 16000,
});

// When ready to finalize the segment
connection.commit();
```

> **Warning**
>
> Meerdere keren handmatig vastleggen in korte tijd kan de modelprestaties verslechteren.

#### Eerdere tekstcontext verzenden

Wanneer je audio voor transcriptie verzendt, kun je samen met het eerste audioblok eerdere tekstcontext meesturen om het model te helpen de context van de spraak te begrijpen. Dit is nuttig in enkele scenario's:

* Agenttekst voor use cases met conversationele AI - Hiermee kan het model de context van het gesprek gemakkelijker begrijpen en betere transcripties maken.
* Opnieuw verbinding maken na een netwerkfout - Hiermee kan het model doorgaan met transcriberen, waarbij de eerdere tekst als richtlijn wordt gebruikt.
* Algemene contextuele informatie - Een korte beschrijving van waar de transcriptie over gaat, helpt het model de context te begrijpen.

> **Warning**
>
> Het verzenden van `previous_text`-context is alleen mogelijk wanneer je het eerste audioblok verzendt via
> `connection.send()`. Als je dit in volgende blokken verzendt, krijg je een fout. Eerdere tekst werkt
> het beste als deze korter is dan *50* tekens.

```python
await connection.send({
  "audio_base_64": audio_base_64,
  "previous_text": "The previous text context",
})
```

```typescript
connection.send({
  audioBase64: audioBase64,
  previousText: "The previous text context",
});
```

### Voice Activity Detection (VAD)

Met de VAD-strategie detecteert de transcriptie-engine automatisch spraak- en stiltefragmenten. Wanneer een stiltedrempel wordt bereikt, legt de transcriptie-engine het transcriptsegment automatisch vast.

Bij het transcriberen van microfoonaudio in de [client-side-integratie](/docs/nl/eleven-api/guides/how-to/speech-to-text/realtime/client-side-streaming) raden we aan de VAD-strategie te gebruiken.

**`Client`**

```typescript title="Client"
import { Scribe, AudioFormat, CommitStrategy } from "@elevenlabs/client";

const connection = Scribe.connect({
  token: "sutkn_1234567890",
  modelId: "scribe_v2_realtime",
  audioFormat: AudioFormat.PCM_16000,
  commitStrategy: CommitStrategy.VAD,
  vadSilenceThresholdSecs: 1.5,
  vadThreshold: 0.4,
  minSpeechDurationMs: 100,
  minSilenceDurationMs: 100,
});
```

```python
from dotenv import load_dotenv
from elevenlabs import AudioFormat, CommitStrategy, ElevenLabs, RealtimeAudioOptions

load_dotenv()

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

connection = await elevenlabs.speech_to_text.realtime.connect(
    RealtimeAudioOptions(
        model_id="scribe_v2_realtime",
        audio_format=AudioFormat.PCM_16000,
        commit_strategy=CommitStrategy.VAD,
        vad_silence_threshold_secs=1.5,
        vad_threshold=0.4,
        min_speech_duration_ms=100,
        min_silence_duration_ms=100,
    )
)
```

**`TypeScript`**

```typescript title="TypeScript"
import { ElevenLabsClient, AudioFormat, CommitStrategy } from '@elevenlabs/elevenlabs-js';

const elevenlabs = new ElevenLabsClient();

const connection = await elevenlabs.speechToText.realtime.connect({
  modelId: "scribe_v2_realtime",
  audioFormat: AudioFormat.PCM_16000,
  commitStrategy: CommitStrategy.VAD,
  vadSilenceThresholdSecs: 1.5,
  vadThreshold: 0.4,
  minSpeechDurationMs: 100,
  minSilenceDurationMs: 100,
});
```

## De verbinding tijdens stiltes actief houden

De officiële SDK's verbreken de verbinding niet als er geen berichten binnenkomen, dus de meeste integraties hebben dit niet nodig. Als je eigen WebSocket-client, of een proxy of load balancer daartussen, de verbinding sluit wanneer er enige tijd geen frames binnenkomen, geef dan bij het verbinden de optionele queryparameter `keepalive_interval_ms` door. Dit is belangrijk tijdens lange stiltes, bijvoorbeeld bij een telefoongesprek met pauzes van 10 tot 15 seconden. Ongeveer eenmaal per interval stuurt de server een keepalive-`partial_transcript`: leeg (`text: ""`) als het huidige segment geen niet-vastgelegde tekst heeft, of een herhaling van de meest recente gedeeltelijke tekst als dat wel het geval is.

> **Warning**
>
> Keepalives zijn geen vrijlopende pings: je moet audio blijven streamen (stilteframes zijn prima).
> Als je stopt met het verzenden van audio, worden er geen keepalives verzonden en sluit de server de verbinding na 15
> seconden zonder clientberichten. Deze serverlimiet is niet configureerbaar.

* Accepteert een geheel getal tussen `500` en `10000` (milliseconden). Standaard is deze optie uitgeschakeld; laat de parameter weg om het bestaande gedrag te behouden.
* Waarden buiten het bereik of niet-gehele waarden zorgen ervoor dat de server een `invalid_request`-fout stuurt en de verbinding sluit.
* Keepalives worden aangestuurd doordat het model de stille audio die je verzendt daadwerkelijk verwerkt, niet door een vrijlopende timer. Ze bevestigen dus ook dat het transcriptiepad actief is.
* Audio wordt verwerkt in blokken van ongeveer 1 seconde, dus keepalives komen ongeveer eenmaal per interval binnen, afgerond op die cadans (bijvoorbeeld: `1000` wordt ongeveer eenmaal per seconde geactiveerd, `3000` ongeveer eenmaal per 3 seconden). De eerste keepalive van een sessie komt ongeveer 2 seconden na het begin binnen, omdat de server de eerste \~2 seconden audio buffert voordat hij transcribeert. Stel je interval in op maximaal ongeveer een derde van je eigen read timeout, zodat je marge overhoudt.
* De `text` van een keepalive is alleen leeg wanneer het huidige segment nog geen niet-vastgelegde tekst heeft. Als er een pauze is na spraak maar vóór een commit — vooral zichtbaar met `filter_background_audio=true` of in de handmatige commitmodus zonder vast te leggen — herhaalt de keepalive in plaats daarvan de meest recente gedeeltelijke tekst, zodat tussentijdse tekst nooit wordt gewist. Na een commit zijn keepalives weer leeg totdat er nieuwe spraak binnenkomt.
* Werkt met zowel `commit_strategy=manual` als `commit_strategy=vad`, en met `filter_background_audio=true`. Heeft geen invloed op de facturering, behalve voor de audio die je al streamt.
* De `config` in het bericht `session_started` geeft `keepalive_interval_ms` terug (`null` wanneer uitgeschakeld).

> **Info**
>
> Een lege `partial_transcript` (`text: ""`) betekent "geen spraak in het huidige segment." Een herhaalde,
> identieke `partial_transcript` tijdens een pauze is ook een keepalive — clients moeten gedeeltelijke transcripten gewoon weergeven
> zoals ze al doen, in plaats van de herhaling apart te behandelen.

Voeg de parameter toe aan de WebSocket-URL:

```text
wss://api.elevenlabs.io/v1/speech-to-text/realtime?model_id=scribe_v2_realtime&commit_strategy=vad&keepalive_interval_ms=1000
```

## Ondersteunde audioformats

| Format     | Samplefrequentie | Beschrijving                            |
| ---------- | ---------------- | --------------------------------------- |
| pcm\_8000  | 8 kHz            | 16-bits PCM, little-endian              |
| pcm\_16000 | 16 kHz           | 16-bits PCM, little-endian (aanbevolen) |
| pcm\_22050 | 22,05 kHz        | 16-bits PCM, little-endian              |
| pcm\_24000 | 24 kHz           | 16-bits PCM, little-endian              |
| pcm\_44100 | 44,1 kHz         | 16-bits PCM, little-endian              |
| pcm\_48000 | 48 kHz           | 16-bits PCM, little-endian              |
| ulaw\_8000 | 8 kHz            | 8-bits μ-law-codering                   |

## Best practices

### Audiokwaliteit

* Gebruik voor de beste resultaten een samplefrequentie van 16 kHz voor een optimale balans tussen kwaliteit en bandbreedte.
* Zorg voor een schone audio-input met minimale achtergrondruis.
* Gebruik een geschikte microfoonversterking om clipping te voorkomen.
* Op dit moment wordt alleen mono-audio ondersteund.

### Blokgrootte

* Verzend audioblokken met een duur van 0,1 tot 1 seconde voor soepel streaming.
* Kleinere blokken zorgen voor lagere latentie, maar meer overhead.
* Grotere blokken zijn efficiënter, maar kunnen latentie veroorzaken.

## Volgende stappen

#### [Server-side streaming](/docs/nl/eleven-api/guides/how-to/speech-to-text/realtime/server-side-streaming)

Stel server-side audiotranscriptie in met de WebSocket API.

#### [Eventreferentie](/docs/nl/eleven-api/guides/how-to/speech-to-text/realtime/event-reference)

Volledige lijst met events en fouttypen van de realtime STT API.