---
title: "Audio im Browser aufnehmen und per API transkribieren"
description: "Mikrofon mit MediaRecorder aufnehmen, WebM oder Safari-MP4 in 16-kHz-WAV umwandeln und über einen kleinen Server, der den Schlüssel hält, transkribieren."
url: https://broadrouter.com/de/blog/record-browser-audio-transcription-api/
lang: de
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Mit KI-Unterstützung aus dem Englischen übersetzt. [Englisches Original lesen](https://broadrouter.com/blog/record-browser-audio-transcription-api/) (aktualisiert am 2026-11-15).

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

Vom Team von BroadNet Inference · 6 Min. Lesezeit · Veröffentlicht 2026-11-15

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.

## Das Wichtigste in Kürze

-   Browser nehmen komprimierte Formate auf: Chrome liefert WebM mit Opus, und WebKit dokumentiert MP4 mit AAC für Safari. OpenAI akzeptiert beides; APIs, die nur WAV oder MP3 annehmen, etwa BroadNet, brauchen einen Umwandlungsschritt.
-   getUserMedia funktioniert nur in einem sicheren Kontext (HTTPS oder localhost). Anderswo ist navigator.mediaDevices undefined; prüfen Sie das also vor dem Aufruf.
-   Ein WAV mit 16 kHz, mono, 16 Bit hat 32.000 Byte pro Sekunde. Das Limit von 26.214.400 Byte bei BroadNet fasst davon etwa 13 Minuten 39 Sekunden; alles Längere müssen Sie aufteilen.
-   decodeAudioData braucht die vollständige Datei und resampelt auf die Rate seines Kontexts. Ein OfflineAudioContext mit 16.000 Hz übernimmt das Resampling also für Sie.
-   Rufen Sie die Transkriptions-API nie aus der Seite auf. Senden Sie das Audio an Ihren Server, prüfen Sie dort Größe und Typ und fügen Sie den Schlüssel serverseitig hinzu.

**Auf dieser Seite**

1.  In welchem Format nimmt der Browser auf?
2.  Wie nehmen Sie vom Mikrofon auf?
3.  Wie wandeln Sie die Aufnahme im Browser in WAV um?
4.  Wie wandeln Sie stattdessen auf dem Server um?
5.  Wie halten Sie den API-Schlüssel aus dem Browser heraus?
6.  Wie haben wir das getestet?
7.  Was kostet das?
8.  Wo BroadNet Inference passt

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

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

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.

```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" });
}
```

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](https://broadrouter.com/de/glossary/sample-rate/).

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](https://broadrouter.com/de/blog/transcribe-long-audio-files-api/) beschrieben. Der [Audio-Splitter](https://broadrouter.com/tools/audio-splitter-ffmpeg/) 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:

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

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

Die Seite sendet dann entweder das WAV oder die Rohaufnahme:

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

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](https://broadrouter.com/de/blog/llm-api-key-security/) behandelt den Rest, und Schlüssel von BroadNet lassen sich mit [IP-Allowlists](https://broadrouter.com/de/guides/api-keys-ip-allow-lists/) 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](https://broadrouter.com/tools/speech-to-text-cost-calculator/). Der [Einkaufsleitfaden für arabische Speech-to-Text-APIs](https://broadrouter.com/de/blog/arabic-speech-to-text-api-buyers-guide/) 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](https://broadrouter.com/de/guides/arabic-speech-to-text-api/), und die [API-Referenz](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-record-browser-audio-transcription-api&utm_content=body) listet die Felder. Laut ihrer Datenschutzerklärung werden Audio und Transkripte nicht gespeichert.

Kostenlose Tools zum Thema (auf Englisch)

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

[Kostenlose Tools (auf Englisch)](https://broadrouter.com/tools/)

## Begriffe in diesem Artikel

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

WAV (Waveform Audio File Format, auch WAVE) ist ein Audiocontainer auf Basis des RIFF-Formats von Microsoft und IBM. Er enthält meist unkomprimierte lineare PCM-Samples, daher ist seine Größe vorhersehbar: Abtastrate mal Bytes pro Sample mal Kanäle, pro Sekunde.

[Speech-to-Text (Spracherkennung)](https://broadrouter.com/de/glossary/speech-to-text/)

Speech-to-Text, auch automatische Spracherkennung (ASR), ist eine Technik, die gesprochenes Audio in geschriebenen Text umwandelt. Eine Speech-to-Text API nimmt eine Audiodatei oder einen Stream entgegen und liefert ein Transkript, meist abgerechnet pro Audiominute. Die Genauigkeit wird mit der Wortfehlerrate gemessen und hängt von Akzent, Dialekt und Aufnahmequalität ab.

[Tool Calling (Function Calling)](https://broadrouter.com/de/glossary/tool-calling/)

Tool Calling, auch Function Calling genannt, ist eine Funktion von LLM-APIs, bei der das Modell eine strukturierte Anfrage zurückgibt, eine vom Entwickler definierte Funktion mit JSON-Argumenten auszuführen. Die Anwendung führt die Funktion aus und sendet das Ergebnis zurück; das Modell selbst führt nie Code aus.

[Ogg Opus](https://broadrouter.com/de/glossary/ogg-opus/)

Ogg Opus ist Audio, das mit dem Opus-Codec (RFC 6716) codiert und in einem Ogg-Container (RFC 7845) gespeichert ist. Es ist für Sprache und interaktives Audio bei niedrigen Bitraten gebaut und das Format, das WhatsApp für Sprachnachrichten nutzt, meist als .ogg- oder .opus-Datei.

[Abtastrate (Sample Rate)](https://broadrouter.com/de/glossary/sample-rate/)

Die Abtastrate (Sample Rate) ist die Zahl der Audio-Samples, die pro Sekunde erfasst werden, gemessen in Hertz (Hz). Spracherkennungsmodelle erwarten meist 16.000 Hz (16 kHz) mono. Zusammen mit Bittiefe und Kanalzahl bestimmt die Abtastrate, wie groß eine unkomprimierte Audiodatei pro Minute ist.

[Rate Limit (Ratenbegrenzung)](https://broadrouter.com/de/glossary/rate-limit/)

Ein Rate Limit ist eine Obergrenze, die eine API festlegt, wie stark ein Client sie in einem Zeitfenster nutzen darf, etwa Anfragen pro Minute oder Tokens pro Minute. Anfragen über dem Limit werden abgelehnt, meist mit HTTP 429 Too Many Requests, bis die Nutzung wieder darunter liegt.

[IP-Allowlist (IP allow list)](https://broadrouter.com/de/glossary/ip-allow-list/)

Eine IP-Allowlist ist eine Sicherheitskontrolle, die nur Anfragen von gelisteten IP-Adressen oder CIDR-Bereichen annimmt und alle anderen ablehnt. Bei einer API begrenzt sie den Schaden eines geleakten Schlüssels, weil der Schlüssel aus nicht gelisteten Netzen nicht funktioniert.

[Zeitstempel (Speech-to-Text)](https://broadrouter.com/de/glossary/timestamps-asr/)

Zeitstempel bei Speech-to-Text sind Start- und Endzeiten in Sekunden, die Teilen eines Transkripts zugeordnet sind. Segment-Zeitstempel gelten für eine Wendung oder einen Satz, Wort-Zeitstempel für jedes Wort. Man braucht sie für Untertitel, die Suche in Aufnahmen und die Zuordnung von Text zu Sprechern.

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

## Weiterlesen

-   [Audio über 25 MB transkribieren: aufteilen, senden, zusammenfügen](https://broadrouter.com/de/blog/transcribe-long-audio-files-api/)
-   [Alternative zur Whisper API: wann wechseln und wie testen](https://broadrouter.com/de/blog/whisper-api-alternative/)
-   [Mehrsprachige Speech-to-Text API: 14 Sprachen, ein Endpoint](https://broadrouter.com/de/blog/multilingual-speech-to-text-api/)
-   [LLM-API-Schlüssel absichern: Speicherung, Rotation, IP-Allowlists](https://broadrouter.com/de/blog/llm-api-key-security/)
-   [Speech-to-Text-API für Arabisch: So wählen Sie 2026 die richtige](https://broadrouter.com/de/blog/arabic-speech-to-text-api-buyers-guide/)
-   [Sprachnachrichten in Text für Firmen: WhatsApp und Telegram zu Tickets](https://broadrouter.com/de/blog/voice-notes-to-text-for-business/)
-   [GPU-Hardware und Serving von BroadNet, wie BroadNet sie beschreibt](https://broadrouter.com/de/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM-Antworten cachen, Kosten senken: ein Exact-Match-Cache in Python](https://broadrouter.com/de/blog/cache-llm-responses-cut-cost/)
-   [Anleitung: WhatsApp-Sprachnachrichten per API in Text umwandeln](https://broadrouter.com/de/guides/transcribe-whatsapp-voice-notes/)
-   [Anleitung: Speech-to-Text API für Arabisch: Schritt für Schritt](https://broadrouter.com/de/guides/arabic-speech-to-text-api/)
-   [Anleitung: OpenAI Node.js SDK mit BroadNet Inference nutzen](https://broadrouter.com/de/guides/openai-node-sdk/)

Testen Sie es mit Ihrem echten Workload. Neue Konten starten mit USD 5 Guthaben für Gemma und Transkription. DeepSeek, GLM und Qwen3.8 erfordern eine Aufladung.

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

**Quellen**

-   [API-Referenz von BroadNet Inference: WAV (audio/wav) oder MP3 (audio/mpeg) bis 26.214.400 Byte, language immer mitsenden, JSON-Antwort mit text (geprüft am 2026-11-15) (auf Englisch)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-record-browser-audio-transcription-api&utm_content=sources)
-   [MDN, MediaDevices.getUserMedia(): nur in sicheren Kontexten, Erlaubnis des Nutzers, NotAllowedError (geprüft am 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)
-   [MDN, MediaRecorder.isTypeSupported(): true garantiert keine erfolgreiche Aufnahme (geprüft am 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/MediaRecorder/isTypeSupported_static)
-   [MDN, Ereignis dataavailable von MediaRecorder: timeslice, stop() und ungenaue Intervalle (geprüft am 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/MediaRecorder/dataavailable_event)
-   [MDN, BaseAudioContext.decodeAudioData(): resampelt auf die Rate des Kontexts, nur vollständige Dateien (geprüft am 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/BaseAudioContext/decodeAudioData)
-   [MDN, Konstruktor OfflineAudioContext(): sampleRate von 3.000 bis 768.000 Hz (geprüft am 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/OfflineAudioContext/OfflineAudioContext)
-   [WebKit-Blog, MediaRecorder API: Safari nimmt MP4 mit H.264-Video und AAC-Audio auf, Formate zur Laufzeit erkennbar (geprüft am 2026-11-15)](https://webkit.org/blog/11353/mediarecorder-api/)
-   [Speech-to-Text-Leitfaden von OpenAI: flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav und webm, Dateien bis 25 MB (geprüft am 2026-11-15)](https://developers.openai.com/api/docs/guides/speech-to-text)
-   [OpenAI Developer Community, „MediaRecorder API w/ Whisper not working on mobile browsers“, Juli bis Dezember 2024 (geprüft am 2026-11-15)](https://community.openai.com/t/mediarecorder-api-w-whisper-not-working-on-mobile-browsers/866019)
