> 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. # Flerkanalig tal-till-text > **Note** > > **Guide** · Förutsätter att du har slutfört [snabbstarten för Speech to Text ](/docs/sv/eleven-api/guides/cookbooks/speech-to-text). ## Översikt Den flerkanaliga Speech to Text-funktionen låter dig transkribera ljudfiler där varje kanal innehåller en egen talare. Det är särskilt användbart för inspelningar där talare är isolerade på separata ljudkanaler, vilket ger renare transkriberingar utan behov av talardiarisering. Varje kanal bearbetas oberoende och tilldelas automatiskt ett talar-ID baserat på kanalnumret (kanal 0 → `speaker_0`, kanal 1 → `speaker_1` osv.). Systemet extraherar enskilda kanaler från din ingående ljudfil och transkriberar dem parallellt. Som standard returnerar API:t en transkribering per kanal. Ange `multichannel_output_style=combined` för att i stället få en enda transkribering där alla kanaler är sammanfogade till en lista sorterad efter starttid, med varje ord märkt med sitt `channel_index`. ### Vanliga användningsfall * **Stereoinspelade intervjuer** - Intervjuare på vänster kanal, intervjuad på höger kanal * **Poddinspelningar med flera spår** - Varje deltagare spelas in på ett separat spår * **Inspelningar från kundtjänstcenter** - Agent och kund på olika kanaler * **Konferensinspelningar** - Enskilda deltagare isolerade på separata kanaler * **Domstolsförhandlingar** - Flera parter spelas in på separata kanaler ## Krav * Ett ElevenLabs-konto med en [API-nyckel](https://elevenlabs.io/app/settings/api-keys) * Flerkanalig ljudfil (WAV, MP3 eller andra format som stöds) * Högst 5 kanaler per ljudfil * Varje kanal ska endast innehålla en talare ## Så fungerar det #### Förbered ditt flerkanaliga ljud Se till att talarna är isolerade på separata kanaler i din ljudfil. Den flerkanaliga funktionen stöder upp till 5 kanaler, där varje kanal mappas till en specifik talare: * Kanal 0 → `speaker_0` * Kanal 1 → `speaker_1` * Kanal 2 → `speaker_2` * Kanal 3 → `speaker_3` * Kanal 4 → `speaker_4` #### Konfigurera API-parametrar När du gör en tal-till-text-begäran måste du ange: * `use_multi_channel`: `true` * `diarize`: `false` (flerkanaligt läge hanterar talarseparering via kanaler) Du kan även styra svarsformatet med: * `multichannel_output_style`: `separate` (standard) returnerar en transkribering per kanal. `combined` sammanfogar alla kanaler till en enda transkribering vars ord sorteras efter starttid, där varje ord har ett `channel_index` — vilket motsvarar standardformatet för svar med en kanal. `combined` kräver tidsstämplar (`timestamps_granularity` får inte vara `none`) och stöds inte med webhook-leverans eller entitetsidentifiering/-maskering. Parametern `num_speakers` kan inte användas med flerkanaligt läge eftersom antalet talare automatiskt bestäms av antalet kanaler. Flerkanaligt läge förutsätter att det finns exakt en talare per kanal. Om det finns fler tilldelas alla talare i kanalen samma talar-ID. #### Bearbeta svaret Som standard (`multichannel_output_style=separate`) returnerar flerkanaligt ljud ett annat svarsformat än en kanal: > **Note** > > Om du anger `use_multi_channel: true` men tillhandahåller en ljudfil med en kanal (mono) får du > ett standardsvar för en kanal, inte det flerkanaliga formatet. Det flerkanaliga svarsformatet > returneras bara när ljudfilen faktiskt innehåller flera kanaler. **`Svar för en kanal`** ```python title="Svar för en kanal" { "language_code": "en", "language_probability": 0.98, "text": "Hello world", "words": [...] } ``` **`Flerkanaligt svar`** ```python title="Flerkanaligt svar" { "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": [...] } ] } ``` **`Kombinerat svar (multichannel_output_style=combined)`** ```python title="Kombinerat svar (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 } ] } ``` Med `multichannel_output_style=combined` använder svaret samma platta format som en transkribering med en kanal (`text` och `words` på toppnivå, ingen `transcripts`-array), där alla kanaler är sammanfogade till en lista sorterad efter starttid. Varje ord innehåller ett `channel_index` (och `speaker_id`) som identifierar kanalen. ## Implementering ### Grundläggande flerkanalig transkribering Här är ett komplett exempel på hur du transkriberar en stereoljudfil med två talare: **`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" ``` ### Skapa konversationstranskriberingar Det enklaste sättet att få en tidsordnad transkribering i konversationsstil är att begära `multichannel_output_style=combined` — API:t returnerar en enda `words`-lista, redan sorterad efter starttid, med ett `channel_index` och `speaker_id` för varje ord: **`Kombinerad utdata (rekommenderas)`** ```python title="Kombinerad utdata (rekommenderas)" 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}") ``` Om du använder standardutdata `separate` kan du i stället sammanfoga transkriberingarna per kanal på klientsidan: ```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']}") ``` ## Använda webhooks med flera kanaler Flerkanalig transkribering stöder [webhook-leverans](/docs/sv/eleven-api/guides/how-to/speech-to-text/batch/webhooks) för asynkron bearbetning: > **Note** > > Webhooks returnerar formatet `separate` (per kanal). `multichannel_output_style=combined` stöds > för närvarande inte med webhook-leverans — använd en synkron begäran eller sammanfoga > webhook-payloaden per kanal på klientsidan. ```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 ``` ## Felhantering ### Vanliga valideringsfel #### Ange diarize=true med flerkanaligt läge **Fel**: Flerkanaligt läge stöder inte diariseringsfunktionen och tilldelar talare baserat på kanalen de talar på. **Lösning**: Ange alltid `diarize=false` när du använder flerkanaligt läge. #### Ange parametern num\_speakers **Fel**: Det går inte att ange num\_speakers när use\_multi\_channel är aktiverat. Antalet talare bestäms automatiskt av antalet kanaler. **Lösning**: Ta bort parametern `num_speakers` från din begäran. #### Ljudfil med fler än 5 kanaler **Fel**: Flerkanaligt läge stöder upp till 5 kanaler, men ljudfilen innehåller X kanaler. **Lösning**: Bearbeta endast de första 5 kanalerna eller förbearbeta ljudet för att minska antalet kanaler. #### Använda kombinerad utdata utan tidsstämplar **Fel**: multichannel\_output\_style='combined' kräver tidsstämplar; ange timestamps\_granularity till 'word' eller 'character'. **Lösning**: Kombinerad utdata sorterar ord efter tid, så ange `timestamps_granularity` till `word` (standard) eller `character`. #### Använda kombinerad utdata med webhooks **Fel**: multichannel\_output\_style='combined' stöds ännu inte med webhook-leverans. **Lösning**: Använd en synkron begäran med `combined`, eller behåll standardutdata `separate` när du använder webhooks och sammanfoga på klientsidan. ## Bästa praxis ### Förbereda ljud > **Tip** > > För bästa resultat: - Använd samplingsfrekvensen 16 kHz för bättre prestanda - Ta bort tysta eller oanvända > kanaler före bearbetning - Se till att varje kanal endast innehåller en talare - Använd förlustfria format > (WAV) när det är möjligt för bästa kvalitet ### Prestandaoptimering Kostnaden för samtidighet ökar linjärt med antalet kanaler. En fil på 60 sekunder med 3 kanaler har tre gånger så hög samtidighetskostnad som en fil med en kanal. Du kan uppskatta bearbetningstiden för flerkanaligt ljud med följande formel: $$ Processing\ Time = (D \cdot 0.3) + 2 + (N \cdot 0.5) $$ Där: * $D$ = filens längd i sekunder * $N$ = antal kanaler * $0.3$ = bearbetningshastighetsfaktor (cirka 30 % av realtid) * $2$ = fast omkostnad i sekunder * $0.5$ = omkostnad per kanal i sekunder **Exempel**: För en stereofil på 60 sekunder (2 kanaler): $$ Processing\ Time = (60 \cdot 0.3) + 2 + (2 \cdot 0.5) = 18 + 2 + 1 = 21\ seconds $$ ### Minneshantering För stora flerkanaliga filer bör du överväga streaming eller uppdelning i segment: **`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 }; } ``` ## Vanliga frågor #### Vad händer om mitt ljud har fler än 5 kanaler? API:t returnerar ett fel. Du behöver antingen välja vilka 5 kanaler som ska skickas till API:t eller mixa ned några kanaler innan du skickar dem till API:t. #### Kan jag bearbeta monoljud med flerkanaligt läge? Ja, men det är onödigt. Om du skickar monoljud med `use_multi_channel=true` får du ett standardsvar för en kanal, inte det flerkanaliga formatet. #### Kan jag få en kombinerad transkribering i stället för separata transkriberingar per kanal? Ja. Ange `multichannel_output_style=combined` för att få en enda transkribering med alla kanaler sammanfogade och sorterade efter starttid, där varje ord är märkt med sitt `channel_index`. Detta motsvarar standardformatet för svar med en kanal. Det kräver tidsstämplar och är inte tillgängligt med webhook- leverans. #### Hur tilldelas talar-ID:n? Talar-ID:n är deterministiska baserat på kanalnummer: kanal 0 blir speaker\_0, kanal 1 blir speaker\_1 och så vidare. #### Kan kanaler ha olika språk? Ja, varje kanal bearbetas oberoende och kan identifiera olika språk. Språkidentifieringen sker per kanal. Med `multichannel_output_style=combined` återspeglar `language_code` på toppnivå kanalen med högst säkerhet, medan varje ord fortfarande har sitt `channel_index`. ## Nästa steg #### [API-referens](/docs/sv/api-reference/speech-to-text) Fullständig API-referens och parametrar för Speech to Text. #### [Webhooks](/docs/sv/eleven-api/guides/how-to/speech-to-text/batch/webhooks) Ta emot transkriberingsresultat asynkront via webhook.