Cómo Transcribir Audio con IA: Tutorial de Whisper y Alternativas

Transcribir audio solía ser un trabajo tedioso, caro y lento. Pagabas a alguien para que lo hiciera a mano, o usabas herramientas automáticas que fallaban más que acertaban.

Whisper, el modelo de transcripción de OpenAI, cambió eso completamente. Es gratuito, open source, funciona en más de 90 idiomas y tiene una precisión que supera a la mayoría de servicios de pago. En español funciona especialmente bien.

En este tutorial te enseño todas las formas de usar Whisper: desde la instalación local (gratis) hasta la API de OpenAI (más fácil), pasando por alternativas para casos específicos.

Qué es Whisper

Whisper es un modelo de IA de OpenAI especializado en:

• Transcripción: Convertir audio a texto
• Traducción: Transcribir audio en cualquier idioma directamente a inglés
• Detección de idioma: Identificar automáticamente el idioma hablado

Es open source (puedes usarlo gratis en tu ordenador) y también está disponible como API de pago.

Modelos disponibles

Modelo	Parámetros	Precisión	Velocidad	VRAM necesaria
tiny	39M	Baja	Muy rápida	~1 GB
base	74M	Media	Rápida	~1 GB
small	244M	Buena	Media	~2 GB
medium	769M	Muy buena	Lenta	~5 GB
large-v3	1550M	Excelente	Muy lenta	~10 GB
turbo	809M	Muy buena	Rápida	~6 GB

Para español, el modelo turbo ofrece el mejor equilibrio calidad/velocidad. Si tu ordenador no tiene GPU potente, el modelo small es suficiente para la mayoría de usos.

Opción A: Whisper Local (Gratis)

Instalar Whisper en tu ordenador es gratis y tus datos no salen de tu máquina. Ideal si trabajas con contenido confidencial.

Paso 1: Requisitos previos

1. Python 3.8+ instalado
2. FFmpeg instalado (necesario para procesar audio):

Windows:

# Con chocolatey
choco install ffmpeg

# O descarga desde ffmpeg.org y añade al PATH

Mac:

brew install ffmpeg

Linux:

sudo apt install ffmpeg

3. Verifica la instalación:

ffmpeg -version

Paso 2: Instalar Whisper

# Crear proyecto
mkdir whisper-tutorial
cd whisper-tutorial
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate

# Instalar Whisper de OpenAI
pip install openai-whisper

Pro tip: Si tienes GPU NVIDIA, instala PyTorch con soporte CUDA primero para transcripciones mucho más rápidas:

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

Paso 3: Transcribir desde la línea de comandos

La forma más rápida de transcribir:

# Transcripción básica
whisper audio.mp3 --language es --model turbo

# Con más opciones
whisper audio.mp3 \
  --language es \
  --model turbo \
  --output_format txt \
  --output_dir ./transcripciones/

# Generar subtítulos SRT
whisper video.mp4 \
  --language es \
  --model turbo \
  --output_format srt

Formatos de salida disponibles:

• txt: Texto plano
• srt: Subtítulos con timestamps
• vtt: Subtítulos WebVTT
• json: Datos completos con timestamps por segmento
• tsv: Datos tabulares

Paso 4: Transcribir desde Python

Para más control, usa Python directamente:

import whisper

# Cargar el modelo (se descarga la primera vez)
model = whisper.load_model("turbo")

# Transcribir
result = model.transcribe(
    "audio.mp3",
    language="es",
    fp16=False  # Cambiar a True si tienes GPU
)

# Texto completo
print(result["text"])

# Segmentos con timestamps
for segment in result["segments"]:
    start = segment["start"]
    end = segment["end"]
    text = segment["text"]
    print(f"[{start:.2f}s - {end:.2f}s] {text}")

Opción B: API de OpenAI (Más Fácil)

Si no quieres instalar nada localmente o necesitas transcripciones rápidas sin GPU, la API es la opción más sencilla.

Paso 1: Configurar

pip install openai python-dotenv

Archivo .env:

OPENAI_API_KEY=tu-api-key-aqui

Paso 2: Transcribir con la API

from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI()

# Transcripción básica
with open("audio.mp3", "rb") as audio_file:
    transcript = client.audio.transcriptions.create(
        model="whisper-1",
        file=audio_file,
        language="es"
    )

print(transcript.text)

Paso 3: Opciones avanzadas de la API

# Con timestamps (formato SRT)
with open("audio.mp3", "rb") as audio_file:
    transcript = client.audio.transcriptions.create(
        model="whisper-1",
        file=audio_file,
        language="es",
        response_format="srt"  # o "vtt", "json", "text"
    )

print(transcript)  # Subtítulos en formato SRT

# Con prompt para mejorar precisión
with open("audio.mp3", "rb") as audio_file:
    transcript = client.audio.transcriptions.create(
        model="whisper-1",
        file=audio_file,
        language="es",
        prompt="Transcripción de una reunión sobre marketing digital y SEO"
    )

Pro tip: El parámetro prompt es muy útil para mejorar la precisión. Dale contexto sobre el tema del audio, nombres propios o términos técnicos que puedan aparecer. Whisper usa esa información para desambiguar.

Coste de la API

• 0.006$/minuto de audio
• Una reunión de 1 hora = 0.36$
• Un podcast de 30 minutos = 0.18$
• Límite de archivo: 25 MB

Para archivos de más de 25 MB, necesitas dividirlos primero:

from pydub import AudioSegment

# Cargar audio largo
audio = AudioSegment.from_file("reunion_larga.mp3")

# Dividir en segmentos de 10 minutos
chunk_length_ms = 10 * 60 * 1000  # 10 minutos
chunks = [audio[i:i+chunk_length_ms] for i in range(0, len(audio), chunk_length_ms)]

# Transcribir cada segmento
transcription_completa = ""
for i, chunk in enumerate(chunks):
    chunk.export(f"temp_chunk_{i}.mp3", format="mp3")
    with open(f"temp_chunk_{i}.mp3", "rb") as f:
        result = client.audio.transcriptions.create(
            model="whisper-1",
            file=f,
            language="es"
        )
    transcription_completa += result.text + " "
    print(f"Segmento {i+1}/{len(chunks)} transcrito")

print(transcription_completa)

Opción C: Faster-Whisper (Local pero Más Rápido)

Faster-Whisper es una reimplementación de Whisper que es hasta 4 veces más rápida con el mismo nivel de precisión. Usa CTranslate2 por debajo.

pip install faster-whisper

from faster_whisper import WhisperModel

# Cargar modelo
model = WhisperModel("large-v3", device="cpu", compute_type="int8")
# Para GPU: device="cuda", compute_type="float16"

# Transcribir
segments, info = model.transcribe("audio.mp3", language="es")

print(f"Idioma detectado: {info.language} (probabilidad: {info.language_probability:.2f})")

for segment in segments:
    print(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")

Si vas a hacer muchas transcripciones localmente, Faster-Whisper es la opción que recomiendo.

Alternativas a Whisper

Whisper es excelente, pero hay alternativas que pueden ser mejores según tu caso de uso:

Servicio	Fuerte en	Precio	Mejor para
Whisper (local)	Gratis, privacidad	0$	Uso general, presupuesto bajo
Whisper (API)	Facilidad de uso	0.006$/min	Desarrollo rápido
AssemblyAI	Diarización, resumen	0.01$/min	Reuniones, entrevistas
Deepgram	Tiempo real, velocidad	0.0043$/min	Streams en vivo, call centers
Google Speech-to-Text	Integración GCP	0.006$/15s	Si ya usas Google Cloud
Amazon Transcribe	Integración AWS	0.024$/min	Si ya usas AWS

AssemblyAI: cuando necesitas más que transcripción

AssemblyAI destaca por sus funciones de post-procesamiento:

import assemblyai as aai

aai.settings.api_key = "tu-api-key"

transcriber = aai.Transcriber()

config = aai.TranscriptionConfig(
    language_code="es",
    speaker_labels=True,  # Diarización: identifica quién habla
    auto_chapters=True,   # Divide en capítulos automáticamente
    entity_detection=True, # Detecta nombres, fechas, etc.
    summarization=True,    # Genera un resumen
    summary_model=aai.SummarizationModel.informative
)

transcript = transcriber.transcribe("reunion.mp3", config=config)

# Transcripción con speakers
for utterance in transcript.utterances:
    print(f"Speaker {utterance.speaker}: {utterance.text}")

# Resumen automático
print(f"\nResumen: {transcript.summary}")

# Capítulos
for chapter in transcript.chapters:
    print(f"\n[{chapter.start/1000:.0f}s] {chapter.headline}")
    print(f"  {chapter.summary}")

La diarización (saber quién dice qué) es algo que Whisper no hace nativamente y donde AssemblyAI destaca.

Casos de Uso Prácticos

Ahora que sabes cómo transcribir, veamos aplicaciones reales que puedes implementar hoy:

1. Transcribir reuniones y generar actas

from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()
client = OpenAI()

# Paso 1: Transcribir la reunión
with open("reunion.mp3", "rb") as f:
    transcript = client.audio.transcriptions.create(
        model="whisper-1",
        file=f,
        language="es",
        prompt="Reunión de equipo sobre proyecto web. Participantes: Ana, Carlos, María."
    )

# Paso 2: Generar acta con ChatGPT
acta = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": """Eres un asistente que genera actas de reunión profesionales.
        Genera el acta con estas secciones:
        - Resumen ejecutivo (3-5 líneas)
        - Temas tratados
        - Decisiones tomadas
        - Acciones pendientes (quién, qué, cuándo)
        - Próxima reunión"""},
        {"role": "user", "content": f"Genera el acta de esta reunión:\n\n{transcript.text}"}
    ]
)

print(acta.choices[0].message.content)

2. Crear subtítulos para vídeos

# Generar archivo SRT directamente
whisper video.mp4 --language es --model turbo --output_format srt

El archivo .srt resultante lo puedes subir directamente a YouTube, Vimeo o cualquier plataforma de vídeo.

3. Transcribir podcasts para SEO

# Transcribir y generar artículo optimizado para SEO
transcript = "..."  # Tu transcripción

articulo = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": """Convierte esta transcripción de podcast en un artículo de blog
        optimizado para SEO. Estructura con H2 y H3, añade una introducción y conclusión,
        y mantén el tono conversacional del podcast."""},
        {"role": "user", "content": transcript}
    ]
)

4. Base de datos de conocimiento desde vídeos

Combina Whisper con RAG:

1. Transcribe todos tus vídeos/podcasts
2. Indexa las transcripciones en una base vectorial
3. Crea un chatbot que responda preguntas sobre tu contenido

Esto es brutal para cursos online, formaciones internas o canales de YouTube con mucho contenido.

Consejos para Mejor Precisión

Calidad del audio importa. Whisper es robusto, pero un audio limpio siempre dará mejores resultados. Si puedes, reduce ruido de fondo antes de transcribir.

Usa el prompt para contexto. Incluye nombres propios, términos técnicos y el tema general. Esto mejora significativamente la precisión en vocabulario especializado.

Elige el modelo adecuado. No uses "tiny" para una transcripción importante. Usa "turbo" o "large-v3" cuando la precisión importa.

Pre-procesa el audio si es necesario:

# Convertir a formato óptimo para Whisper
ffmpeg -i input.wav -ar 16000 -ac 1 -c:a pcm_s16le output.wav

Revisa siempre el resultado. Especialmente para nombres propios, números y términos técnicos. La IA es buena, pero no perfecta.

Errores Comunes

No instalar FFmpeg. Whisper necesita FFmpeg para procesar audio. Sin él, obtendrás errores al intentar transcribir. Instálalo primero.

Usar un modelo demasiado grande para tu hardware. Si tu ordenador no tiene GPU, el modelo large-v3 puede tardar 10x más que la duración del audio. Empieza con small o base y sube si necesitas más precisión.

Transcribir archivos enormes sin dividir. Para la API, el límite es 25 MB. Para uso local, archivos muy largos pueden agotar la memoria. Divide en segmentos de 10-15 minutos.

No especificar el idioma. Aunque Whisper detecta el idioma automáticamente, especificarlo con language="es" mejora la precisión y evita que confunda idiomas similares.

Ignorar la diarización cuando es necesaria. Si transcribes reuniones o entrevistas, necesitas saber quién dice qué. Whisper no incluye diarización nativa; usa AssemblyAI o pyannote-audio para eso.

Conclusión: Elige tu Camino

Tienes tres caminos claros dependiendo de tu situación:

1. Quieres algo rápido y fácil: API de OpenAI. Pagas céntimos, no instalas nada, funciona en 5 minutos.

2. Quieres gratis y privacidad: Whisper local (o Faster-Whisper). Necesitas algo de setup pero tus datos no salen de tu máquina.

3. Necesitas funciones avanzadas (diarización, resumen, capítulos): AssemblyAI o Deepgram. Coste algo mayor pero funcionalidad mucho más rica.

Mi recomendación: empieza con la API de OpenAI para probar el concepto. Si lo usas mucho o necesitas privacidad, migra a Faster-Whisper local. Y si necesitas diarización, AssemblyAI.

La transcripción con IA abre muchas puertas: generar contenido desde vídeos, crear bases de conocimiento, automatizar actas, subtitular vídeos... El primer paso es transcribir. Lo que hagas después con ese texto es donde está el verdadero valor.