Tutoriales Voice / marzo 04, 2026

Utiliza whisper para generar texto de audios

whisper.cpp permite transcribir audio a texto de forma local utilizando el modelo Whisper, sin depender de servicios cloud. Es una solución ideal para proyectos de automatización y Home Assistant donde la privacidad y el control de los datos son clave.

Don T3rr0rZ0n3

5 minutos

whisper.cpp es una implementación en C/C++ del modelo Whisper de OpenAI, diseñada para ejecutar transcripción de audio a texto de forma local, sin depender de servicios externos ni conexión a Internet. Su principal ventaja es que permite aprovechar la potencia del modelo Whisper en entornos autoalojados, con un consumo de recursos contenido y soporte para múltiples arquitecturas, incluyendo CPU sin GPU y dispositivos modestos.

Esta herramienta es especialmente útil en escenarios donde la privacidad, el control de los datos y la independencia de servicios cloud son prioritarios. Gracias a su enfoque local, el audio nunca sale del sistema, lo que la convierte en una opción ideal para proyectos de self-hosting, automatización y domótica.

En el contexto de Home Assistant, whisper.cpp se utiliza como motor de transcripción interno dentro de su sistema de Voice Assistant, permitiendo convertir audio capturado desde micrófonos o dispositivos compatibles en texto de forma completamente local. Este texto es el que posteriormente se procesa para interpretar comandos, ejecutar automatizaciones o interactuar con el asistente de voz, todo ello sin enviar el audio a servicios externos. Gracias a whisper.cpp, Home Assistant puede ofrecer reconocimiento de voz autoalojado, preservando la privacidad y manteniendo el control total sobre la infraestructura.

Instalación de Whisper

Tendremos que descargarnos el repositorio para compilarlo posteriormente:

git clone https://github.com/ggerganov/whisper.cpp
cd whisper.cpp

Dentro del directorio, ejecutamos el comando para compilar:

make

Tardará un rato en compilar todo, cuando acabe, ya podremos usar whisper.

Descargar el modelo

Para que funcione correctamente whisper, es recomendable descargar un modelo de lenguaje, puede ser tiny, base, small, medium o large.

bash models/download-ggml-model.sh small

Transcribir tu audio

Ahora para transformar tu audio en texto, podemos utilizar este comando:

./build/bin/whisper-cli -m models/ggml-small.bin -l es -f audio.mp3

Ejemplo de transcripción

Para hacer este tutorial, he grabado un trozo de texto que he leído de la Wikipedia que habla sobre las naranjas. De esta manera podemos mirar como es el proceso completo:

Ejecutamos el comando:

./build/bin/whisper-cli -m models/ggml-medium.bin -l es -f naranjas.mp3

Y este es el resultado completo del comando:

whisper_init_from_file_with_params_no_state: loading model from 'models/ggml-medium.bin'
whisper_init_with_params_no_state: use gpu    = 1
whisper_init_with_params_no_state: flash attn = 1
whisper_init_with_params_no_state: gpu_device = 0
whisper_init_with_params_no_state: dtw        = 0
whisper_init_with_params_no_state: devices    = 1
whisper_init_with_params_no_state: backends   = 1
whisper_model_load: loading model
whisper_model_load: n_vocab       = 51865
whisper_model_load: n_audio_ctx   = 1500
whisper_model_load: n_audio_state = 768
whisper_model_load: n_audio_head  = 12
whisper_model_load: n_audio_layer = 12
whisper_model_load: n_text_ctx    = 448
whisper_model_load: n_text_state  = 768
whisper_model_load: n_text_head   = 12
whisper_model_load: n_text_layer  = 12
whisper_model_load: n_mels        = 80
whisper_model_load: ftype         = 1
whisper_model_load: qntvr         = 0
whisper_model_load: type          = 3 (medium)
whisper_model_load: adding 1608 extra tokens
whisper_model_load: n_langs       = 99
whisper_model_load:          CPU total size =   487.01 MB
whisper_model_load: model size    =  487.01 MB
whisper_backend_init_gpu: device 0: CPU (type: 0)
whisper_backend_init_gpu: no GPU found
whisper_init_state: kv self size  =   18.87 MB
whisper_init_state: kv cross size =   56.62 MB
whisper_init_state: kv pad  size  =    4.72 MB
whisper_init_state: compute buffer (conv)   =   22.42 MB
whisper_init_state: compute buffer (encode) =   33.85 MB
whisper_init_state: compute buffer (cross)  =    6.20 MB
whisper_init_state: compute buffer (decode) =   97.28 MB

system_info: n_threads = 4 / 16 | WHISPER : COREML = 0 | OPENVINO = 0 | CPU : SSE3 = 1 | SSSE3 = 1 | AVX = 1 | AVX2 = 1 | F16C = 1 | FMA = 1 | BMI2 = 1 | OPENMP = 1 | REPACK = 1 | 

main: processing 'naranjas.mp3' (775314 samples, 48.5 sec), 4 threads, 1 processors, 5 beams + best of 5, lang = es, task = transcribe, timestamps = 1 ...


[00:00:00.000 --> 00:00:08.040]   La naranja es una fruta cítica obtenida del naranjo dulce, del naranjo amargo y de los
[00:00:08.040 --> 00:00:14.880]   naranjos de otras variedades o híbitidos, de origen asiático. Se cultiva como un antiguo
[00:00:14.880 --> 00:00:23.520]   árbol ornamental y para obtener fragancias de sus frutos. Es más pequeña y dulce que
[00:00:23.520 --> 00:00:31.000]   el pomelo o la toronja y más grande, aunque menos perfumada que la mandarina. Existen numerosas
[00:00:31.000 --> 00:00:36.720]   variedades de naranja, siendo la mayoría híbitos productos a partir de especies citrus máxima.
[00:00:36.720 --> 00:00:43.440]   Las naranjas dulces crecen en la variedad de tamaños diferentes y formas que varían
[00:00:43.440 --> 00:00:46.000]   desde esféricas hasta oblongas.

whisper_print_timings:     load time =   920.92 ms
whisper_print_timings:     fallbacks =   0 p /   0 h
whisper_print_timings:      mel time =    44.37 ms
whisper_print_timings:   sample time =   278.39 ms /   871 runs (     0.32 ms per run)
whisper_print_timings:   encode time = 11516.07 ms /     2 runs (  5758.04 ms per run)
whisper_print_timings:   decode time =    17.46 ms /     1 runs (    17.46 ms per run)
whisper_print_timings:   batchd time =  6033.75 ms /   863 runs (     6.99 ms per run)
whisper_print_timings:   prompt time =   432.19 ms /    89 runs (     4.86 ms per run)
whisper_print_timings:    total time = 19416.10 ms

Y como podemos observar en toda la salida, aquí tenemos la transcripción del audio:

[00:00:00.000 --> 00:00:08.040]   La naranja es una fruta cítica obtenida del naranjo dulce, del naranjo amargo y de los
[00:00:08.040 --> 00:00:14.880]   naranjos de otras variedades o híbitidos, de origen asiático. Se cultiva como un antiguo
[00:00:14.880 --> 00:00:23.520]   árbol ornamental y para obtener fragancias de sus frutos. Es más pequeña y dulce que
[00:00:23.520 --> 00:00:31.000]   el pomelo o la toronja y más grande, aunque menos perfumada que la mandarina. Existen numerosas
[00:00:31.000 --> 00:00:36.720]   variedades de naranja, siendo la mayoría híbitos productos a partir de especies citrus máxima.
[00:00:36.720 --> 00:00:43.440]   Las naranjas dulces crecen en la variedad de tamaños diferentes y formas que varían
[00:00:43.440 --> 00:00:46.000]   desde esféricas hasta oblongas.

¿Ni tan mal, verdad?

Conclusión

En este tutorial hemos visto cómo utilizar whisper.cpp para transcribir un archivo de audio a texto de forma local, rápida y sin depender de servicios externos. A lo largo del proceso hemos comprobado que se trata de una herramienta potente, flexible y sorprendentemente eficiente, incluso en sistemas sin aceleración por GPU.

Más allá de la simple transcripción, whisper.cpp abre la puerta a múltiples usos avanzados: automatizaciones, asistentes de voz personalizados, indexación de audios o integración con plataformas como Home Assistant. Todo ello con una premisa clara: los datos se quedan en casa.

Si buscas una solución fiable para convertir voz en texto dentro de tu propia infraestructura, whisper.cpp es una opción sólida, madura y alineada con la filosofía del software libre y el self-hosting. A partir de aquí, el siguiente paso natural es integrarlo en tus flujos habituales y sacarle partido en escenarios reales.

Más sobre ./voidNull

Haz que cada palabra cuente: tu donación nos inspira a seguir creando contenido. Accede al apartado de Donación para hacer tu aportación