Cómo crear un podcast generado con IA usando Azure

Llevo tiempo viendo cómo los podcasts no paran de crecer en popularidad. Cada vez somos más los que preferimos consumir contenido en audio en lugar de leer largos artículos o ver vídeos que requieren el 100% de nuestra atención. Ya sea mientras programamos un nuevo componente, vamos de camino al trabajo en el coche, o simplemente cuando salimos a hacer deporte; el podcasting se ha convertido en el compañero perfecto para nuestro día a día.

Y no es para menos, plataformas como Spotify, Apple Podcasts o iVoox nos lo han puesto facilísimo para distribuir o descubrir lo que otros tienen que contar.

Pero claro, la realidad del creador de contenido es muy distinta. Si alguna vez te ha picado el gusanillo y has intentado producir uno, sabrás de sobra que lleva su tiempo. No se trata solo de sentarse frente a un micrófono y hablar. Tienes que pensar la idea, estructurar y escribir un guion medianamente coherente, grabar (y regrabar porque te has trabado en la misma frase cuarenta veces), y finalmente pelearte con el editor de audio para cortar los silencios incómodos y darle fluidez.

Por suerte, la Inteligencia Artificial está aquí para echarnos un cable tremendo.

Seguro que a estas alturas ya has trasteado con cosas como ChatGPT para pedirle que te genere textos, te resuma documentos o incluso te ayude a debuggear algo de código. Pero la cosa va mucho más allá. ¿Sabías que la síntesis de voz ha evolucionado hasta el punto de sonar casi 100% humana? Atrás quedaron los tiempos de Loquendo y esas voces robóticas sin alma.

En este artículo te quiero enseñar paso a paso cómo he logrado montar un podcast entero de forma semiautomática usando Inteligencia Artificial. Y para conseguir ese nivel de calidad en el audio que marque la diferencia, me he apoyado en los servicios de Azure. Vamos a repasar juntos todo el flujo de trabajo: desde que le pedimos a la IA que nos escupa el texto, hasta que picamos un script para convertirlo a un archivo de audio con un sonido espectacular y un acento de España que da el pego por completo.

¿Por qué elegir Azure para esta locura?

Es probable que te preguntes por qué me he decantado por la nube de Microsoft habiendo otras opciones como Google Cloud, AWS o plataformas específicas como ElevenLabs. He probado varios sistemas y APIs de Text-to-Speech durante estos últimos meses, pero al final siempre acabo volviendo a Azure por varios motivos de peso que, para mí, marcan la diferencia.

El primero y más evidente: Azure Speech ofrece unas voces neuronales que son una auténtica pasada. Cuentan con un abanico de tonalidades muy variadas y, lo más importante, su acento en español de España (al igual que el de otros muchos países hispanohablantes) prácticamente no suena a robot. Puedes jugar con voces como la de “Álvaro” o “Elvira” y notar la cadencia y la entonación que esperarías de un humano normal y corriente leyendo un texto.

Además, hay otras ventajas clave en el entorno de desarrollo:

• La API es híper robusta: Se nota que es un servicio maduro. La documentación es completísima y Microsoft mantiene los SDKs súper actualizados.
• Integración sin fricciones: Instalar su paquete de NPM en cualquier script de Node.js o Python y tenerlo funcionando te lleva literalmente un par de minutos.
• SSML (Speech Synthesis Markup Language): Si la voz de base no te convence del todo, puedes usar etiquetas estándar XML para meter pausas de un segundo, subir el tono de voz al final de una pregunta o cambiar la velocidad de ciertas frases clave de forma súper granular. Esto da mucho juego si quieres automatizar hasta la respiración del locutor.
• La capa gratuita (Free Tier): Azure te da una tarifa F0 en el servicio de Speech que te ofrece miles de caracteres gratuitos al mes, lo que da de sobra para hacer pruebas, proyectos personales y validar ideas sin tener que pasar la tarjeta por caja a las primeras de cambio.

Lo que vas a necesitar antes de empezar

Antes de ponernos a ensuciarnos las manos picando código, asegúrate de tener todo esto preparado en tu entorno de trabajo:

• Una cuenta de Azure activa. Si no la tienes, te puedes registrar totalmente gratis desde su portal y te dan crédito inicial.
• Preferiblemente Node.js instalado en su versión 16 LTS o superior.
• Tu editor de código favorito listo para la acción (yo soy “team VS Code” a muerte).
• Una cuenta de OpenAI (o Azure OpenAI) con su API Key lista por si quieres seguir el flujo completo y automatizar también la parte creativa de la generación de guiones.

Paso 1: Configurar nuestro servicio de Azure Speech

Lo primero de todo es irnos al portal de Azure para levantar el servicio que hará el trabajo duro de poner voz a nuestras palabras.

1. Una vez dentro de tu dashboard de Azure, haz clic en “Crear un recurso” (el clásico botón del menú superior) y usa la barra de búsqueda para encontrar “Speech” (o Voz, dependiendo del idioma de tu portal).
2. Dale al botón de crear. Se te abrirá un formulario para rellenar los datos. Ponle un nombre descriptivo a la instancia, algo como podcast-ia-demo.
3. Selecciona la suscripción que vayas a usar, escoge un grupo de recursos existente (o crea uno nuevo para tenerlo todo organizadito) y como tarifa asegúrate de escoger la F0 (gratuita) para empezar. Esta tarifa es tu mejor amiga para hacer experimentos.
4. Asígnalo a tu región más cercana. En mi caso, estando en España, casi siempre suelo elegir West Europe.
5. Una vez que Azure termine de desplegar el recurso (suele tardar muy poco), vete al panel del servicio y busca la sección “Claves y punto de conexión” en el menú lateral de la izquierda.
6. Aquí verás dos claves y el nombre de la región. Te va a hacer falta copiar la “Clave 1” y la región exacta. Guárdalas a buen recaudo que luego las vamos a inyectar en nuestras variables de entorno. ¡Y recuerda no subirlas a ningún repositorio público!

Paso 2: Preparando nuestra estructura local

Con el backend en la nube preparado, vamos a montar la estructura de nuestro proyecto en el PC desde la terminal:

mkdir podcast-ia-azure
cd podcast-ia-azure
npm init -y

Ahora nos toca instalar las tres librerías de NPM que nos van a dar la vida y hacer que todo esto conecte con apenas un par de bloques de código: el SDK oficial de Azure, la librería de OpenAI, y dotenv para no tener que harcodear nuestras credenciales.

npm install microsoft-cognitiveservices-speech-sdk openai dotenv

Para organizarme un poco mejor y no acabar con un mar de archivos sueltos, yo me creo un par de subcarpetas para ir almacenando de forma limpia los guiones generados, los audios resultantes y los propios scripts de ejecución. Tu proyecto debería quedar parecido a esto:

podcast-ia-azure/
├── guiones/
├── audios/
├── scripts/
│   ├── generarGuion.js
│   └── generarPodcast.js
├── .env
├── package.json

Paso 3: Poniendo a GPT a currar como nuestro guionista

Llegados a este punto podrías ser tú quien escriba el texto si ya tienes inspiración o quieres narrar un post tuyo. Pero ya que estamos automatizando cosas, ¿por qué no le pedimos a un modelo de lenguaje que nos haga él el borrador del guion?

Crea un archivo llamado .env en la raíz de tu proyecto e introduce ahí tu key de OpenAI:

OPENAI_API_KEY=sk-tu_clave_super_secreta_de_openai

Después, crea tu primer script al que vamos a llamar scripts/generarGuion.js. Le pasaremos un tema por consola y nos tiene que devolver un archivo con el speech completo:

require('dotenv').config();
const fs = require('fs');
const { Configuration, OpenAIApi } = require('openai');

const configuration = new Configuration({
  apiKey: process.env.OPENAI_API_KEY,
});

const openai = new OpenAIApi(configuration);

async function generarGuion(tema, archivoSalida) {
  // Ajustamos el prompt para que suene a locutor amigable y casual
  const prompt = `Escribe un guion para un podcast de unos 5 minutos. El tema del que tienes que hablar de manera amena es: ${tema}. Exprésate con un tono muy cercano, entretenido y natural. Puedes saludar a la audiencia como si estuvieran contigo.`;

  console.log(`Pensando el guion para el tema: "${tema}"... Dame un momento.`);

  const response = await openai.createChatCompletion({
    model: 'gpt-4',
    // La temperatura a 0.7 suele ir genial para equilibrar creatividad y coherencia narrativa
    temperature: 0.7,
    messages: [
      { role: 'system', content: 'Eres el locutor principal de un podcast de éxito sobre desarrollo y curiosidades tech. Hablas como si estuvieras charlando tranquilamente con un buen amigo.' },
      { role: 'user', content: prompt }
    ]
  });

  const guion = response.data.choices[0].message.content;

  // Guardamos el texto en la ruta que le hayamos indicado
  fs.writeFileSync(archivoSalida, guion);
  console.log(`¡Guion escrito y pulido! Lo he guardado sano y salvo en ${archivoSalida}`);
}

// Capturamos los argumentos de la terminal
const [tema, archivoSalida] = process.argv.slice(2);
generarGuion(tema || "Por qué migrar a la nube no es magia negra", archivoSalida || "guiones/episodio1.txt");

¡Es la hora de probarlo! Vamos a ejecutar el script pasándole el parámetro de lo que queremos hablar:

node scripts/generarGuion.js "La revolución de los desarrollos Serverless" guiones/episodio_serverless.txt

En cuestión de segundos tendrás tu guion esperándote en la carpeta de guiones. Es muy recomendable que le eches un primer vistazo, ya que el modelo suele organizar muy bien el saludo, el desarrollo del contenido y suele incluir hasta una buena llamada a la acción al final (“no olvides suscribirte si te ha gustado…”).

Paso 4: La magia ocurre (Convertir texto a voz)

Es aquí donde el código cobra vida, literalmente. Volvemos un segundo a nuestro .env y añadimos los valores que nos apuntamos del portal de Azure hace un rato:

AZURE_SPEECH_KEY=la_clave_que_sacaste_del_portal
AZURE_SPEECH_REGION=tu_region_ejemplo_westeurope

A continuación toca armar nuestro plato principal: scripts/generarPodcast.js. En este archivo le vamos a decir al SDK de Voz de Azure: “Coge este fichero de texto, aplícale tus modelos neuronales, y devuélveme un clip de audio prístino”.

require('dotenv').config();
const fs = require('fs');
// Importamos el SDK oficial
const sdk = require('microsoft-cognitiveservices-speech-sdk');

const speechKey = process.env.AZURE_SPEECH_KEY;
const serviceRegion = process.env.AZURE_SPEECH_REGION;

// Recuperamos el archivo origen y el destino de los argumentos, o pillamos los default
const archivoGuion = process.argv[2] || 'guiones/episodio1.txt';
const archivoAudio = process.argv[3] || 'audios/episodio1.wav';

const texto = fs.readFileSync(archivoGuion, 'utf8');

// Inicializamos la config con las keys
const speechConfig = sdk.SpeechConfig.fromSubscription(speechKey, serviceRegion);

// Asignamos una voz específica. 'es-ES-AlvaroNeural' funciona increíble para un tono neutro español.
// Si prefieres intentar con voz femenina, la variante 'es-ES-ElviraNeural' también tiene matices tremendos.
speechConfig.speechSynthesisVoiceName = 'es-ES-AlvaroNeural';

// Le decimos al SDK que en vez de hablar por los altavoces de tu portátil, renderice directo a un archivo
const audioConfig = sdk.AudioConfig.fromAudioFileOutput(archivoAudio);
const synthesizer = new sdk.SpeechSynthesizer(speechConfig, audioConfig);

console.log(`Renderizando la voz del archivo ${archivoGuion}. Esto suele tardar unos segundos...`);

// Lanzamos la acción asíncrona principal
synthesizer.speakTextAsync(texto, result => {
  if (result.reason === sdk.ResultReason.SynthesizingAudioCompleted) {
    console.log(`¡Boom! Renderización completada al 100%. Tienes el audio esperándote en ${archivoAudio}`);
  } else {
    // Si algo falla (ej. clave mal puesta), nos escupe el error por consola
    console.error('Ha ocurrido un error al intentar sintetizar la voz:', result.errorDetails);
  }
  // Importante: cerrar el sintetizador para liberar recursos
  synthesizer.close();
});

Probemos a ejecutar esta maravilla por primera vez:

node scripts/generarPodcast.js guiones/episodio_serverless.txt audios/episodio_serverless.wav

De verdad, ponte unos buenos auriculares, navega hasta tu carpeta de audios, y dale al play al WAV resultante. Si es tu primera vez usando voces neuronales de Azure, te va a sorprender una barbaridad lo humana que llega a sonar la entonación y las pausas que hace al leer las comas y los puntos.

Un paso más allá: Expandiendo tu automatización

A estas alturas ya tenemos lo fundamental: un archivo con una voz narrando el contenido. Sin embargo, si lo escuchas tal cual, posiblemente notes el audio un pelín “clínico” o vacío, ya que el locutor está hablando en el absoluto de los vacíos sonoros.

Para darle el toque maestro, hay un par de cositas de post-producción que te recomiendo aplicar siempre.

Si buscas el control absoluto y no te importa invertir un par de minutos más, te puedes abrir el archivo directamente en un programa libre de edición como Audacity. Te echas el WAV generado a la pista principal, añades una pista secundaria pregrabada con alguna melodía de Lo-Fi o jazz relajante (ojo con los derechos de autor, Free Music Archive es genial para esto) y un par de “woosh” de efectos de sonido para la intro y el outro. Subirle unos decibelios a la voz y bajar la música te dará un nivel súper profesional al instante.

Pero si, al igual que a nosotros, te va la marcha pura y dura y prefieres ser fiel a la filosofía de automatizarlo absolutamente todo, puedes usar herramientas como ffmpeg desde la propia terminal para mezclar automáticamente tu podcast con una base musical. La idea es que baje el volumen de la música de fondo para que tu voz se escuche clara (el famoso efecto “ducking”):

ffmpeg -i audios/episodio1.wav -i musica_fondo.mp3 -filter_complex "[0:a][1:a]amix=inputs=2:duration=first:dropout_transition=2" audios/episodio1_final.mp3

¿Te sabe a poco? Vamos a subir el nivel integrando la API de YouTube. Imagina que fabricamos un vídeo MP4 con una carátula estática y nuestro audio final. Puedes usar este comando rapidísimo de ffmpeg:

ffmpeg -loop 1 -i portada.png -i audios/episodio1_final.mp3 -c:v libx264 -tune stillimage -c:a aac -b:a 192k -pix_fmt yuv420p -shortest videos/episodio1.mp4

Una vez que tienes el archivo MP4 listo en tu carpeta videos/, el siguiente paso lógico de automatización es subirlo directamente a tu canal usando OAuth 2.0 y el cliente oficial de Google APIs. Te dejo aquí un snippet bastante avanzado donde he creado un objeto uploadToYouTube para enviar el archivo directamente a los servidores de YouTube sin tener que abrir el navegador:

const fs = require('fs');
// Lógica que envuelve la llamada a googleapis e instanciación del cliente de YouTube
const { uploadToYouTube } = require('../utils/youtube-upload');

// Le pasamos el buffer de nuestro vídeo recién renderizado
const videoBuffer = fs.readFileSync('videos/episodio1.mp4');

// Rellenamos los metadatos. ¡Esto también te lo podría generar GPT!
const post = {
  title: 'Episodio 1: La historia de la IA',
  description: 'Podcast generado con IA y Azure. En este episodio hablamos sobre la historia de la inteligencia artificial.',
  tags: [ { name: 'podcast' }, { name: 'inteligencia artificial' }, { name: 'azure' } ],
  featureImage: 'portada.png'
};

const scriptData = {};
const env = process.env;

console.log("Subiendo vídeo a YouTube...");

// Lanzamos nuestra mega-integración
uploadToYouTube(videoBuffer, post, scriptData, env)
  .then(result => {
    console.log('¡Vídeo subido y listado con éxito!', result.url);
  })
  .catch(err => {
    console.error('El script ha petado subiendo a YouTube:', err);
  });

Si metes esto último en un entorno de integración continua (como GitHub Actions) tras hacer un push de tus guiones en texto plano, tienes un bot autónomo que renderiza voces neuronales, hace postproducción de vídeo final al vuelo, y auto-publica la obra maestra en YouTube sin que te hayas despeinado.

Espero que de verdad este recorrido te haya aportado ideas frescas de todo lo que puedes lograr combinando tan solo un entorno básico de Node, junto a un par de servicios cloud impresionantes como los que tenemos a nuestra disposición hoy en día. ¿Te imaginas configurando una alarma matutina que te lea el resumen de los pull requests que te han asignado en voz de locutor de radio? Porque con estas herramientas, la barrera principal acaba siendo puramente la imaginación.

Si acabas de probar el código, encuentras alguna cosa curiosa en Azure Speech o te apetece enseñarme los resultados, ya sabes dónde estoy en los comentarios o puedes buscar mis redes sociales. ¡Dale duro!