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

# Transcriptions et stratégies de validation

> **Note**
>
> **Guide pratique** · Suppose que vous avez suivi le guide de [streaming côté client](/docs/fr/eleven-api/guides/how-to/speech-to-text/realtime/client-side-streaming) ou de
> [streaming côté serveur](/docs/fr/eleven-api/guides/how-to/speech-to-text/realtime/server-side-streaming).

## Vue d’ensemble

Lors de la transcription d’un audio, vous recevez des transcriptions partielles et validées.

* **Transcriptions partielles** : les résultats intermédiaires de la transcription
* **Transcriptions validées** : les résultats finaux du segment de transcription envoyés lorsqu’un message « commit » est reçu. Une session peut comporter plusieurs transcriptions validées.

La transcription validée peut éventuellement contenir des horodatages au niveau des mots. Ceux-ci sont reçus uniquement lorsque l’option « include timestamps » est définie sur `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
});
```

## Stratégies de validation

Lors de l’envoi de fragments audio via WebSocket, les segments de transcription peuvent être validés de deux manières : validation manuelle ou détection d’activité vocale (VAD).

### Validation manuelle

Avec la stratégie de validation manuelle, vous contrôlez le moment où les segments de transcription sont validés. Cette stratégie est utilisée par défaut. La validation d’un segment efface la transcription accumulée déjà traitée et démarre un nouveau segment sans perdre le contexte. Pour réduire la latence, il est recommandé de valider toutes les 20 à 30 secondes. Même sans validation manuelle, le modèle valide automatiquement après environ 36 secondes d’audio accumulé.

Pour de meilleurs résultats, validez pendant les périodes de silence ou à un autre point logique, comme un changement de tour de parole.

> **Info**
>
> Le traitement de la transcription commence après l’envoi des 2 premières secondes d’audio.

```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**
>
> Valider manuellement plusieurs fois de suite sur une courte période peut dégrader les performances du modèle.

#### Envoi du contexte textuel précédent

Lors de l’envoi d’audio à transcrire, vous pouvez envoyer le contexte textuel précédent avec le premier fragment audio pour aider le modèle à comprendre le contexte de la parole. Cela s’avère utile dans plusieurs scénarios :

* Texte de l’agent pour les cas d’usage d’IA conversationnelle : permet au modèle de mieux comprendre le contexte de la conversation et de produire de meilleures transcriptions.
* Reconnexion après une erreur réseau : permet au modèle de poursuivre la transcription en utilisant le texte précédent comme indication.
* Informations contextuelles générales : une brève description du sujet de la transcription aide le modèle à comprendre le contexte.

> **Warning**
>
> L’envoi du contexte `previous_text` est possible uniquement lors de l’envoi du premier fragment audio via
> `connection.send()`. L’envoyer dans les fragments suivants provoque une erreur. Le texte précédent fonctionne
> mieux lorsqu’il comporte moins de *50* caractères.

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

### Détection d’activité vocale (VAD)

Avec la stratégie VAD, le moteur de transcription détecte automatiquement les segments de parole et de silence. Lorsqu’un seuil de silence est atteint, le moteur de transcription valide automatiquement le segment de transcription.

Lors de la transcription d’audio depuis le microphone dans l’[intégration côté client](/docs/fr/eleven-api/guides/how-to/speech-to-text/realtime/client-side-streaming), il est recommandé d’utiliser la stratégie VAD.

`vad_silence_threshold_secs` accepte des valeurs de 0,192 à 3,0 secondes. Les SDK JavaScript et React acceptent uniquement des valeurs de 0,3 à 3,0.

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

## Filtrer l’audio d’arrière-plan

Définissez le paramètre de requête `filter_background_audio=true` pour réduire les activations erronées dues à la parole en arrière-plan, comme les conversations à proximité, et au bruit ambiant. Lorsque le filtrage est activé, la détection d’activité vocale utilise un modèle configuré pour ignorer la parole en arrière-plan, et `vad_threshold` est défini par défaut sur `0.15`, sauf si vous le définissez vous-même.

> **Warning**
>
> `filter_background_audio` ne peut pas être combiné avec `include_timestamps`. Si vous définissez les deux, le serveur
> envoie une erreur `invalid_request` et ferme la connexion.

Le filtrage ne modifie pas la facturation : tous les flux audio envoyés sont facturés, y compris l’audio ignoré par le filtre.

## Maintenir la connexion pendant les silences

Les SDK officiels ne ferment pas la connexion lorsqu’aucun message n’arrive. La plupart des intégrations n’en ont donc pas besoin. Si votre propre client WebSocket, ou un proxy ou répartiteur de charge intermédiaire, ferme la connexion lorsqu’aucune trame n’arrive pendant un certain temps, transmettez le paramètre de requête facultatif `keepalive_interval_ms` lors de la connexion. Cela est important lors de longues périodes de silence, par exemple pendant un appel téléphonique comportant des pauses de 10 à 15 secondes. Environ une fois par intervalle, le serveur envoie un `partial_transcript` de maintien : vide (`text: ""`) si le segment actuel ne contient aucun texte non validé, ou une répétition du dernier texte partiel dans le cas contraire.

> **Warning**
>
> Les messages de maintien ne sont pas des pings autonomes : vous devez continuer à diffuser de l’audio (les trames de silence conviennent).
> Si vous cessez d’envoyer de l’audio, aucun message de maintien n’est envoyé et le serveur ferme la connexion après 15
> secondes sans message du client. Cette limite serveur n’est pas configurable.

* Accepte un entier entre `500` et `10000` (millisecondes). Ce paramètre est désactivé par défaut ; omettez-le pour conserver le comportement existant.
* Les valeurs hors plage ou non entières conduisent le serveur à envoyer une erreur `invalid_request` et à fermer la connexion.
* Les messages de maintien dépendent du traitement effectif par le modèle de l’audio silencieux que vous envoyez, et non d’une minuterie autonome. Ils confirment donc également que le chemin de transcription est actif.
* L’audio est traité par fragments d’environ 1 seconde. Les messages de maintien arrivent donc environ une fois par intervalle, arrondi à cette cadence. Par exemple, `1000` se déclenche environ une fois par seconde et `3000` environ toutes les 3 secondes. Le premier message de maintien d’une session arrive environ 2 secondes après son démarrage, car le serveur met en mémoire tampon les \~2 premières secondes d’audio avant de transcrire. Définissez votre intervalle à environ un tiers au plus de votre propre délai d’expiration de lecture afin de conserver une marge.
* Le champ `text` d’un message de maintien n’est vide que lorsque le segment actuel ne contient pas encore de texte non validé. Si une pause survient après de la parole mais avant une validation, surtout avec `filter_background_audio=true` ou en mode de validation manuelle sans validation, le message de maintien répète le dernier texte partiel. Il n’efface donc jamais le texte intermédiaire. Après une validation, les messages de maintien redeviennent vides jusqu’à l’arrivée d’une nouvelle parole.
* Fonctionne avec `commit_strategy=manual` comme avec `commit_strategy=vad`, ainsi qu’avec `filter_background_audio=true`. N’a aucun impact sur la facturation au-delà de l’audio que vous diffusez déjà.
* La configuration du message `session_started` renvoie `keepalive_interval_ms` (`null` lorsqu’il est désactivé).

> **Info**
>
> Un `partial_transcript` vide (`text: ""`) signifie « aucune parole dans le segment actuel ». Un
> `partial_transcript` répété et identique pendant une pause est aussi un message de maintien. Les clients doivent simplement afficher
> les résultats partiels comme ils le font déjà, sans traiter la répétition comme un cas particulier.

Ajoutez le paramètre à l’URL WebSocket :

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

## Formats audio pris en charge

| Format    | Fréquence d’échantillonnage | Description                              |
| --------- | --------------------------- | ---------------------------------------- |
| pcm_8000  | 8 kHz                       | PCM 16 bits, petit-boutiste              |
| pcm_16000 | 16 kHz                      | PCM 16 bits, petit-boutiste (recommandé) |
| pcm_22050 | 22,05 kHz                   | PCM 16 bits, petit-boutiste              |
| pcm_24000 | 24 kHz                      | PCM 16 bits, petit-boutiste              |
| pcm_44100 | 44,1 kHz                    | PCM 16 bits, petit-boutiste              |
| pcm_48000 | 48 kHz                      | PCM 16 bits, petit-boutiste              |
| ulaw_8000 | 8 kHz                       | Encodage μ-law 8 bits                    |

## Bonnes pratiques

### Qualité audio

* Pour de meilleurs résultats, utilisez une fréquence d’échantillonnage de 16 kHz afin d’obtenir un équilibre optimal entre qualité et bande passante.
* Assurez-vous que l’entrée audio est propre et que le bruit de fond est minimal.
* Utilisez un gain de microphone approprié pour éviter l’écrêtage.
* Seul l’audio mono est actuellement pris en charge.

### Taille des fragments

* Envoyez des fragments audio de 0,1 à 1 seconde pour un streaming fluide.
* Les fragments plus petits réduisent la latence, mais augmentent la surcharge.
* Les fragments plus grands sont plus efficaces, mais peuvent introduire de la latence.

## Étapes suivantes

#### [Streaming côté serveur](/docs/fr/eleven-api/guides/how-to/speech-to-text/realtime/server-side-streaming)

Configurez la transcription audio côté serveur avec l’API WebSocket.

#### [Référence des événements](/docs/fr/eleven-api/guides/how-to/speech-to-text/realtime/event-reference)

Liste complète des événements et des types d’erreur de l’API STT en temps réel.