DEV Community: transcribir audio

Cómo transcribir un podcast y convertirlo en un artículo que sí merece publicarse

transcribir audio — Tue, 04 Aug 2026 09:59:10 +0000

Publicar la transcripción completa de un podcast no convierte automáticamente el episodio en un buen artículo.

Una conversación de una hora puede contener ideas valiosas, pero también incluye:

saludos;
pausas;
repeticiones;
interrupciones;
cambios de tema;
bromas internas;
preguntas mal formuladas;
respuestas que solo se entienden después de escuchar el tono.

Si copias el texto automático y lo publicas sin editar, el resultado suele ser largo, difícil de leer y poco útil para quien llega desde Google.

El trabajo correcto tiene dos fases distintas:

Podcast grabado
→ transcripción revisada
→ artículo editorial

La transcripción conserva lo que se dijo.

El artículo reorganiza ese contenido para que una persona pueda entenderlo sin haber escuchado el episodio.

Decide qué quieres crear antes de transcribir

No todos los podcasts necesitan el mismo resultado.

Puedes querer producir:

una transcripción completa;
unas show notes;
un artículo independiente;
un resumen para newsletter;
citas para redes sociales;
subtítulos para vídeo;
un documento para el invitado;
un archivo interno que permita buscar episodios anteriores.

Esta decisión cambia la forma de revisar el texto.

Si solo necesitas show notes, no hace falta corregir cada muletilla.

Si vas a publicar citas textuales, sí debes comprobar cada frase contra el audio.

Si quieres escribir un artículo, la prioridad no es mantener el orden exacto de la conversación, sino construir una estructura clara.

Consigue el archivo original

Utiliza siempre la mejor versión disponible.

El archivo original suele estar en:

el programa de grabación;
el editor de audio;
la plataforma donde alojas el podcast;
la carpeta del episodio;
el almacenamiento del productor.

Evita transcribir una copia descargada de una red social si todavía conservas el archivo original.

Una versión recomprimida puede perder claridad, especialmente en:

voces bajas;
consonantes;
intervenciones breves;
personas que hablan al mismo tiempo;
nombres poco comunes.

Formatos como MP3, WAV y M4A suelen ser suficientes. No conviertas el archivo solo por costumbre si la herramienta acepta el formato original.

Guarda una estructura ordenada por episodio

No trabajes con archivos llamados:

final.mp3
final-bueno.mp3
episodio-nuevo-2.mp3

Utiliza una estructura consistente:

podcast/
└── episodio-042/
    ├── episodio-042-original.wav
    ├── episodio-042-editado.mp3
    ├── episodio-042-transcripcion.docx
    ├── episodio-042-articulo.md
    └── episodio-042-citas.txt

Esto evita confundir:

el audio original;
la versión editada;
el borrador automático;
la transcripción corregida;
el artículo final.

La transcripción y el artículo nunca deberían ser el mismo archivo.

Genera primero una transcripción completa

Puedes utilizar una herramienta para transcribir audio a texto y obtener un primer borrador del episodio.

En esta fase no intentes redactar todavía el artículo.

Primero necesitas un texto base que permita:

localizar temas;
buscar nombres;
recuperar citas;
identificar cambios de sección;
volver al minuto exacto;
separar las intervenciones.

El texto automático no es el contenido final. Es un índice detallado del episodio.

Corrige primero los nombres de los hablantes

En un podcast de entrevista puedes recibir algo parecido a:

Hablante 1
Hablante 2

Cámbialo inmediatamente por:

Lucía — presentadora
Daniel — invitado

Si existe una tercera persona:

Lucía — presentadora
Daniel — invitado
Marta — copresentadora

No empieces a editar el contenido antes de resolver quién dijo cada cosa.

Una pregunta del presentador puede parecer una afirmación del invitado si la separación de voces está mal.

Por ejemplo:

¿Entonces consideras que el modelo de suscripción no funciona?

No es una opinión del invitado. Es una pregunta.

Revisa nombres, marcas, cifras y negaciones

No hace falta corregir todas las palabras con el mismo nivel de detalle.

Prioriza los elementos que pueden cambiar el significado:

nombres y apellidos;
empresas;
productos;
libros;
ciudades;
fechas;
cantidades;
porcentajes;
URLs;
términos técnicos;
palabras negativas.

Compara:

No recomendamos lanzar todavía.

con:

Recomendamos lanzar todavía.

Una sola palabra ausente invierte la conclusión.

También debes comprobar cifras aunque la frase parezca natural.

Conseguimos quince clientes.

no es lo mismo que:

Conseguimos cincuenta clientes.

Mantén las marcas de tiempo en las partes importantes

No necesitas una marca en cada frase, pero sí en:

citas que publicarás;
datos que deben verificarse;
cambios de tema;
ejemplos especialmente útiles;
historias que pueden convertirse en clips;
afirmaciones sensibles.

Ejemplo:

[00:18:42]
“No teníamos un problema de tráfico. Teníamos un problema de activación.”

La marca permite:

comprobar la cita;
extraer un clip;
enlazar la sección en YouTube;
encontrar el contexto;
revisar una corrección con el invitado.

No publiques la conversación en el orden original

Una conversación funciona porque dos personas reaccionan en tiempo real.

Un artículo necesita una estructura distinta.

El episodio puede seguir este orden:

Presentación
Historia personal
Cambio de tema
Explicación del problema
Broma
Ejemplo
Vuelta a la historia
Consejo práctico

El artículo puede reorganizarlo así:

1. El problema
2. Por qué ocurre
3. El caso del invitado
4. Qué intentaron
5. Qué funcionó
6. Qué harían hoy

Reordenar no significa falsear.

Puedes cambiar la secuencia siempre que no alteres:

quién dijo qué;
la relación entre causa y efecto;
el contexto de una cita;
la conclusión original.

Elige una tesis para el artículo

Un episodio puede tratar diez temas.

Un artículo no debería intentar posicionarse por todos.

Antes de escribir, completa esta frase:

Después de leer este artículo, el lector entenderá…

Ejemplos:

…por qué una newsletter con muchos suscriptores puede seguir sin generar ventas.

…cómo preparar una entrevista remota con audio limpio.

…qué errores retrasaron seis meses el lanzamiento del producto.

…cómo un equipo redujo las reuniones sin perder coordinación.

La tesis ayuda a decidir qué partes del episodio entran y cuáles quedan fuera.

No todo lo interesante pertenece al mismo artículo.

Utiliza la pregunta principal como título

Un título como:

Conversación con Daniel Pérez

solo interesa a quien ya conoce al invitado.

Un título orientado al problema puede ser:

Por qué tener más usuarios no resuelve un problema de activación

Cómo validar un producto antes de invertir seis meses en desarrollarlo

El nombre del invitado puede aparecer como contexto secundario:

Cómo validar un producto antes de desarrollarlo: conversación con Daniel Pérez

El lector busca una respuesta, no necesariamente una entrevista.

Extrae las ideas, no todos los turnos de palabra

Una transcripción puede contener:

Presentadora:
Claro. Y en ese momento, ¿qué hicisteis?

Invitado:
Bueno, al principio no lo teníamos muy claro. Probamos varias cosas. Primero cambiamos la página, pero no pasó mucho. Luego hablamos con algunos usuarios y vimos que el problema estaba antes.

Presentadora:
¿Antes del registro?

Invitado:
Sí, exactamente. La gente no entendía para quién era el producto.

El artículo puede condensarlo:

El equipo empezó modificando la página de registro, pero el cambio no tuvo efecto. Las entrevistas posteriores mostraron que el problema ocurría antes: los visitantes no entendían para quién estaba pensado el producto.

La idea se conserva, pero desaparece la mecánica de la conversación.

Conserva citas solo cuando aporten algo

No conviertas cada respuesta en una cita destacada.

Una cita merece conservarse cuando:

resume una idea con precisión;
tiene una formulación difícil de mejorar;
refleja claramente la voz del invitado;
contiene una experiencia personal;
expresa una conclusión importante.

Ejemplo útil:

“No teníamos un problema de tráfico. Teníamos un problema de activación.”

Ejemplo que no necesita cita:

“Bueno, sí, creo que en ese momento empezamos a verlo de otra manera.”

La segunda frase puede integrarse en la narración.

No corrijas tanto que el invitado deje de sonar como él mismo

El lenguaje hablado contiene imperfecciones.

Puedes eliminar:

repeticiones accidentales;
muletillas;
falsos comienzos;
frases incompletas sin contenido;
interrupciones irrelevantes.

Pero no deberías:

convertir una duda en una certeza;
añadir términos que el invitado no utilizó;
hacer que una respuesta informal suene académica;
eliminar reservas importantes;
cambiar la intensidad de una crítica.

Compara:

Creo que probablemente no lo volveríamos a hacer así.

con:

Nunca volveríamos a hacerlo así.

La segunda versión es más contundente, pero no significa lo mismo.

Separa hechos, opiniones e interpretaciones

Un artículo basado en una conversación puede mezclar fácilmente tres niveles.

Hecho

El equipo lanzó la primera versión en marzo.

Opinión del invitado

Según Daniel, el lanzamiento se hizo demasiado pronto.

Interpretación del autor

El problema parece haber sido la falta de entrevistas previas.

No presentes una interpretación como si fuera una afirmación del invitado.

Utiliza expresiones claras:

“según el invitado”;
“en su experiencia”;
“el equipo observó”;
“esto sugiere”;
“una posible lectura es”.

Convierte el episodio en secciones útiles

Una estructura práctica puede ser:

Introducción
El problema inicial
La primera solución que no funcionó
Lo que descubrieron al hablar con usuarios
El cambio que produjo resultados
Errores que evitarían hoy
Consejos para equipos en la misma situación

Cada sección debe responder una pregunta.

Evita encabezados vacíos como:

Algunas reflexiones
Más detalles
Otros aspectos
Conclusión final

Utiliza encabezados concretos:

Por qué cambiar el precio no resolvió el problema
Qué revelaron las entrevistas con usuarios
Cuándo supieron que debían abandonar la primera idea

Crea show notes distintas del artículo

Las show notes no tienen que repetir el artículo.

Su función es ayudar a decidir si escuchar el episodio y localizar secciones.

Un formato útil:

En este episodio hablamos de:

- Por qué el equipo confundió tráfico con activación.
- Qué preguntas hicieron en las entrevistas.
- Por qué la primera página de precios falló.
- Qué métrica cambió después del nuevo onboarding.
- Qué harían diferente al lanzar otro producto.

Capítulos:

00:00 Introducción
03:18 El problema inicial
11:42 Las primeras entrevistas
19:10 El cambio de onboarding
31:25 Qué harían hoy

El artículo desarrolla las ideas.

Las show notes describen el episodio.

Convierte una transcripción en varios activos, pero no repitas lo mismo

Un solo episodio puede generar:

un artículo;
una newsletter;
cinco citas;
un carrusel;
varios clips;
una lista de recursos;
una página de preguntas frecuentes.

Pero cada formato necesita adaptación.

No publiques el mismo párrafo en cinco canales sin cambiarlo.

Artículo

Explica la idea completa.

Destaca una lección y lleva al episodio.

Red social

Presenta una observación concreta.

Clip

Conserva una intervención con contexto suficiente.

FAQ

Responde preguntas específicas mencionadas durante la conversación.

Reutilizar contenido no significa duplicarlo literalmente.

Añade recursos mencionados durante el episodio

Mientras revisas la transcripción, crea una lista de:

libros;
herramientas;
artículos;
empresas;
informes;
personas;
episodios anteriores;
documentos.

Después verifica cada nombre y URL.

No enlaces automáticamente cualquier palabra que parezca una marca. Comprueba que corresponde al recurso mencionado.

Una sección final puede ser:

Recursos mencionados

- Libro citado por el invitado
- Herramienta utilizada por el equipo
- Estudio mencionado durante la conversación
- Episodio anterior relacionado

Esto mejora la utilidad real del artículo.

Decide cuándo publicar la transcripción completa

La transcripción íntegra puede ser útil para:

accesibilidad;
investigación;
consulta precisa;
entrevistas públicas;
clases;
archivos institucionales.

Pero no siempre debe ocupar el cuerpo principal.

Una buena solución es publicar:

el artículo editorial;
las show notes;
un bloque desplegable o página separada con la transcripción completa.

Así cada lector elige:

entender las ideas rápidamente;
escuchar el episodio;
consultar el texto exacto.

Revisa el consentimiento antes de publicar

Que una conversación haya sido grabada no significa que todo pueda publicarse.

Comprueba:

si el invitado aceptó la grabación;
si sabía que se publicaría;
si alguna parte se declaró privada;
si aparecen datos personales;
si se mencionan clientes;
si existen acusaciones o información sensible;
si se acordó una revisión previa.

En una entrevista informal pueden aparecer comentarios que el invitado no esperaba ver convertidos en texto indexable.

El audio y el texto no tienen exactamente el mismo nivel de exposición. Una frase enterrada en el minuto 47 puede aparecer en Google si se publica escrita.

Lista de revisión antes de publicar

Comprueba:

¿El título responde una pregunta real?
¿El artículo tiene una tesis clara?
¿Los nombres están bien escritos?
¿Las cifras coinciden con el audio?
¿Las citas mantienen su contexto?
¿Se distingue entre hechos y opiniones?
¿La estructura funciona sin escuchar el episodio?
¿Se han eliminado repeticiones?
¿Se conservan las reservas importantes?
¿Los recursos enlazados son correctos?
¿Existe permiso para publicar?
¿El texto aporta más que una transcripción automática?

El artículo debe poder vivir sin el episodio

Una persona que llega desde Google puede no querer escuchar una hora de audio.

El artículo debe permitirle comprender:

cuál era el problema;
qué ocurrió;
qué aprendió el invitado;
qué decisiones tomó;
qué puede aplicar el lector.

El episodio ofrece:

voz;
tono;
personalidad;
matices;
conversación completa.

El artículo ofrece:

estructura;
búsqueda;
síntesis;
referencias;
lectura rápida.

No compiten. Cumplen funciones distintas.

Conclusión

Transcribir un podcast no consiste en publicar cada palabra pronunciada.

El flujo útil es:

Obtener el audio original
→ generar una transcripción
→ corregir nombres, cifras y hablantes
→ identificar la tesis
→ reorganizar las ideas
→ comprobar las citas
→ crear el artículo
→ preparar show notes y capítulos

La transcripción reduce el tiempo necesario para encontrar el contenido.

La edición convierte ese contenido en algo que merece ser leído.

Un buen artículo basado en un podcast no intenta fingir que nunca existió una conversación. Conserva la voz del invitado, pero elimina el esfuerzo que supondría para el lector escuchar y ordenar mentalmente todo el episodio.
Video a Texto

Cómo transcribir archivos de audio con JavaScript y Node.js sin exponer tu API key

transcribir audio — Tue, 04 Aug 2026 09:50:44 +0000

Un formulario para convertir audio en texto parece fácil de construir:

el usuario selecciona un archivo;
JavaScript lo envía a una API;
la API devuelve la transcripción;
el navegador muestra el resultado.

El error habitual aparece en el segundo paso: llamar al proveedor de transcripción directamente desde el navegador y colocar la API key dentro del código JavaScript.

const apiKey = "sk-...";

Aunque la clave no se muestre en la interfaz, cualquier visitante puede encontrarla desde:

las herramientas de desarrollo;
el código JavaScript descargado;
las peticiones de red;
un mapa de código fuente;
una extensión del navegador.

Una clave incluida en el frontend debe considerarse pública.

La arquitectura correcta separa responsabilidades:

Navegador
    ↓
Servidor Node.js
    ↓
Proveedor de transcripción

El navegador selecciona y sube el archivo. El servidor valida el audio, conserva la API key y realiza la petición externa.

En este tutorial construiremos una aplicación que:

acepta archivos desde el navegador;
valida formato y tamaño;
no expone la API key;
devuelve un identificador de trabajo;
procesa la transcripción fuera de la petición inicial;
permite consultar el estado;
muestra el resultado;
elimina los archivos temporales;
controla los errores más frecuentes.

El ejemplo utiliza Express, Multer y el SDK de OpenAI, pero la estructura puede adaptarse a otros proveedores.

Qué vamos a construir

El flujo será este:

1. El usuario selecciona un audio.
2. El navegador envía el archivo a POST /api/transcriptions.
3. Node.js valida y guarda temporalmente el archivo.
4. El servidor devuelve un task_id.
5. El navegador consulta GET /api/transcriptions/:task_id.
6. Un proceso interno envía el audio al proveedor.
7. El servidor guarda el resultado.
8. El navegador muestra la transcripción.
9. El archivo temporal se elimina.

No mantendremos abierta una petición HTTP durante toda la transcripción.

Esto evita que una petición lenta termine por:

timeout;
cierre del navegador;
fallo del proxy;
pérdida de conexión;
reintento accidental del mismo archivo.

Requisitos

Necesitas:

Node.js 20 o superior;
npm;
una API key;
un archivo MP3, WAV, M4A, MP4, MPEG, MPGA o WEBM para probar.

Crea el proyecto:

mkdir audio-transcription-node
cd audio-transcription-node
npm init -y

Instala las dependencias:

npm install express multer openai dotenv

Instala una dependencia de desarrollo para reiniciar el servidor automáticamente:

npm install --save-dev nodemon

Estructura del proyecto

Crea esta estructura:

audio-transcription-node/
├── public/
│   ├── index.html
│   ├── app.js
│   └── styles.css
├── uploads/
├── .env
├── .gitignore
├── package.json
└── server.js

La carpeta uploads almacenará temporalmente los archivos recibidos.

No debe utilizarse como almacenamiento permanente.

Configurar package.json

Modifica package.json:

{
  "name": "audio-transcription-node",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "scripts": {
    "dev": "nodemon server.js",
    "start": "node server.js"
  },
  "dependencies": {
    "dotenv": "^16.0.0",
    "express": "^5.0.0",
    "multer": "^2.0.0",
    "openai": "^5.0.0"
  },
  "devDependencies": {
    "nodemon": "^3.0.0"
  }
}

Las versiones exactas pueden variar cuando instales los paquetes. No es necesario copiarlas manualmente si ya ejecutaste npm install.

Guardar la API key

Crea .env:

OPENAI_API_KEY=tu_clave_aqui
PORT=3000
MAX_AUDIO_SIZE_MB=25

Crea .gitignore:

node_modules/
.env
uploads/*
!uploads/.gitkeep

Añade un archivo vacío:

touch uploads/.gitkeep

En Windows PowerShell:

New-Item uploads/.gitkeep -ItemType File

Nunca subas .env a GitHub.

Una API key expuesta debe revocarse. Eliminarla del último commit no basta, porque puede seguir presente en el historial del repositorio.

Estados de una transcripción

Cada trabajo tendrá uno de estos estados:

queued
processing
completed
failed

La respuesta inicial será similar a:

{
  "taskId": "1b78bf8f-27dc-49d1-8f2d-7df81d4eeef2",
  "status": "queued"
}

Después, el navegador consultará el estado:

{
  "taskId": "1b78bf8f-27dc-49d1-8f2d-7df81d4eeef2",
  "status": "completed",
  "text": "Texto obtenido del archivo..."
}

Crear el servidor

Crea server.js:

import "dotenv/config";

import crypto from "node:crypto";
import fs from "node:fs";
import path from "node:path";
import { fileURLToPath } from "node:url";

import express from "express";
import multer from "multer";
import OpenAI from "openai";


const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const PORT = Number.parseInt(process.env.PORT ?? "3000", 10);
const MAX_AUDIO_SIZE_MB = Number.parseInt(
  process.env.MAX_AUDIO_SIZE_MB ?? "25",
  10,
);

if (!process.env.OPENAI_API_KEY) {
  throw new Error(
    "Falta OPENAI_API_KEY en el archivo .env",
  );
}

if (!Number.isFinite(PORT) || PORT <= 0) {
  throw new Error("PORT no es válido.");
}

if (
  !Number.isFinite(MAX_AUDIO_SIZE_MB)
  || MAX_AUDIO_SIZE_MB <= 0
) {
  throw new Error("MAX_AUDIO_SIZE_MB no es válido.");
}

const app = express();

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

const uploadsDirectory = path.join(__dirname, "uploads");
const publicDirectory = path.join(__dirname, "public");

await fs.promises.mkdir(uploadsDirectory, {
  recursive: true,
});

app.use(express.json());
app.use(express.static(publicDirectory));

const jobs = new Map();

const allowedMimeTypes = new Set([
  "audio/mpeg",
  "audio/mp3",
  "audio/mp4",
  "audio/x-m4a",
  "audio/wav",
  "audio/x-wav",
  "audio/webm",
  "video/mp4",
  "video/webm",
]);

const allowedExtensions = new Set([
  ".mp3",
  ".mp4",
  ".mpeg",
  ".mpga",
  ".m4a",
  ".wav",
  ".webm",
]);

function sanitizeExtension(originalName) {
  const extension = path
    .extname(originalName)
    .toLowerCase();

  if (!allowedExtensions.has(extension)) {
    return "";
  }

  return extension;
}

const storage = multer.diskStorage({
  destination: (_request, _file, callback) => {
    callback(null, uploadsDirectory);
  },

  filename: (_request, file, callback) => {
    const extension = sanitizeExtension(
      file.originalname,
    );

    const generatedName =
      `${crypto.randomUUID()}${extension}`;

    callback(null, generatedName);
  },
});

const upload = multer({
  storage,

  limits: {
    fileSize: MAX_AUDIO_SIZE_MB * 1024 * 1024,
    files: 1,
  },

  fileFilter: (_request, file, callback) => {
    const extension = sanitizeExtension(
      file.originalname,
    );

    const validMime =
      allowedMimeTypes.has(file.mimetype);

    if (!extension || !validMime) {
      callback(
        new Error(
          "Formato no permitido. "
          + "Utiliza MP3, M4A, WAV, MP4 o WEBM.",
        ),
      );
      return;
    }

    callback(null, true);
  },
});

La extensión y el MIME se revisan, pero esto todavía no garantiza que el archivo sea realmente audio.

Un atacante puede cambiar el nombre de cualquier archivo a .mp3.

En producción conviene inspeccionar el contenido mediante FFprobe, una biblioteca de detección binaria o ambos.

Crear un trabajo

Añade este endpoint:

app.post(
  "/api/transcriptions",
  upload.single("audio"),
  async (request, response, next) => {
    try {
      if (!request.file) {
        response.status(400).json({
          error: "Debes seleccionar un archivo.",
        });
        return;
      }

      const taskId = crypto.randomUUID();
      const now = new Date().toISOString();

      const job = {
        taskId,
        status: "queued",
        originalName: request.file.originalname,
        storedPath: request.file.path,
        mimeType: request.file.mimetype,
        size: request.file.size,
        text: null,
        error: null,
        createdAt: now,
        updatedAt: now,
      };

      jobs.set(taskId, job);

      response.status(202).json({
        taskId,
        status: job.status,
      });

      setImmediate(() => {
        processTranscription(taskId).catch(
          (error) => {
            console.error(
              "Error no controlado en el trabajo:",
              error,
            );
          },
        );
      });
    } catch (error) {
      next(error);
    }
  },
);

La respuesta utiliza el código HTTP 202 Accepted.

Significa que el servidor aceptó el trabajo, pero todavía no lo ha terminado.

Procesar la transcripción

Añade esta función:

async function processTranscription(taskId) {
  const job = jobs.get(taskId);

  if (!job || job.status !== "queued") {
    return;
  }

  job.status = "processing";
  job.updatedAt = new Date().toISOString();

  try {
    const transcription =
      await openai.audio.transcriptions.create({
        file: fs.createReadStream(job.storedPath),
        model: "whisper-1",
        language: "es",
        response_format: "json",
      });

    job.status = "completed";
    job.text = transcription.text;
    job.error = null;
    job.updatedAt = new Date().toISOString();
  } catch (error) {
    console.error(
      `Falló la transcripción ${taskId}:`,
      error,
    );

    job.status = "failed";
    job.text = null;
    job.error = normalizeProviderError(error);
    job.updatedAt = new Date().toISOString();
  } finally {
    await removeTemporaryFile(job.storedPath);
    job.storedPath = null;
  }
}

function normalizeProviderError(error) {
  if (
    error
    && typeof error === "object"
    && "status" in error
  ) {
    if (error.status === 401) {
      return "La credencial del proveedor no es válida.";
    }

    if (error.status === 413) {
      return "El archivo supera el límite del proveedor.";
    }

    if (error.status === 429) {
      return (
        "El proveedor ha limitado temporalmente "
        + "las peticiones."
      );
    }
  }

  return "No se pudo completar la transcripción.";
}

async function removeTemporaryFile(filePath) {
  if (!filePath) {
    return;
  }

  try {
    await fs.promises.unlink(filePath);
  } catch (error) {
    if (error?.code !== "ENOENT") {
      console.error(
        `No se pudo borrar ${filePath}:`,
        error,
      );
    }
  }
}

La clave solo existe en el proceso de Node.js.

El navegador nunca la recibe.

Consultar el estado

Añade:

app.get(
  "/api/transcriptions/:taskId",
  (request, response) => {
    const job = jobs.get(request.params.taskId);

    if (!job) {
      response.status(404).json({
        error: "No se encontró el trabajo.",
      });
      return;
    }

    response.json({
      taskId: job.taskId,
      status: job.status,
      originalName: job.originalName,
      text: job.text,
      error: job.error,
      createdAt: job.createdAt,
      updatedAt: job.updatedAt,
    });
  },
);

No devolvemos:

la ruta temporal;
la API key;
detalles internos del proveedor;
stack traces;
nombres de directorios del servidor.

Eliminar trabajos antiguos

El archivo temporal ya se elimina al terminar, pero el objeto permanece dentro de jobs.

Añade una limpieza periódica:

const JOB_TTL_MS = 60 * 60 * 1000;

setInterval(() => {
  const expirationTime = Date.now() - JOB_TTL_MS;

  for (const [taskId, job] of jobs.entries()) {
    const updatedAt = Date.parse(job.updatedAt);

    if (
      Number.isFinite(updatedAt)
      && updatedAt < expirationTime
    ) {
      jobs.delete(taskId);
    }
  }
}, 10 * 60 * 1000).unref();

Los resultados se eliminan de memoria una hora después de la última actualización.

Este almacenamiento es intencionadamente sencillo. Más adelante veremos por qué no sirve para múltiples servidores.

Controlar errores de Multer

Añade al final:

app.use((error, _request, response, _next) => {
  console.error(error);

  if (error instanceof multer.MulterError) {
    if (error.code === "LIMIT_FILE_SIZE") {
      response.status(413).json({
        error:
          `El archivo supera ${MAX_AUDIO_SIZE_MB} MB.`,
      });
      return;
    }

    response.status(400).json({
      error: "No se pudo procesar el archivo.",
    });
    return;
  }

  response.status(400).json({
    error:
      error instanceof Error
        ? error.message
        : "Error inesperado.",
  });
});

app.listen(PORT, () => {
  console.log(
    `Servidor disponible en http://localhost:${PORT}`,
  );
});

Código completo del servidor

server.js debería quedar así:

import "dotenv/config";

import crypto from "node:crypto";
import fs from "node:fs";
import path from "node:path";
import { fileURLToPath } from "node:url";

import express from "express";
import multer from "multer";
import OpenAI from "openai";


const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const PORT = Number.parseInt(
  process.env.PORT ?? "3000",
  10,
);

const MAX_AUDIO_SIZE_MB = Number.parseInt(
  process.env.MAX_AUDIO_SIZE_MB ?? "25",
  10,
);

if (!process.env.OPENAI_API_KEY) {
  throw new Error(
    "Falta OPENAI_API_KEY en el archivo .env",
  );
}

if (!Number.isFinite(PORT) || PORT <= 0) {
  throw new Error("PORT no es válido.");
}

if (
  !Number.isFinite(MAX_AUDIO_SIZE_MB)
  || MAX_AUDIO_SIZE_MB <= 0
) {
  throw new Error("MAX_AUDIO_SIZE_MB no es válido.");
}

const app = express();

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

const uploadsDirectory = path.join(
  __dirname,
  "uploads",
);

const publicDirectory = path.join(
  __dirname,
  "public",
);

await fs.promises.mkdir(
  uploadsDirectory,
  { recursive: true },
);

app.use(express.json());
app.use(express.static(publicDirectory));

const jobs = new Map();

const allowedMimeTypes = new Set([
  "audio/mpeg",
  "audio/mp3",
  "audio/mp4",
  "audio/x-m4a",
  "audio/wav",
  "audio/x-wav",
  "audio/webm",
  "video/mp4",
  "video/webm",
]);

const allowedExtensions = new Set([
  ".mp3",
  ".mp4",
  ".mpeg",
  ".mpga",
  ".m4a",
  ".wav",
  ".webm",
]);

function sanitizeExtension(originalName) {
  const extension = path
    .extname(originalName)
    .toLowerCase();

  return allowedExtensions.has(extension)
    ? extension
    : "";
}

const storage = multer.diskStorage({
  destination: (_request, _file, callback) => {
    callback(null, uploadsDirectory);
  },

  filename: (_request, file, callback) => {
    const extension = sanitizeExtension(
      file.originalname,
    );

    callback(
      null,
      `${crypto.randomUUID()}${extension}`,
    );
  },
});

const upload = multer({
  storage,

  limits: {
    fileSize:
      MAX_AUDIO_SIZE_MB * 1024 * 1024,
    files: 1,
  },

  fileFilter: (_request, file, callback) => {
    const extension = sanitizeExtension(
      file.originalname,
    );

    const validMime =
      allowedMimeTypes.has(file.mimetype);

    if (!extension || !validMime) {
      callback(
        new Error(
          "Formato no permitido. "
          + "Utiliza MP3, M4A, WAV, MP4 o WEBM.",
        ),
      );
      return;
    }

    callback(null, true);
  },
});

function normalizeProviderError(error) {
  if (
    error
    && typeof error === "object"
    && "status" in error
  ) {
    if (error.status === 401) {
      return "La credencial del proveedor no es válida.";
    }

    if (error.status === 413) {
      return "El archivo supera el límite del proveedor.";
    }

    if (error.status === 429) {
      return (
        "El proveedor ha limitado temporalmente "
        + "las peticiones."
      );
    }
  }

  return "No se pudo completar la transcripción.";
}

async function removeTemporaryFile(filePath) {
  if (!filePath) {
    return;
  }

  try {
    await fs.promises.unlink(filePath);
  } catch (error) {
    if (error?.code !== "ENOENT") {
      console.error(
        `No se pudo borrar ${filePath}:`,
        error,
      );
    }
  }
}

async function processTranscription(taskId) {
  const job = jobs.get(taskId);

  if (!job || job.status !== "queued") {
    return;
  }

  job.status = "processing";
  job.updatedAt = new Date().toISOString();

  try {
    const transcription =
      await openai.audio.transcriptions.create({
        file: fs.createReadStream(
          job.storedPath,
        ),
        model: "whisper-1",
        language: "es",
        response_format: "json",
      });

    job.status = "completed";
    job.text = transcription.text;
    job.error = null;
    job.updatedAt = new Date().toISOString();
  } catch (error) {
    console.error(
      `Falló la transcripción ${taskId}:`,
      error,
    );

    job.status = "failed";
    job.text = null;
    job.error =
      normalizeProviderError(error);
    job.updatedAt = new Date().toISOString();
  } finally {
    await removeTemporaryFile(
      job.storedPath,
    );

    job.storedPath = null;
  }
}

app.post(
  "/api/transcriptions",
  upload.single("audio"),
  async (request, response, next) => {
    try {
      if (!request.file) {
        response.status(400).json({
          error:
            "Debes seleccionar un archivo.",
        });
        return;
      }

      const taskId = crypto.randomUUID();
      const now = new Date().toISOString();

      const job = {
        taskId,
        status: "queued",
        originalName:
          request.file.originalname,
        storedPath: request.file.path,
        mimeType: request.file.mimetype,
        size: request.file.size,
        text: null,
        error: null,
        createdAt: now,
        updatedAt: now,
      };

      jobs.set(taskId, job);

      response.status(202).json({
        taskId,
        status: job.status,
      });

      setImmediate(() => {
        processTranscription(taskId).catch(
          (error) => {
            console.error(
              "Error no controlado:",
              error,
            );
          },
        );
      });
    } catch (error) {
      next(error);
    }
  },
);

app.get(
  "/api/transcriptions/:taskId",
  (request, response) => {
    const job = jobs.get(
      request.params.taskId,
    );

    if (!job) {
      response.status(404).json({
        error:
          "No se encontró el trabajo.",
      });
      return;
    }

    response.json({
      taskId: job.taskId,
      status: job.status,
      originalName: job.originalName,
      text: job.text,
      error: job.error,
      createdAt: job.createdAt,
      updatedAt: job.updatedAt,
    });
  },
);

const JOB_TTL_MS = 60 * 60 * 1000;

setInterval(() => {
  const expirationTime =
    Date.now() - JOB_TTL_MS;

  for (
    const [taskId, job]
    of jobs.entries()
  ) {
    const updatedAt =
      Date.parse(job.updatedAt);

    if (
      Number.isFinite(updatedAt)
      && updatedAt < expirationTime
    ) {
      jobs.delete(taskId);
    }
  }
}, 10 * 60 * 1000).unref();

app.use(
  (error, _request, response, _next) => {
    console.error(error);

    if (
      error instanceof multer.MulterError
    ) {
      if (
        error.code === "LIMIT_FILE_SIZE"
      ) {
        response.status(413).json({
          error:
            `El archivo supera `
            + `${MAX_AUDIO_SIZE_MB} MB.`,
        });
        return;
      }

      response.status(400).json({
        error:
          "No se pudo procesar el archivo.",
      });
      return;
    }

    response.status(400).json({
      error:
        error instanceof Error
          ? error.message
          : "Error inesperado.",
    });
  },
);

app.listen(PORT, () => {
  console.log(
    `Servidor disponible en `
    + `http://localhost:${PORT}`,
  );
});

Crear la interfaz HTML

Crea public/index.html:

<!doctype html>
<html lang="es">
  <head>
    <meta charset="UTF-8" />

    <meta
      name="viewport"
      content="width=device-width, initial-scale=1"
    />

    <title>Transcribir audio con Node.js</title>

    <link
      rel="stylesheet"
      href="/styles.css"
    />
  </head>

  <body>
    <main class="container">
      <section class="card">
        <h1>Transcribir un archivo de audio</h1>

        <p>
          Selecciona un archivo MP3, M4A,
          WAV, MP4 o WEBM.
        </p>

        <form id="transcription-form">
          <label for="audio">
            Archivo de audio
          </label>

          <input
            id="audio"
            name="audio"
            type="file"
            accept="
              audio/mpeg,
              audio/mp4,
              audio/wav,
              audio/webm,
              video/mp4,
              video/webm,
              .mp3,
              .m4a,
              .wav,
              .mp4,
              .webm
            "
            required
          />

          <button type="submit">
            Transcribir
          </button>
        </form>

        <div
          id="status"
          class="status"
          aria-live="polite"
        ></div>

        <section
          id="result-section"
          hidden
        >
          <h2>Resultado</h2>

          <textarea
            id="result"
            rows="18"
            readonly
          ></textarea>

          <button
            id="copy-button"
            type="button"
          >
            Copiar texto
          </button>
        </section>
      </section>
    </main>

    <script
      type="module"
      src="/app.js"
    ></script>
  </body>
</html>

Crear el JavaScript del navegador

Crea public/app.js:

const form = document.querySelector(
  "#transcription-form",
);

const fileInput = document.querySelector(
  "#audio",
);

const statusElement = document.querySelector(
  "#status",
);

const resultSection = document.querySelector(
  "#result-section",
);

const resultElement = document.querySelector(
  "#result",
);

const copyButton = document.querySelector(
  "#copy-button",
);

const submitButton = form.querySelector(
  'button[type="submit"]',
);

const MAX_CLIENT_SIZE_MB = 25;

let pollingController = null;

function setStatus(message, type = "info") {
  statusElement.textContent = message;
  statusElement.dataset.type = type;
}

function setLoading(isLoading) {
  submitButton.disabled = isLoading;
  fileInput.disabled = isLoading;

  submitButton.textContent = isLoading
    ? "Procesando…"
    : "Transcribir";
}

function validateFile(file) {
  if (!file) {
    throw new Error(
      "Selecciona un archivo.",
    );
  }

  const maximumBytes =
    MAX_CLIENT_SIZE_MB * 1024 * 1024;

  if (file.size > maximumBytes) {
    throw new Error(
      `El archivo supera `
      + `${MAX_CLIENT_SIZE_MB} MB.`,
    );
  }

  const allowedExtensions = [
    ".mp3",
    ".m4a",
    ".wav",
    ".mp4",
    ".webm",
    ".mpeg",
    ".mpga",
  ];

  const lowerName =
    file.name.toLowerCase();

  const validExtension =
    allowedExtensions.some(
      (extension) =>
        lowerName.endsWith(extension),
    );

  if (!validExtension) {
    throw new Error(
      "Formato no permitido.",
    );
  }
}

async function createTranscription(file) {
  const formData = new FormData();
  formData.append("audio", file);

  const response = await fetch(
    "/api/transcriptions",
    {
      method: "POST",
      body: formData,
    },
  );

  const data = await response.json();

  if (!response.ok) {
    throw new Error(
      data.error
      ?? "No se pudo subir el archivo.",
    );
  }

  return data;
}

function delay(
  milliseconds,
  signal,
) {
  return new Promise(
    (resolve, reject) => {
      const timer = setTimeout(
        resolve,
        milliseconds,
      );

      signal?.addEventListener(
        "abort",
        () => {
          clearTimeout(timer);

          reject(
            new DOMException(
              "Operación cancelada",
              "AbortError",
            ),
          );
        },
        { once: true },
      );
    },
  );
}

async function getJob(taskId, signal) {
  const response = await fetch(
    `/api/transcriptions/${taskId}`,
    { signal },
  );

  const data = await response.json();

  if (!response.ok) {
    throw new Error(
      data.error
      ?? "No se pudo consultar el trabajo.",
    );
  }

  return data;
}

async function waitForCompletion(
  taskId,
  signal,
) {
  const maximumAttempts = 180;

  for (
    let attempt = 0;
    attempt < maximumAttempts;
    attempt += 1
  ) {
    const job = await getJob(
      taskId,
      signal,
    );

    if (job.status === "completed") {
      return job;
    }

    if (job.status === "failed") {
      throw new Error(
        job.error
        ?? "La transcripción ha fallado.",
      );
    }

    if (job.status === "queued") {
      setStatus(
        "El archivo está en cola.",
      );
    }

    if (job.status === "processing") {
      setStatus(
        "Transcribiendo el audio…",
      );
    }

    await delay(2000, signal);
  }

  throw new Error(
    "La operación tardó demasiado.",
  );
}

form.addEventListener(
  "submit",
  async (event) => {
    event.preventDefault();

    pollingController?.abort();
    pollingController =
      new AbortController();

    resultSection.hidden = true;
    resultElement.value = "";

    try {
      const file =
        fileInput.files?.[0];

      validateFile(file);
      setLoading(true);
      setStatus("Subiendo el archivo…");

      const created =
        await createTranscription(file);

      setStatus(
        "Archivo recibido. "
        + "Preparando la transcripción…",
      );

      const completed =
        await waitForCompletion(
          created.taskId,
          pollingController.signal,
        );

      resultElement.value =
        completed.text ?? "";

      resultSection.hidden = false;

      setStatus(
        "Transcripción completada.",
        "success",
      );
    } catch (error) {
      if (error?.name === "AbortError") {
        return;
      }

      console.error(error);

      setStatus(
        error instanceof Error
          ? error.message
          : "Ha ocurrido un error.",
        "error",
      );
    } finally {
      setLoading(false);
    }
  },
);

copyButton.addEventListener(
  "click",
  async () => {
    const text =
      resultElement.value.trim();

    if (!text) {
      return;
    }

    try {
      await navigator.clipboard.writeText(
        text,
      );

      setStatus(
        "Texto copiado.",
        "success",
      );
    } catch {
      resultElement.select();

      document.execCommand("copy");

      setStatus(
        "Texto copiado.",
        "success",
      );
    }
  },
);

Añadir estilos mínimos

Crea public/styles.css:

* {
  box-sizing: border-box;
}

body {
  margin: 0;
  min-height: 100vh;
  font-family:
    system-ui,
    -apple-system,
    BlinkMacSystemFont,
    "Segoe UI",
    sans-serif;
  color: #1f2937;
  background: #f3f4f6;
}

button,
input,
textarea {
  font: inherit;
}

.container {
  width: min(760px, calc(100% - 32px));
  margin: 0 auto;
  padding: 48px 0;
}

.card {
  display: grid;
  gap: 20px;
  padding: 28px;
  border: 1px solid #d1d5db;
  border-radius: 16px;
  background: #ffffff;
}

h1,
h2,
p {
  margin: 0;
}

form {
  display: grid;
  gap: 14px;
}

input[type="file"] {
  width: 100%;
  padding: 12px;
  border: 1px solid #9ca3af;
  border-radius: 10px;
}

button {
  width: fit-content;
  padding: 10px 18px;
  border: 0;
  border-radius: 10px;
  cursor: pointer;
}

button:disabled {
  cursor: not-allowed;
  opacity: 0.6;
}

.status {
  min-height: 24px;
}

.status[data-type="error"] {
  font-weight: 600;
}

.status[data-type="success"] {
  font-weight: 600;
}

#result-section {
  display: grid;
  gap: 12px;
}

#result-section[hidden] {
  display: none;
}

textarea {
  width: 100%;
  resize: vertical;
  padding: 14px;
  line-height: 1.6;
  border: 1px solid #9ca3af;
  border-radius: 10px;
}

Ejecutar la aplicación

Inicia el servidor:

npm run dev

Abre:

http://localhost:3000

Selecciona un archivo en español y pulsa Transcribir.

Por qué no llamamos a la API desde el navegador

Este código sería un error:

const response = await fetch(
  "https://api.example.com/transcriptions",
  {
    method: "POST",
    headers: {
      Authorization:
        "Bearer CLAVE_PRIVADA",
    },
    body: formData,
  },
);

La clave aparece dentro de la petición.

Un usuario puede abrir la pestaña Network y copiarla.

No importa que:

el código esté minificado;
la variable tenga otro nombre;
el archivo JavaScript esté ofuscado;
la clave se construya concatenando cadenas;
la aplicación utilice React, Vue o Next.js.

Si el navegador necesita la clave para realizar la llamada, el visitante puede recuperarla.

Las variables de entorno del frontend tampoco solucionan el problema cuando su contenido termina incluido en el bundle público.

La validación del navegador no protege el servidor

En app.js validamos extensión y tamaño.

Eso mejora la experiencia, pero no es una medida de seguridad suficiente.

Un usuario puede enviar directamente:

curl

o utilizar Postman sin cargar tu HTML.

Por eso repetimos la validación en Node.js.

La regla es:

Validación del navegador:
comodidad

Validación del servidor:
obligatoria

El almacenamiento en memoria tiene límites

El ejemplo utiliza:

const jobs = new Map();

Esto funciona para:

desarrollo local;
demostraciones;
una sola instancia;
trabajos temporales;
poco tráfico.

No funciona bien si:

reinicias el servidor;
utilizas varios procesos;
despliegas varias instancias;
necesitas conservar el historial;
procesas muchos archivos.

Si el proceso se reinicia, todos los estados desaparecen.

En producción, guarda los trabajos en PostgreSQL, Redis u otra base compartida.

Una tabla mínima puede contener:

id
status
original_name
storage_key
result_text
error_message
created_at
updated_at

setImmediate tampoco es una cola real

Este código:

setImmediate(() => {
  processTranscription(taskId);
});

separa el trabajo de la petición inicial, pero no proporciona:

reintentos;
prioridad;
persistencia;
control de concurrencia;
recuperación después de reiniciar;
distribución entre servidores.

Para producción utiliza una cola como:

BullMQ;
RabbitMQ;
SQS;
una cola basada en PostgreSQL;
un sistema de workers propio.

El servidor web debería recibir el archivo y crear el trabajo. El worker debería procesarlo.

Evitar transcripciones duplicadas

Un usuario puede pulsar dos veces o repetir una petición.

Para archivos grandes, conviene calcular un hash:

import crypto from "node:crypto";
import fs from "node:fs";

async function calculateSha256(filePath) {
  return new Promise(
    (resolve, reject) => {
      const hash =
        crypto.createHash("sha256");

      const stream =
        fs.createReadStream(filePath);

      stream.on("data", (chunk) => {
        hash.update(chunk);
      });

      stream.on("end", () => {
        resolve(hash.digest("hex"));
      });

      stream.on("error", reject);
    },
  );
}

Puedes combinar:

hash del archivo
+
idioma
+
modelo
+
opciones de transcripción

Si ya existe un trabajo idéntico completado, puedes reutilizarlo según tus políticas de privacidad.

No reutilices resultados entre usuarios sin asegurarte de que los permisos lo permiten.

Comprobar el archivo con FFprobe

La extensión y el MIME declarado por el navegador pueden falsificarse.

Una validación más sólida utiliza FFprobe:

ffprobe \
  -v error \
  -show_entries format=duration,format_name \
  -show_entries stream=codec_type,codec_name \
  -of json \
  archivo.mp3

Desde Node.js:

import { spawn } from "node:child_process";

function inspectMedia(filePath) {
  return new Promise(
    (resolve, reject) => {
      const process = spawn(
        "ffprobe",
        [
          "-v",
          "error",
          "-show_entries",
          "format=duration,format_name",
          "-show_entries",
          "stream=codec_type,codec_name",
          "-of",
          "json",
          filePath,
        ],
      );

      let stdout = "";
      let stderr = "";

      process.stdout.on("data", (chunk) => {
        stdout += chunk;
      });

      process.stderr.on("data", (chunk) => {
        stderr += chunk;
      });

      process.on("close", (code) => {
        if (code !== 0) {
          reject(
            new Error(
              stderr
              || "FFprobe no pudo leer el archivo.",
            ),
          );
          return;
        }

        try {
          const data = JSON.parse(stdout);

          const hasAudio =
            data.streams?.some(
              (stream) =>
                stream.codec_type === "audio",
            );

          if (!hasAudio) {
            reject(
              new Error(
                "El archivo no contiene audio.",
              ),
            );
            return;
          }

          resolve(data);
        } catch {
          reject(
            new Error(
              "Respuesta inválida de FFprobe.",
            ),
          );
        }
      });
    },
  );
}

Con esto puedes comprobar:

que existe una pista de audio;
la duración real;
el códec;
el formato contenedor.

Limitar la duración, no solo el tamaño

Dos archivos de 20 MB pueden tener duraciones muy diferentes.

Un audio altamente comprimido puede durar horas.

Después de FFprobe:

const duration =
  Number.parseFloat(
    inspection.format.duration,
  );

const MAX_DURATION_SECONDS =
  2 * 60 * 60;

if (
  !Number.isFinite(duration)
  || duration <= 0
) {
  throw new Error(
    "No se pudo determinar la duración.",
  );
}

if (duration > MAX_DURATION_SECONDS) {
  throw new Error(
    "La duración máxima es de dos horas.",
  );
}

El límite debe relacionarse con:

coste;
tiempo;
almacenamiento;
plan del usuario;
capacidad del worker.

No devolver errores internos al navegador

Evita respuestas como:

{
  "error": "ENOENT /home/app/uploads/...",
  "stack": "..."
}

Pueden revelar:

rutas del servidor;
bibliotecas;
arquitectura interna;
nombres de contenedores;
detalles del proveedor.

Registra el error completo en el servidor y devuelve un mensaje limitado al usuario.

También puedes guardar un código interno:

{
  "error": "No se pudo completar la transcripción.",
  "code": "TRANSCRIPTION_PROVIDER_ERROR"
}

Añadir límites por usuario o IP

Sin límites, una persona puede enviar cientos de archivos y consumir tu saldo.

Como mínimo, limita:

peticiones por minuto;
trabajos simultáneos;
duración diaria;
tamaño por archivo;
número de trabajos pendientes.

La limitación por IP puede servir para una demostración pública, pero no es suficiente para un producto de pago.

Usuarios detrás de una misma red pueden compartir IP y un atacante puede utilizar múltiples direcciones.

Para un producto real, registra el consumo por cuenta.

No guardar archivos privados indefinidamente

Define una política clara:

Archivo original:
eliminar después de procesar

Resultado:
conservar según la cuenta

Trabajo fallido:
eliminar el temporal igualmente

Logs:
no incluir contenido transcrito

El bloque finally del ejemplo garantiza que el temporal se intenta eliminar tanto si la transcripción funciona como si falla.

Aun así, también necesitas una tarea periódica que elimine archivos abandonados después de:

reinicios;
cierres forzados;
errores inesperados;
procesos terminados por el sistema.

Cuándo merece la pena construirlo

Construir tu propio flujo tiene sentido cuando:

la transcripción forma parte de tu producto;
necesitas integrar usuarios y pagos;
quieres controlar formatos y resultados;
necesitas guardar un historial;
procesas archivos regularmente;
debes conectar el texto con otros procesos.

No tiene sentido mantener toda esta infraestructura para convertir un archivo de vez en cuando.

En ese caso tendrías que mantener:

Node.js;
almacenamiento;
validaciones;
colas;
workers;
API externa;
reintentos;
límites;
eliminación de archivos;
control de costes;
seguridad de las claves.

Para una entrevista, una reunión o una clase ocasional, es más directo utilizar una herramienta para transcribir audio a texto sin desplegar una aplicación propia.

La decisión práctica es:

Uso ocasional:
herramienta web

Función integrada en un producto:
backend propio

Volumen elevado:
backend, cola, almacenamiento y workers

Qué cambiar antes de producción

La demostración es funcional, pero antes de publicarla deberías sustituir:

Map en memoria

por una base de datos compartida.

Sustituir:

setImmediate

por una cola persistente.

Sustituir:

disco local

por almacenamiento de objetos cuando utilices varios servidores.

También deberías añadir:

autenticación;
límites por usuario;
verificación real del archivo;
límites de duración;
reintentos controlados;
estados persistentes;
monitorización;
métricas de coste;
borrado de trabajos antiguos;
política de privacidad;
consentimiento para archivos con terceros.

Conclusión

Proteger una API key no consiste en esconderla mejor dentro de JavaScript.

Consiste en no enviarla nunca al navegador.

La arquitectura correcta es:

Navegador
→ backend propio
→ proveedor externo

El frontend debe encargarse de:

seleccionar el archivo;
validar lo básico;
subirlo;
consultar el progreso;
mostrar el resultado.

El backend debe encargarse de:

validar de nuevo;
proteger la clave;
controlar el tamaño;
crear el trabajo;
llamar al proveedor;
manejar errores;
eliminar temporales;
limitar el consumo.

El ejemplo utiliza una cola simulada y almacenamiento en memoria para que el flujo sea fácil de entender. Eso es suficiente para una demostración, pero no debe confundirse con una arquitectura de producción.

La diferencia entre una prueba y un producto no está en conseguir la primera transcripción. Está en controlar qué ocurre cuando el archivo es inválido, la API falla, el servidor se reinicia, el usuario repite la petición o cien personas suben audio al mismo tiempo.

DEV Community: transcribir audio

Cómo transcribir un podcast y convertirlo en un artículo que sí merece publicarse

Decide qué quieres crear antes de transcribir

Consigue el archivo original

Guarda una estructura ordenada por episodio

Genera primero una transcripción completa

Corrige primero los nombres de los hablantes

Revisa nombres, marcas, cifras y negaciones

Mantén las marcas de tiempo en las partes importantes

No publiques la conversación en el orden original

Elige una tesis para el artículo

Utiliza la pregunta principal como título

Extrae las ideas, no todos los turnos de palabra

Conserva citas solo cuando aporten algo

No corrijas tanto que el invitado deje de sonar como él mismo

Separa hechos, opiniones e interpretaciones

Hecho

Opinión del invitado

Interpretación del autor

Convierte el episodio en secciones útiles

Crea show notes distintas del artículo

Convierte una transcripción en varios activos, pero no repitas lo mismo

Artículo

Newsletter

Red social

Clip

FAQ

Añade recursos mencionados durante el episodio

Decide cuándo publicar la transcripción completa

Revisa el consentimiento antes de publicar

Lista de revisión antes de publicar

El artículo debe poder vivir sin el episodio

Conclusión

Cómo transcribir archivos de audio con JavaScript y Node.js sin exponer tu API key

Qué vamos a construir

Requisitos

Estructura del proyecto

Configurar package.json

Guardar la API key

Estados de una transcripción

Crear el servidor

Crear un trabajo

Procesar la transcripción

Consultar el estado

Eliminar trabajos antiguos

Controlar errores de Multer

Código completo del servidor

Crear la interfaz HTML

Crear el JavaScript del navegador

Añadir estilos mínimos

Ejecutar la aplicación

Por qué no llamamos a la API desde el navegador

La validación del navegador no protege el servidor

El almacenamiento en memoria tiene límites

setImmediate tampoco es una cola real

Evitar transcripciones duplicadas

Comprobar el archivo con FFprobe

Limitar la duración, no solo el tamaño

No devolver errores internos al navegador

Añadir límites por usuario o IP

No guardar archivos privados indefinidamente

Cuándo merece la pena construirlo

Qué cambiar antes de producción

Conclusión