---
title: "Enregistrer l’audio du navigateur et le transcrire par API"
description: "Enregistrer le micro avec MediaRecorder, convertir le WebM ou le MP4 de Safari en WAV 16 kHz et l’envoyer à une API de transcription via un petit serveur."
url: https://broadrouter.com/fr/blog/record-browser-audio-transcription-api/
lang: fr
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/blog/record-browser-audio-transcription-api/) (mis à jour le 2026-11-15).

# Enregistrer l’audio du navigateur, l’envoyer à une API speech-to-text

Par l’équipe BroadNet Inference · 6 min de lecture · Publié 2026-11-15

Enregistrez avec getUserMedia et MediaRecorder, choisissez le format avec isTypeSupported et ignorez les chunks vides. Si l’API n’accepte que le WAV ou le MP3, décodez l’enregistrement dans le navigateur et encodez un WAV mono 16 kHz, ou envoyez-le au serveur et convertissez-le avec ffmpeg. Dans les deux cas, passez par votre propre backend pour que la clé d’API n’arrive jamais dans le navigateur.

## À retenir

-   Les navigateurs enregistrent des formats compressés : Chrome produit du WebM avec Opus, et WebKit documente du MP4 avec AAC pour Safari. OpenAI accepte les deux ; les API qui ne prennent que le WAV ou le MP3, comme BroadNet, demandent une étape de conversion.
-   getUserMedia ne fonctionne que dans un contexte sécurisé (HTTPS ou localhost). Ailleurs, navigator.mediaDevices vaut undefined : vérifiez sa présence avant de l’appeler.
-   Un WAV mono 16 kHz 16 bits pèse 32 000 octets par seconde. La limite de 26 214 400 octets de BroadNet en contient environ 13 minutes 39 secondes ; au-delà, découpez.
-   decodeAudioData exige le fichier complet et rééchantillonne à la fréquence de son contexte : un OfflineAudioContext à 16 000 Hz fait donc le rééchantillonnage pour vous.
-   N’appelez jamais l’API de transcription depuis la page. Envoyez l’audio à votre serveur, vérifiez-y la taille et le type, et ajoutez la clé côté serveur.

**Sur cette page**

1.  Dans quel format le navigateur enregistre-t-il ?
2.  Comment enregistrer depuis le micro ?
3.  Comment convertir l’enregistrement en WAV dans le navigateur ?
4.  Comment convertir plutôt sur le serveur ?
5.  Comment garder la clé d’API hors du navigateur ?
6.  Comment avons-nous testé ?
7.  Combien cela coûte-t-il ?
8.  La place de BroadNet Inference

Enregistrer un message vocal dans une application web demande une trentaine de lignes de JavaScript. Les problèmes commencent à l’envoi du fichier : le navigateur a enregistré du WebM ou du MP4, l’API attend autre chose, un iPhone renvoie « Thank you » pour un clip silencieux, et le tutoriel que vous avez copié place la clé d’API dans la page. Cet article construit tout le parcours et teste chaque étape : enregistrer, convertir en WAV, vérifier la taille et transmettre via un petit serveur.

Les exemples visent une API qui n’accepte que le WAV ou le MP3. BroadNet Inference en fait partie : sa documentation indique WAV (`audio/wav`) ou MP3 (`audio/mpeg`) jusqu’à 26 214 400 octets par fichier. Si votre API accepte le WebM, sautez la conversion et gardez le reste. Le guide speech-to-text d’OpenAI cite flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav et webm, jusqu’à 25 Mo.

## Dans quel format le navigateur enregistre-t-il ?

`MediaRecorder` enregistre dans un format compressé choisi par le navigateur, sauf si vous en demandez un qu’il prend en charge. Interrogez-le avec `MediaRecorder.isTypeSupported()` et prenez la première correspondance :

| Chaîne de type | Navigateur typique |
| --- | --- |
| `audio/webm;codecs=opus` | Chrome, Edge, Firefox |
| `audio/mp4` | Safari ([WebKit documente le MP4 avec AAC](https://webkit.org/blog/11353/mediarecorder-api/)) ; Chromium l’a aussi signalé dans notre test |
| `audio/ogg;codecs=opus` | Firefox |

Dans Chromium headless, le 2026-11-15, `isTypeSupported` a renvoyé true pour WebM/Opus et MP4, et false pour Ogg/Opus. Voyez ce tableau comme un point de départ, pas comme une promesse. MDN précise que `true` signifie que le navigateur peut enregistrer ce type en principe ; l’enregistrement peut encore échouer si les ressources manquent. Lisez toujours `recorder.mimeType` après la création, et étiquetez l’envoi avec cette valeur, pas avec celle que vous avez demandée.

## Comment enregistrer depuis le micro ?

Deux règles du navigateur façonnent le code. D’abord, `getUserMedia` n’existe que dans un [contexte sécurisé](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia) : HTTPS, `localhost` ou une URL `file:`. En HTTP simple depuis un autre hôte, `navigator.mediaDevices` vaut `undefined`, et l’appel lève donc une `TypeError` au lieu de demander l’autorisation. Ensuite, l’utilisateur doit accorder l’accès, et un refus lève `NotAllowedError`. Traitez les deux cas avec un message sur lequel l’utilisateur peut agir.

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

Trois détails de ce code viennent de vrais rapports de bugs :

-   **Ignorer les chunks vides.** Dans un fil du forum d’OpenAI sur MediaRecorder et les iPhone, un développeur a constaté que `dataavailable` se déclenchait avec des données vides sur iOS, et le filtrage de ces chunks a résolu le problème. Un autre a corrigé le même symptôme en démarrant avec un timeslice, `start(1000)`.
-   **Arrêter les pistes.** Arrêter l’enregistreur ne libère pas le micro. Sans `getTracks().forEach(t => t.stop())`, le navigateur continue d’afficher l’indicateur d’enregistrement.
-   **Ne pas mesurer la durée en comptant les chunks.** MDN prévient que les intervalles de timeslice sont inexacts et peuvent s’allonger quand Safari met le micro en pause ou que Chrome sur Android verrouille l’écran. Gardez votre propre minuteur si vous affichez une durée ou imposez une limite.

## Comment convertir l’enregistrement en WAV dans le navigateur ?

La Web Audio API sait décoder tout ce que le navigateur a enregistré. Deux faits tirés de MDN rendent cela court : `decodeAudioData` ne fonctionne que sur un fichier complet, pas sur des fragments, donc décodez après `stop()` ; et il rééchantillonne l’audio décodé à la fréquence d’échantillonnage de son contexte. Un `OfflineAudioContext` créé à 16 000 Hz renvoie donc des échantillons à 16 kHz sans code de rééchantillonnage supplémentaire. Son constructeur accepte toute fréquence de 3 000 à 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" });
}
```

Pourquoi du mono 16 kHz : c’est le réglage de l’exemple ffmpeg de BroadNet lui-même (`-ar 16000 -ac 1`), il conserve la bande de la parole, et il pèse un tiers des octets du 48 kHz. La stéréo double la taille sans rien apporter pour une seule voix. Voir [fréquence d’échantillonnage](https://broadrouter.com/fr/glossary/sample-rate/) pour les compromis.

Le calcul de taille compte, car le WAV n’est pas compressé. 16 000 échantillons par seconde à 2 octets chacun font 32 000 octets par seconde. Avec l’en-tête de 44 octets, la limite de 26 214 400 octets de BroadNet contient 819 secondes : environ 13 minutes 39 secondes. Au-delà, arrêtez l’enregistrement à une limite, ou découpez sur le serveur comme dans [transcrire de longs fichiers audio](https://broadrouter.com/fr/blog/transcribe-long-audio-files-api/). Le [découpeur audio](https://broadrouter.com/tools/audio-splitter-ffmpeg/) génère les commandes ffmpeg.

Convertir dans le navigateur consomme le processeur et la mémoire de l’utilisateur, et tout le clip décodé reste en mémoire sous forme de flottants 32 bits. C’est sans problème pour des messages vocaux de quelques minutes. Pour de longs enregistrements, envoyez plutôt le fichier compressé et convertissez sur le serveur.

## Comment convertir plutôt sur le serveur ?

Envoyez l’enregistrement compressé tel quel et laissez ffmpeg faire le travail. Moins de code dans la page, un envoi plus léger, et le même résultat :

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

Écrivez l’envoi dans un fichier temporaire plutôt que de le passer à ffmpeg par un pipe. Les fichiers MP4 peuvent placer leur index à la fin, et ffmpeg ne sait pas toujours les lire depuis un pipe. Le [guide des messages vocaux WhatsApp](https://broadrouter.com/fr/guides/transcribe-whatsapp-voice-notes/) utilise la même commande pour les fichiers `.ogg`.

## Comment garder la clé d’API hors du navigateur ?

Placez un petit endpoint entre la page et l’API. Il reçoit l’enregistrement, le convertit si besoin, vérifie la taille, ajoute la clé depuis une variable d’environnement et transmet la requête. Node 18 et les versions suivantes intègrent `fetch`, `FormData` et `Blob`, donc aucun paquet n’est nécessaire :

```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 page envoie ensuite soit le WAV, soit l’enregistrement brut :

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

Points à conserver quand vous l’adaptez :

-   **Envoyez toujours `language`.** La documentation de BroadNet indique que l’arabe peut sinon revenir translittéré en caractères latins. Utilisez `ar` avec le modèle arabe, ou passez à `broadnet/cohere-transcribe` avec le bon code pour l’une de ses 14 langues.
-   **Renvoyez des erreurs génériques.** La première version de notre proxy de test renvoyait l’erreur de ffmpeg, qui contenait un chemin de fichier du serveur. Le code ci-dessus renvoie « Could not read the recording. » à la place.
-   **Ajoutez une authentification et une limite de débit** avant de déployer. Sinon, quiconque trouve `/transcribe` dépense votre solde. [La sécurité des clés d’API LLM](https://broadrouter.com/fr/blog/llm-api-key-security/) couvre le reste, et les clés BroadNet peuvent être restreintes avec des [listes d’adresses IP autorisées](https://broadrouter.com/fr/guides/api-keys-ip-allow-lists/).
-   **Rejetez les clips quasi silencieux.** Les signalements du forum sur des transcriptions inventées comme « Thank you » ou « Bye » concernent des enregistrements silencieux ou défectueux. Vérifiez la durée (octets WAV ÷ 32 000) et, si possible, le niveau du signal avant de payer pour la transcription.

## Comment avons-nous testé ?

Aucune clé BroadNet n’a été utilisée. Le 2026-11-15, nous avons exécuté le code ci-dessus contre une simulation locale de `/v1/audio/transcriptions` :

1.  **Encodeur dans Node.** `encodeWav` appliqué à une seconde d’un son à 440 Hz avec deux échantillons saturés a produit 32 044 octets. Le module `wave` de Python l’a lu comme 1 canal, 16 000 Hz, échantillons de 2 octets, 16 000 trames, et ffmpeg comme `pcm_s16le, 16000 Hz, mono`. Les échantillons saturés sont sortis à 32767 et −32768.
2.  **Parcours navigateur dans Chromium.** Playwright a lancé Chromium headless avec un faux micro. `startRecording` a enregistré 3 secondes en `audio/webm;codecs=opus` (40 563 octets), et `toWav16k` en a fait un WAV de 96 044 octets : 3,0 secondes, 16 kHz, mono.
3.  **Proxy.** Le WAV et le WebM brut ont tous deux renvoyé 200. La simulation a reçu à chaque fois une authentification `Bearer`, l’identifiant du modèle arabe, `language=ar` et un fichier `audio/wav` mono 16 kHz ; ffmpeg a converti le WebM sur le serveur. Un WAV de 26 214 401 octets a reçu 413 sans appel en amont. Un corps qui n’était pas de l’audio a reçu 400.
4.  **Origine non sécurisée.** Chargée depuis l’adresse réseau local de la machine en HTTP simple, la page a indiqué `isSecureContext` à false, et `startRecording` a levé notre message HTTPS au lieu d’une `TypeError`.

Nous n’avons testé ni Safari, ni Firefox, ni une vraie transcription. Essayez sur un vrai iPhone avant la mise en production.

## Combien cela coûte-t-il ?

BroadNet facture la transcription à la minute d’audio : $0.0042 pour Transcribe Arabic et $0.002 pour le modèle multilingue. Une heure de messages vocaux en arabe coûte $0.25. Les deux fonctionnent avec le crédit de départ de $5, qui couvre environ 1,190 minutes d’arabe. Pour vos propres volumes, utilisez le [calculateur de coût speech-to-text](https://broadrouter.com/tools/speech-to-text-cost-calculator/). Le [guide d’achat des API speech-to-text pour l’arabe](https://broadrouter.com/fr/blog/arabic-speech-to-text-api-buyers-guide/) compare les fournisseurs.

## La place de BroadNet Inference

BroadRouter est le site de BroadNet. BroadNet Inference transcrit des fichiers envoyés : WAV ou MP3, une requête par fichier, avec une réponse JSON contenant le texte. La transcription en direct ou en streaming, les horodatages et l’identification des locuteurs ne sont pas documentés. Si votre application doit afficher les mots pendant que l’utilisateur parle, choisissez un fournisseur doté d’une API vocale en streaming. Pour les messages vocaux, les notes et les formulaires, où l’utilisateur enregistre puis envoie, le flux d’envoi ci-dessus suffit. La configuration se trouve dans le [guide de l’API speech-to-text pour l’arabe](https://broadrouter.com/fr/guides/arabic-speech-to-text-api/), et la [référence de l’API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-record-browser-audio-transcription-api&utm_content=body) liste les champs. Sa déclaration de confidentialité indique que l’audio et les transcriptions ne sont pas conservés.

Outils gratuits sur ce sujet (en anglais)

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

[Outils gratuits (en anglais)](https://broadrouter.com/tools/)

## Termes de cet article

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

Le WAV (Waveform Audio File Format, ou WAVE) est un conteneur audio fondé sur le format RIFF de Microsoft et IBM. Il contient en général des échantillons PCM linéaires non compressés, d’où une taille prévisible : fréquence d’échantillonnage fois octets par échantillon fois canaux, par seconde.

[Speech-to-text (reconnaissance vocale)](https://broadrouter.com/fr/glossary/speech-to-text/)

Le speech-to-text, ou reconnaissance automatique de la parole (ASR), est une technologie qui convertit l’audio parlé en texte écrit. Une API speech-to-text accepte un fichier ou un flux audio et renvoie une transcription, généralement facturée à la minute d’audio. La précision se mesure avec le taux d’erreur de mots et varie selon l’accent, le dialecte et la qualité d’enregistrement.

[Streaming](https://broadrouter.com/fr/glossary/streaming/)

Le streaming est une manière de renvoyer la réponse d’un modèle de langage par petits chunks pendant sa génération, plutôt qu’en un seul bloc à la fin. Les API compatibles OpenAI streament via des server-sent events quand la requête règle stream sur true.

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

L’Ogg Opus est de l’audio encodé avec le codec Opus (RFC 6716) et stocké dans un conteneur Ogg (RFC 7845). Conçu pour la parole et l’audio interactif à faible débit, c’est le format qu’utilise WhatsApp pour les messages vocaux, en général sous forme de fichiers .ogg ou .opus.

[Appel d’outils (tool calling, function calling)](https://broadrouter.com/fr/glossary/tool-calling/)

L’appel d’outils, aussi appelé function calling, est une fonctionnalité des API LLM dans laquelle le modèle renvoie une demande structurée d’exécution d’une fonction définie par le développeur, avec des arguments JSON. L’application exécute la fonction et renvoie le résultat ; le modèle n’exécute jamais de code lui-même.

[Clé d’API (API key)](https://broadrouter.com/fr/glossary/api-key/)

Une clé d’API est une chaîne secrète qui identifie et autorise un client qui appelle une API. Les API LLM l’attendent généralement dans un en-tête Authorization: Bearer, et quiconque détient la clé peut envoyer des requêtes facturées au compte qui la possède.

[Fréquence d’échantillonnage (sample rate)](https://broadrouter.com/fr/glossary/sample-rate/)

La fréquence d’échantillonnage (sample rate) est le nombre d’échantillons audio captés par seconde, mesuré en hertz (Hz). Les modèles de reconnaissance vocale attendent souvent un audio mono à 16 000 Hz (16 kHz). Avec la profondeur de bits et le nombre de canaux, elle fixe la taille d’un fichier audio non compressé par minute.

[Débit (throughput)](https://broadrouter.com/fr/glossary/throughput/)

Le débit (throughput), dans le service de LLM, est la quantité totale de travail qu’un système accomplit par unité de temps sur toutes les requêtes simultanées, généralement mesurée en tokens de sortie par seconde ou en requêtes par seconde. Il se distingue de la vitesse par flux, c’est-à-dire la vitesse à laquelle une seule requête reçoit ses tokens.

## Questions fréquentes

### Puis-je envoyer directement un fichier WebM de MediaRecorder à une API speech-to-text ?

Seulement si l’API accepte le WebM. L’endpoint de transcription d’OpenAI cite webm et mp4 parmi ses formats. BroadNet n’accepte que le WAV et le MP3 : convertissez d’abord, dans le navigateur avec la Web Audio API, ou sur votre serveur avec ffmpeg -i in.webm -ar 16000 -ac 1 out.wav.

### Pourquoi getUserMedia indique-t-il que navigator.mediaDevices est undefined ?

La page n’est pas dans un contexte sécurisé. Selon MDN, getUserMedia ne fonctionne qu’en HTTPS, sur localhost ou depuis des URL file. En HTTP simple depuis un autre hôte, navigator.mediaDevices n’existe pas. Servez la page en HTTPS ; localhost suffit pour le développement.

### Quelle durée d’enregistrement tient dans un envoi de 25 Mo en WAV ?

Le WAV mono 16 kHz 16 bits pèse 32 000 octets par seconde, plus un en-tête de 44 octets. La limite de 26 214 400 octets de BroadNet contient environ 819 secondes, soit 13 minutes 39 secondes. Le MP3 ou une fréquence d’échantillonnage plus basse en contient davantage ; pour un audio plus long, découpez-le.

### Pourquoi j’obtiens « Thank you » ou « Bye » à partir d’un enregistrement vide sur iPhone ?

Des développeurs sur le forum d’OpenAI signalent de courtes phrases inventées à partir d’enregistrements silencieux ou défectueux, et ont attribué des cas sur iOS à des chunks dataavailable vides ; filtrer les chunks de taille 0 et démarrer l’enregistreur avec un timeslice a résolu le problème chez eux. Vérifiez la durée avant l’envoi.

### Le navigateur doit-il appeler directement l’API de transcription ?

Non. Tout ce qui se trouve dans le code frontend, y compris une clé d’API, peut être lu par l’utilisateur. Envoyez l’audio à votre propre endpoint, qui vérifie la taille et le type, ajoute la clé depuis une variable d’environnement et transmet la requête.

## À lire ensuite

-   [Transcrire un audio de plus de 25 Mo : découper, envoyer, recoller](https://broadrouter.com/fr/blog/transcribe-long-audio-files-api/)
-   [Alternative à l’API Whisper : quand changer et comment tester](https://broadrouter.com/fr/blog/whisper-api-alternative/)
-   [API speech-to-text multilingue : 14 langues, un seul endpoint](https://broadrouter.com/fr/blog/multilingual-speech-to-text-api/)
-   [Sécuriser une clé d’API LLM : stockage, rotation et listes d’IP](https://broadrouter.com/fr/blog/llm-api-key-security/)
-   [API speech-to-text pour l’arabe : comment la choisir en 2026](https://broadrouter.com/fr/blog/arabic-speech-to-text-api-buyers-guide/)
-   [Messages vocaux en texte : de WhatsApp et Telegram aux tickets](https://broadrouter.com/fr/blog/voice-notes-to-text-for-business/)
-   [Matériel GPU et serving de BroadNet, tels que BroadNet les décrit](https://broadrouter.com/fr/blog/broadnet-gpu-fleet-and-serving/)
-   [Mettre en cache les réponses d’API LLM : un cache exact en Python](https://broadrouter.com/fr/blog/cache-llm-responses-cut-cost/)
-   [Guide : Transcrire les messages vocaux WhatsApp en texte avec une API](https://broadrouter.com/fr/guides/transcribe-whatsapp-voice-notes/)
-   [Guide : API speech-to-text pour l’arabe, étape par étape](https://broadrouter.com/fr/guides/arabic-speech-to-text-api/)
-   [Guide : Utiliser le SDK Node.js d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-node-sdk/)

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

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

**Sources**

-   [Référence de l’API BroadNet Inference : WAV (audio/wav) ou MP3 (audio/mpeg) jusqu’à 26 214 400 octets, toujours envoyer language, réponse JSON avec text (vérifiée le 2026-11-15) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-record-browser-audio-transcription-api&utm_content=sources)
-   [MDN, MediaDevices.getUserMedia() : contextes sécurisés uniquement, autorisation de l’utilisateur, NotAllowedError (vérifié le 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)
-   [MDN, MediaRecorder.isTypeSupported() : true ne garantit pas la réussite de l’enregistrement (vérifié le 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/MediaRecorder/isTypeSupported_static)
-   [MDN, événement dataavailable de MediaRecorder : timeslice, stop() et intervalles inexacts (vérifié le 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/MediaRecorder/dataavailable_event)
-   [MDN, BaseAudioContext.decodeAudioData() : rééchantillonne à la fréquence du contexte, fichiers complets uniquement (vérifié le 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/BaseAudioContext/decodeAudioData)
-   [MDN, constructeur OfflineAudioContext() : sampleRate de 3 000 à 768 000 Hz (vérifié le 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/OfflineAudioContext/OfflineAudioContext)
-   [Blog WebKit, API MediaRecorder : Safari enregistre du MP4 avec vidéo H.264 et audio AAC, formats détectables à l’exécution (vérifié le 2026-11-15)](https://webkit.org/blog/11353/mediarecorder-api/)
-   [Guide speech-to-text d’OpenAI : flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav et webm, fichiers jusqu’à 25 Mo (vérifié le 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 », juillet à décembre 2024 (vérifié le 2026-11-15)](https://community.openai.com/t/mediarecorder-api-w-whisper-not-working-on-mobile-browsers/866019)
