---
title: "Trascrivere audio oltre 25 MB via API: dividi e ricuci"
description: "Come trascrivere registrazioni oltre il limite di un’API speech-to-text: riduci il file, dividilo sui silenzi con ffmpeg, invia i pezzi in parallelo e ricuci."
url: https://broadrouter.com/it/blog/transcribe-long-audio-files-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/transcribe-long-audio-files-api/) (aggiornato il 2026-11-15).

# Trascrivere audio lunghi oltre 25 MB: dividere, inviare, ricucire

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

La maggior parte delle API di trascrizione rifiuta un singolo file oltre circa 25 MB. Per prima cosa converti la registrazione in mono a 16 kHz: già così nel limite di 26.214.400 byte di BroadNet entrano circa 13 minuti di WAV o 54 minuti di MP3 a 64 kbit/s. Per audio più lunghi, dividi sui silenzi con ffmpeg, trascrivi i pezzi in parallelo e unisci il testo in ordine.

## Punti chiave

-   Il limite è in byte, non in minuti. Un WAV mono a 16 kHz occupa 32.000 byte al secondo, quindi 26.214.400 byte sono circa 13,6 minuti; un MP3 a 64 kbit/s circa 54 minuti.
-   Dividi per tempo in corrispondenza di un silenzio, mai a un offset in byte. Un taglio in byte rompe i frame audio, e un taglio a metà parola fa perdere parole.
-   Tieni i pezzi ben sotto il limite, per esempio 10 minuti di WAV, così un file rumoroso non restituisce mai 413.
-   Invia i pezzi in parallelo fino al limite della chiave: 4 richieste in corso e 30 al minuto con una chiave BroadNet a consumo.
-   Dividere non cambia la durata dell’audio che paghi. Un’ora di arabo costa $0.25 su BroadNet Transcribe Arabic.

**In questa pagina**

1.  Perché una registrazione lunga fallisce?
2.  Passo 1: come si riduce il file?
3.  Passo 2: come si divide l’audio senza tagliare le parole?
4.  Com’è lo script completo?
5.  Quanti pezzi si possono inviare insieme?
6.  Serve una sovrapposizione tra i pezzi?
7.  Il pezzo successivo può usare il testo del precedente come contesto?
8.  Quanto costa un file lungo?
9.  Quali errori evitare?
10.  Quando dividere in pezzi è lo strumento sbagliato?
11.  Dove si inserisce BroadNet Inference

La maggior parte delle API speech-to-text accetta un file di circa 25 MB per richiesta. BroadNet Inference accetta WAV o MP3 fino a 26.214.400 byte. Una riunione lunga, una lezione o un podcast superano facilmente questa soglia, e la richiesta fallisce con 413. La soluzione ha quattro passi: ridurre il file, dividerlo sui silenzi, inviare i pezzi in parallelo e ricucire il testo.

## Perché una registrazione lunga fallisce?

Il limite è in byte, non in minuti. Quanti minuti ci stanno dipende dal formato:

| Formato | Byte al secondo | Quanto sta in 26.214.400 byte |
| --- | --- | --- |
| WAV, 44,1 kHz stereo, 16 bit | 176.400 | Circa 2,5 minuti |
| WAV, 16 kHz mono, 16 bit | 32.000 | Circa 13,6 minuti |
| MP3, 64 kbit/s | 8.000 | Circa 54 minuti |
| MP3, 32 kbit/s | 4.000 | Circa 109 minuti |

Sono semplici moltiplicazioni: byte al secondo per secondi. Una registrazione da telefono o da laptop è spesso stereo a 44,1 o 48 kHz, e riempie il limite in pochi minuti. Per il parlato non serve. Convertire prima in mono a 16 kHz è il guadagno più grande in assoluto.

Quando un file è ancora troppo grande, l’API lo rifiuta senza appello. Su BroadNet la risposta è 413, “the request exceeds the endpoint byte or text limit” (traduzione: la richiesta supera il limite di byte o di testo dell’endpoint), e non viene trascritto nulla. Vedi la [guida ai codici di errore](https://broadrouter.com/it/guides/errors-and-retries/).

## Passo 1: come si riduce il file?

Converti in mono a 16 kHz prima di qualsiasi altra cosa. Basta un comando ffmpeg:

```bash
ffmpeg -i meeting.m4a -ac 1 -ar 16000 meeting.wav
```

Per BroadNet, l’output deve essere WAV (`audio/wav`) o MP3 (`audio/mpeg`). Formati come `.m4a`, `.ogg` e `.webm` vanno comunque convertiti, quindi fai il ricampionamento nello stesso passaggio.

Meglio WAV o MP3? Il WAV è lossless, quindi non si perde nulla, ma riempie il limite in circa 13 minuti. L’MP3 a 64 kbit/s fa stare quattro volte più audio in una richiesta, ma è lossy. Se usi l’MP3, fai una prova breve: trascrivi gli stessi cinque minuti in WAV e in MP3 e confronta il testo. La voce [frequenza di campionamento](https://broadrouter.com/it/glossary/sample-rate/) spiega perché 16 kHz bastano per il parlato.

## Passo 2: come si divide l’audio senza tagliare le parole?

Dividi per tempo, mai per byte. Un taglio a un offset in byte può cadere a metà di un frame audio, e il file non si decodifica. Un taglio a tempo fisso può cadere a metà di una parola. La stessa guida di OpenAI sconsiglia di dividere a metà frase perché «can remove context and reduce accuracy» (traduzione: può eliminare contesto e ridurre l’accuratezza).

Il metodo affidabile è tagliare dentro un silenzio vicino alla lunghezza obiettivo. Per avere comandi pronti per la dimensione e la durata del tuo file, usa il [generatore gratuito di comandi per dividere l’audio](https://broadrouter.com/tools/audio-splitter-ffmpeg/). A mano funziona così:

1.  Esegui il filtro [silencedetect](https://ffmpeg.org/ffmpeg-filters.html) di ffmpeg per elencare i silenzi.
2.  Scorri la registrazione. Quando un pezzo arriva a circa 10 minuti, taglia al silenzio successivo.
3.  Taglia ogni pezzo con ffmpeg, da un punto di taglio al successivo.

Dieci minuti di WAV mono a 16 kHz sono 19,2 MB, che lasciano margine sotto il limite. Se qualcuno parla a lungo senza pause, lo script qui sotto taglia invece al massimo rigido.

Anche il [segment muxer](https://ffmpeg.org/ffmpeg-formats.html) di ffmpeg può dividere un file in pezzi «of nearly fixed duration» (traduzione: di durata quasi fissa) con un solo comando. È veloce, ma non cerca i silenzi, quindi usalo solo quando una parola persa a ogni confine è accettabile, oppure aggiungi una sovrapposizione (vedi sotto).

## Com’è lo script completo?

Questo script Python converte, divide sui silenzi, invia fino a quattro pezzi alla volta e unisce il testo. Usa l’SDK di OpenAI puntato su BroadNet Inference.

```python
# pip install openai
import os, re, subprocess, tempfile
from concurrent.futures import ThreadPoolExecutor
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
TARGET, HARD_MAX = 600, 750   # seconds: aim for 10 min, never above 12.5 min

def run(*args):
    return subprocess.run(args, capture_output=True, text=True, check=True)

def silences(path):
    """Midpoints (in seconds) of silent gaps of 0.5 s or more."""
    out = run("ffmpeg", "-i", path, "-af", "silencedetect=noise=-35dB:d=0.5",
              "-f", "null", "-").stderr
    starts = [float(x) for x in re.findall(r"silence_start: ([\d.]+)", out)]
    ends = [float(x) for x in re.findall(r"silence_end: ([\d.]+)", out)]
    return [(s + e) / 2 for s, e in zip(starts, ends)]

def duration(path):
    return float(run("ffprobe", "-v", "error", "-show_entries", "format=duration",
                     "-of", "csv=p=0", path).stdout)

def cut_points(path):
    total, gaps, cuts, last = duration(path), silences(path), [0.0], 0.0
    while total - last > HARD_MAX:
        ok = [g for g in gaps if last + TARGET <= g <= last + HARD_MAX]
        last = ok[0] if ok else last + HARD_MAX   # no silence: hard cut
        cuts.append(last)
    return cuts + [total]

def transcribe(chunk):
    with open(chunk, "rb") as f:
        return client.audio.transcriptions.create(
            model="broadnet/cohere-transcribe-arabic", file=f, language="ar").text

def transcribe_long(src):
    with tempfile.TemporaryDirectory() as tmp:
        wav = os.path.join(tmp, "full.wav")
        run("ffmpeg", "-y", "-i", src, "-ac", "1", "-ar", "16000", wav)
        cuts, chunks = cut_points(wav), []
        for i, (a, b) in enumerate(zip(cuts, cuts[1:])):
            out = os.path.join(tmp, f"part{i:03d}.wav")
            run("ffmpeg", "-y", "-i", wav, "-ss", str(a), "-to", str(b), out)
            chunks.append(out)
        with ThreadPoolExecutor(max_workers=4) as pool:   # map() keeps order
            return "\n".join(pool.map(transcribe, chunks))

print(transcribe_long("meeting.m4a"))
```

Note sullo script:

-   **Lingua.** La documentazione di BroadNet dice di inviare sempre `language`; senza, l’arabo «can otherwise be transliterated into Latin letters» (traduzione: altrimenti può essere traslitterato in caratteri latini). Usa `broadnet/cohere-transcribe` con il codice di lingua giusto per l’inglese, il francese o una qualsiasi delle altre [lingue supportate](https://broadrouter.com/it/blog/multilingual-speech-to-text-api/).
-   **Soglie.** `-35dB` e `0.5` secondi vanno bene per una stanza silenziosa. Gli ambienti rumorosi richiedono un valore di rumore più alto, per esempio `-30dB`. Stampa una volta i punti di taglio e controllali.
-   **Ordine.** `pool.map` restituisce i risultati nell’ordine di input, quindi il testo si unisce nella sequenza giusta anche se i pezzi finiscono in momenti diversi.

## Quanti pezzi si possono inviare insieme?

Quanti ne consente la tua chiave. Una chiave BroadNet a consumo consente 4 richieste in corso e 30 richieste al minuto, ed è per questo che lo script usa quattro worker. Una quinta richiesta contemporanea riceve 429. Ripeti le risposte 429 e 5xx con backoff esponenziale; non ripetere le 413, perché lo stesso file fallirà di nuovo. [Come gestire gli errori 429](https://broadrouter.com/it/blog/handle-llm-api-429-rate-limits/) contiene un helper di retry da avvolgere attorno a `transcribe()`.

Con quattro worker, una registrazione di due ore in pezzi da 10 minuti diventa 12 richieste in tre ondate. Il tempo totale è più o meno quello di tre andata-e-ritorno, non di dodici.

## Serve una sovrapposizione tra i pezzi?

No, se tagli dentro i silenzi: al confine non c’è parlato da perdere. La sovrapposizione serve per i tagli a tempo fisso. Fai iniziare ogni pezzo un secondo o due prima della fine del precedente, poi togli le parole ripetute quando unisci il testo. Il modo classico è confrontare le ultime parole di un pezzo con le prime del successivo ed eliminare la corrispondenza.

La sovrapposizione costa un po’. Due secondi per ogni pezzo da 10 minuti aggiungono circa lo 0,3% all’audio che paghi.

## Il pezzo successivo può usare il testo del precedente come contesto?

Alcune API lo consentono. OpenAI elenca «carrying context from a previous chunk of a longer recording» (traduzione: portare il contesto da un pezzo precedente di una registrazione più lunga) tra gli usi del suo parametro `prompt`. Il riferimento API di BroadNet elenca per la trascrizione solo `model`, `language` e `file`, e restituisce un JSON con un campo `text`. Quindi su BroadNet tratta ogni pezzo come indipendente e correggi nomi e termini dopo. Una correzione economica è inviare la trascrizione unita a un modello chat con un elenco delle grafie corrette di persone, prodotti e luoghi.

## Quanto costa un file lungo?

Lo speech-to-text si paga al minuto di audio, quindi dividere non cambia il totale. Alle tariffe pubblicate da BroadNet:

| Audio | BroadNet Transcribe Arabic | BroadNet Transcribe (14 lingue) |
| --- | --- | --- |
| Prezzo al minuto | $0.0042 | $0.002 |
| Un’ora | $0.25 | $0.12 |
| 1.000 ore | $252.00 | $120.00 |

La pagina prezzi indica un prezzo al minuto di audio e non dice nulla su minimi per file o arrotondamenti. Controlla la pagina di utilizzo dopo il primo batch per verificare che il totale corrisponda alla durata dell’audio. Entrambi i modelli di trascrizione sono disponibili con il credito iniziale gratuito di $5, che copre circa 1,190 minuti di arabo. Per stimare i tuoi volumi usa il [calcolatore dei costi speech-to-text](https://broadrouter.com/tools/speech-to-text-cost-calculator/); per confrontare i provider, vedi il [dataset dei prezzi delle API speech-to-text](https://broadrouter.com/data/speech-to-text-api-prices/).

## Quali errori evitare?

-   **Inviare il file originale.** Un WAV stereo a 48 kHz è sei volte più grande del necessario.
-   **Tagliare a offset in byte.** Il pezzo non si decodifica, oppure il primo secondo è rumore.
-   **Pezzi proprio al limite.** Un pezzo da 25,9 MB passa oggi e fallisce quando una registrazione è un po’ più forte. Lascia margine.
-   **Parallelismo senza limiti.** Lanciare 50 pezzi insieme fa prendere un 429 alla maggior parte. Limita i worker al numero di richieste in corso consentite dalla chiave.
-   **Dimenticare la lingua.** Ogni pezzo è una richiesta separata, quindi ognuno ha bisogno di `language`.

## Quando dividere in pezzi è lo strumento sbagliato?

Se ti servono etichette dei parlanti o timestamp per parola, dividere in pezzi un’API che restituisce solo testo non te li darà. La risposta di trascrizione di BroadNet è solo testo. I provider che restituiscono [diarizzazione](https://broadrouter.com/it/glossary/diarization/) e [timestamp](https://broadrouter.com/it/glossary/timestamps-asr/) gestiscono anche i file lunghi in modo più diretto; la [guida all’acquisto di un’API speech-to-text per l’arabo](https://broadrouter.com/it/blog/arabic-speech-to-text-api-buyers-guide/) li confronta. Per le registrazioni di chiamate stereo, dividi per canale invece che per tempo: la [pipeline per call center](https://broadrouter.com/it/blog/transcribe-call-center-recordings/) mostra come.

## Dove si inserisce BroadNet Inference

BroadNet Transcribe Arabic costa $0.0042 al minuto, e BroadNet lo dà #2 su 37 (dato di settembre 2026; la classifica in tempo reale lo indicava #4 su 39 il 15 novembre 2026) nella [Open Universal Arabic ASR Leaderboard](https://huggingface.co/spaces/elmresearchcenter/open_universal_arabic_asr_leaderboard). Audio e trascrizioni non vengono conservati dopo la richiesta. È adatto alla trascrizione batch di lunghe registrazioni in arabo, una volta divise come sopra. Non fa per te se ti servono timestamp, etichette dei parlanti o streaming dal vivo nella stessa API. La [guida allo speech-to-text in arabo](https://broadrouter.com/it/guides/arabic-speech-to-text-api/) copre la prima richiesta; questo articolo copre i file troppo grandi per una sola.

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

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

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

[Pagamento a consumo (pay-as-you-go)](https://broadrouter.com/it/glossary/pay-as-you-go/)

Il pagamento a consumo è un modello di prezzo in cui paghi solo ciò che usi, misurato per unità come token, richieste o minuti di audio, senza abbonamento né impegno minimo. La maggior parte delle API LLM fattura così, da un saldo prepagato o con una fattura periodica.

[Speaker diarization (diarizzazione del parlato)](https://broadrouter.com/it/glossary/diarization/)

La speaker diarization è il compito di dividere una registrazione audio in segmenti per parlante, rispondendo a "chi ha parlato e quando". Etichetta ogni tratto di parlato con un ID anonimo come SPEAKER\_00 e di solito si combina con una trascrizione per mostrare chi ha detto ogni battuta.

[Concorrenza (concurrency)](https://broadrouter.com/it/glossary/concurrency/)

La concorrenza è il numero di richieste che un client ha in corso nello stesso momento. Le API LLM spesso la limitano per chiave o per piano, separatamente dalle richieste al minuto, perché ogni richiesta aperta occupa capacità GPU finché la sua risposta non è terminata.

[Prefill e decode](https://broadrouter.com/it/glossary/prefill-and-decode/)

Prefill e decode sono le due fasi dell’inferenza di un LLM. Nel prefill il modello elabora tutto il prompt in parallelo e riempie la sua KV cache; nel decode genera la risposta un token alla volta, riusando quella cache. Il prefill determina soprattutto il tempo al primo token; il decode la velocità di output.

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

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

## Domande frequenti

### Come trascrivo un file audio più grande di 25 MB?

Prima convertilo in mono a 16 kHz, che spesso basta a farlo stare nel limite. Se è ancora troppo grande, dividilo con ffmpeg in pezzi di circa 10 minuti nei punti di silenzio, trascrivi ogni pezzo con la stessa impostazione di lingua e unisci i testi in ordine.

### Quanti minuti di audio stanno in 25 MB?

Dipende dal formato. Un WAV mono a 16 kHz e 16 bit usa 32.000 byte al secondo, quindi 26.214.400 byte contengono circa 13,6 minuti. Un MP3 a 64 kbit/s ne contiene circa 54. Un WAV stereo o a 44,1 kHz ne contiene molti meno.

### Che cosa succede se carico un file oltre il limite?

La richiesta viene rifiutata. BroadNet Inference restituisce 413, che la sua documentazione definisce come una richiesta che supera il limite di byte o di testo dell’endpoint. Non viene trascritto nulla, quindi dividi e reinvia.

### Perdo parole ai confini tra i pezzi?

Può succedere, se tagli a un tempo fisso nel mezzo del parlato. Taglia invece dentro un silenzio. Se devi tagliare a tempo fisso, sovrapponi i pezzi di un secondo o due e togli le parole ripetute quando li unisci.

### Dividere un file costa di più?

Paghi i minuti di audio, quindi la durata totale è la stessa. La pagina prezzi di BroadNet indica un prezzo al minuto di audio e non menziona minimi per file né arrotondamenti; controlla la pagina di utilizzo dopo il primo batch per conferma.

### Posso inviare il testo del pezzo precedente come contesto?

Alcune API prevedono un prompt per questo; OpenAI cita il passaggio di contesto da un pezzo precedente tra gli usi del suo parametro prompt. La documentazione di BroadNet elenca solo model, language e file, quindi lì non contare su un prompt.

## Continua a leggere

-   [Trascrivere le chiamate del call center: pipeline pronta per l’arabo](https://broadrouter.com/it/blog/transcribe-call-center-recordings/)
-   [API speech-to-text multilingue: 14 lingue, un solo endpoint](https://broadrouter.com/it/blog/multilingual-speech-to-text-api/)
-   [API speech-to-text per l’arabo: come sceglierla nel 2026](https://broadrouter.com/it/blog/arabic-speech-to-text-api-buyers-guide/)
-   [Alternative all’API Whisper: quando cambiare e come provarle](https://broadrouter.com/it/blog/whisper-api-alternative/)
-   [Prezzi delle API speech-to-text a confronto: costo al minuto (2026)](https://broadrouter.com/it/blog/speech-to-text-api-pricing-compared/)
-   [Sottotitoli in arabo (SRT) da un’API speech-to-text: cosa serve](https://broadrouter.com/it/blog/arabic-subtitles-srt-api/)
-   [Registrare audio nel browser e inviarlo a un’API speech-to-text](https://broadrouter.com/it/blog/record-browser-audio-transcription-api/)
-   [Tradurre audio arabo in testo inglese con un’API: una pipeline testata](https://broadrouter.com/it/blog/translate-arabic-audio-to-english/)
-   [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: API speech-to-text in arabo, passo dopo passo](https://broadrouter.com/it/guides/arabic-speech-to-text-api/)
-   [Guida: Trascrivere i vocali WhatsApp in testo con un’API](https://broadrouter.com/it/guides/transcribe-whatsapp-voice-notes/)
-   [Guida: Codici di errore di BroadNet Inference e quando ritentare](https://broadrouter.com/it/guides/errors-and-retries/)

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-transcribe-long-audio-files-api&utm_content=page-cta) ·

**Fonti**

-   [Riferimento API di BroadNet Inference: WAV o MP3 fino a 26.214.400 byte, campo language, errori 413 e 429, limiti a consumo (consultato il 2026-11-15) (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-transcribe-long-audio-files-api&utm_content=sources)
-   [Pagina prezzi di BroadNet Inference, prezzo di trascrizione al minuto di audio (consultata il 2026-11-15) (in inglese)](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-transcribe-long-audio-files-api&utm_content=sources)
-   [Guida speech-to-text di OpenAI: limite di 25 MB per file, divisione in blocchi, evitare tagli a metà frase (consultata il 2026-11-15)](https://developers.openai.com/api/docs/guides/speech-to-text)
-   [Documentazione dei formati FFmpeg, segment muxer (consultata il 2026-11-15)](https://ffmpeg.org/ffmpeg-formats.html)
-   [Open Universal Arabic ASR Leaderboard su Hugging Face (posizione dichiarata da BroadNet; verificata da BroadRouter il 2026-11-15)](https://huggingface.co/spaces/elmresearchcenter/open_universal_arabic_asr_leaderboard)
-   [Documentazione dei filtri FFmpeg, silencedetect (consultata il 2026-11-15)](https://ffmpeg.org/ffmpeg-filters.html)
