---
title: "Registrare audio nel browser e trascriverlo via API | BroadRouter"
description: "Registra il microfono con MediaRecorder, converti WebM o l’MP4 di Safari in WAV a 16 kHz e invialo all’API di trascrizione via un piccolo server con la chiave."
url: https://broadrouter.com/it/blog/record-browser-audio-transcription-api/
lang: it
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Tradotto dall’inglese con l’aiuto dell’IA. [Leggi l’originale in inglese](https://broadrouter.com/blog/record-browser-audio-transcription-api/) (aggiornato il 2026-11-15).

# Registrare audio nel browser e inviarlo a un’API speech-to-text

A cura del team di BroadNet Inference · 6 min di lettura · Pubblicato 2026-11-15

Registra con getUserMedia e MediaRecorder, scegli il formato con isTypeSupported e scarta i chunk vuoti. Se l’API accetta solo WAV o MP3, decodifica la registrazione nel browser e codificala in WAV mono a 16 kHz, oppure caricala e convertila con ffmpeg sul tuo server. In entrambi i casi passa dal tuo backend, così la chiave API non arriva mai al browser.

## Punti chiave

-   I browser registrano formati compressi: Chrome produce WebM con Opus, e WebKit documenta MP4 con AAC per Safari. OpenAI li accetta entrambi; le API che accettano solo WAV o MP3, come BroadNet, richiedono una conversione.
-   getUserMedia funziona solo in un contesto sicuro (HTTPS o localhost). Altrove navigator.mediaDevices è undefined, quindi controllane l’esistenza prima di chiamarlo.
-   Un WAV mono a 16 kHz e 16 bit occupa 32.000 byte al secondo. Il limite di 26.214.400 byte di BroadNet ne contiene circa 13 minuti e 39 secondi; dividi tutto ciò che è più lungo.
-   decodeAudioData richiede il file completo e ricampiona alla frequenza del suo contesto, quindi un OfflineAudioContext a 16.000 Hz fa il ricampionamento al posto tuo.
-   Non chiamare mai l’API di trascrizione dalla pagina. Invia l’audio al tuo server, controllane lì dimensione e tipo e aggiungi la chiave lato server.

**In questa pagina**

1.  Che formato registra il browser?
2.  Come si registra dal microfono?
3.  Come si converte la registrazione in WAV nel browser?
4.  Come si converte invece sul server?
5.  Come si tiene la chiave API fuori dal browser?
6.  Come l’abbiamo testato?
7.  Quanto costa?
8.  Dove si colloca BroadNet Inference

Registrare un messaggio vocale in una web app richiede una trentina di righe di JavaScript. I problemi iniziano quando invii il file: il browser ha registrato WebM o MP4, l’API vuole altro, un iPhone restituisce «Thank you» per una clip silenziosa, e il tutorial che hai copiato mette la chiave API nella pagina. Questo articolo costruisce l’intero percorso e testa ogni pezzo: registrazione, conversione in WAV, controllo della dimensione e inoltro tramite un piccolo server.

Gli esempi puntano a un’API che accetta solo WAV o MP3. BroadNet Inference è una di queste: la sua documentazione indica WAV (`audio/wav`) o MP3 (`audio/mpeg`) fino a 26.214.400 byte per file. Se la tua API accetta WebM, salta la conversione e tieni il resto. La guida speech-to-text di OpenAI elenca flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav e webm, fino a 25 MB.

## Che formato registra il browser?

`MediaRecorder` registra in un formato compresso scelto dal browser, a meno che tu non ne chieda uno supportato. Chiedilo con `MediaRecorder.isTypeSupported()` e prendi la prima corrispondenza:

| Stringa del tipo | Browser tipico |
| --- | --- |
| `audio/webm;codecs=opus` | Chrome, Edge, Firefox |
| `audio/mp4` | Safari ([WebKit documenta MP4 con AAC](https://webkit.org/blog/11353/mediarecorder-api/)); nel nostro test lo ha indicato anche Chromium |
| `audio/ogg;codecs=opus` | Firefox |

In Chromium headless, il 2026-11-15, `isTypeSupported` ha restituito true per WebM/Opus e MP4 e false per Ogg/Opus. Considera la tabella un punto di partenza, non una promessa. MDN precisa che `true` significa che il browser può registrare quel tipo in linea di principio; la registrazione può comunque fallire se le risorse scarseggiano. Leggi sempre `recorder.mimeType` dopo averlo creato, ed etichetta l’upload con quello, non con quello che avevi chiesto.

## Come si registra dal microfono?

Due regole del browser determinano il codice. Primo, `getUserMedia` esiste solo in un [contesto sicuro](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia): HTTPS, `localhost` o un URL `file:`. In HTTP semplice da un altro host, `navigator.mediaDevices` è `undefined`, quindi chiamarlo lancia un `TypeError` invece di chiedere il permesso. Secondo, l’utente deve concedere l’accesso, e un rifiuto solleva `NotAllowedError`. Gestisci entrambi i casi con un messaggio su cui l’utente possa agire.

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

Tre dettagli vengono da segnalazioni di bug reali:

-   **Scarta i chunk vuoti.** In una discussione sul forum di OpenAI dedicata a MediaRecorder su iPhone, uno sviluppatore ha scoperto che su iOS `dataavailable` scattava con dati vuoti, e filtrare quei chunk ha risolto. Un altro ha risolto lo stesso sintomo avviando con un timeslice, `start(1000)`.
-   **Ferma le tracce.** Fermare il registratore non rilascia il microfono. Senza `getTracks().forEach(t => t.stop())` il browser continua a mostrare l’indicatore di registrazione.
-   **Non misurare la durata contando i chunk.** MDN avverte che gli intervalli del timeslice non sono esatti e possono allungarsi quando Safari mette in pausa il microfono o Chrome su Android blocca lo schermo. Usa un tuo timer se mostri una durata o imponi un limite.

## Come si converte la registrazione in WAV nel browser?

La Web Audio API sa decodificare qualunque cosa abbia registrato il browser. Due fatti tratti da MDN accorciano il lavoro: `decodeAudioData` funziona solo su un file completo, non su frammenti, quindi decodifica dopo `stop()`; e ricampiona l’audio decodificato alla frequenza di campionamento del suo contesto. Un `OfflineAudioContext` creato a 16.000 Hz restituisce quindi campioni a 16 kHz senza codice di ricampionamento aggiuntivo. Il suo costruttore accetta qualsiasi frequenza da 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" });
}
```

Perché 16 kHz mono: è l’impostazione usata nell’esempio ffmpeg di BroadNet stessa (`-ar 16000 -ac 1`), conserva la banda del parlato e occupa un terzo dei byte rispetto a 48 kHz. Lo stereo raddoppia la dimensione senza alcun vantaggio per una voce sola. Per i compromessi vedi [frequenza di campionamento](https://broadrouter.com/it/glossary/sample-rate/).

I calcoli sulla dimensione contano, perché il WAV non è compresso. 16.000 campioni al secondo da 2 byte ciascuno fanno 32.000 byte al secondo. Con l’intestazione da 44 byte, il limite di 26.214.400 byte di BroadNet contiene 819 secondi: circa 13 minuti e 39 secondi. Per durate maggiori, ferma la registrazione a un limite, oppure dividi sul server come in [trascrivere file audio lunghi](https://broadrouter.com/it/blog/transcribe-long-audio-files-api/). Lo [splitter audio](https://broadrouter.com/tools/audio-splitter-ffmpeg/) scrive i comandi ffmpeg per te.

Convertire nel browser consuma CPU e memoria dell’utente, e l’intera clip decodificata resta in memoria come float a 32 bit. Per messaggi vocali di pochi minuti va bene. Per registrazioni lunghe, carica il file compresso e converti sul server.

## Come si converte invece sul server?

Invia la registrazione compressa così com’è e lascia lavorare ffmpeg. Meno codice nella pagina, un upload più piccolo e lo stesso risultato:

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

Scrivi l’upload in un file temporaneo invece di passarlo a ffmpeg tramite pipe. I file MP4 possono avere l’indice alla fine, e ffmpeg non sempre riesce a leggerli da una pipe. La [guida sui vocali WhatsApp](https://broadrouter.com/it/guides/transcribe-whatsapp-voice-notes/) usa lo stesso comando per i file `.ogg`.

## Come si tiene la chiave API fuori dal browser?

Metti un piccolo endpoint tra la pagina e l’API. Riceve la registrazione, la converte se serve, controlla la dimensione, aggiunge la chiave da una variabile d’ambiente e la inoltra. Node 18 e successivi hanno `fetch`, `FormData` e `Blob` integrati, quindi non servono pacchetti:

```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 pagina invia poi il WAV oppure la registrazione grezza:

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

Punti da conservare quando lo adatti:

-   **Invia sempre `language`.** La documentazione di BroadNet avverte che altrimenti l’arabo può tornare traslitterato in caratteri latini. Usa `ar` con il modello arabo, oppure passa a `broadnet/cohere-transcribe` con il codice giusto per una delle sue 14 lingue.
-   **Restituisci errori generici.** La prima versione del nostro proxy di test rimandava indietro l’errore di ffmpeg, che conteneva un percorso di file del server. Il codice sopra restituisce invece «Could not read the recording.» (traduzione: impossibile leggere la registrazione).
-   **Aggiungi autenticazione e rate limit** prima del deploy. Altrimenti chiunque trovi `/transcribe` spende il tuo saldo. [Sicurezza delle chiavi API LLM](https://broadrouter.com/it/blog/llm-api-key-security/) copre il resto, e le chiavi BroadNet si possono limitare con le [allow-list di IP](https://broadrouter.com/it/guides/api-keys-ip-allow-lists/).
-   **Rifiuta le clip quasi silenziose.** Le segnalazioni sul forum di trascrizioni inventate come «Thank you» o «Bye» riguardano registrazioni silenziose o danneggiate. Controlla la durata (byte del WAV ÷ 32.000) e, se puoi, il livello del segnale prima di pagarla.

## Come l’abbiamo testato?

Non abbiamo usato nessuna chiave BroadNet. Il 2026-11-15 abbiamo eseguito il codice sopra contro un mock locale di `/v1/audio/transcriptions`:

1.  **Encoder in Node.** `encodeWav` su un secondo di tono a 440 Hz con due campioni saturati ha prodotto 32.044 byte. Il modulo `wave` di Python l’ha letto come 1 canale, 16.000 Hz, campioni da 2 byte, 16.000 frame, e ffmpeg come `pcm_s16le, 16000 Hz, mono`. I campioni saturati sono usciti come 32767 e −32768.
2.  **Percorso nel browser in Chromium.** Playwright ha avviato Chromium headless con un microfono finto. `startRecording` ha registrato 3 secondi come `audio/webm;codecs=opus` (40.563 byte), e `toWav16k` li ha trasformati in un WAV da 96.044 byte: 3,0 secondi, 16 kHz, mono.
3.  **Proxy.** Sia il WAV sia il WebM grezzo hanno restituito 200. Il mock ha ricevuto ogni volta l’autenticazione `Bearer`, l’ID del modello arabo, `language=ar` e un file `audio/wav` mono a 16 kHz; ffmpeg ha convertito il WebM sul server. Un WAV da 26.214.401 byte ha ricevuto 413 senza alcuna chiamata a monte. Un corpo che non era audio ha ricevuto 400.
4.  **Origine non sicura.** Caricata dall’indirizzo LAN della macchina in HTTP semplice, la pagina ha riportato `isSecureContext` false e `startRecording` ha lanciato il nostro messaggio sull’HTTPS invece di un `TypeError`.

Non abbiamo testato Safari né Firefox, né una trascrizione reale. Prova su un iPhone vero prima di andare in produzione.

## Quanto costa?

BroadNet fattura la trascrizione per minuto di audio: $0.0042 per Transcribe Arabic e $0.002 per il modello multilingue. Un’ora di messaggi vocali in arabo costa $0.25. Entrambi funzionano con il credito iniziale di $5, che copre circa 1,190 minuti di arabo. Per i tuoi volumi, usa il [calcolatore dei costi speech-to-text](https://broadrouter.com/tools/speech-to-text-cost-calculator/). La [guida all’acquisto di API speech-to-text in arabo](https://broadrouter.com/it/blog/arabic-speech-to-text-api-buyers-guide/) confronta i provider.

## Dove si colloca BroadNet Inference

BroadRouter è il sito di BroadNet. BroadNet Inference trascrive file caricati: WAV o MP3, una richiesta per file, con una risposta JSON che contiene il testo. Non documenta trascrizione dal vivo o in streaming, timestamp né etichette dei parlanti. Se la tua app deve mostrare le parole mentre l’utente parla, usa un provider con un’API vocale in streaming. Per messaggi vocali, note e moduli, dove l’utente registra e poi invia, il flusso di upload qui sopra è tutto ciò che serve. La configurazione è nella [guida all’API speech-to-text in arabo](https://broadrouter.com/it/guides/arabic-speech-to-text-api/), e il [riferimento API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-record-browser-audio-transcription-api&utm_content=body) elenca i campi. La sua informativa privacy dichiara che audio e trascrizioni non vengono conservati.

Strumenti gratuiti sul tema (in inglese)

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

[Strumenti gratuiti (in inglese)](https://broadrouter.com/tools/)

## Termini in questo articolo

[WAV (file audio WAV)](https://broadrouter.com/it/glossary/wav/)

WAV (Waveform Audio File Format, o WAVE) è un contenitore audio basato sul formato RIFF di Microsoft e IBM. Di solito contiene campioni PCM lineari non compressi, quindi la sua dimensione è prevedibile: frequenza di campionamento per byte per campione per canali, al secondo.

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

Lo speech-to-text, detto anche riconoscimento automatico del parlato (ASR), è la tecnologia che converte l’audio parlato in testo scritto. Un’API speech-to-text riceve un file o uno stream audio e restituisce una trascrizione, di solito a prezzo per minuto di audio. L’accuratezza si misura con il word error rate e varia con accento, dialetto e qualità della registrazione.

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

Lo streaming è un modo di restituire la risposta di un modello linguistico in piccoli pezzi mentre viene ancora generata, invece che in un’unica risposta alla fine. Le API compatibili con OpenAI trasmettono in streaming tramite server-sent event quando la richiesta imposta stream a true.

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

Ogg Opus è audio codificato con il codec Opus (RFC 6716) e salvato in un container Ogg (RFC 7845). È pensato per il parlato e l’audio interattivo a bitrate bassi, ed è il formato che WhatsApp usa per i messaggi vocali, di solito come file .ogg o .opus.

[Chiave API (API key)](https://broadrouter.com/it/glossary/api-key/)

Una chiave API è una stringa segreta che identifica e autorizza un client che chiama un’API. Le API LLM di solito la vogliono in un header Authorization: Bearer, e chiunque possieda la chiave può fare richieste fatturate all’account a cui appartiene.

[Frequenza di campionamento (sample rate)](https://broadrouter.com/it/glossary/sample-rate/)

La frequenza di campionamento (sample rate) è il numero di campioni audio acquisiti al secondo, misurato in hertz (Hz). I modelli di riconoscimento vocale si aspettano di solito audio mono a 16.000 Hz (16 kHz). Insieme a profondità di bit e numero di canali, determina quanto pesa al minuto un file audio non compresso.

[Rate limit (limite di frequenza)](https://broadrouter.com/it/glossary/rate-limit/)

Un rate limit è un tetto che un’API pone a quanto un client può usarla in un intervallo di tempo, per esempio richieste al minuto o token al minuto. Le richieste oltre il limite vengono rifiutate, di solito con HTTP 429 Too Many Requests, finché l’uso non torna sotto la soglia.

[Tool calling (chiamata di strumenti)](https://broadrouter.com/it/glossary/tool-calling/)

Il tool calling, detto anche function calling, è una funzionalità delle API LLM in cui il modello restituisce una richiesta strutturata di eseguire una funzione definita dallo sviluppatore, con argomenti JSON. L’applicazione esegue la funzione e rimanda il risultato; il modello non esegue mai codice da solo.

## Domande frequenti

### Posso inviare il file WebM di MediaRecorder direttamente a un’API speech-to-text?

Solo se l’API accetta WebM. L’endpoint di trascrizione di OpenAI elenca webm e mp4 tra i formati. BroadNet accetta solo WAV e MP3, quindi converti prima: nel browser con la Web Audio API, oppure sul server con ffmpeg -i in.webm -ar 16000 -ac 1 out.wav.

### Perché getUserMedia dice che navigator.mediaDevices è undefined?

La pagina non è in un contesto sicuro. Secondo MDN getUserMedia funziona solo via HTTPS, su localhost o da URL file. In HTTP semplice da un altro host, navigator.mediaDevices non esiste. Servi la pagina in HTTPS; per lo sviluppo localhost va bene.

### Quanto dura una registrazione WAV che sta in un upload da 25 MB?

Un WAV mono a 16 kHz e 16 bit occupa 32.000 byte al secondo più un’intestazione di 44 byte. Il limite di 26.214.400 byte di BroadNet contiene circa 819 secondi, cioè 13 minuti e 39 secondi. Con MP3 o una frequenza di campionamento più bassa ci sta di più; per audio più lunghi, dividili in parti.

### Perché da una registrazione vuota su iPhone ottengo «Thank you» o «Bye»?

Alcuni sviluppatori sul forum di OpenAI segnalano brevi frasi inventate da registrazioni silenziose o danneggiate, e hanno ricondotto i casi iOS a chunk dataavailable vuoti; filtrare i chunk di dimensione 0 e avviare il registratore con un timeslice ha risolto il problema. Controlla la durata prima dell’upload.

### Il browser deve chiamare direttamente l’API di trascrizione?

No. Qualsiasi cosa nel codice frontend, chiave API compresa, è leggibile dall’utente. Invia l’audio a un tuo endpoint, che controlla dimensione e tipo, aggiunge la chiave da una variabile d’ambiente e lo inoltra.

## Continua a leggere

-   [Trascrivere audio lunghi oltre 25 MB: dividere, inviare, ricucire](https://broadrouter.com/it/blog/transcribe-long-audio-files-api/)
-   [Alternative all’API Whisper: quando cambiare e come provarle](https://broadrouter.com/it/blog/whisper-api-alternative/)
-   [API speech-to-text multilingue: 14 lingue, un solo endpoint](https://broadrouter.com/it/blog/multilingual-speech-to-text-api/)
-   [Chiavi API LLM sicure: conservazione, rotazione e IP consentiti](https://broadrouter.com/it/blog/llm-api-key-security/)
-   [API speech-to-text per l’arabo: come sceglierla nel 2026](https://broadrouter.com/it/blog/arabic-speech-to-text-api-buyers-guide/)
-   [Trascrivere i vocali per le aziende: da WhatsApp e Telegram ai ticket](https://broadrouter.com/it/blog/voice-notes-to-text-for-business/)
-   [Hardware GPU e serving di BroadNet, come li descrive BroadNet](https://broadrouter.com/it/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache delle risposte delle API LLM: una cache esatta in Python](https://broadrouter.com/it/blog/cache-llm-responses-cut-cost/)
-   [Guida: Trascrivere i vocali WhatsApp in testo con un’API](https://broadrouter.com/it/guides/transcribe-whatsapp-voice-notes/)
-   [Guida: API speech-to-text in arabo, passo dopo passo](https://broadrouter.com/it/guides/arabic-speech-to-text-api/)
-   [Guida: Usare l’SDK Node.js di OpenAI con BroadNet Inference](https://broadrouter.com/it/guides/openai-node-sdk/)

Provalo sul tuo carico di lavoro reale. I nuovi account partono con USD 5 di credito per Gemma e trascrizione. DeepSeek, GLM e Qwen3.8 richiedono una ricarica.

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

**Fonti**

-   [Riferimento API di BroadNet Inference: WAV (audio/wav) o MP3 (audio/mpeg) fino a 26.214.400 byte, inviare sempre language, risposta JSON con text (verifica del 2026-11-15) (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-record-browser-audio-transcription-api&utm_content=sources)
-   [MDN, MediaDevices.getUserMedia(): solo contesti sicuri, permesso dell’utente, NotAllowedError (verifica del 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)
-   [MDN, MediaRecorder.isTypeSupported(): true non garantisce che la registrazione riesca (verifica del 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/MediaRecorder/isTypeSupported_static)
-   [MDN, evento dataavailable di MediaRecorder: timeslice, stop() e intervalli non esatti (verifica del 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/MediaRecorder/dataavailable_event)
-   [MDN, BaseAudioContext.decodeAudioData(): ricampiona alla frequenza del contesto, solo file completi (verifica del 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/BaseAudioContext/decodeAudioData)
-   [MDN, costruttore OfflineAudioContext(): sampleRate da 3.000 a 768.000 Hz (verifica del 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/API/OfflineAudioContext/OfflineAudioContext)
-   [Blog di WebKit, API MediaRecorder: Safari registra MP4 con video H.264 e audio AAC, formati rilevabili a runtime (verifica del 2026-11-15)](https://webkit.org/blog/11353/mediarecorder-api/)
-   [Guida speech-to-text di OpenAI: flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav e webm, file fino a 25 MB (verifica del 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», da luglio a dicembre 2024 (verifica del 2026-11-15)](https://community.openai.com/t/mediarecorder-api-w-whisper-not-working-on-mobile-browsers/866019)
