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ì:
- Esegui il filtro silencedetect di ffmpeg per elencare i silenzi.
- Scorri la registrazione. Quando un pezzo arriva a circa 10 minuti, taglia al silenzio successivo.
- 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). Usabroadnet/cohere-transcribecon il codice di lingua giusto per l’inglese, il francese o una qualsiasi delle altre lingue supportate. - Soglie.
-35dBe0.5secondi 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.maprestituisce 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.
