Locución con voz: ElevenLabs, stack de TTS, contenido de voz

Módulo: Content Factory AI | Tiempo: ~25 min de teoría + 35 min de práctica

Lo esencial

La voz de un locutor es un gasto aparte: agenda, estudio, tarifa por hora. Una plataforma de síntesis de voz cobra de otra manera: pagas por volumen (créditos al mes), y en textos largos la diferencia se nota (planes vigentes: Lo vigente). Claude escribe el guion (o el código), ElevenLabs pone la voz y FFmpeg arma el video. Sin locutor, sin estudio, sin agenda. Configuras el pipeline (una cadena de pasos sucesivos) una vez y después la fábrica funciona sola.

🎨 Imagínalo así: un actor de voz es como un taxi: pagas cada viaje. Un pipeline de TTS (Text-to-Speech, síntesis de voz a partir de texto) es como tener coche propio: lo compras una vez y manejas cuanto quieras. Y cada viaje siguiente cuesta centavos.

Conceptos clave

• TTS (Text-to-Speech): tecnología que sintetiza voz a partir de texto
• Voice cloning: clonación de voz (crear una copia de una voz con IA), un clon digital de tu voz a partir de una muestra
• ElevenLabs: una de las principales plataformas comerciales de TTS
• ElevenLabs MCP (protocolo de contexto del modelo): integración directa con Claude Code: un servidor alojado con acceso por OAuth o un servidor local
• Eleven v4: el modelo nuevo de ElevenLabs (28.09.2026): más control de la entonación, 90+ idiomas; antes el principal era Multilingual v2
• Kokoro TTS: alternativa open source para locución sin conexión (el español está entre sus idiomas)
• Pipeline de TTS: Claude escribe el guion → TTS lo locuta → FFmpeg arma el video

Teoría

Por qué TTS en tu stack de IA: una cuestión de escala

La locución es el último paso manual en la producción de contenido. Claude escribe el texto automáticamente, Midjourney genera las imágenes, FFmpeg arma el video. Pero el locutor sigue siendo una persona con agenda y tarifa.

TTS cubre ese hueco.

Tres escenarios donde TTS cambia la economía:

Escenario 1: un canal de YouTube a escala

Un locutor graba 4-5 videos a la semana: es su límite físico. Con TTS son 20-30 videos, con la misma calidad, en una sola noche. La voz siempre está del mismo humor, nunca se cansa y no pide repetir la toma.

Escenario 2: localización

Traducir un video a 10 idiomas con locutores reales significa 10 locutores y 10 agendas. Con Eleven v4 la misma voz suena en decenas de idiomas (90+ según ElevenLabs a octubre de 2026), y el pipeline en sí toma horas. Antes de publicar, un hablante nativo revisa la pronunciación y la traducción.

Escenario 3: audiolibros y podcasts

Un libro de 80 000 palabras le toma a un locutor 8-10 horas de grabación más la edición. La síntesis gasta créditos del plan: cuenta los caracteres del manuscrito y compáralos con el límite de tu plan (precios vigentes: Lo vigente). Claude lee el manuscrito, lo mejora para escucharse y ElevenLabs lo locuta por capítulos.

ElevenLabs: cómo funciona y cuánto cuesta

ElevenLabs es una de las plataformas de TTS profesional más conocidas.

Qué incluye (a octubre de 2026):

Planes a octubre de 2026 (precios vigentes: Lo vigente y la página de planes de ElevenLabs):

El consumo de créditos depende del modelo y de la longitud del texto: mídelo con una prueba corta y multiplícalo por tu volumen. El plan gratuito no tiene licencia comercial; para proyectos de clientes necesitas uno de pago.

Voice Cloning: una fotografía de la voz

Voice cloning (clonación de voz) es crear un clon digital de una voz a partir de una muestra de audio. Después de clonarla, el sistema sintetiza voz con el mismo timbre, entonación y ritmo.

🎨 Imagínalo así: clonar una voz es como una fotografía. Te sientas una vez frente a la cámara y luego tu imagen se puede imprimir miles de veces. La voz se graba una vez y se locuta sin fin.

Requisitos de la muestra:

• Clon rápido: una muestra corta de voz limpia (ElevenLabs anuncia un clon a partir de 10 segundos de grabación para Eleven v4). Cuanto más limpia y variada la grabación, mejor el resultado
• Clon profesional: una grabación bastante más larga (los requisitos exactos están en la ayuda de ElevenLabs)
• Formato: WAV o MP3, sin ruido de fondo
• Sin música, sin otras voces, sin eco

Instrucciones para el clon rápido:

1. Entra a elevenlabs.io → sección Voices → agregar voz → clon rápido (requiere el plan Starter o superior)
2. Sube el archivo de audio
3. Ponle un nombre a la voz (por ejemplo "MyVoice_ES")
4. Confirma que la voz es tuya o que tienes permiso de su dueño
5. Espera el procesamiento y copia el Voice ID desde los ajustes de la voz

Una vez clonada, la voz está disponible por API. El Voice ID se necesita en todas las solicitudes.

Importante: ElevenLabs exige el consentimiento del dueño de la voz para clonarla. No clones voces sin permiso: viola los ToS (Terms of Service, condiciones de uso) y la ley de muchos países.

Ejemplo básico: Claude escribe el guion, ElevenLabs lo locuta

from elevenlabs.client import ElevenLabs
import anthropic
import os

anthropic_client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
eleven = ElevenLabs(api_key=os.environ["ELEVENLABS_API_KEY"])

# Paso 1: generamos el guion con Claude
response = anthropic_client.messages.create(
    model="claude-sonnet-5-5",  # identificadores vigentes de los modelos: documentación de Anthropic
    max_tokens=1000,
    messages=[{
        "role": "user",
        "content": (
            "Escribe un guion de 60 segundos para anunciar los servicios de un consultor de IA. "
            "Tono: profesional, seguro, sin promesas vacías. "
            "Unas 150-160 palabras. Solo el texto para locutar, sin acotaciones."
        )
    }]
)

script = "".join(b.text for b in response.content if b.type == "text")
print(f"Guion ({len(script.split())} palabras):\n{script}\n")

# Paso 2: lo locutamos con ElevenLabs
audio = eleven.text_to_speech.convert(
    text=script,
    voice_id="JBFqnCBsd6RMkjVDRZzb",  # voz del ejemplo de la documentación; tu propio Voice ID está en la sección Voices
    model_id="eleven_v4",             # modelo a octubre de 2026; consulta los nombres vigentes en la documentación
    output_format="mp3_44100_128",
)

with open("ad-script.mp3", "wb") as f:
    for chunk in audio:
        f.write(chunk)
print("Archivo guardado: ad-script.mp3")

Instalación:

pip install elevenlabs anthropic

Variables de entorno:

export ANTHROPIC_API_KEY="sk-ant-..."
export ELEVENLABS_API_KEY="sk_..."

ElevenLabs MCP: locución directo desde Claude Code

ElevenLabs ofrece servidores MCP oficiales. A octubre de 2026 la opción recomendada es el servidor alojado: no hay que instalar nada en la computadora y el acceso es por OAuth. El servidor local anterior está marcado como obsoleto en el repositorio de ElevenLabs. Una vez conectado, Claude puede locutar texto, elegir voces y guardar archivos directo desde el chat, sin scripts de Python.

Conexión:

# Servidor alojado de ElevenLabs (recomendado; acceso por OAuth, no hace falta clave de API)
claude mcp add --transport http elevenlabs https://api.elevenlabs.io/v1/mcp
# luego, dentro de Claude Code: /mcp e inicia sesión

# Servidor local anterior (marcado como obsoleto en el repositorio; requiere uv y la clave de API en el entorno)
claude mcp add elevenlabs --env ELEVENLABS_API_KEY=tu_clave -- uvx elevenlabs-mcp

O mediante .mcp.json (servidor local):

{
  "mcpServers": {
    "elevenlabs": {
      "command": "uvx",
      "args": ["elevenlabs-mcp"],
      "env": {
        "ELEVENLABS_API_KEY": "${ELEVENLABS_API_KEY}"
      }
    }
  }
}

Una vez conectado, Claude obtiene herramientas (el conjunto depende del servidor; la lista exacta está en elevenlabs.io/mcp y en el repositorio del servidor):

• Síntesis de voz a partir de texto
• Clonación de voz y manejo de voces
• Transcripción, limpieza de audio, conversión de voz a voz
• Generación de paisajes sonoros y música

Ejemplo de solicitud en el chat:

Locuta el siguiente texto con una de las voces disponibles y guárdalo en el archivo intro.mp3:

"Bienvenido a la lección sobre locución.
En los próximos diez minutos vas a armar tu primer pipeline:
guion, voz y un archivo de audio terminado."

Claude llamará a la herramienta MCP y guardará el archivo sin código adicional.

Alternativas gratuitas: cuando ElevenLabs es demasiado

OpenAI TTS: la API es igual a los demás endpoints de OpenAI (puntos de acceso de la API), 13 voces integradas, admite español (según la documentación de OpenAI). No permite clonar tu propia voz. Conviene si ya usas OpenAI.

import openai, os

client = openai.OpenAI(api_key=os.environ["OPENAI_API_KEY"])

with client.audio.speech.with_streaming_response.create(
    model="gpt-4o-mini-tts",    # tts-1 y tts-1-hd son modelos anteriores
    voice="coral",              # una de las voces integradas; la lista está en la documentación de OpenAI
    input="Aquí va el texto para locutar",
    instructions="Habla con calma y de forma amigable.",
) as response:
    response.stream_to_file("output.mp3")

Kokoro TTS: open source, funciona localmente, pesos con licencia Apache 2.0. Calidad menor que ElevenLabs, pero gratis y sin enviar datos a la nube. Según el README del proyecto, Kokoro admite inglés americano y británico, español, francés, hindi, italiano, japonés, portugués de Brasil y chino. El español está en la lista, así que sirve para prototipos locales en español; el código de idioma y las voces disponibles están en el README y en la lista de voces del proyecto.

pip install "kokoro>=0.9.4" soundfile

from kokoro import KPipeline
import soundfile as sf

pipeline = KPipeline(lang_code="a")  # "a" es inglés americano; para español, toma el código del README
generator = pipeline("Text for local voiceover", voice="af_heart")
for i, (_, _, audio) in enumerate(generator):
    sf.write(f"output-{i}.wav", audio, 24000)

macOS say: viene en cada Mac, es gratis y funciona sin conexión. La calidad suena robótica, pero para prototipos y pruebas es ideal.

# Locución básica
say "Hola, esta es una locución de prueba"

# Guardando en un archivo
say -v "Paulina" -o output.aiff "Texto para locutar"

# Convertir a MP3 con ffmpeg
say -v "Paulina" -o /tmp/output.aiff "Texto" && \
ffmpeg -i /tmp/output.aiff output.mp3 -y -loglevel error

# Lista de voces disponibles en español
say -v "?" | grep es_

Pipeline para YouTube con locución TTS

Script completo: el tema del video entra y sale un MP4 (archivo de video) terminado.

#!/usr/bin/env bash
# tts-video-pipeline.sh
# Uso: ./tts-video-pipeline.sh "Tema del video" background.jpg
set -euo pipefail

TOPIC="$1"
BACKGROUND="${2:-background.jpg}"
OUTPUT_DIR="./output"
mkdir -p "$OUTPUT_DIR"

echo "Tema: $TOPIC"

# Paso 1: Claude escribe el guion (con el CLI de claude)
echo "Escribiendo el guion..."
SCRIPT=$(claude -p "Escribe un guion de YouTube de 3 minutos sobre: $TOPIC.
Tono: conversacional, concreto, sin clichés.
Extensión: 400-450 palabras. Solo el texto del locutor, sin acotaciones ni títulos.")

echo "$SCRIPT" > "$OUTPUT_DIR/script.txt"
echo "Guion: $(echo "$SCRIPT" | wc -w) palabras"

# Paso 2: ElevenLabs lo locuta
echo "Locutando..."
python3 << PYEOF
from elevenlabs.client import ElevenLabs
import os

client = ElevenLabs(api_key=os.environ["ELEVENLABS_API_KEY"])

with open("$OUTPUT_DIR/script.txt", encoding="utf-8") as f:
    text = f.read()

audio = client.text_to_speech.convert(
    text=text,
    voice_id="JBFqnCBsd6RMkjVDRZzb",  # voz del ejemplo de la documentación, cámbiala por tu Voice ID
    model_id="eleven_v4",
    output_format="mp3_44100_128",
)

with open("$OUTPUT_DIR/voiceover.mp3", "wb") as out:
    for chunk in audio:
        out.write(chunk)
print("Locución lista")
PYEOF

# Paso 3: FFmpeg crea el video
echo "Armando el video..."
DURATION=$(ffprobe -v error -show_entries format=duration \
    -of csv=p=0 "$OUTPUT_DIR/voiceover.mp3" | awk '{print int($1+1)}')

ffmpeg \
    -loop 1 -i "$BACKGROUND" \
    -i "$OUTPUT_DIR/voiceover.mp3" \
    -c:v libx264 -tune stillimage \
    -c:a aac -b:a 192k \
    -pix_fmt yuv420p \
    -t "$DURATION" \
    "$OUTPUT_DIR/video.mp4" \
    -y -loglevel error

echo "Listo: $OUTPUT_DIR/video.mp4 (${DURATION}s)"

Ejecución:

chmod +x tts-video-pipeline.sh
./tts-video-pipeline.sh "Cómo funciona RAG en Claude" background.jpg

Diario de voz y podcast en 5 minutos

Dices tus ideas en voz alta → Whisper (STT, Speech-to-Text, reconocimiento de voz a texto) transcribe → Claude edita para el oído → ElevenLabs locuta de forma profesional.

import whisper
import anthropic
from elevenlabs.client import ElevenLabs
import os

# Modelos
whisper_model = whisper.load_model("small")
claude = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
eleven = ElevenLabs(api_key=os.environ["ELEVENLABS_API_KEY"])

def voice_to_podcast(audio_file: str, output_file: str = "podcast.mp3"):
    """
    audio_file: grabación de voz (WAV/MP3)
    output_file: episodio de podcast terminado
    """

    # Paso 1: transcribimos la nota de voz
    print("Transcribiendo...")
    result = whisper_model.transcribe(audio_file, language="es")
    raw_text = result["text"]
    print(f"Transcripción ({len(raw_text.split())} palabras): {raw_text[:100]}...")

    # Paso 2: Claude edita para escucharse bien
    print("Editando...")
    response = claude.messages.create(
        model="claude-sonnet-5-5",  # identificadores vigentes de los modelos: documentación de Anthropic
        max_tokens=2000,
        messages=[{
            "role": "user",
            "content": (
                "Esta es la transcripción de un texto hablado. Edítala para un podcast:\n"
                "- Quita las muletillas (eh, este, o sea, pues)\n"
                "- Corrige las frases cortadas\n"
                "- Conserva el tono conversacional y la estructura de la idea\n"
                "- No agregues nada nuevo, solo edita\n\n"
                f"Texto:\n{raw_text}"
            )
        }]
    )
    edited_text = "".join(b.text for b in response.content if b.type == "text")

    # Paso 3: ElevenLabs locuta de forma profesional
    print("Locutando...")
    audio = eleven.text_to_speech.convert(
        text=edited_text,
        voice_id="JBFqnCBsd6RMkjVDRZzb",  # voz del ejemplo de la documentación, cámbiala por tu Voice ID
        model_id="eleven_v4",
        output_format="mp3_44100_128",
    )
    with open(output_file, "wb") as out:
        for chunk in audio:
            out.write(chunk)

    print(f"Podcast listo: {output_file}")
    return edited_text

# Ejecución
edited = voice_to_podcast("my-thoughts.wav", "podcast-ep01.mp3")
print("\nTexto editado guardado en podcast-ep01-script.txt")
with open("podcast-ep01-script.txt", "w", encoding="utf-8") as f:
    f.write(edited)

Servicios basados en TTS

TTS no es solo una herramienta para ti. Es la base de tres tipos de servicios. Aquí no hay precios a propósito: calcula el precio de tu servicio con la lección Cómo poner precio; nadie garantiza ingresos.

Opción 1: locución de libros y cursos

El cliente trae un manuscrito y tú entregas el audio por capítulos. Claude edita el texto para el oído y ElevenLabs lo locuta. El costo se calcula en créditos: los caracteres del manuscrito contra los créditos del plan. Necesitas un plan de pago con licencia comercial y los derechos del cliente sobre el texto confirmados.

La idea: decenas de horas de trabajo de un locutor se sustituyen por unas horas de tu pipeline. Revisa la calidad escuchando: los errores de acentuación y de nombres propios siguen siendo tu responsabilidad.

Opción 2: localización de contenido

Un creador o un negocio quiere traducir un curso en video a varios idiomas. Tú usas Eleven v4 con la misma voz. Un hablante nativo revisa la traducción y la pronunciación; si no, los errores llegan a la publicación.

Opción 3: TTS SaaS (Software-as-a-Service, software como servicio) para pequeños negocios

Agentes inmobiliarios, profesores particulares, pequeños negocios: todos graban anuncios y presentaciones con su voz. Puedes envolver la API de ElevenLabs en una interfaz web sencilla: subo el texto → elijo la voz → descargo el MP3. Antes de lanzarlo, revisa las condiciones de la API de ElevenLabs sobre reventa y uso comercial, y calcula el costo con la lección Cuánto cuesta un cliente y cuánto te deja.

Práctica

1. Regístrate en elevenlabs.io → obtén una clave de API (el plan Free alcanza para empezar)

2. Instala las dependencias:

   pip install elevenlabs anthropic

3. Ejecuta el script básico "Claude escribe → ElevenLabs locuta" de la sección de teoría. Escucha el resultado.

4. Clona tu voz (requiere el plan Starter o superior): graba 60 segundos de voz clara (lee cualquier texto), súbela a ElevenLabs en la sección Voices (clon rápido). Cambia el voice_id del código por tu Voice ID.

5. Crea el archivo tts-video-pipeline.sh, hazlo ejecutable y ejecútalo con cualquier tema. Revisa el MP4 final.

6. (Avanzado) Instala Kokoro TTS localmente, locuta un texto en español y compáralo con ElevenLabs. Toma nota de la diferencia de calidad.

Herramientas y recursos

• ElevenLabs: registro, clave de API, clonación de voz
• ElevenLabs API Docs: documentación completa
• ElevenLabs MCP: servidor MCP alojado; el local anterior: elevenlabs-mcp
• OpenAI TTS: alternativa, 13 voces integradas
• Kokoro TTS: open source (código abierto), sin conexión, con español entre sus idiomas
• OpenAI Whisper: para la parte STT del pipeline
• Precios y versiones: Lo vigente

Ideas clave

TTS es el último paso manual del pipeline de contenido. ElevenLabs lo cubre. Una voz → muchos videos, 90+ idiomas en Eleven v4, sin estudio.

Voice cloning = una muestra corta → locución sin fin. La grabas una vez y tu voz trabaja sin ti, siempre que tengas el permiso del dueño de la voz.

Los servicios con TTS (locución de libros, localización, TTS SaaS) calcúlalos por su costo: créditos del plan, tu tiempo, revisión de un hablante nativo. Nadie garantiza precios ni ingresos.

Stack gratuito para empezar: macOS say para pruebas, Kokoro TTS para prototipos sin conexión, ElevenLabs Free (10 000 créditos al mes, sin licencia comercial) para los primeros experimentos.

Siguiente lección

→ Música con IA: Suno y diseño sonoro: música de fondo, jingles y efectos de sonido para video y podcasts