---
title: "Grabar audio en el navegador y transcribirlo con una API"
description: "Grabe el micrófono con MediaRecorder, convierta WebM o el MP4 de Safari a WAV de 16 kHz y envíelo a una API de transcripción con un servidor que guarda la clave."
url: https://broadrouter.com/es/blog/record-browser-audio-transcription-api/
lang: es
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traducido del inglés con ayuda de IA. [Lea el original en inglés](https://broadrouter.com/blog/record-browser-audio-transcription-api/) (actualizado el 2026-11-15).

# 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 2026-11-15

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.

## Puntos clave

-   Los navegadores graban formatos comprimidos: Chrome entrega WebM con Opus, y WebKit documenta MP4 con AAC para Safari. OpenAI acepta ambos; las API que solo admiten WAV o MP3, como BroadNet, necesitan un paso de conversión.
-   getUserMedia solo funciona en un contexto seguro (HTTPS o localhost). En otros casos navigator.mediaDevices es undefined, así que compruebe que exista antes de llamarlo.
-   Un WAV mono de 16 bits a 16 kHz ocupa 32,000 bytes por segundo. El límite de 26,214,400 bytes de BroadNet admite unos 13 minutos 39 segundos; divida cualquier grabación más larga.
-   decodeAudioData necesita el archivo completo y remuestrea a la frecuencia de su contexto, así que un OfflineAudioContext a 16,000 Hz hace el remuestreo por usted.
-   Nunca llame a la API de transcripción desde la página. Envíe el audio a su servidor, compruebe allí el tamaño y el tipo, y añada la clave en el servidor.

**En esta página**

1.  ¿En qué formato graba el navegador?
2.  ¿Cómo se graba desde el micrófono?
3.  ¿Cómo se convierte la grabación a WAV en el navegador?
4.  ¿Cómo se convierte en el servidor?
5.  ¿Cómo se mantiene la clave de API fuera del navegador?
6.  ¿Cómo lo probamos?
7.  ¿Cuánto cuesta?
8.  Dónde encaja BroadNet Inference

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](https://webkit.org/blog/11353/mediarecorder-api/)); 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://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia): 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.

```js
// 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.

```js
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](https://broadrouter.com/es/glossary/sample-rate/) 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](https://broadrouter.com/es/blog/transcribe-long-audio-files-api/). El [divisor de audio](https://broadrouter.com/tools/audio-splitter-ffmpeg/) 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:

```bash
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](https://broadrouter.com/es/guides/transcribe-whatsapp-voice-notes/) 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:

```js
// 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:

```js
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](https://broadrouter.com/es/blog/llm-api-key-security/) cubre el resto, y las claves de BroadNet pueden restringirse con [listas de IP permitidas](https://broadrouter.com/es/guides/api-keys-ip-allow-lists/).
-   **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](https://broadrouter.com/tools/speech-to-text-cost-calculator/). La [guía de compra de API de voz a texto en árabe](https://broadrouter.com/es/blog/arabic-speech-to-text-api-buyers-guide/) 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](https://broadrouter.com/es/guides/arabic-speech-to-text-api/), y la [referencia de la API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-record-browser-audio-transcription-api&utm_content=body) enumera los campos. Su declaración de privacidad indica que el audio y las transcripciones no se conservan.

Herramientas gratuitas sobre este tema (en inglés)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Herramientas gratuitas (en inglés)](https://broadrouter.com/tools/)

## Términos de este artículo

[WAV (archivo de audio)](https://broadrouter.com/es/glossary/wav/)

WAV (Waveform Audio File Format, o WAVE) es un contenedor de audio basado en el formato RIFF de Microsoft e IBM. Suele llevar muestras PCM lineales sin comprimir, así que su tamaño es predecible: frecuencia de muestreo por bytes por muestra por canales, por segundo.

[Voz a texto (speech-to-text)](https://broadrouter.com/es/glossary/speech-to-text/)

La conversión de voz a texto, o reconocimiento automático del habla (ASR), transforma audio hablado en texto escrito. Una API de voz a texto recibe un archivo o stream de audio y devuelve una transcripción, normalmente cobrada por minuto. La precisión se mide con la tasa de error por palabra y varía según el acento, el dialecto y la grabación.

[Streaming (respuestas en tiempo real)](https://broadrouter.com/es/glossary/streaming/)

El streaming es una forma de devolver la respuesta de un modelo de lenguaje en pequeños fragmentos mientras aún se genera, en lugar de una sola respuesta al final. Las APIs compatibles con OpenAI hacen streaming mediante server-sent events cuando la solicitud define stream como true.

[Ogg Opus (formato de notas de voz de WhatsApp)](https://broadrouter.com/es/glossary/ogg-opus/)

Ogg Opus es audio codificado con el códec Opus (RFC 6716) y guardado en un contenedor Ogg (RFC 7845). Está pensado para voz y audio interactivo a bajas tasas de bits, y es el formato que WhatsApp usa para las notas de voz, normalmente como archivos .ogg u .opus.

[Clave de API (API key)](https://broadrouter.com/es/glossary/api-key/)

Una clave de API es una cadena secreta que identifica y autoriza a un cliente que llama a una API. Las APIs de LLM suelen esperarla en un encabezado Authorization: Bearer, y cualquiera que tenga la clave puede hacer solicitudes que se facturan a la cuenta propietaria.

[Llamadas a herramientas (tool calling)](https://broadrouter.com/es/glossary/tool-calling/)

Las llamadas a herramientas (tool calling), también llamadas function calling, son una función de las APIs de LLM en la que el modelo devuelve una solicitud estructurada para ejecutar una función definida por el desarrollador, con argumentos JSON. La aplicación ejecuta la función y devuelve el resultado; el modelo nunca ejecuta código.

[Límite de frecuencia (rate limit)](https://broadrouter.com/es/glossary/rate-limit/)

Un límite de frecuencia (rate limit) es un tope que una API impone a cuánto puede usarla un cliente en un periodo, como solicitudes por minuto o tokens por minuto. Las solicitudes que lo superan se rechazan, normalmente con HTTP 429 Too Many Requests, hasta que el uso vuelve a quedar por debajo.

[Marcas de tiempo en voz a texto (timestamps)](https://broadrouter.com/es/glossary/timestamps-asr/)

Las marcas de tiempo en voz a texto son tiempos de inicio y fin, en segundos, asociados a partes de una transcripción. Las de segmento cubren una frase u oración; las de palabra cubren cada palabra. Se necesitan para subtítulos, para buscar dentro de grabaciones y para alinear el texto con los hablantes.

## 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.

## Siga leyendo

-   [Transcribir audio largo de más de 25 MB: dividir, enviar y unir](https://broadrouter.com/es/blog/transcribe-long-audio-files-api/)
-   [Alternativa a la API de Whisper: cuándo cambiar y cómo probarla](https://broadrouter.com/es/blog/whisper-api-alternative/)
-   [API de voz a texto multilingüe: 14 idiomas, un solo endpoint](https://broadrouter.com/es/blog/multilingual-speech-to-text-api/)
-   [Claves de API de LLM seguras: almacenamiento, rotación y listas de IP](https://broadrouter.com/es/blog/llm-api-key-security/)
-   [API de voz a texto en árabe: cómo elegir una en 2026](https://broadrouter.com/es/blog/arabic-speech-to-text-api-buyers-guide/)
-   [Notas de voz a texto para empresas: de WhatsApp y Telegram a tickets](https://broadrouter.com/es/blog/voice-notes-to-text-for-business/)
-   [El hardware GPU de BroadNet y cómo sirve los modelos, según BroadNet](https://broadrouter.com/es/blog/broadnet-gpu-fleet-and-serving/)
-   [Caché de respuestas de APIs de LLM para reducir costos en Python](https://broadrouter.com/es/blog/cache-llm-responses-cut-cost/)
-   [Guía: Transcribir notas de voz de WhatsApp a texto con una API](https://broadrouter.com/es/guides/transcribe-whatsapp-voice-notes/)
-   [Guía: API de voz a texto en árabe, paso a paso](https://broadrouter.com/es/guides/arabic-speech-to-text-api/)
-   [Guía: Usar el SDK de OpenAI para Node.js con BroadNet Inference](https://broadrouter.com/es/guides/openai-node-sdk/)

Pruébelo con su carga de trabajo real. Las cuentas nuevas empiezan con USD 5 de crédito para Gemma y transcripción. DeepSeek, GLM y Qwen3.8 requieren una recarga.

[Comenzar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-record-browser-audio-transcription-api&utm_content=page-cta) ·

**Fuentes**

-   [Referencia de la API de BroadNet Inference: WAV (audio/wav) o MP3 (audio/mpeg) hasta 26,214,400 bytes, enviar siempre language, respuesta JSON con text (consultado el 2026-11-15) (en inglés)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-record-browser-audio-transcription-api&utm_content=sources)
-   [MDN, MediaDevices.getUserMedia(): solo en contextos seguros, permiso del usuario, NotAllowedError (consultado el 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)
-   [MDN, MediaRecorder.isTypeSupported(): true no garantiza que la grabación funcione (consultado el 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/MediaRecorder/isTypeSupported_static)
-   [MDN, evento dataavailable de MediaRecorder: timeslice, stop() e intervalos inexactos (consultado el 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/MediaRecorder/dataavailable_event)
-   [MDN, BaseAudioContext.decodeAudioData(): remuestrea a la frecuencia del contexto, solo archivos completos (consultado el 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/BaseAudioContext/decodeAudioData)
-   [MDN, constructor OfflineAudioContext(): sampleRate de 3,000 a 768,000 Hz (consultado el 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/OfflineAudioContext/OfflineAudioContext)
-   [Blog de WebKit, API MediaRecorder: Safari graba MP4 con video H.264 y audio AAC, formatos detectables en tiempo de ejecución (consultado el 2026-11-15)](https://webkit.org/blog/11353/mediarecorder-api/)
-   [Guía de voz a texto de OpenAI: flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav y webm, archivos de hasta 25 MB (consultado el 2026-11-15)](https://developers.openai.com/api/docs/guides/speech-to-text)
-   [Comunidad de desarrolladores de OpenAI, "MediaRecorder API w/ Whisper not working on mobile browsers", de julio a diciembre de 2024 (consultado el 2026-11-15)](https://community.openai.com/t/mediarecorder-api-w-whisper-not-working-on-mobile-browsers/866019)
