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
dataavailableunter 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
languagemitsenden. Laut Doku von BroadNet kann Arabisch sonst in lateinische Buchstaben transliteriert zurückkommen. Verwenden Siearmit dem arabischen Modell, oder wechseln Sie zubroadnet/cohere-transcribeund 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
/transcribefindet, 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:
- Encoder in Node.
encodeWaverzeugte aus einer Sekunde eines 440-Hz-Tons mit zwei übersteuerten Samples 32.044 Byte. Pythons Modulwavelas die Datei als 1 Kanal, 16.000 Hz, 2-Byte-Samples, 16.000 Frames, und ffmpeg alspcm_s16le, 16000 Hz, mono. Die übersteuerten Samples kamen als 32767 und −32768 heraus. - Browser-Pfad in Chromium. Playwright startete Headless-Chromium mit einem simulierten Mikrofon.
startRecordingnahm 3 Sekunden alsaudio/webm;codecs=opusauf (40.563 Byte), undtoWav16kmachte daraus ein WAV mit 96.044 Byte: 3,0 Sekunden, 16 kHz, mono. - Proxy. Das WAV und das rohe WebM lieferten beide 200. Das Mock sah jedes Mal
Bearer-Authentifizierung, die ID des arabischen Modells,language=arund eineaudio/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. - Unsicherer Ursprung. Über die LAN-Adresse des Rechners per reinem HTTP geladen, meldete die Seite
isSecureContextfalse, undstartRecordingwarf unsere HTTPS-Meldung statt einesTypeError.
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.
