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

# Voz a Texto multicanal

> **Note**
>
> **Guía práctica** · Da por hecho que has completado la [guía de inicio rápido de Voz a Texto ](/docs/es/eleven-api/guides/cookbooks/speech-to-text).

## Resumen

La función de Voz a Texto multicanal te permite transcribir archivos de audio en los que cada canal contiene un hablante distinto. Es especialmente útil para grabaciones en las que los hablantes están aislados en canales de audio independientes, ya que ofrece transcripciones más limpias sin necesidad de diarización de hablantes.

Cada canal se procesa de forma independiente y se le asigna automáticamente un ID de hablante según su número de canal (canal 0 → `speaker_0`, canal 1 → `speaker_1`, etc.). El sistema extrae canales individuales de tu archivo de audio de entrada y los transcribe en paralelo. De forma predeterminada, la API devuelve una transcripción por canal; configura `multichannel_output_style=combined` para recibir una única transcripción con todos los canales combinados en una lista ordenada por hora de inicio, con cada palabra etiquetada con su `channel_index`.

### Casos de uso habituales

* **Grabaciones de entrevistas en estéreo** - Entrevistador en el canal izquierdo y entrevistado en el derecho
* **Grabaciones de podcasts multipista** - Cada participante grabado en una pista independiente
* **Grabaciones de centros de llamadas** - Agente y cliente separados en canales diferentes
* **Grabaciones de conferencias** - Participantes individuales aislados en canales independientes
* **Procedimientos judiciales** - Varias partes grabadas en canales distintos

## Requisitos

* Una cuenta de ElevenLabs con una [clave de API](https://elevenlabs.io/app/settings/api-keys)
* Archivo de audio multicanal (WAV, MP3 u otros formatos compatibles)
* Máximo de 5 canales por archivo de audio
* Cada canal debe contener un solo hablante

## Cómo funciona

#### Prepara tu audio multicanal

Asegúrate de que tu archivo de audio tenga los hablantes aislados en canales independientes. La función multicanal admite hasta 5 canales, cada uno asignado a un hablante específico:

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

#### Configura los parámetros de la API

Al realizar una solicitud de voz a texto, debes configurar:

* `use_multi_channel`: `true`
* `diarize`: `false` (el modo multicanal separa los hablantes mediante canales)

Opcionalmente, controla la estructura de la respuesta con:

* `multichannel_output_style`: `separate` (valor predeterminado) devuelve una transcripción por canal. `combined` combina todos los canales en una única transcripción cuyas palabras se ordenan por hora de inicio, cada una con un `channel_index`, igual que la estructura de respuesta estándar de un solo canal. `combined` requiere marcas de tiempo (`timestamps_granularity` no debe ser `none`) y no es compatible con la entrega mediante webhook ni con la detección o redacción de entidades.

El parámetro `num_speakers` no se puede usar con el modo multicanal, ya que el número de hablantes se determina automáticamente según el número de canales. El modo multicanal presupone que habrá exactamente un hablante por canal. Si hay más, asignará el mismo ID de hablante a todos los hablantes del canal.

#### Procesa la respuesta

De forma predeterminada (`multichannel_output_style=separate`), el audio multicanal devuelve un formato de respuesta diferente al de un solo canal:

> **Note**
>
> Si configuras `use_multi_channel: true` pero proporcionas un archivo de audio de un solo canal (mono),
> recibirás una respuesta estándar de un solo canal, no el formato multicanal. El formato de respuesta
> multicanal solo se devuelve cuando el archivo de audio contiene realmente varios canales.

**`Respuesta de un solo canal`**

```python title="Respuesta de un solo canal"
{
  "language_code": "en",
  "language_probability": 0.98,
  "text": "Hello world",
  "words": [...]
}
```

**`Respuesta multicanal`**

```python title="Respuesta 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": [...]
    }
  ]
}
```

**`Respuesta combinada (multichannel_output_style=combined)`**

```python title="Respuesta combinada (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 }
  ]
}
```

Con `multichannel_output_style=combined`, la respuesta utiliza la misma estructura plana que una transcripción de un solo canal (`text` y `words` de nivel superior, sin matriz `transcripts`), con todos los canales combinados en una lista ordenada por hora de inicio. Cada palabra incluye un `channel_index` (y `speaker_id`) que identifica su canal.

## Implementación

### Transcripción multicanal básica

Aquí tienes un ejemplo completo para transcribir un archivo de audio estéreo con dos hablantes:

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

### Crear transcripciones de conversaciones

La forma más sencilla de obtener una transcripción ordenada por tiempo y al estilo de una conversación es solicitar `multichannel_output_style=combined`: la API devuelve una única lista `words`, ya ordenada por hora de inicio, con un `channel_index` y un `speaker_id` en cada palabra:

**`Salida combinada (recomendada)`**

```python title="Salida combinada (recomendada)"
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 utilizas la salida `separate` predeterminada, puedes combinar las transcripciones por canal en el cliente:

```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']}")
```

## Usar webhooks con multicanal

La transcripción multicanal admite [entrega mediante webhook](/docs/es/eleven-api/guides/how-to/speech-to-text/batch/webhooks) para el procesamiento asíncrono:

> **Note**
>
> Los webhooks devuelven el formato `separate` (por canal). `multichannel_output_style=combined` no es
> compatible actualmente con la entrega mediante webhook; usa una solicitud síncrona o combina la carga útil
> del webhook por canal en el cliente.

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

## Gestión de errores

### Errores de validación habituales

#### Configurar diarize=true con el modo multicanal

**Error**: El modo multicanal no admite diarización y asigna los hablantes según el canal en el que hablan.

**Solución**: Configura siempre `diarize=false` al usar el modo multicanal.

#### Proporcionar el parámetro num_speakers

**Error**: No se puede especificar num_speakers cuando use_multi_channel está activado. El número de hablantes
se determina automáticamente según el número de canales. **Solución**: Elimina el parámetro
`num_speakers` de tu solicitud.

#### Archivo de audio con más de 5 canales

**Error**: El modo multicanal admite hasta 5 canales, pero el archivo de audio contiene X canales.

**Solución**: Procesa solo los primeros 5 canales o procesa previamente tu audio para reducir el número
de canales.

#### Usar salida combinada sin marcas de tiempo

**Error**: multichannel_output_style='combined' requiere marcas de tiempo; configura timestamps_granularity
como 'word' o 'character'.

**Solución**: La salida combinada ordena las palabras por tiempo, así que configura `timestamps_granularity` como `word`
(el valor predeterminado) o `character`.

#### Usar salida combinada con webhooks

**Error**: multichannel_output_style='combined' aún no es compatible con la entrega mediante webhook.

**Solución**: Usa una solicitud síncrona con `combined` o mantén la salida `separate` predeterminada
al usar webhooks y combina los resultados en el cliente.

## Buenas prácticas

### Preparación del audio

> **Tip**
>
> Para obtener resultados óptimos: - Usa una frecuencia de muestreo de 16 kHz para mejorar el rendimiento - Elimina los canales silenciosos o sin usar antes del procesamiento - Asegúrate de que cada canal contenga un solo hablante - Usa formatos sin pérdida (WAV) siempre que sea posible para obtener la mejor calidad

### Optimización del rendimiento

El coste de concurrencia aumenta linealmente con el número de canales. Un archivo de 60 segundos con 3 canales tiene un coste de concurrencia 3 veces mayor que un archivo de un solo canal.

Puedes estimar el tiempo de procesamiento del audio multicanal mediante la siguiente fórmula:

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

Donde:

* $D$ = duración del archivo en segundos
* $N$ = número de canales
* $0.3$ = factor de velocidad de procesamiento (aproximadamente el 30 % del tiempo real)
* $2$ = sobrecarga fija en segundos
* $0.5$ = sobrecarga por canal en segundos

**Ejemplo**: Para un archivo estéreo de 60 segundos (2 canales):

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

### Consideraciones de memoria

Para archivos multicanal grandes, considera la transmisión o la división en fragmentos:

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

## Preguntas frecuentes

#### ¿Qué ocurre si mi audio tiene más de 5 canales?

La API devolverá un error. Tendrás que seleccionar qué 5 canales enviar a la API o mezclar algunos canales antes de enviarlos a la API.

#### ¿Puedo procesar audio mono con el modo multicanal?

Sí, pero no es necesario. Si envías audio mono con `use_multi_channel=true`, recibirás una respuesta estándar de un solo canal, no el formato multicanal.

#### ¿Puedo obtener una transcripción combinada en lugar de transcripciones independientes por canal?

Sí. Configura `multichannel_output_style=combined` para recibir una única transcripción con todos los canales combinados y ordenados por hora de inicio, con cada palabra etiquetada con su `channel_index`. Esto coincide con la estructura de respuesta estándar de un solo canal. Requiere marcas de tiempo y no está disponible con la entrega mediante webhook.

#### ¿Cómo se asignan los ID de hablante?

Los ID de hablante se determinan según el número de canal: el canal 0 pasa a ser speaker_0, el canal 1 pasa a ser speaker_1, y así sucesivamente.

#### ¿Pueden los canales tener idiomas diferentes?

Sí, cada canal se procesa de forma independiente y puede detectar idiomas diferentes. La detección de idioma se realiza por canal. Con `multichannel_output_style=combined`, el `language_code` de nivel superior refleja el canal con mayor confianza, mientras que cada palabra mantiene su `channel_index`.

## Siguientes pasos

#### [Referencia de la API](/docs/es/api-reference/speech-to-text)

Referencia y parámetros completos de la API de Voz a Texto.

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

Recibe los resultados de la transcripción de forma asíncrona mediante webhook.