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

# Transkripte und Commit-Strategien

> **Note**
>
> **Anleitung** · Setzt voraus, dass Sie die Anleitung für
> [clientseitiges](/docs/de/eleven-api/guides/how-to/speech-to-text/realtime/client-side-streaming) oder
> [serverseitiges Streaming](/docs/de/eleven-api/guides/how-to/speech-to-text/realtime/server-side-streaming) abgeschlossen haben.

## Überblick

Beim Transkribieren von Audio erhalten Sie teilweise und abgeschlossene Transkripte.

* **Teilweise Transkripte** – die Zwischenergebnisse der Transkription
* **Abgeschlossene Transkripte** – die endgültigen Ergebnisse des Transkriptionssegments, die beim Empfang einer „Commit“-Nachricht gesendet werden. Eine Sitzung kann mehrere abgeschlossene Transkripte enthalten.

Das abgeschlossene Transkript kann optional Zeitstempel auf Wortebene enthalten. Diese werden nur empfangen, wenn die Option „include timestamps“ auf `true` gesetzt ist.

```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
});
```

## Commit-Strategien

Beim Senden von Audio-Chunks über WebSocket können Transkriptsegmente auf zwei Arten abgeschlossen werden: manueller Commit oder Voice Activity Detection (VAD).

### Manueller Commit

Mit der manuellen Commit-Strategie steuern Sie, wann Transkriptsegmente abgeschlossen werden. Diese Strategie wird standardmäßig verwendet. Das Abschließen eines Segments löscht das verarbeitete, angesammelte Transkript und startet ein neues Segment, ohne Kontext zu verlieren. Um die Latenz zu verbessern, empfiehlt es sich, alle 20–30 Sekunden einen Commit auszuführen. Auch ohne manuellen Commit schließt das Modell nach etwa 36 Sekunden angesammeltem Audio automatisch ab.

Für beste Ergebnisse führen Sie den Commit während Sprechpausen oder an einem anderen logischen Punkt aus, etwa bei einem Sprecherwechsel.

> **Info**
>
> Die Verarbeitung des Transkripts beginnt, nachdem die ersten 2 Sekunden Audio gesendet wurden.

```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**
>
> Mehrere manuelle Commits in kurzer Folge können die Modellleistung beeinträchtigen.

#### Vorherigen Textkontext senden

Beim Senden von Audio zur Transkription können Sie zusammen mit dem ersten Audio-Chunk vorherigen Textkontext senden. So versteht das Modell den Kontext der Sprache besser. Das ist in einigen Szenarien nützlich:

* Agententext für Anwendungsfälle mit konversationeller KI – Ermöglicht dem Modell, den Gesprächskontext leichter zu verstehen und bessere Transkriptionen zu erstellen.
* Wiederverbindung nach einem Netzwerkfehler – Dadurch kann das Modell die Transkription mithilfe des vorherigen Texts als Orientierung fortsetzen.
* Allgemeine Kontextinformationen – Eine kurze Beschreibung, worum es in der Transkription geht, hilft dem Modell, den Kontext zu verstehen.

> **Warning**
>
> Das Senden des Kontexts `previous_text` ist nur beim Senden des ersten Audio-Chunks über
> `connection.send()` möglich. Das Senden in nachfolgenden Chunks führt zu einem Fehler. Vorheriger Text funktioniert
> am besten, wenn er weniger als *50* Zeichen lang ist.

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

Mit der VAD-Strategie erkennt die Transkriptions-Engine automatisch Sprach- und Stillesegmente. Wenn ein Schwellenwert für Stille erreicht wird, schließt die Transkriptions-Engine das Transkriptsegment automatisch ab.

Beim Transkribieren von Mikrofon-Audio in der [clientseitigen Integration](/docs/de/eleven-api/guides/how-to/speech-to-text/realtime/client-side-streaming) wird die VAD-Strategie empfohlen.

**`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,
});
```

## Verbindung während Stille aufrechterhalten

Die offiziellen SDKs trennen die Verbindung nicht, wenn keine Nachrichten eingehen. Daher benötigen die meisten Integrationen dies nicht. Wenn Ihr eigener WebSocket-Client, ein Proxy oder ein vorgeschalteter Load Balancer die Verbindung schließt, sobald eine Zeit lang keine Frames eingehen, übergeben Sie beim Verbinden den optionalen Abfrageparameter `keepalive_interval_ms`. Das ist bei längeren Stillephasen wichtig, etwa bei einem Telefongespräch mit Pausen von 10–15 Sekunden. Etwa einmal pro Intervall sendet der Server ein Keepalive-`partial_transcript`: leer (`text: ""`), wenn das aktuelle Segment keinen nicht abgeschlossenen Text enthält, oder als Wiederholung des neuesten teilweisen Texts, falls es solchen enthält.

> **Warning**
>
> Keepalives sind keine fortlaufenden Pings: Sie müssen weiterhin Audio streamen (Stille-Frames sind ausreichend).
> Wenn Sie kein Audio mehr senden, werden keine Keepalives gesendet, und der Server schließt die Verbindung nach 15
> Sekunden ohne Client-Nachrichten. Dieses Serverlimit kann nicht konfiguriert werden.

* Akzeptiert eine Ganzzahl zwischen `500` und `10000` (Millisekunden). Standardmäßig ist die Funktion deaktiviert; lassen Sie den Parameter weg, um das bisherige Verhalten beizubehalten.
* Werte außerhalb des Bereichs oder keine Ganzzahlen führen dazu, dass der Server einen `invalid_request`-Fehler sendet und die Verbindung schließt.
* Keepalives werden durch die tatsächliche Verarbeitung des gesendeten stillen Audios durch das Modell ausgelöst, nicht durch einen fortlaufenden Timer. Sie bestätigen somit auch, dass der Transkriptionspfad aktiv ist.
* Audio wird in Chunks von etwa 1 Sekunde verarbeitet. Keepalives treffen daher etwa einmal pro Intervall ein, gerundet auf diesen Takt (zum Beispiel löst `1000` etwa einmal pro Sekunde aus, `3000` etwa alle 3 Sekunden). Das erste Keepalive einer Sitzung trifft etwa 2 Sekunden nach ihrem Start ein, da der Server die ersten etwa 2 Sekunden Audio vor der Transkription puffert. Setzen Sie Ihr Intervall auf höchstens etwa ein Drittel Ihres eigenen Lese-Timeouts, um Spielraum zu lassen.
* Der `text` eines Keepalives ist nur leer, wenn das aktuelle Segment noch keinen nicht abgeschlossenen Text enthält. Tritt eine Pause nach Sprache, aber vor einem Commit auf – besonders sichtbar mit `filter_background_audio=true` oder im manuellen Commit-Modus ohne Commit –, wiederholt das Keepalive stattdessen den neuesten teilweisen Text. Zwischentexte werden also nie geleert. Nach einem Commit sind Keepalives wieder leer, bis neue Sprache eingeht.
* Funktioniert mit `commit_strategy=manual` und `commit_strategy=vad` sowie mit `filter_background_audio=true`. Abgesehen von dem Audio, das Sie bereits streamen, entstehen keine zusätzlichen Kosten.
* Die `config` der Nachricht `session_started` gibt `keepalive_interval_ms` zurück (`null`, wenn deaktiviert).

> **Info**
>
> Ein leeres `partial_transcript` (`text: ""`) bedeutet „keine Sprache im aktuellen Segment“. Ein wiederholtes,
> identisches `partial_transcript` während einer Pause ist ebenfalls ein Keepalive – Clients sollten Teilergebnisse
> einfach wie gewohnt darstellen, statt die Wiederholung gesondert zu behandeln.

Fügen Sie den Parameter zur WebSocket-URL hinzu:

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

## Unterstützte Audioformate

| Format    | Abtastrate | Beschreibung                          |
| --------- | ---------- | ------------------------------------- |
| pcm_8000  | 8 kHz      | 16-Bit-PCM, Little-Endian             |
| pcm_16000 | 16 kHz     | 16-Bit-PCM, Little-Endian (empfohlen) |
| pcm_22050 | 22,05 kHz  | 16-Bit-PCM, Little-Endian             |
| pcm_24000 | 24 kHz     | 16-Bit-PCM, Little-Endian             |
| pcm_44100 | 44,1 kHz   | 16-Bit-PCM, Little-Endian             |
| pcm_48000 | 48 kHz     | 16-Bit-PCM, Little-Endian             |
| ulaw_8000 | 8 kHz      | 8-Bit-μ-Law-Kodierung                 |

## Best Practices

### Audioqualität

* Verwenden Sie für ein optimales Verhältnis von Qualität und Bandbreite eine Abtastrate von 16 kHz.
* Sorgen Sie für ein sauberes Audiosignal mit möglichst wenig Hintergrundgeräuschen.
* Verwenden Sie eine passende Mikrofonverstärkung, um Clipping zu vermeiden.
* Derzeit wird nur Mono-Audio unterstützt.

### Chunk-Größe

* Senden Sie Audio-Chunks mit einer Länge von 0,1–1 Sekunde für reibungsloses Streaming.
* Kleinere Chunks führen zu geringerer Latenz, aber mehr Overhead.
* Größere Chunks sind effizienter, können aber Latenz verursachen.

## Nächste Schritte

#### [Serverseitiges Streaming](/docs/de/eleven-api/guides/how-to/speech-to-text/realtime/server-side-streaming)

Richten Sie serverseitige Audio-Transkription mit der WebSocket API ein.

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

Vollständige Liste der Ereignisse und Fehlertypen der Echtzeit-STT-API.