BroadRouter

Audio im Browser aufnehmen und an eine Speech-to-Text API senden

Vom Team von BroadNet Inference · 6 Min. Lesezeit · Veröffentlicht

Nehmen Sie mit getUserMedia und MediaRecorder auf, wählen Sie das Format per isTypeSupported und verwerfen Sie leere Chunks. Akzeptiert die API nur WAV oder MP3, dekodieren Sie die Aufnahme im Browser und erzeugen 16-kHz-Mono-WAV, oder Sie laden sie hoch und wandeln sie auf dem Server mit ffmpeg um. In beiden Fällen läuft der Upload über Ihr eigenes Backend, damit der API-Schlüssel nie im Browser landet.

Eine Sprachnachricht in einer Web-App aufzunehmen, kostet etwa dreißig Zeilen JavaScript. Die Probleme beginnen beim Senden der Datei: Der Browser hat WebM oder MP4 aufgenommen, die API will etwas anderes, ein iPhone liefert „Thank you“ für einen stillen Clip, und das kopierte Tutorial legt den API-Schlüssel in die Seite. Dieser Beitrag baut den ganzen Weg auf und testet jedes Teil: aufnehmen, in WAV umwandeln, Größe prüfen und über einen kleinen Server weiterleiten.

Die Beispiele zielen auf eine API, die nur WAV oder MP3 annimmt. BroadNet Inference ist eine solche: Laut Doku sind WAV (audio/wav) oder MP3 (audio/mpeg) bis 26.214.400 Byte pro Datei erlaubt. Nimmt Ihre API WebM an, überspringen Sie die Umwandlung und behalten den Rest. Der Speech-to-Text-Leitfaden von OpenAI listet flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav und webm bis 25 MB.

In welchem Format nimmt der Browser auf?

MediaRecorder nimmt in einem komprimierten Format auf, das der Browser wählt, sofern Sie nicht ein unterstütztes Format anfordern. Fragen Sie mit MediaRecorder.isTypeSupported() und nehmen Sie den ersten Treffer:

Typ-String Typischer Browser
audio/webm;codecs=opus Chrome, Edge, Firefox
audio/mp4 Safari (WebKit dokumentiert MP4 mit AAC); auch Chromium meldete es in unserem Test
audio/ogg;codecs=opus Firefox

In Headless-Chromium lieferte isTypeSupported am 2026-11-15 true für WebM/Opus und MP4 und false für Ogg/Opus. Sehen Sie die Tabelle als Ausgangspunkt, nicht als Zusage. MDN weist darauf hin, dass true nur bedeutet, dass der Browser den Typ grundsätzlich aufnehmen kann; bei knappen Ressourcen kann die Aufnahme trotzdem scheitern. Lesen Sie nach dem Erzeugen immer recorder.mimeType und kennzeichnen Sie den Upload damit, nicht mit dem, was Sie angefordert haben.

Wie nehmen Sie vom Mikrofon auf?

Zwei Browser-Regeln bestimmen den Code. Erstens existiert getUserMedia nur in einem sicheren Kontext: HTTPS, localhost oder eine file:-URL. Bei reinem HTTP von einem anderen Host ist navigator.mediaDevices undefined, der Aufruf wirft also einen TypeError, statt um Erlaubnis zu bitten. Zweitens muss der Nutzer den Zugriff erlauben; eine Ablehnung löst NotAllowedError aus. Behandeln Sie beides mit einer Meldung, mit der der Nutzer etwas anfangen kann.

// 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();
  });
}

Drei Details darin stammen aus echten Fehlerberichten:

  • Leere Chunks verwerfen. In einem Thread im Forum von OpenAI zu MediaRecorder auf iPhones stellte ein Entwickler fest, dass dataavailable unter iOS mit leeren Daten feuerte; das Herausfiltern dieser Chunks behob das Problem. Ein anderer behob dasselbe Symptom, indem er mit einem timeslice startete, start(1000).
  • Die Tracks stoppen. Den Recorder anzuhalten, gibt das Mikrofon nicht frei. Ohne getTracks().forEach(t => t.stop()) zeigt der Browser weiter die Aufnahmeanzeige.
  • Die Dauer nicht über die Anzahl der Chunks messen. MDN warnt, dass timeslice-Intervalle ungenau sind und sich dehnen können, wenn Safari das Mikrofon pausiert oder Chrome auf Android den Bildschirm sperrt. Führen Sie einen eigenen Timer, wenn Sie eine Dauer anzeigen oder ein Limit durchsetzen.

Wie wandeln Sie die Aufnahme im Browser in WAV um?

Die Web Audio API kann dekodieren, was auch immer der Browser aufgenommen hat. Zwei Fakten aus MDN halten das kurz: decodeAudioData funktioniert nur mit einer vollständigen Datei, nicht mit Fragmenten, also dekodieren Sie nach stop(); und es resampelt das dekodierte Audio auf die Abtastrate seines Kontexts. Ein OfflineAudioContext mit 16.000 Hz liefert also 16-kHz-Samples ohne eigenen Resampling-Code. Sein Konstruktor akzeptiert jede Rate von 3.000 bis 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" });
}

Warum 16 kHz mono: Das ist die Einstellung im ffmpeg-Beispiel von BroadNet selbst (-ar 16000 -ac 1), sie erhält das Sprachband und braucht ein Drittel der Bytes von 48 kHz. Stereo verdoppelt die Größe ohne Gewinn bei einer einzelnen Stimme. Die Abwägungen finden Sie unter Abtastrate.

Die Größenrechnung zählt, denn WAV ist unkomprimiert. 16.000 Samples pro Sekunde zu je 2 Byte ergeben 32.000 Byte pro Sekunde. Mit dem Header von 44 Byte fasst das Limit von 26.214.400 Byte bei BroadNet 819 Sekunden: etwa 13 Minuten 39 Sekunden. Für alles Längere beenden Sie die Aufnahme an einem Limit oder teilen auf dem Server auf, wie unter lange Audiodateien transkribieren beschrieben. Der Audio-Splitter schreibt die ffmpeg-Befehle.

Die Umwandlung im Browser kostet CPU und Arbeitsspeicher des Nutzers, und der ganze dekodierte Clip liegt als 32-Bit-Floats im Speicher. Für Sprachnachrichten von ein paar Minuten ist das kein Problem. Bei langen Aufnahmen laden Sie besser die komprimierte Datei hoch und wandeln auf dem Server um.

Wie wandeln Sie stattdessen auf dem Server um?

Senden Sie die komprimierte Aufnahme unverändert und lassen Sie ffmpeg die Arbeit machen. Das bedeutet weniger Code in der Seite, einen kleineren Upload und dasselbe Ergebnis:

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

Schreiben Sie den Upload in eine temporäre Datei, statt ihn per Pipe an ffmpeg zu geben. MP4-Dateien können ihren Index am Ende haben, und den kann ffmpeg aus einer Pipe nicht immer lesen. Der Leitfaden zu WhatsApp-Sprachnachrichten nutzt denselben Befehl für .ogg-Dateien.

Wie halten Sie den API-Schlüssel aus dem Browser heraus?

Setzen Sie einen kleinen Endpoint zwischen Seite und API. Er nimmt die Aufnahme an, wandelt sie bei Bedarf um, prüft die Größe, fügt den Schlüssel aus einer Umgebungsvariablen hinzu und leitet sie weiter. Ab Node 18 sind fetch, FormData und Blob eingebaut, Sie brauchen also keine Pakete:

// 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);

Die Seite sendet dann entweder das WAV oder die Rohaufnahme:

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();

Was Sie beim Anpassen beibehalten sollten:

  • Immer language mitsenden. Laut Doku von BroadNet kann Arabisch sonst in lateinische Buchstaben transliteriert zurückkommen. Verwenden Sie ar mit dem arabischen Modell, oder wechseln Sie zu broadnet/cohere-transcribe und dem passenden Code für eine seiner 14 Sprachen.
  • Generische Fehler zurückgeben. Die erste Version unseres Test-Proxys gab den Fehler von ffmpeg weiter, und der enthielt einen Dateipfad des Servers. Der Code oben gibt stattdessen „Could not read the recording.“ zurück.
  • Authentifizierung und ein Rate Limit ergänzen, bevor Sie deployen. Sonst verbraucht jeder, der /transcribe findet, Ihr Guthaben. Sicherheit von LLM-API-Schlüsseln behandelt den Rest, und Schlüssel von BroadNet lassen sich mit IP-Allowlists einschränken.
  • Fast stille Clips ablehnen. Die Forenberichte über erfundene Transkripte wie „Thank you“ oder „Bye“ betreffen stille oder defekte Aufnahmen. Prüfen Sie die Dauer (WAV-Bytes ÷ 32.000) und, wenn möglich, den Pegel, bevor Sie dafür bezahlen.

Wie haben wir das getestet?

Es wurde kein Schlüssel von BroadNet verwendet. Am 2026-11-15 lief der Code oben gegen ein lokales Mock von /v1/audio/transcriptions:

  1. Encoder in Node. encodeWav erzeugte aus einer Sekunde eines 440-Hz-Tons mit zwei übersteuerten Samples 32.044 Byte. Pythons Modul wave las die Datei als 1 Kanal, 16.000 Hz, 2-Byte-Samples, 16.000 Frames, und ffmpeg als pcm_s16le, 16000 Hz, mono. Die übersteuerten Samples kamen als 32767 und −32768 heraus.
  2. Browser-Pfad in Chromium. Playwright startete Headless-Chromium mit einem simulierten Mikrofon. startRecording nahm 3 Sekunden als audio/webm;codecs=opus auf (40.563 Byte), und toWav16k machte daraus ein WAV mit 96.044 Byte: 3,0 Sekunden, 16 kHz, mono.
  3. Proxy. Das WAV und das rohe WebM lieferten beide 200. Das Mock sah jedes Mal Bearer-Authentifizierung, die ID des arabischen Modells, language=ar und eine audio/wav-Datei mit 16 kHz mono; ffmpeg wandelte das WebM auf dem Server um. Ein WAV mit 26.214.401 Byte bekam 413 ohne Aufruf nach oben. Ein Body, der kein Audio war, bekam 400.
  4. Unsicherer Ursprung. Über die LAN-Adresse des Rechners per reinem HTTP geladen, meldete die Seite isSecureContext false, und startRecording warf unsere HTTPS-Meldung statt eines TypeError.

Safari, Firefox und eine echte Transkription haben wir nicht getestet. Probieren Sie es vor dem Release auf einem echten iPhone aus.

Was kostet das?

BroadNet rechnet Transkription pro Audiominute ab: $0.0042 für Transcribe Arabic und $0.002 für das mehrsprachige Modell. Eine Stunde arabischer Sprachnachrichten kostet $0.25. Beide laufen mit dem Startguthaben von $5, das etwa 1,190 Minuten Arabisch abdeckt. Für Ihre eigenen Volumen nutzen Sie den Speech-to-Text-Kostenrechner. Der Einkaufsleitfaden für arabische Speech-to-Text-APIs vergleicht Anbieter.

Wo BroadNet Inference passt

BroadRouter ist die Website von BroadNet selbst. BroadNet Inference transkribiert hochgeladene Dateien: WAV oder MP3, eine Anfrage pro Datei, mit einer JSON-Antwort, die den Text enthält. Live- oder Streaming-Transkription, Zeitstempel oder Sprecherkennzeichnung sind nicht dokumentiert. Wenn in Ihrer App Wörter erscheinen sollen, während der Nutzer spricht, nehmen Sie einen Anbieter mit Streaming-Speech-API. Für Sprachnachrichten, Notizen und Formulare, bei denen der Nutzer aufnimmt und dann absendet, reicht der Upload-Ablauf oben. Die Einrichtung steht im Leitfaden zur arabischen Speech-to-Text API, und die API-Referenz listet die Felder. Laut ihrer Datenschutzerklärung werden Audio und Transkripte nicht gespeichert.

Häufige Fragen

Kann ich eine WebM-Datei von MediaRecorder direkt an eine Speech-to-Text API schicken?

Nur wenn die API WebM annimmt. Der Transkriptions-Endpoint von OpenAI listet webm und mp4 unter seinen Formaten. BroadNet akzeptiert nur WAV und MP3, also wandeln Sie vorher um: im Browser mit der Web Audio API oder auf Ihrem Server mit ffmpeg -i in.webm -ar 16000 -ac 1 out.wav.

Warum meldet getUserMedia, dass navigator.mediaDevices undefined ist?

Die Seite läuft nicht in einem sicheren Kontext. Laut MDN funktioniert getUserMedia nur über HTTPS, auf localhost oder aus file-URLs. Bei reinem HTTP von einem anderen Host existiert navigator.mediaDevices nicht. Liefern Sie die Seite über HTTPS aus; für die Entwicklung reicht localhost.

Wie lange Aufnahme passt als WAV in einen Upload von 25 MB?

WAV mit 16 kHz, mono, 16 Bit hat 32.000 Byte pro Sekunde plus einen Header von 44 Byte. Das Limit von 26.214.400 Byte bei BroadNet fasst etwa 819 Sekunden, also 13 Minuten 39 Sekunden. MP3 oder eine niedrigere Abtastrate fasst mehr; längeres Audio teilen Sie auf.

Warum bekomme ich auf dem iPhone „Thank you“ oder „Bye“ aus einer leeren Aufnahme?

Entwickler im Forum von OpenAI berichten von kurzen erfundenen Phrasen bei stillen oder defekten Aufnahmen und führten iOS-Fälle auf leere dataavailable-Chunks zurück; Chunks mit Größe 0 herauszufiltern und den Recorder mit einem timeslice zu starten, hat es bei ihnen behoben. Prüfen Sie die Dauer vor dem Upload.

Sollte der Browser die Transkriptions-API direkt aufrufen?

Nein. Alles im Frontend-Code, auch ein API-Schlüssel, kann der Nutzer auslesen. Senden Sie das Audio an Ihren eigenen Endpoint, der Größe und Typ prüft, den Schlüssel aus einer Umgebungsvariablen hinzufügt und die Anfrage weiterleitet.

Als Markdown lesenChatGPT fragenClaude fragenPerplexity fragen