> 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. # Mehrkanal-Speech-to-Text > **Note** > > **Anleitung** · Setzt voraus, dass Sie den [Speech to Text- Schnellstart](/docs/de/eleven-api/guides/cookbooks/speech-to-text) abgeschlossen haben. ## Überblick Mit der Mehrkanal-Funktion von Speech to Text können Sie Audiodateien transkribieren, bei denen jeder Kanal einen eigenen Sprecher enthält. Das ist besonders für Aufnahmen nützlich, bei denen Sprecher auf separaten Audiokanälen isoliert sind. So erhalten Sie sauberere Transkriptionen ohne Sprecherdiarisierung. Jeder Kanal wird unabhängig verarbeitet und anhand seiner Kanalnummer automatisch einer Sprecher-ID zugeordnet (Kanal 0 → `speaker_0`, Kanal 1 → `speaker_1` usw.). Das System extrahiert die einzelnen Kanäle aus Ihrer Eingabe-Audiodatei und transkribiert sie parallel. Standardmäßig gibt die API ein Transkript pro Kanal zurück. Legen Sie stattdessen `multichannel_output_style=combined` fest, um ein einzelnes Transkript mit allen Kanälen in einer nach Startzeit sortierten Liste zu erhalten, wobei jedes Wort mit seinem `channel_index` gekennzeichnet ist. ### Häufige Anwendungsfälle * **Stereo-Interviewaufnahmen** – Interviewer auf dem linken Kanal, Interviewte Person auf dem rechten Kanal * **Mehrspurige Podcast-Aufnahmen** – Jeder Teilnehmer wird auf einer separaten Spur aufgenommen * **Callcenter-Aufnahmen** – Agent und Kunde auf unterschiedlichen Kanälen * **Konferenzaufnahmen** – Einzelne Teilnehmer auf separaten Kanälen isoliert * **Gerichtsverfahren** – Mehrere Parteien auf unterschiedlichen Kanälen aufgezeichnet ## Anforderungen * Ein ElevenLabs-Konto mit einem [API-Schlüssel](https://elevenlabs.io/app/settings/api-keys) * Mehrkanal-Audiodatei (WAV, MP3 oder andere unterstützte Formate) * Maximal 5 Kanäle pro Audiodatei * Jeder Kanal sollte nur einen Sprecher enthalten ## Funktionsweise #### Mehrkanal-Audio vorbereiten Stellen Sie sicher, dass die Sprecher in Ihrer Audiodatei auf separaten Kanälen isoliert sind. Die Mehrkanal-Funktion unterstützt bis zu 5 Kanäle, wobei jeder Kanal einem bestimmten Sprecher zugeordnet wird: * Kanal 0 → `speaker_0` * Kanal 1 → `speaker_1` * Kanal 2 → `speaker_2` * Kanal 3 → `speaker_3` * Kanal 4 → `speaker_4` #### API-Parameter konfigurieren Bei einer Speech-to-Text-Anfrage müssen Sie Folgendes festlegen: * `use_multi_channel`: `true` * `diarize`: `false` (der Mehrkanalmodus trennt Sprecher über Kanäle) Optional können Sie das Antwortformat festlegen: * `multichannel_output_style`: `separate` (Standard) gibt ein Transkript pro Kanal zurück. `combined` führt alle Kanäle in einem einzelnen Transkript zusammen, dessen Wörter nach Startzeit sortiert sind und jeweils einen `channel_index` enthalten – entsprechend dem Standard-Antwortformat für einen einzelnen Kanal. `combined` erfordert Zeitstempel (`timestamps_granularity` darf nicht `none` sein) und wird nicht mit Webhook-Bereitstellung oder Entitätserkennung/-schwärzung unterstützt. Der Parameter `num_speakers` kann im Mehrkanalmodus nicht verwendet werden, da die Sprecheranzahl automatisch durch die Anzahl der Kanäle bestimmt wird. Der Mehrkanalmodus setzt voraus, dass jeder Kanal genau einen Sprecher enthält. Bei mehreren Sprechern wird allen Sprechern im Kanal dieselbe Sprecher-ID zugewiesen. #### Antwort verarbeiten Standardmäßig (`multichannel_output_style=separate`) gibt Mehrkanal-Audio ein anderes Antwortformat zurück als ein einzelner Kanal: > **Note** > > Wenn Sie `use_multi_channel: true` festlegen, aber eine einkanalige (Mono-)Audiodatei bereitstellen, erhalten Sie > eine Standardantwort für einen einzelnen Kanal und nicht das Mehrkanalformat. Das Mehrkanal-Antwortformat > wird nur zurückgegeben, wenn die Audiodatei tatsächlich mehrere Kanäle enthält. **`Single channel response`** ```python title="Single channel response" { "language_code": "en", "language_probability": 0.98, "text": "Hello world", "words": [...] } ``` **`Multichannel response`** ```python title="Multichannel response" { "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": [...] } ] } ``` **`Combined response (multichannel_output_style=combined)`** ```python title="Combined response (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 } ] } ``` Mit `multichannel_output_style=combined` verwendet die Antwort dieselbe flache Struktur wie eine Transkription für einen einzelnen Kanal (oberste Ebene mit `text` und `words`, ohne `transcripts`-Array). Alle Kanäle werden in einer nach Startzeit sortierten Liste zusammengeführt. Jedes Wort enthält einen `channel_index` (und `speaker_id`) zur Identifizierung seines Kanals. ## Implementierung ### Einfache Mehrkanal-Transkription Hier ist ein vollständiges Beispiel für die Transkription einer Stereo-Audiodatei mit zwei Sprechern: **`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" ``` ### Gesprächstranskripte erstellen Am einfachsten erhalten Sie ein nach Zeit geordnetes Transkript im Gesprächsstil, indem Sie `multichannel_output_style=combined` anfordern. Die API gibt eine einzelne `words`-Liste zurück, die bereits nach Startzeit sortiert ist und bei jedem Wort einen `channel_index` und `speaker_id` enthält: **`Combined output (recommended)`** ```python title="Combined output (recommended)" 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}") ``` Wenn Sie die Standardausgabe `separate` verwenden, können Sie die Transkripte pro Kanal stattdessen clientseitig zusammenführen: ```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']}") ``` ## Webhooks mit Mehrkanal verwenden Die Mehrkanal-Transkription unterstützt die [Webhook-Bereitstellung](/docs/de/eleven-api/guides/how-to/speech-to-text/batch/webhooks) für die asynchrone Verarbeitung: > **Note** > > Webhooks geben das Format `separate` (pro Kanal) zurück. `multichannel_output_style=combined` wird derzeit > nicht mit Webhook-Bereitstellung unterstützt – verwenden Sie eine synchrone Anfrage oder führen Sie die Nutzdaten > der Webhooks pro Kanal clientseitig zusammen. ```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 ``` ## Fehlerbehandlung ### Häufige Validierungsfehler #### diarize=true im Mehrkanalmodus festlegen **Fehler**: Der Mehrkanalmodus unterstützt keine Diarisierung und weist Sprecher anhand des Kanals zu, auf dem sie sprechen. **Lösung**: Legen Sie bei Verwendung des Mehrkanalmodus immer `diarize=false` fest. #### Parameter num_speakers bereitstellen **Fehler**: num_speakers kann nicht angegeben werden, wenn use_multi_channel aktiviert ist. Die Sprecheranzahl wird automatisch durch die Anzahl der Kanäle bestimmt. **Lösung**: Entfernen Sie den Parameter `num_speakers` aus Ihrer Anfrage. #### Audiodatei mit mehr als 5 Kanälen **Fehler**: Der Mehrkanalmodus unterstützt bis zu 5 Kanäle, aber die Audiodatei enthält X Kanäle. **Lösung**: Verarbeiten Sie nur die ersten 5 Kanäle oder bereiten Sie Ihr Audio vorab so auf, dass sich die Anzahl der Kanäle reduziert. #### Kombinierte Ausgabe ohne Zeitstempel verwenden **Fehler**: multichannel_output_style='combined' erfordert Zeitstempel; setzen Sie timestamps_granularity auf 'word' oder 'character'. **Lösung**: Die kombinierte Ausgabe sortiert Wörter nach Zeit. Setzen Sie daher `timestamps_granularity` auf `word` (den Standardwert) oder `character`. #### Kombinierte Ausgabe mit Webhooks verwenden **Fehler**: multichannel_output_style='combined' wird noch nicht mit Webhook-Bereitstellung unterstützt. **Lösung**: Verwenden Sie eine synchrone Anfrage mit `combined`, oder behalten Sie die Standardausgabe `separate` bei Webhooks bei und führen Sie die Ergebnisse clientseitig zusammen. ## Best Practices ### Audio vorbereiten > **Tip** > > Für optimale Ergebnisse: - Verwenden Sie eine Abtastrate von 16 kHz für bessere Leistung - Entfernen Sie stille oder ungenutzte > Kanäle vor der Verarbeitung - Stellen Sie sicher, dass jeder Kanal nur einen Sprecher enthält - Verwenden Sie nach Möglichkeit verlustfreie Formate > (WAV) für beste Qualität ### Leistung optimieren Die Parallelitätskosten steigen linear mit der Anzahl der Kanäle. Eine 60-sekündige Datei mit 3 Kanälen verursacht die dreifachen Parallelitätskosten einer einkanaligen Datei. Sie können die Verarbeitungszeit für Mehrkanal-Audio mit der folgenden Formel schätzen: $$ Processing\ Time = (D \cdot 0.3) + 2 + (N \cdot 0.5) $$ Dabei gilt: * $D$ = Dateidauer in Sekunden * $N$ = Anzahl der Kanäle * $0.3$ = Faktor für die Verarbeitungsgeschwindigkeit (etwa 30 % der Echtzeit) * $2$ = fester Overhead in Sekunden * $0.5$ = Overhead pro Kanal in Sekunden **Beispiel**: Für eine 60-sekündige Stereo-Datei (2 Kanäle): $$ Processing\ Time = (60 \cdot 0.3) + 2 + (2 \cdot 0.5) = 18 + 2 + 1 = 21\ seconds $$ ### Speicheraspekte Bei großen Mehrkanaldateien sollten Sie Streaming oder Aufteilung in Chunks erwägen: **`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 #### Was passiert, wenn mein Audio mehr als 5 Kanäle hat? Die API gibt einen Fehler zurück. Sie müssen entweder auswählen, welche 5 Kanäle Sie an die API senden, oder einige Kanäle vor dem Senden an die API zusammenmischen. #### Kann ich Mono-Audio im Mehrkanalmodus verarbeiten? Ja, aber das ist nicht nötig. Wenn Sie Mono-Audio mit `use_multi_channel=true` senden, erhalten Sie eine Standardantwort für einen einzelnen Kanal und nicht das Mehrkanalformat. #### Kann ich ein kombiniertes Transkript statt separater Transkripte pro Kanal erhalten? Ja. Setzen Sie `multichannel_output_style=combined`, um ein einzelnes Transkript mit allen Kanälen zu erhalten, die zusammengeführt und nach Startzeit sortiert sind. Jedes Wort ist mit seinem `channel_index` gekennzeichnet. Dies entspricht dem Standard-Antwortformat für einen einzelnen Kanal. Es erfordert Zeitstempel und ist nicht mit Webhook- Bereitstellung verfügbar. #### Wie werden Sprecher-IDs zugewiesen? Sprecher-IDs werden anhand der Kanalnummer deterministisch zugewiesen: Kanal 0 wird zu speaker_0, Kanal 1 wird zu speaker_1 usw. #### Können Kanäle unterschiedliche Sprachen haben? Ja, jeder Kanal wird unabhängig verarbeitet und kann unterschiedliche Sprachen erkennen. Die Spracherkennung erfolgt pro Kanal. Mit `multichannel_output_style=combined` spiegelt der `language_code` auf oberster Ebene den Kanal mit der höchsten Erkennungswahrscheinlichkeit wider, während jedes Wort weiterhin seinen `channel_index` enthält. ## Nächste Schritte #### [API-Referenz](/docs/de/api-reference/speech-to-text) Vollständige Speech to Text API-Referenz und Parameter. #### [Webhooks](/docs/de/eleven-api/guides/how-to/speech-to-text/batch/webhooks) Transkriptionsergebnisse asynchron über Webhook erhalten.