Whisper en local: transcribir audio con tu GPU gratis [2026]

1. ¿Qué es Whisper y por qué usarlo en local?

Whisper es un modelo de reconocimiento de voz creado por OpenAI y publicado como open-source en septiembre de 2022. Fue entrenado con 680.000 horas de audio multilingüe y es capaz de transcribir más de 100 idiomas con una precisión que rivaliza con humanos profesionales. La versión Large V3, publicada en noviembre de 2023, mejoró especialmente en idiomas distintos del inglés — incluyendo español.

Pero aquí viene lo importante: Whisper es completamente gratuito y funciona en tu máquina sin conexión a internet. No necesitas cuenta de OpenAI, no necesitas API key, no pagas por minuto de audio. Descargas el modelo una vez (~3 GB para Large V3) y a partir de ahí, cada transcripción es gratis. Para siempre. Sin límites.

Esto lo convierte en una de las aplicaciones más prácticas y accesibles de la IA local. Mientras que correr un LLM de 70B parámetros necesita una GPU de 1.600€, Whisper Large V3 corre perfectamente en una RTX 3060 de menos de 300€ — o incluso en CPU si no tienes GPU dedicada.

2. Modelos Whisper: cuál elegir según tu hardware

Whisper viene en 5 tamaños. El truco está en que incluso el modelo más grande es increíblemente ligero comparado con los LLMs de texto. Mientras que Llama 3 8B necesita 6+ GB de VRAM, Whisper Large V3 con 1.5B de parámetros solo necesita 1.5 GB. Esto es porque los modelos de audio son fundamentalmente más compactos.

La regla general: usa el modelo más grande que tu hardware permita sin problemas. Si tienes cualquier GPU con 2+ GB de VRAM, ve directo a Whisper Large V3. Si estás en CPU o con una GPU muy antigua, Whisper Small es tu punto dulce.

3. Requisitos de hardware

La buena noticia: Whisper es el modelo de IA más accesible que existe. Si tu ordenador tiene menos de 10 años, puede correr Whisper. La pregunta no es "¿puedo?" sino "¿a qué velocidad?".

Un detalle importante: Whisper usa muy poca VRAM pero sí se beneficia mucho del ancho de banda de memoria de la GPU. No necesitas una RTX 4060 por su VRAM (8 GB es absurdamente más de lo que Whisper necesita) sino por su velocidad de cómputo CUDA. De hecho, la RTX 3060 con 12 GB rinde casi igual que la RTX 4060 en Whisper — los modelos de audio no escalan con VRAM como los LLMs de texto.

¿No estás seguro de lo que tu GPU aguanta? La calculadora de VRAM te dice exactamente qué modelos caben en tu tarjeta gráfica.

4. Instalación con faster-whisper (Python)

faster-whisper es la implementación de Whisper más popular para Python. Usa CTranslate2 como backend, lo que la hace hasta 4x más rápida que el Whisper original de OpenAI y consume menos memoria. Si trabajas con Python, esta es tu herramienta.

Paso 1: Instalar faster-whisper

pip install faster-whisper

Si tienes GPU NVIDIA con CUDA, faster-whisper la detecta automáticamente. Para CPU, no necesitas hacer nada extra — funciona out of the box.

Paso 2: Tu primera transcripción (5 líneas)

from faster_whisper import WhisperModel

model = WhisperModel("large-v3", device="cuda", compute_type="float16")

segments, info = model.transcribe("mi_audio.mp3", language="es")

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

Eso es todo. La primera vez que ejecutes este código, el modelo se descarga automáticamente (~3 GB para Large V3). Las siguientes ejecuciones cargan desde el cache local — instantáneo.

Si estás en CPU, cambia la línea del modelo a:

model = WhisperModel("large-v3", device="cpu", compute_type="int8")

El compute_type="int8" reduce el uso de memoria y mejora la velocidad en CPU. En GPU usamos float16 porque las GPUs NVIDIA tienen unidades de cómputo optimizadas para ese formato.

Paso 3: Exportar a formato SRT (subtítulos)

from faster_whisper import WhisperModel

model = WhisperModel("large-v3", device="cuda", compute_type="float16")
segments, info = model.transcribe("podcast.mp3", language="es")

with open("podcast.srt", "w", encoding="utf-8") as f:
    for i, segment in enumerate(segments, 1):
        start = segment.start
        end = segment.end
        start_h, start_m = int(start // 3600), int((start % 3600) // 60)
        start_s, start_ms = int(start % 60), int((start % 1) * 1000)
        end_h, end_m = int(end // 3600), int((end % 3600) // 60)
        end_s, end_ms = int(end % 60), int((end % 1) * 1000)
        f.write(f"{i}\n")
        f.write(f"{start_h:02d}:{start_m:02d}:{start_s:02d},{start_ms:03d} --> ")
        f.write(f"{end_h:02d}:{end_m:02d}:{end_s:02d},{end_ms:03d}\n")
        f.write(f"{segment.text.strip()}\n\n")

print(f"Subtítulos guardados en podcast.srt")

Este script genera un archivo .srt que puedes importar directamente en cualquier editor de vídeo, YouTube, o reproductor multimedia. Timestamps precisos incluidos.

5. Instalación con whisper.cpp (CLI)

whisper.cpp es una reimplementación de Whisper en C/C++ puro creada por Georgi Gerganov (el mismo creador de llama.cpp). Es la opción más rápida en CPU y tiene soporte nativo para CUDA, Metal (Mac) y OpenCL. Si prefieres trabajar desde terminal sin depender de Python, esta es tu herramienta.

Paso 1: Compilar whisper.cpp

# Clonar el repositorio
git clone https://github.com/ggerganov/whisper.cpp.git
cd whisper.cpp

# Compilar con soporte CUDA (GPU NVIDIA)
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j

# Si NO tienes GPU, compila solo para CPU:
# cmake -B build
# cmake --build build --config Release -j

Paso 2: Descargar el modelo

# Descargar Whisper Large V3 en formato GGML
bash ./models/download-ggml-model.sh large-v3

Paso 3: Transcribir

# Transcribir un archivo WAV
./build/bin/whisper-cli -m models/ggml-large-v3.bin -f mi_audio.wav -l es

# Exportar como SRT (subtítulos)
./build/bin/whisper-cli -m models/ggml-large-v3.bin -f mi_audio.wav -l es -osrt

# Transcripción en tiempo real desde micrófono
./build/bin/whisper-cli -m models/ggml-large-v3.bin -l es --stream

Un detalle: whisper.cpp espera archivos WAV de 16 kHz mono. Si tienes un MP3 o cualquier otro formato, conviértelo primero con ffmpeg:

ffmpeg -i podcast.mp3 -ar 16000 -ac 1 -c:a pcm_s16le podcast.wav

6. Usando Whisper con Ollama (método más simple)

Si ya tienes Ollama instalado, puedes usarlo para transcribir audio de forma extremadamente sencilla. Un solo comando y listo.

Instalación y uso

# Si no tienes Ollama instalado:
curl -fsSL https://ollama.com/install.sh | sh

# Descargar y ejecutar Whisper
ollama run whisper

Ollama detecta tu GPU automáticamente y optimiza el modelo para tu hardware. La ventaja de este método es la simplicidad absoluta: no necesitas compilar nada, no necesitas Python, no necesitas configurar CUDA manualmente. La desventaja es que tienes menos control sobre parámetros avanzados como VAD, beam size o formatos de salida.

Para más detalle sobre Ollama vs otras herramientas de IA local, revisa nuestra comparativa Ollama vs LM Studio.

6b. WhisperX: transcripción con identificación de hablantes

WhisperX es una extensión de Whisper que añade tres funcionalidades clave que el modelo original no tiene: alineación forzada de timestamps (mucho más precisos), Voice Activity Detection integrada, y lo más importante — speaker diarization. Es decir, identifica quién habla en cada momento.

# Instalar WhisperX
pip install whisperx

# Uso básico con diarization
import whisperx

model = whisperx.load_model("large-v3", device="cuda", compute_type="float16")
audio = whisperx.load_audio("reunion.mp3")
result = model.transcribe(audio, language="es")

# Alinear timestamps con precisión de palabra
model_a, metadata = whisperx.load_align_model(language_code="es", device="cuda")
result = whisperx.align(result["segments"], model_a, metadata, audio, device="cuda")

# Identificar hablantes (requiere token de HuggingFace)
diarize_model = whisperx.DiarizationPipeline(use_auth_token="TU_HF_TOKEN")
diarize_segments = diarize_model(audio)
result = whisperx.assign_word_speakers(diarize_segments, result)

for segment in result["segments"]:
    speaker = segment.get("speaker", "???")
    print(f"[{speaker}] {segment['text']}")

El resultado es algo así:

[SPEAKER_00] Buenos días, hoy vamos a revisar el informe trimestral.
[SPEAKER_01] Perfecto. Yo tengo los números de ventas listos.
[SPEAKER_00] Genial. Empecemos por la región norte.
[SPEAKER_02] Antes de eso, quería comentar un tema de presupuesto.

WhisperX es la opción ideal para transcribir reuniones, entrevistas, podcasts con múltiples participantes, o cualquier audio donde saber quién dijo qué es fundamental. La diarization necesita un poco más de VRAM (~2-3 GB adicionales), pero sigue siendo perfectamente manejable con una GPU de gama media.

7. Benchmarks: velocidad de Whisper por GPU

Estos son datos reales con Whisper Large V3, audio en español, archivo de 1 hora, faster-whisper con float16 y beam_size=5. El RTF (Real-Time Factor) indica qué fracción del tiempo real tarda el procesamiento: RTF 0.2 significa que 1 hora de audio se procesa en 0.2 horas (12 minutos).

Con Whisper Small en vez de Large V3, todas las GPUs son aún más rápidas. En la RTX 3060, 1 hora de audio se transcribe en ~4 minutos con el modelo Small. Para uso casual (notas de voz, audios de WhatsApp, podcasts cortos), Small es más que suficiente y casi instantáneo.

Puedes explorar más datos de rendimiento por GPU en nuestro Model Browser, donde puedes filtrar modelos por tamaño y ver benchmarks por tarjeta gráfica.

8. Casos de uso reales

Whisper local no es un juguete — es una herramienta de productividad seria. Estos son los casos donde más brilla:

9. Whisper local vs servicios cloud: comparativa de costes

Los servicios de transcripción cloud cobran por minuto de audio procesado. Parece barato hasta que haces las cuentas con volúmenes reales. Aquí los números:

* El coste real de Whisper local es la electricidad: una RTX 3060 consume ~170W bajo carga. Transcribir 1.000 horas de audio (~200 horas de GPU) cuesta ~34 kWh ≈ 5-8€ en electricidad en España. El coste de hardware (la GPU) lo amortizas también con otros usos: LLMs, generación de imágenes, gaming.

10. Preguntas frecuentes

11. Hardware recomendado para Whisper local

Whisper no necesita hardware caro, pero una buena GPU marca la diferencia entre "funciona" y "vuela". Estas son las opciones con mejor relación rendimiento/precio para transcripción:

Hardware recomendado para Whisper local

GPUs verificadas para transcripción con Whisper — actualizado en 2026.

€269

budget Amazon Prime

NVIDIA GeForce RTX 3060 12GB

4.8 (1,400 reviews)

Pros

• Whisper Large V3 a ~5× tiempo real
• 12 GB VRAM — holgura para batches
• Mejor precio para transcripción

Cons

• Menos velocidad vs Ada en inferencia

Ver en Amazon

€299

mid Amazon Prime

NVIDIA GeForce RTX 4060 8GB

4.6 (980 reviews)

Pros

• Whisper Large V3 a ~5× tiempo real
• Bajo consumo — ideal 24/7
• Ada Lovelace eficiencia máxima

Cons

• 8 GB — justo para batches grandes

Ver en Amazon

€399

mid Amazon Prime

NVIDIA GeForce RTX 4060 Ti 8GB

4.7 (650 reviews)

Pros

• Whisper Large V3 con margen
• Mayor bandwidth que RTX 4060
• Ideal para transcripción + LLMs

Cons

• Precio algo superior a RTX 4060

Ver en Amazon

€1799

pro Amazon Prime

NVIDIA GeForce RTX 4090 24GB

4.8 (1,200 reviews)

Pros

• Whisper Large V3 a ~30× tiempo real
• 24 GB — batches masivos sin problema
• Transcripción de 1h en ~2 min

Cons

• Overkill salvo uso profesional masivo

Ver en Amazon

Como asociado de Amazon, ganamos una comisión por compras que cumplan los requisitos. Esto no afecta nuestras recomendaciones.

12. Conclusión: Whisper es la killer app de la IA local

Si alguien te pregunta "¿para qué sirve la IA local en la vida real?", la respuesta más clara y directa es Whisper. Transcribir audio ilimitado, gratis, offline, con calidad profesional, desde tu propia máquina. Sin API keys, sin límites de minutos, sin subir tus grabaciones a servidores de terceros.

Los números hablan solos: Whisper Large V3 necesita solo 1.5 GB de VRAM. Cualquier GPU de los últimos 8 años lo corre. Una RTX 3060 de menos de 300€ transcribe 1 hora de audio en 12 minutos. Incluso sin GPU, un procesador i7 lo hace en ~42 minutos. Y el modelo Small (0.4 GB de VRAM) es suficientemente bueno para la mayoría de casos de uso cotidianos.

Si transcribes audio con cierta frecuencia — ya sea para trabajo, estudios, creación de contenido o accesibilidad — configurar Whisper en tu máquina es una de las mejores inversiones de tiempo que puedes hacer. 15 minutos de setup, beneficio de por vida.