> 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. # Speech to Text multicanal > **Note** > > **Guide pratique** · Suppose que vous avez suivi le [guide de démarrage rapide de Speech to Text ](/docs/fr/eleven-api/guides/cookbooks/speech-to-text). ## Vue d’ensemble La fonctionnalité Speech to Text multicanal vous permet de transcrire des fichiers audio dont chaque canal contient un locuteur distinct. Elle est particulièrement utile pour les enregistrements dans lesquels les locuteurs sont isolés sur des canaux audio séparés, afin d’obtenir des transcriptions plus propres sans recourir à la diarisation des locuteurs. Chaque canal est traité indépendamment et reçoit automatiquement un identifiant de locuteur selon son numéro de canal (canal 0 → `speaker_0`, canal 1 → `speaker_1`, etc.). Le système extrait les différents canaux de votre fichier audio d’entrée et les transcrit en parallèle. Par défaut, l’API renvoie une transcription par canal. Définissez `multichannel_output_style=combined` pour recevoir à la place une seule transcription regroupant tous les canaux dans une liste triée par heure de début, chaque mot étant étiqueté avec son `channel_index`. ### Cas d’utilisation courants * **Enregistrements d’entretiens stéréo** : interviewer sur le canal gauche, personne interrogée sur le canal droit * **Enregistrements de podcasts multipistes** : chaque participant est enregistré sur une piste distincte * **Enregistrements de centres d’appels** : agent et client séparés sur différents canaux * **Enregistrements de conférences** : participants individuels isolés sur des canaux distincts * **Procédures judiciaires** : plusieurs parties enregistrées sur des canaux distincts ## Prérequis * Un compte ElevenLabs avec une [clé API](https://elevenlabs.io/app/settings/api-keys) * Un fichier audio multicanal (WAV, MP3 ou autres formats pris en charge) * Maximum 5 canaux par fichier audio * Chaque canal ne doit contenir qu’un seul locuteur ## Fonctionnement #### Préparez votre audio multicanal Assurez-vous que les locuteurs de votre fichier audio sont isolés sur des canaux distincts. La fonctionnalité multicanal prend en charge jusqu’à 5 canaux, chaque canal étant associé à un locuteur spécifique : * Canal 0 → `speaker_0` * Canal 1 → `speaker_1` * Canal 2 → `speaker_2` * Canal 3 → `speaker_3` * Canal 4 → `speaker_4` #### Configurez les paramètres de l’API Lorsque vous effectuez une requête Speech to Text, vous devez définir : * `use_multi_channel`: `true` * `diarize`: `false` (le mode multicanal sépare les locuteurs via les canaux) Vous pouvez également contrôler le format de la réponse avec : * `multichannel_output_style`: `separate` (par défaut) renvoie une transcription par canal. `combined` fusionne tous les canaux en une seule transcription dont les mots sont triés par heure de début et comportent chacun un `channel_index`, conformément au format de réponse standard pour un seul canal. `combined` nécessite des horodatages (`timestamps_granularity` ne doit pas être `none`) et n’est pas pris en charge avec la livraison par webhook ni avec la détection ou la suppression d’entités. Le paramètre `num_speakers` ne peut pas être utilisé avec le mode multicanal, car le nombre de locuteurs est automatiquement déterminé par le nombre de canaux. Le mode multicanal suppose qu’il y a exactement un locuteur par canal. S’il y en a davantage, le même identifiant de locuteur sera attribué à tous les locuteurs du canal. #### Traitez la réponse Par défaut (`multichannel_output_style=separate`), l’audio multicanal renvoie un format de réponse différent de celui d’un seul canal : > **Note** > > Si vous définissez `use_multi_channel: true` mais fournissez un fichier audio à un seul canal (mono), vous > recevrez une réponse standard à un seul canal, et non le format multicanal. Le format de réponse multicanal > est uniquement renvoyé lorsque le fichier audio contient réellement plusieurs canaux. **`Réponse à un seul canal`** ```python title="Réponse à un seul canal" { "language_code": "en", "language_probability": 0.98, "text": "Hello world", "words": [...] } ``` **`Réponse multicanal`** ```python title="Réponse multicanal" { "transcripts": [ { "language_code": "en", "language_probability": 0.98, "text": "Hello from channel one.", "channel_index": 0, "words": [...] }, { "language_code": "en", "language_probability": 0.97, "text": "Greetings from channel two.", "channel_index": 1, "words": [...] } ] } ``` **`Réponse combinée (multichannel_output_style=combined)`** ```python title="Réponse combinée (multichannel_output_style=combined)" { "language_code": "en", "language_probability": 0.98, "text": "Hello from channel one. Greetings from channel two.", "words": [ { "text": "Hello", "start": 0.0, "end": 0.5, "type": "word", "speaker_id": "speaker_0", "channel_index": 0 }, { "text": "Greetings", "start": 0.6, "end": 1.2, "type": "word", "speaker_id": "speaker_1", "channel_index": 1 } ] } ``` Avec `multichannel_output_style=combined`, la réponse utilise le même format plat qu’une transcription à un seul canal (`text` et `words` au niveau supérieur, sans tableau `transcripts`), tous les canaux étant fusionnés dans une liste triée par heure de début. Chaque mot comprend un `channel_index` (ainsi qu’un `speaker_id`) qui identifie son canal. ## Mise en œuvre ### Transcription multicanal de base Voici un exemple complet de transcription d’un fichier audio stéréo contenant deux locuteurs : **`Python`** ```python title="Python" from elevenlabs import ElevenLabs elevenlabs = ElevenLabs(api_key="YOUR_API_KEY") def transcribe_multichannel(audio_file_path): with open(audio_file_path, 'rb') as audio_file: result = elevenlabs.speech_to_text.convert( file=audio_file, model_id='scribe_v2', use_multi_channel=True, diarize=False, timestamps_granularity='word' ) return result # Process the response result = transcribe_multichannel('stereo_interview.wav') if hasattr(result, 'transcripts'): # Multichannel response for transcript in result.transcripts: channel = transcript.channel_index text = transcript.text print(f"Channel {channel} (speaker_{channel}): {text}") else: # Single channel response (fallback) print(f"Text: {result.text}") ``` **`JavaScript`** ```javascript title="JavaScript" import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js"; import fs from "fs"; const elevenlabs = new ElevenLabsClient({ apiKey: process.env.ELEVENLABS_API_KEY, }); async function transcribeMultichannel(audioFilePath) { try { const audioFile = fs.createReadStream(audioFilePath); const result = await elevenlabs.speechToText.convert({ file: audioFile, modelId: "scribe_v2", useMultiChannel: true, diarize: false, timestampsGranularity: "word", }); // With useMultiChannel: true the SDK returns one transcript per channel result.transcripts.forEach((transcript) => { console.log(`Channel ${transcript.channelIndex}: ${transcript.text}`); }); return result; } catch (error) { console.error("Error transcribing audio:", error); throw error; } } ``` **`cURL`** ```bash title="cURL" curl -X POST "https://api.elevenlabs.io/v1/speech-to-text" \ -H "xi-api-key: YOUR_API_KEY" \ -F "file=@stereo_audio_file.wav" \ -F "model_id=scribe_v2" \ -F "use_multi_channel=true" \ -F "diarize=false" \ -F "timestamps_granularity=word" ``` ### Création de transcriptions de conversation Le moyen le plus simple d’obtenir une transcription de conversation triée par heure est de demander `multichannel_output_style=combined` : l’API renvoie une seule liste `words`, déjà triée par heure de début, avec un `channel_index` et un `speaker_id` pour chaque mot : **`Sortie combinée (recommandée)`** ```python title="Sortie combinée (recommandée)" with open("stereo_interview.wav", "rb") as audio_file: result = elevenlabs.speech_to_text.convert( file=audio_file, model_id="scribe_v2", use_multi_channel=True, multichannel_output_style="combined", diarize=False, timestamps_granularity="word", ) for word in result.words: if word.type == "word": print(f"speaker_{word.channel_index}: {word.text}") ``` Si vous utilisez la sortie `separate` par défaut, vous pouvez plutôt fusionner côté client les transcriptions par canal : ```python def create_conversation_transcript(multichannel_result): """Create a conversation-style transcript with speaker labels""" all_words = [] if hasattr(multichannel_result, 'transcripts'): # Collect all words from all channels for transcript in multichannel_result.transcripts: for word in transcript.words or []: if word.type == 'word': all_words.append({ 'text': word.text, 'start': word.start, 'speaker_id': word.speaker_id, 'channel': transcript.channel_index }) # Sort by timestamp all_words.sort(key=lambda w: w['start']) # Group consecutive words by speaker conversation = [] current_speaker = None current_text = [] for word in all_words: if word['speaker_id'] != current_speaker: if current_text: conversation.append({ 'speaker': current_speaker, 'text': ' '.join(current_text) }) current_speaker = word['speaker_id'] current_text = [word['text']] else: current_text.append(word['text']) # Add the last segment if current_text: conversation.append({ 'speaker': current_speaker, 'text': ' '.join(current_text) }) return conversation # Format the output conversation = create_conversation_transcript(result) for turn in conversation: print(f"{turn['speaker']}: {turn['text']}") ``` ## Utiliser des webhooks avec le mode multicanal La transcription multicanal prend en charge la [livraison par webhook](/docs/fr/eleven-api/guides/how-to/speech-to-text/batch/webhooks) pour le traitement asynchrone : > **Note** > > Les webhooks renvoient le format `separate` (par canal). `multichannel_output_style=combined` n’est pas > actuellement pris en charge avec la livraison par webhook. Utilisez une requête synchrone ou fusionnez > côté client la charge utile du webhook par canal. ```python from elevenlabs import ElevenLabs elevenlabs = ElevenLabs(api_key="YOUR_API_KEY") async def transcribe_multichannel_with_webhook(audio_file_path): with open(audio_file_path, 'rb') as audio_file: result = await elevenlabs.speech_to_text.convert_async( file=audio_file, model_id='scribe_v2', use_multi_channel=True, diarize=False, webhook=True # Enable webhook delivery ) print(f"Transcription started with task ID: {result.task_id}") return result.task_id ``` ## Gestion des erreurs ### Erreurs de validation courantes #### Définir diarize=true avec le mode multicanal **Erreur** : le mode multicanal ne prend pas en charge la diarisation et attribue les locuteurs selon le canal sur lequel ils parlent. **Solution** : définissez toujours `diarize=false` lorsque vous utilisez le mode multicanal. #### Fournir le paramètre num_speakers **Erreur** : impossible de spécifier num_speakers lorsque use_multi_channel est activé. Le nombre de locuteurs est automatiquement déterminé par le nombre de canaux. **Solution** : retirez le paramètre `num_speakers` de votre requête. #### Fichier audio comportant plus de 5 canaux **Erreur** : le mode multicanal prend en charge jusqu’à 5 canaux, mais le fichier audio contient X canaux. **Solution** : traitez uniquement les 5 premiers canaux ou prétraitez votre audio pour réduire le nombre de canaux. #### Utiliser la sortie combinée sans horodatages **Erreur** : multichannel_output_style='combined' nécessite des horodatages ; définissez timestamps_granularity sur 'word' ou 'character'. **Solution** : la sortie combinée trie les mots par heure. Définissez donc `timestamps_granularity` sur `word` (valeur par défaut) ou `character`. #### Utiliser la sortie combinée avec des webhooks **Erreur** : multichannel_output_style='combined' n’est pas encore pris en charge avec la livraison par webhook. **Solution** : utilisez une requête synchrone avec `combined`, ou conservez la sortie `separate` par défaut lorsque vous utilisez des webhooks et fusionnez côté client. ## Bonnes pratiques ### Préparation de l’audio > **Tip** > > Pour des résultats optimaux : - Utilisez une fréquence d’échantillonnage de 16 kHz pour de meilleures performances - Supprimez les canaux silencieux ou inutilisés avant le traitement - Assurez-vous que chaque canal ne contient qu’un seul locuteur - Utilisez des formats sans perte (WAV) lorsque cela est possible pour une qualité optimale ### Optimisation des performances Le coût en requêtes simultanées augmente linéairement avec le nombre de canaux. Un fichier de 60 secondes comportant 3 canaux coûte 3 fois plus en requêtes simultanées qu’un fichier à un seul canal. Vous pouvez estimer le temps de traitement d’un audio multicanal à l’aide de la formule suivante : $$ Processing\ Time = (D \cdot 0.3) + 2 + (N \cdot 0.5) $$ Où : * $D$ = durée du fichier en secondes * $N$ = nombre de canaux * $0.3$ = facteur de vitesse de traitement (environ 30 % du temps réel) * $2$ = surcharge fixe en secondes * $0.5$ = surcharge par canal en secondes **Exemple** : pour un fichier stéréo de 60 secondes (2 canaux) : $$ Processing\ Time = (60 \cdot 0.3) + 2 + (2 \cdot 0.5) = 18 + 2 + 1 = 21\ seconds $$ ### Considérations liées à la mémoire Pour les fichiers multicanaux volumineux, envisagez le streaming ou le découpage en segments : **`Python`** ```python title="Python" def process_large_multichannel_file(file_path, chunk_duration=300): """Process large files in chunks (5-minute segments)""" from pydub import AudioSegment from elevenlabs import ElevenLabs import os elevenlabs = ElevenLabs(api_key="YOUR_API_KEY") audio = AudioSegment.from_file(file_path) duration_ms = len(audio) chunk_size_ms = chunk_duration * 1000 all_transcripts = [] for start_ms in range(0, duration_ms, chunk_size_ms): end_ms = min(start_ms + chunk_size_ms, duration_ms) # Extract chunk chunk = audio[start_ms:end_ms] chunk_file = f"temp_chunk_{start_ms}.wav" chunk.export(chunk_file, format="wav") # Transcribe chunk using SDK with open(chunk_file, 'rb') as audio_file: result = elevenlabs.speech_to_text.convert( file=audio_file, model_id='scribe_v2', use_multi_channel=True, diarize=False, timestamps_granularity='word' ) # Adjust timestamps if hasattr(result, 'transcripts'): for transcript in result.transcripts: for word in transcript.words or []: word.start += start_ms / 1000 word.end += start_ms / 1000 all_transcripts.extend(result.transcripts) # Clean up os.remove(chunk_file) return all_transcripts ``` **`JavaScript`** ```javascript title="JavaScript" import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js"; import { exec } from "child_process"; import fs from "fs"; import path from "path"; import { promisify } from "util"; const execAsync = promisify(exec); const elevenlabs = new ElevenLabsClient({ apiKey: process.env.ELEVENLABS_API_KEY, }); async function processLargeMultichannelFile(filePath, chunkDuration = 300) { /** * Process large files in chunks (5-minute segments) * Requires ffmpeg to be installed */ // Get audio duration using ffprobe const { stdout } = await execAsync( `ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "${filePath}"` ); const durationSeconds = parseFloat(stdout); const allTranscripts = []; for (let startSeconds = 0; startSeconds < durationSeconds; startSeconds += chunkDuration) { const endSeconds = Math.min(startSeconds + chunkDuration, durationSeconds); const chunkFile = path.join(path.dirname(filePath), `temp_chunk_${startSeconds}.wav`); // Extract chunk using ffmpeg await execAsync( `ffmpeg -i "${filePath}" -ss ${startSeconds} -t ${chunkDuration} -c:a pcm_s16le "${chunkFile}" -y` ); try { // Transcribe chunk const audioFile = fs.createReadStream(chunkFile); const result = await elevenlabs.speechToText.convert({ file: audioFile, modelId: "scribe_v2", useMultiChannel: true, diarize: false, timestampsGranularity: "word", }); // Adjust timestamps if (result.transcripts) { for (const transcript of result.transcripts) { for (const word of transcript.words || []) { word.start += startSeconds; word.end += startSeconds; } } allTranscripts.push(...result.transcripts); } } finally { // Clean up fs.unlinkSync(chunkFile); } } return { transcripts: allTranscripts }; } ``` ## FAQ #### Que se passe-t-il si mon audio comporte plus de 5 canaux ? L’API renverra une erreur. Vous devrez sélectionner les 5 canaux à envoyer à l’API ou mixer certains canaux avant de les envoyer à l’API. #### Puis-je traiter un audio mono avec le mode multicanal ? Oui, mais ce n’est pas nécessaire. Si vous envoyez un audio mono avec `use_multi_channel=true`, vous recevrez une réponse standard à un seul canal, et non le format multicanal. #### Puis-je obtenir une transcription combinée au lieu de transcriptions distinctes par canal ? Oui. Définissez `multichannel_output_style=combined` pour recevoir une seule transcription regroupant tous les canaux et triée par heure de début, chaque mot étant étiqueté avec son `channel_index`. Cela correspond au format de réponse standard pour un seul canal. Des horodatages sont requis et cette option n’est pas disponible avec la livraison par webhook. #### Comment les identifiants de locuteur sont-ils attribués ? Les identifiants de locuteur sont déterministes selon le numéro de canal : le canal 0 devient speaker_0, le canal 1 devient speaker_1, et ainsi de suite. #### Les canaux peuvent-ils avoir des langues différentes ? Oui, chaque canal est traité indépendamment et peut détecter différentes langues. La détection de la langue s’effectue par canal. Avec `multichannel_output_style=combined`, le `language_code` de niveau supérieur reflète le canal détecté avec le plus de certitude, tandis que chaque mot conserve son `channel_index`. ## Étapes suivantes #### [Guide de l’API](/docs/fr/api-reference/speech-to-text) Guide complet de l’API Speech to Text et de ses paramètres. #### [Webhooks](/docs/fr/eleven-api/guides/how-to/speech-to-text/batch/webhooks) Recevez les résultats de transcription de manière asynchrone via webhook.