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

# Spraak-naar-tekst met meerdere kanalen

> **Note**
>
> **Stapsgewijze handleiding** · Hierbij wordt ervan uitgegaan dat je de [korte introductie voor Speech to Text ](/docs/nl/eleven-api/guides/cookbooks/speech-to-text) hebt voltooid.

## Overzicht

Met de Speech to Text-functie voor meerdere kanalen kun je audiobestanden transcriberen waarin elk kanaal een afzonderlijke spreker bevat. Dit is vooral nuttig voor opnamen waarbij sprekers zijn geïsoleerd op afzonderlijke audiokanalen, zodat je schonere transcripties krijgt zonder sprekerdiarisatie.

Elk kanaal wordt onafhankelijk verwerkt en krijgt automatisch een spreker-ID toegewezen op basis van het kanaalnummer (kanaal 0 → `speaker_0`, kanaal 1 → `speaker_1`, enzovoort). Het systeem extraheert afzonderlijke kanalen uit je ingevoerde audiobestand en transcribeert ze parallel. Standaard retourneert de API één transcript per kanaal; stel `multichannel_output_style=combined` in om in plaats daarvan één transcript te ontvangen waarin alle kanalen zijn samengevoegd tot één lijst, gesorteerd op starttijd, waarbij elk woord is gelabeld met de bijbehorende `channel_index`.

### Veelvoorkomende toepassingen

* **Stereo-interviewopnamen** - Interviewer op het linkerkanaal, geïnterviewde op het rechterkanaal
* **Podcastopnamen met meerdere tracks** - Elke deelnemer wordt op een afzonderlijke track opgenomen
* **Callcenteropnamen** - Agent en klant zijn gescheiden op verschillende kanalen
* **Conferentieopnamen** - Afzonderlijke deelnemers zijn geïsoleerd op aparte kanalen
* **Rechtszittingen** - Meerdere partijen worden op afzonderlijke kanalen opgenomen

## Vereisten

* Een ElevenLabs-account met een [API-sleutel](https://elevenlabs.io/app/settings/api-keys)
* Audiobestand met meerdere kanalen (WAV, MP3 of andere ondersteunde formaten)
* Maximaal 5 kanalen per audiobestand
* Elk kanaal mag slechts één spreker bevatten

## Zo werkt het

#### Bereid je audio met meerdere kanalen voor

Zorg dat de sprekers in je audiobestand op afzonderlijke kanalen zijn geïsoleerd. De functie voor meerdere kanalen ondersteunt maximaal 5 kanalen, waarbij elk kanaal aan een specifieke spreker wordt toegewezen:

* Kanaal 0 → `speaker_0`
* Kanaal 1 → `speaker_1`
* Kanaal 2 → `speaker_2`
* Kanaal 3 → `speaker_3`
* Kanaal 4 → `speaker_4`

#### Configureer API-parameters

Wanneer je een spraak-naar-tekstrequest doet, moet je het volgende instellen:

* `use_multi_channel`: `true`
* `diarize`: `false` (de modus voor meerdere kanalen scheidt sprekers via kanalen)

Je kunt de vorm van de response optioneel bepalen met:

* `multichannel_output_style`: `separate` (standaard) retourneert één transcript per kanaal. Met `combined` worden alle kanalen samengevoegd tot één transcript waarvan de woorden op starttijd zijn gesorteerd, elk met een `channel_index` — overeenkomstig de standaardresponse voor één kanaal. Voor `combined` zijn timestamps vereist (`timestamps_granularity` mag niet `none` zijn) en dit wordt niet ondersteund met webhooklevering of entiteitsdetectie/-redactie.

De parameter `num_speakers` kan niet worden gebruikt met de modus voor meerdere kanalen, omdat het aantal sprekers automatisch wordt bepaald door het aantal kanalen. De modus voor meerdere kanalen gaat ervan uit dat er precies één spreker per kanaal is. Als er meer zijn, wordt dezelfde spreker-ID toegewezen aan alle sprekers in het kanaal.

#### Verwerk de response

Standaard (`multichannel_output_style=separate`) retourneert audio met meerdere kanalen een andere response-indeling dan audio met één kanaal:

> **Note**
>
> Als je `use_multi_channel: true` instelt maar een audiobestand met één kanaal (mono) opgeeft, ontvang je
> een standaardresponse voor één kanaal, niet de indeling voor meerdere kanalen. De response-indeling voor meerdere kanalen
> wordt alleen geretourneerd wanneer het audiobestand daadwerkelijk meerdere kanalen bevat.

**`Response voor één kanaal`**

```python title="Response voor één kanaal"
{
  "language_code": "en",
  "language_probability": 0.98,
  "text": "Hello world",
  "words": [...]
}
```

**`Response voor meerdere kanalen`**

```python title="Response voor meerdere kanalen"
{
  "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": [...]
    }
  ]
}
```

**`Gecombineerde response (multichannel_output_style=combined)`**

```python title="Gecombineerde 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 }
  ]
}
```

Met `multichannel_output_style=combined` gebruikt de response dezelfde platte structuur als een transcriptie voor één kanaal (`text` en `words` op hoofdniveau, geen `transcripts`-array), waarbij alle kanalen zijn samengevoegd tot één lijst die is gesorteerd op starttijd. Elk woord bevat een `channel_index` (en `speaker_id`) die het kanaal aangeeft.

## Implementatie

### Eenvoudige transcriptie met meerdere kanalen

Hier is een volledig voorbeeld van het transcriberen van een stereo-audiobestand met twee sprekers:

**`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"
```

### Gesprekstranscripten maken

De eenvoudigste manier om een transcript in gespreksstijl op tijdvolgorde te krijgen, is `multichannel_output_style=combined` aan te vragen — de API retourneert één `words`-lijst, al gesorteerd op starttijd, met een `channel_index` en `speaker_id` bij elk woord:

**`Gecombineerde uitvoer (aanbevolen)`**

```python title="Gecombineerde uitvoer (aanbevolen)"
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}")
```

Als je de standaarduitvoer `separate` gebruikt, kun je de transcripten per kanaal in plaats daarvan client-side samenvoegen:

```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 gebruiken met meerdere kanalen

Transcriptie met meerdere kanalen ondersteunt [webhooklevering](/docs/nl/eleven-api/guides/how-to/speech-to-text/batch/webhooks) voor asynchrone verwerking:

> **Note**
>
> Webhooks retourneren de indeling `separate` (per kanaal). `multichannel_output_style=combined` wordt
> momenteel niet ondersteund met webhooklevering — gebruik een synchrone request, of voeg de webhook-payloads
> per kanaal client-side samen.

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

## Foutafhandeling

### Veelvoorkomende validatiefouten

#### diarize=true instellen met de modus voor meerdere kanalen

**Fout**: De modus voor meerdere kanalen ondersteunt geen diarization en wijst sprekers toe op basis van het
kanaal waarop ze spreken.

**Oplossing**: Stel altijd `diarize=false` in wanneer je de modus voor meerdere kanalen gebruikt.

#### De parameter num\_speakers opgeven

**Fout**: Kan num\_speakers niet opgeven wanneer use\_multi\_channel is ingeschakeld. Het aantal sprekers
wordt automatisch bepaald door het aantal kanalen. **Oplossing**: Verwijder de parameter
`num_speakers` uit je request.

#### Audiobestand met meer dan 5 kanalen

**Fout**: De modus voor meerdere kanalen ondersteunt maximaal 5 kanalen, maar het audiobestand bevat X kanalen.

**Oplossing**: Verwerk alleen de eerste 5 kanalen of verwerk je audio vooraf om het aantal kanalen te
verminderen.

#### Gecombineerde uitvoer zonder timestamps gebruiken

**Fout**: multichannel\_output\_style='combined' vereist timestamps; stel timestamps\_granularity
in op 'word' of 'character'.

**Oplossing**: De gecombineerde uitvoer sorteert woorden op tijd, dus stel `timestamps_granularity` in op `word`
(de standaardwaarde) of `character`.

#### Gecombineerde uitvoer met webhooks gebruiken

**Fout**: multichannel\_output\_style='combined' wordt nog niet ondersteund met webhooklevering.

**Oplossing**: Gebruik een synchrone request met `combined`, of behoud de standaarduitvoer `separate`
wanneer je webhooks gebruikt en voeg client-side samen.

## Best practices

### Audio voorbereiden

> **Tip**
>
> Voor optimale resultaten: - Gebruik een samplefrequentie van 16 kHz voor betere prestaties - Verwijder stille of ongebruikte
> kanalen vóór verwerking - Zorg dat elk kanaal slechts één spreker bevat - Gebruik waar mogelijk lossless-formaten
> (WAV) voor de beste kwaliteit

### Prestaties optimaliseren

De concurrencykosten nemen lineair toe met het aantal kanalen. Een bestand van 60 seconden met 3 kanalen heeft 3x de concurrencykosten van een bestand met één kanaal.

Je kunt de verwerkingstijd voor audio met meerdere kanalen schatten met de volgende formule:

$$
Processing\ Time = (D \cdot 0.3) + 2 + (N \cdot 0.5)
$$

Waarbij:

* $D$ = bestandsduur in seconden
* $N$ = aantal kanalen
* $0.3$ = verwerkingssnelheidsfactor (ongeveer 30% van realtime)
* $2$ = vaste overhead in seconden
* $0.5$ = overhead per kanaal in seconden

**Voorbeeld**: Voor een stereobestand van 60 seconden (2 kanalen):

$$
Processing\ Time = (60 \cdot 0.3) + 2 + (2 \cdot 0.5) = 18 + 2 + 1 = 21\ seconds
$$

### Overwegingen voor geheugen

Overweeg voor grote bestanden met meerdere kanalen streaming of chunking:

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

## Veelgestelde vragen

#### Wat gebeurt er als mijn audio meer dan 5 kanalen heeft?

De API retourneert een fout. Je moet kiezen welke 5 kanalen je naar de API stuurt
of enkele kanalen mixen voordat je ze naar de API stuurt.

#### Kan ik mono-audio verwerken met de modus voor meerdere kanalen?

Ja, maar dat is niet nodig. Als je mono-audio verstuurt met `use_multi_channel=true`, ontvang je
een standaardresponse voor één kanaal, niet de indeling voor meerdere kanalen.

#### Kan ik één gecombineerd transcript krijgen in plaats van afzonderlijke transcripten per kanaal?

Ja. Stel `multichannel_output_style=combined` in om één transcript te ontvangen waarin alle kanalen
zijn samengevoegd en op starttijd zijn gesorteerd, waarbij elk woord is gelabeld met de bijbehorende `channel_index`. Dit komt overeen met de
standaardresponse-indeling voor één kanaal. Hiervoor zijn timestamps vereist en dit is niet beschikbaar met webhook-
levering.

#### Hoe worden spreker-ID's toegewezen?

Spreker-ID's worden deterministisch toegewezen op basis van het kanaalnummer: kanaal 0 wordt speaker\_0, kanaal 1
wordt speaker\_1, enzovoort.

#### Kunnen kanalen verschillende talen hebben?

Ja, elk kanaal wordt onafhankelijk verwerkt en kan verschillende talen detecteren. De taaldetectie
vindt per kanaal plaats. Met `multichannel_output_style=combined` geeft `language_code` op hoofdniveau
het kanaal met de grootste zekerheid weer, terwijl elk woord nog steeds de bijbehorende
`channel_index` bevat.

## Volgende stappen

#### [API-referentie](/docs/nl/api-reference/speech-to-text)

Volledige Speech to Text-API-referentie en parameters.

#### [Webhooks](/docs/nl/eleven-api/guides/how-to/speech-to-text/batch/webhooks)

Ontvang transcriptieresultaten asynchroon via webhook.