BroadRouter

Grabar audio en el navegador y enviarlo a una API de voz a texto

Por el equipo de BroadNet Inference · 6 min de lectura · Publicado

Grabe con getUserMedia y MediaRecorder, elija el formato con isTypeSupported y descarte los fragmentos vacíos. Si la API solo acepta WAV o MP3, decodifique la grabación en el navegador y codifique un WAV mono de 16 kHz, o súbala y conviértala con ffmpeg en su servidor. En ambos casos, envíela a través de su propio backend para que la clave de API nunca llegue al navegador.

Grabar un mensaje de voz en una aplicación web requiere unas treinta líneas de JavaScript. Los problemas empiezan al enviar el archivo: el navegador grabó WebM o MP4, la API quiere otra cosa, un iPhone devuelve “Thank you” para un clip en silencio y el tutorial que usted copió pone la clave de API en la página. Este artículo construye el recorrido completo y prueba cada pieza: grabar, convertir a WAV, comprobar el tamaño y reenviar a través de un servidor pequeño.

Los ejemplos apuntan a una API que solo acepta WAV o MP3. BroadNet Inference es una de ellas: su documentación indica WAV (audio/wav) o MP3 (audio/mpeg) de hasta 26,214,400 bytes por archivo. Si su API acepta WebM, omita la conversión y conserve el resto. La guía de voz a texto de OpenAI incluye flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav y webm, hasta 25 MB.

¿En qué formato graba el navegador?

MediaRecorder graba en un formato comprimido que elige el navegador, salvo que usted pida uno compatible. Pregunte con MediaRecorder.isTypeSupported() y tome la primera coincidencia:

Cadena de tipo Navegador habitual
audio/webm;codecs=opus Chrome, Edge, Firefox
audio/mp4 Safari (WebKit documenta MP4 con AAC); Chromium también lo reportó en nuestra prueba
audio/ogg;codecs=opus Firefox

En Chromium sin interfaz (headless), el 2026-11-15, isTypeSupported devolvió true para WebM/Opus y MP4, y false para Ogg/Opus. Tome la tabla como punto de partida, no como una promesa. MDN advierte que true significa que el navegador puede grabar el tipo en principio; la grabación puede fallar igualmente si faltan recursos. Lea siempre recorder.mimeType después de crearlo y etiquete la subida con ese valor, no con el que pidió.

¿Cómo se graba desde el micrófono?

Dos reglas del navegador determinan el código. Primera: getUserMedia solo existe en un contexto seguro: HTTPS, localhost o una URL file:. Por HTTP simple desde otro host, navigator.mediaDevices es undefined, así que llamarlo lanza un TypeError en lugar de pedir permiso. Segunda: el usuario debe conceder acceso, y una negativa lanza NotAllowedError. Gestione ambos casos con un mensaje que el usuario pueda resolver.

// record.js: record from the microphone, return a 16 kHz mono WAV Blob.
const TYPES = ["audio/webm;codecs=opus", "audio/mp4", "audio/ogg;codecs=opus"];

export async function startRecording() {
  if (!navigator.mediaDevices?.getUserMedia) {
    throw new Error("Microphone access needs HTTPS (or localhost).");
  }
  const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
  const mimeType = TYPES.find((t) => MediaRecorder.isTypeSupported(t));
  const rec = new MediaRecorder(stream, mimeType ? { mimeType } : {});
  const chunks = [];
  rec.ondataavailable = (e) => { if (e.data.size > 0) chunks.push(e.data); };
  rec.start(1000); // a chunk every second, so a crash loses at most one second
  return () => new Promise((resolve) => {
    rec.onstop = () => {
      stream.getTracks().forEach((t) => t.stop()); // turn the mic indicator off
      resolve(new Blob(chunks, { type: rec.mimeType }));
    };
    rec.stop();
  });
}

Tres detalles del código provienen de reportes de errores reales:

  • Descarte los fragmentos vacíos. En un hilo del foro de OpenAI sobre MediaRecorder en iPhone, un desarrollador encontró que dataavailable se disparaba con datos vacíos en iOS, y filtrar esos fragmentos lo resolvió. Otro corrigió el mismo síntoma iniciando con un timeslice, start(1000).
  • Detenga las pistas. Detener el grabador no libera el micrófono. Sin getTracks().forEach(t => t.stop()), el navegador sigue mostrando el indicador de grabación.
  • No mida la grabación contando fragmentos. MDN advierte que los intervalos de timeslice son inexactos y pueden alargarse cuando Safari pausa el micrófono o Chrome en Android bloquea la pantalla. Use su propio temporizador si muestra una duración o impone un límite.

¿Cómo se convierte la grabación a WAV en el navegador?

La Web Audio API puede decodificar lo que haya grabado el navegador. Dos datos de MDN lo simplifican: decodeAudioData solo funciona con un archivo completo, no con fragmentos, así que decodifique después de stop(); y remuestrea el audio decodificado a la frecuencia de muestreo de su contexto. Por eso, un OfflineAudioContext creado a 16,000 Hz devuelve muestras de 16 kHz sin código extra de remuestreo. Su constructor acepta cualquier frecuencia de 3,000 a 768,000 Hz.

export async function toWav16k(blob) {
  // decodeAudioData needs the whole file and resamples to the context's rate.
  const ctx = new OfflineAudioContext(1, 1, 16000);
  const audio = await ctx.decodeAudioData(await blob.arrayBuffer());
  return encodeWav(mixDown(audio), 16000);
}

export function mixDown(audio) {
  const out = new Float32Array(audio.length);
  for (let c = 0; c < audio.numberOfChannels; c++) {
    const ch = audio.getChannelData(c);
    for (let i = 0; i < out.length; i++) out[i] += ch[i] / audio.numberOfChannels;
  }
  return out;
}

export function encodeWav(samples, rate) {
  const buf = new ArrayBuffer(44 + samples.length * 2);
  const v = new DataView(buf);
  const str = (o, s) => [...s].forEach((ch, i) => v.setUint8(o + i, ch.charCodeAt(0)));
  str(0, "RIFF"); v.setUint32(4, 36 + samples.length * 2, true); str(8, "WAVE");
  str(12, "fmt "); v.setUint32(16, 16, true); v.setUint16(20, 1, true); // PCM
  v.setUint16(22, 1, true); v.setUint32(24, rate, true);                // mono
  v.setUint32(28, rate * 2, true); v.setUint16(32, 2, true); v.setUint16(34, 16, true);
  str(36, "data"); v.setUint32(40, samples.length * 2, true);
  for (let i = 0; i < samples.length; i++) {
    const s = Math.max(-1, Math.min(1, samples[i]));
    v.setInt16(44 + i * 2, s < 0 ? s * 0x8000 : s * 0x7fff, true);
  }
  return new Blob([buf], { type: "audio/wav" });
}

¿Por qué 16 kHz mono? Es el ajuste que usa el propio ejemplo de ffmpeg de BroadNet (-ar 16000 -ac 1), conserva la banda de la voz y ocupa un tercio de los bytes de 48 kHz. El estéreo duplica el tamaño sin ganancia para una sola voz. Consulte frecuencia de muestreo para ver las ventajas y desventajas.

El cálculo del tamaño importa, porque WAV no está comprimido. 16,000 muestras por segundo a 2 bytes cada una son 32,000 bytes por segundo. Con la cabecera de 44 bytes, el límite de 26,214,400 bytes de BroadNet admite 819 segundos: unos 13 minutos 39 segundos. Para algo más largo, detenga la grabación al llegar a un límite o divídala en el servidor, como en transcribir archivos de audio largos. El divisor de audio escribe los comandos de ffmpeg.

Convertir en el navegador consume CPU y memoria del usuario, y todo el clip decodificado queda en memoria como flotantes de 32 bits. Eso está bien para mensajes de voz de pocos minutos. Para grabaciones largas, suba el archivo comprimido y conviértalo en el servidor.

¿Cómo se convierte en el servidor?

Envíe la grabación comprimida tal cual y deje que ffmpeg haga el trabajo. Es menos código en la página, una subida más pequeña y el mismo resultado:

ffmpeg -i in.webm -ar 16000 -ac 1 out.wav

Escriba la subida en un archivo temporal en lugar de pasarla a ffmpeg por una tubería (pipe). Los archivos MP4 pueden guardar su índice al final, y ffmpeg no siempre puede leerlos desde una tubería. La guía de notas de voz de WhatsApp usa el mismo comando para archivos .ogg.

¿Cómo se mantiene la clave de API fuera del navegador?

Ponga un endpoint pequeño entre la página y la API. Recibe la grabación, la convierte si hace falta, comprueba el tamaño, añade la clave desde una variable de entorno y la reenvía. Node 18 y posteriores incluyen fetch, FormData y Blob, así que no necesita paquetes:

// server.mjs: POST /transcribe with the recording as the body. The key stays here.
import http from "node:http";
import { execFile } from "node:child_process";
import { mkdtemp, writeFile, readFile, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { promisify } from "node:util";

const API = process.env.BROADNET_BASE_URL ?? "https://inference.broadnet.ai/v1";
const KEY = process.env.BROADNET_API_KEY;
const FFMPEG = process.env.FFMPEG ?? "ffmpeg";
const MAX = 26_214_400; // BroadNet's per-file cap in bytes
const run = promisify(execFile);

async function readBody(req, limit) {
  const parts = []; let n = 0;
  for await (const c of req) { n += c.length; if (n > limit) throw Object.assign(new Error("too large"), { code: 413 }); parts.push(c); }
  return Buffer.concat(parts);
}

async function toWav(bytes) {
  // Temp files, not pipes: an MP4 from Safari can keep its index at the end.
  const dir = await mkdtemp(join(tmpdir(), "rec-"));
  try {
    await writeFile(join(dir, "in"), bytes);
    await run(FFMPEG, ["-v", "error", "-i", join(dir, "in"), "-ar", "16000", "-ac", "1", join(dir, "out.wav")]);
    return await readFile(join(dir, "out.wav"));
  } finally { await rm(dir, { recursive: true, force: true }); }
}

http.createServer(async (req, res) => {
  const reply = (code, obj) => { res.writeHead(code, { "content-type": "application/json" }); res.end(JSON.stringify(obj)); };
  if (req.method !== "POST" || req.url !== "/transcribe") return reply(404, { error: "not found" });
  try {
    const type = (req.headers["content-type"] ?? "").split(";")[0];
    let body = await readBody(req, 4 * MAX);
    if (type !== "audio/wav" && type !== "audio/mpeg") {
      try { body = await toWav(body); }
      catch { return reply(400, { error: "Could not read the recording." }); }
    }
    if (body.length > MAX) return reply(413, { error: "Recording too long; split it first." });
    const form = new FormData();
    form.append("model", "broadnet/cohere-transcribe-arabic");
    form.append("language", "ar");
    form.append("file", new Blob([body], { type: type === "audio/mpeg" ? "audio/mpeg" : "audio/wav" }),
      type === "audio/mpeg" ? "audio.mp3" : "audio.wav");
    const r = await fetch(`${API}/audio/transcriptions`, {
      method: "POST", headers: { Authorization: `Bearer ${KEY}` }, body: form,
    });
    const data = await r.json();
    return r.ok ? reply(200, { text: data.text }) : reply(r.status, { error: data });
  } catch (e) {
    return reply(e.code === 413 ? 413 : 500, { error: String(e.message ?? e) });
  }
}).listen(process.env.PORT ?? 8787);

La página envía entonces el WAV o la grabación sin procesar:

const stop = await startRecording();
// ...later, when the user taps Stop:
const raw = await stop();
const wav = await toWav16k(raw);          // or send `raw` and let the server convert
const r = await fetch("/transcribe", { method: "POST", headers: { "content-type": wav.type }, body: wav });
const { text } = await r.json();

Puntos que conviene conservar al adaptarlo:

  • Envíe siempre language. La documentación de BroadNet indica que, de lo contrario, el árabe puede volver transliterado en letras latinas. Use ar con el modelo árabe, o cambie a broadnet/cohere-transcribe con el código correcto de uno de sus 14 idiomas.
  • Devuelva errores genéricos. La primera versión de nuestro proxy de prueba devolvía el error de ffmpeg, que incluía una ruta de archivo del servidor. El código anterior devuelve en su lugar “Could not read the recording.” (Traducción: No se pudo leer la grabación.).
  • Añada autenticación y un límite de tasa antes de desplegarlo. De lo contrario, cualquiera que encuentre /transcribe gastará su saldo. Seguridad de las claves de API de LLM cubre el resto, y las claves de BroadNet pueden restringirse con listas de IP permitidas.
  • Rechace los clips casi silenciosos. Los reportes del foro sobre transcripciones inventadas como “Thank you” o “Bye” involucran grabaciones silenciosas o dañadas. Compruebe la duración (bytes del WAV ÷ 32,000) y, si puede, el nivel de señal antes de pagar por ella.

¿Cómo lo probamos?

No se usó ninguna clave de BroadNet. El 2026-11-15 ejecutamos el código anterior contra una simulación local de /v1/audio/transcriptions:

  1. Codificador en Node. encodeWav sobre un segundo de un tono de 440 Hz con dos muestras recortadas produjo 32,044 bytes. El módulo wave de Python lo leyó como 1 canal, 16,000 Hz, muestras de 2 bytes y 16,000 tramas, y ffmpeg como pcm_s16le, 16000 Hz, mono. Las muestras recortadas salieron como 32767 y −32768.
  2. Recorrido del navegador en Chromium. Playwright lanzó Chromium sin interfaz con un micrófono simulado. startRecording grabó 3 segundos como audio/webm;codecs=opus (40,563 bytes), y toWav16k lo convirtió en un WAV de 96,044 bytes: 3.0 segundos, 16 kHz, mono.
  3. Proxy. Tanto el WAV como el WebM sin procesar devolvieron 200. La simulación recibió cada vez autenticación Bearer, el ID del modelo árabe, language=ar y un archivo audio/wav mono de 16 kHz; ffmpeg convirtió el WebM en el servidor. Un WAV de 26,214,401 bytes recibió 413 sin llamada al servicio de origen. Un cuerpo que no era audio recibió 400.
  4. Origen inseguro. Cargada desde la dirección LAN de la máquina por HTTP simple, la página reportó isSecureContext en false y startRecording lanzó nuestro mensaje sobre HTTPS en lugar de un TypeError.

No probamos Safari ni Firefox, ni una transcripción real. Pruebe en un iPhone real antes de publicar.

¿Cuánto cuesta?

BroadNet factura la transcripción por minuto de audio: $0.0042 para Transcribe Arabic y $0.002 para el modelo multilingüe. Una hora de mensajes de voz en árabe cuesta $0.25. Ambos funcionan con el crédito inicial de $5, que cubre unos 1,190 minutos de árabe. Para sus propios volúmenes, use la calculadora de costo de voz a texto. La guía de compra de API de voz a texto en árabe compara proveedores.

Dónde encaja BroadNet Inference

BroadRouter es el sitio web de BroadNet. BroadNet Inference transcribe archivos subidos: WAV o MP3, una solicitud por archivo, con una respuesta JSON que contiene el texto. No documenta transcripción en vivo ni en streaming, marcas de tiempo ni etiquetas de hablante. Si su aplicación necesita que las palabras aparezcan mientras el usuario habla, use un proveedor con una API de voz en streaming. Para mensajes de voz, notas y formularios, en los que el usuario graba y luego envía, el flujo de subida anterior es todo lo que necesita. La configuración está en la guía de la API de voz a texto en árabe, y la referencia de la API enumera los campos. Su declaración de privacidad indica que el audio y las transcripciones no se conservan.

Preguntas frecuentes

¿Puedo enviar el WebM de MediaRecorder directamente a una API de voz a texto?

Solo si la API acepta WebM. El endpoint de transcripción de OpenAI incluye webm y mp4 entre sus formatos. BroadNet solo acepta WAV y MP3, así que convierta primero: en el navegador con la Web Audio API, o en su servidor con ffmpeg -i in.webm -ar 16000 -ac 1 out.wav.

¿Por qué getUserMedia dice que navigator.mediaDevices es undefined?

La página no está en un contexto seguro. MDN indica que getUserMedia solo funciona por HTTPS, en localhost o desde URL file. Por HTTP simple desde otro host, navigator.mediaDevices no existe. Sirva la página por HTTPS; para desarrollo, localhost es suficiente.

¿Cuánto dura una grabación en WAV que cabe en una subida de 25 MB?

Un WAV mono de 16 bits a 16 kHz ocupa 32,000 bytes por segundo más una cabecera de 44 bytes. El límite de 26,214,400 bytes de BroadNet admite unos 819 segundos, es decir, 13 minutos 39 segundos. En MP3 o con una frecuencia de muestreo menor cabe más; para audio más largo, divídalo en partes.

¿Por qué recibo "Thank you" o "Bye" de una grabación vacía en iPhone?

Desarrolladores en el foro de OpenAI reportan frases cortas inventadas a partir de grabaciones silenciosas o dañadas, y rastrearon los casos de iOS hasta fragmentos dataavailable vacíos; filtrar los fragmentos de tamaño 0 e iniciar el grabador con un timeslice lo resolvió. Compruebe la duración antes de subir.

¿Debe el navegador llamar directamente a la API de transcripción?

No. El usuario puede leer todo lo que hay en el código del frontend, incluida una clave de API. Envíe el audio a su propio endpoint, que comprueba el tamaño y el tipo, añade la clave desde una variable de entorno y lo reenvía.

Leer en MarkdownPreguntar a ChatGPTPreguntar a ClaudePreguntar a Perplexity