BroadRouter

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

A cura del team di BroadNet Inference · 6 min di lettura · Pubblicato

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.

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.

Passo 1: come si riduce il file?

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

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 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. A mano funziona così:

  1. Esegui il filtro silencedetect 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 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.

# 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.
  • 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 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; per confrontare i provider, vedi il dataset dei prezzi delle API speech-to-text.

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 e timestamp gestiscono anche i file lunghi in modo più diretto; la guida all’acquisto di un’API speech-to-text per l’arabo li confronta. Per le registrazioni di chiamate stereo, dividi per canale invece che per tempo: la pipeline per call center 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. 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 copre la prima richiesta; questo articolo copre i file troppo grandi per una sola.

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.

Leggi in MarkdownChiedi a ChatGPTChiedi a ClaudeChiedi a Perplexity