I sottotitoli sono testo con dei tempi associati. In una pipeline di sottotitoli in arabo, gran parte del lavoro consiste nell’ottenere quei tempi. Alcune API speech-to-text te li forniscono come timestamp per parola o come file SRT già pronto. Altre, tra cui BroadNet Inference, restituiscono solo il testo della trascrizione. Questo articolo spiega cosa serve a un file SRT, quali provider documentano i timestamp e come costruire sottotitoli in arabo utilizzabili da un’API solo testo, dichiarando chiaramente i limiti.
BroadRouter è il sito di BroadNet. Se ti serve una temporizzazione precisa al fotogramma, la risposta onesta qui sotto è un provider con timestamp per parola, non BroadNet.
Che cosa serve a un file SRT?
Un file SRT (SubRip) è testo semplice. Ogni sottotitolo ha quattro parti: un numero, una riga con i tempi, una o due righe di testo e una riga vuota.
1
00:00:00,000 --> 00:00:02,800
مرحباً بكم في الحلقة الأولى
2
00:00:03,600 --> 00:00:07,600
اليوم نتحدث عن تحويل الكلام إلى نص وكيف
نصنع ملف ترجمة مصاحبة
La descrizione del formato della Library of Congress indica il formato del tempo come ore:minuti:secondi,millisecondi e la freccia come due trattini e una parentesi angolare chiusa. Dice anche che SRT è “not well standardized” (traduzione: non ben standardizzato) e che i file SRT “do not have a character encoding standard” (traduzione: non hanno uno standard di codifica dei caratteri). Per l’arabo scrivi in UTF-8 e fai un test nel player di destinazione. WebVTT, il suo successore per il web, usa un punto invece della virgola prima dei millisecondi.
Quindi il requisito imprescindibile è un tempo di inizio e di fine per ogni sottotitolo. Il solo testo non basta.
Quanto dovrebbe essere lunga una riga di sottotitolo in arabo?
Usa una guida di stile pubblicata invece di andare a intuito. L’Arabic Timed Text Style Guide di Netflix (registro delle modifiche datato 2025-12-19) stabilisce:
| Regola | Valore Netflix |
|---|---|
| Caratteri per riga | 42 |
| Righe per sottotitolo | Al massimo due |
| Velocità di lettura, programmi per adulti | Fino a 20 caratteri al secondo |
| Velocità di lettura, programmi per bambini | Fino a 17 caratteri al secondo |
| Interruzioni di riga | Non separare un verbo dal suo soggetto, una preposizione dal suo nome o un numero da ciò che conta |
I requisiti generali di Netflix aggiungono un minimo di cinque sesti di secondo e un massimo di 7 secondi per sottotitolo. La guida per l’arabo chiede anche l’arabo standard moderno nei sottotitoli tradotti. È una regola di traduzione; la trascrizione di un parlato dialettale resta in dialetto.
Questi numeri si traducono in codice: vai a capo a 42 caratteri, due righe per sottotitolo, un avviso sopra i 20 caratteri al secondo e mai un sottotitolo sullo schermo per più di 7 secondi.
Quali API speech-to-text documentano timestamp o SRT?
Il 15 novembre 2026 abbiamo letto la documentazione attuale di ogni provider. La tabella riporta ciò che documentano, non quanto sia precisa la temporizzazione.
| Provider | Cosa offre la documentazione | Arabo |
|---|---|---|
| OpenAI | response_format srt, vtt o verbose_json, e timestamp_granularities[] per parola o segmento, solo su whisper-1. gpt-4o-transcribe e gpt-4o-mini-transcribe restituiscono solo json |
Non verificato. La pagina delle deprecazioni di OpenAI indica whisper-1, gpt-4o-transcribe, gpt-4o-mini-transcribe e gpt-4o-transcribe-diarize come deprecati, tutti in spegnimento il 26 febbraio 2027, e consiglia al loro posto gpt-transcribe o gpt-live-transcribe |
| AssemblyAI | GET /v2/transcript/{transcript_id}/srt o /vtt, con chars_per_caption |
Arabo elencato su Universal-2, nella fascia di WER tra il 10 e il 25% |
| Speechmatics | format=srt sull’endpoint della trascrizione; srt_overrides con max_line_length e max_lines; le voci per parola riportano start_time ed end_time |
Arabo, più un pacchetto arabo-inglese ar_en |
| Deepgram | Timestamp per parola e per enunciato; librerie ufficiali Python e JavaScript per sottotitoli che scrivono SRT e WebVTT | Arabo e codici regionali su Nova-3 |
| ElevenLabs | timestamps_granularity per parola o per carattere; ogni parola ha start ed end in secondi |
Arabo elencato, nella fascia di WER tra il 10 e il 20% |
| BroadNet Inference | Solo {"text": ...} |
Un modello specifico per l’arabo e un modello per 14 lingue |
Se puoi eseguire modelli in autonomia, il filtro whisper di FFmpeg, compilato con whisper.cpp, può scrivere direttamente srt e ha un’opzione max_len per righe più corte.
Per un primo confronto di precisione e prezzo sull’arabo, leggi la guida all’acquisto di API speech-to-text per l’arabo e il confronto dei prezzi speech-to-text. I timestamp sono una riga di quella decisione, non l’unica.
Come si creano sottotitoli da un’API solo testo?
Crei i tuoi timestamp a partire dai punti in cui tagli l’audio. I passaggi:
- Trova le pause.
silencedetectdi FFmpeg registrasilence_startesilence_endin secondi ovunque il livello resti sotto una soglia per un tempo minimo. - Trasforma le pause in intervalli di parlato. Tutto ciò che sta tra due silenzi è un intervallo. Limita gli intervalli a circa 12 secondi, così anche chi parla senza mai fermarsi produce sottotitoli brevi.
- Trascrivi ogni intervallo. Taglialo in un WAV mono a 16 kHz e invialo con
language=ar. - Temporizza i sottotitoli. Inizio e fine dell’intervallo sono i tuoi tempi di ancoraggio. Se il testo richiede più righe, dividi il tempo dell’intervallo tra di esse in proporzione alla loro lunghezza.
- Scrivi l’SRT e verifica lunghezza delle righe, velocità di lettura e durata rispetto alle regole di stile.
È la stessa suddivisione di trascrivere file audio lunghi, con un obiettivo diverso. Lì i chunk durano circa 10 minuti e ti interessa solo il testo unito. Qui i chunk durano pochi secondi perché ognuno diventa tempi di sottotitolo. Lo strumento per dividere l’audio genera i comandi FFmpeg se preferisci dividere a mano.
La pipeline in Python
Questo script usa l’SDK Python di OpenAI e FFmpeg. L’abbiamo eseguito il 15 novembre 2026 contro un server mock locale che risponde come l’endpoint documentato di BroadNet ({"text": ...}), con un file di test generato fatto di toni e pause. L’SRT qui sopra è il suo output. Non è stata usata nessuna chiave BroadNet, quindi il testo arabo proveniva dal mock, non dal modello.
import os, re, subprocess, sys
from openai import OpenAI
FFMPEG = os.environ.get("FFMPEG", "ffmpeg")
client = OpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
api_key=os.environ["BROADNET_API_KEY"])
MODEL = "broadnet/cohere-transcribe-arabic"
MAX_CHARS, MAX_LINES, MAX_CUE, MAX_CPS = 42, 2, 7.0, 20 # Netflix Arabic / general guide values
def find_speech(path, noise="-35dB", min_silence=0.4, max_span=12.0):
"""Return [(start, end)] seconds of speech between silences, each at most max_span long."""
log = subprocess.run([FFMPEG, "-hide_banner", "-nostats", "-i", path,
"-af", f"silencedetect=n={noise}:d={min_silence}", "-f", "null", "-"],
capture_output=True, text=True).stderr
h, m, s = re.search(r"Duration: (\d+):(\d+):([\d.]+)", log).groups()
total = int(h) * 3600 + int(m) * 60 + float(s)
starts = [float(x) for x in re.findall(r"silence_start: (-?[\d.]+)", log)]
ends = [float(x) for x in re.findall(r"silence_end: ([\d.]+)", log)]
spans, t = [], 0.0
for i, s0 in enumerate(starts):
if s0 - t > 0.2:
spans.append((t, s0))
t = ends[i] if i < len(ends) else total
if total - t > 0.2:
spans.append((t, total))
out = []
for a, b in spans: # no pause found: cut at a fixed length
while b - a > max_span:
out.append((a, a + max_span)); a += max_span
out.append((a, b))
return out
def transcribe_span(path, a, b, name):
subprocess.run([FFMPEG, "-hide_banner", "-loglevel", "error", "-y", "-ss", f"{a:.3f}",
"-to", f"{b:.3f}", "-i", path, "-ar", "16000", "-ac", "1", name], check=True)
with open(name, "rb") as f:
return client.audio.transcriptions.create(model=MODEL, file=f, language="ar").text.strip()
def to_cues(text, a, b):
"""Wrap text into lines of <= MAX_CHARS, give each line a share of the span's time
in proportion to its length, then pack lines into cues of <= MAX_LINES and <= MAX_CUE s."""
lines, cur = [], ""
for w in text.split():
if cur and len(cur) + 1 + len(w) > MAX_CHARS:
lines.append(cur); cur = w
else:
cur = f"{cur} {w}".strip()
if cur:
lines.append(cur)
chars = sum(len(l) for l in lines) or 1
cues, t = [], a
for line in lines:
d = (b - a) * len(line) / chars
last = cues[-1] if cues else None
if last and len(last[2]) < MAX_LINES and t + d - last[0] <= MAX_CUE:
last[1] = t + d; last[2].append(line)
else:
cues.append([t, t + d, [line]])
t += d
for c in cues: # a long pause inside a span: don't hold text on screen
c[1] = min(c[1], c[0] + MAX_CUE)
return cues
def ts(x):
ms = round(x * 1000)
return f"{ms // 3600000:02}:{ms // 60000 % 60:02}:{ms // 1000 % 60:02},{ms % 1000:03}"
def make_srt(path, out="out.srt"):
cues = []
for i, (a, b) in enumerate(find_speech(path)):
text = transcribe_span(path, a, b, f"chunk-{i:04}.wav")
if text:
cues += to_cues(text, a, b)
with open(out, "w", encoding="utf-8") as f:
for n, (a, b, g) in enumerate(cues, 1):
cps = len(" ".join(g)) / (b - a)
if b - a > MAX_CUE or cps > MAX_CPS:
print(f"check cue {n}: {b - a:.1f} s, {cps:.0f} chars/s", file=sys.stderr)
f.write(f"{n}\n{ts(a)} --> {ts(b)}\n" + "\n".join(g) + "\n\n")
return len(cues)
if __name__ == "__main__":
print(make_srt(sys.argv[1], sys.argv[2] if len(sys.argv) > 2 else "out.srt"), "cues written")
Eseguilo con BROADNET_API_KEY impostata: python make_srt.py episode.wav episode.srt. Sul file di test, il rilevamento delle pause ha trovato intervalli da 0 a 2,8 s, da 3,6 a 7,6 s, da 8,8 a 28,8 s (tagliato a 12 s perché non aveva pause) e da 29,4 a 30,9 s, in linea con il modo in cui il file era stato costruito. L’output è stato interpretato senza errori dal pacchetto Python srt e convertito in WebVTT con FFmpeg.
Regola due valori in base al tuo audio. noise è il livello che conta come silenzio: prova da -30 a -40 dB per un parlato pulito e valori più alti per stanze rumorose. min_silence è quanto deve durare una pausa: da 0,3 a 0,5 secondi intercetta le pause tra le frasi senza spezzare a ogni respiro.
Quanto è precisa la temporizzazione a livello di chunk?
Sii chiaro su cosa questo metodo può e non può fare.
- I bordi degli intervalli sono la parte migliore. Gli inizi e le fini dei sottotitoli che cadono su una pausa reale sono precisi quanto il rilevamento del silenzio. Sul nostro file di test sintetico coincidevano esattamente; le registrazioni reali, con respiri e rumore ambientale, sono più disordinate.
- I tempi all’interno di un intervallo sono stime. Quando un intervallo contiene due o tre sottotitoli, lo script divide il tempo in base al numero di caratteri. Chi parla non ha un ritmo costante, quindi quei confini interni possono sbagliare di un secondo o più.
- I tagli fissi possono spezzare le parole. Quando un intervallo supera il tetto di 12 secondi senza una pausa, il taglio cade dove capita. Una parola sul taglio può andare persa o risultare storpiata. Alza prima
noiseo abbassamin_silence, così meno intervalli richiedono un taglio fisso. - I chunk brevi danno al modello meno contesto. Una clip di 3 secondi ha meno parole attorno a ogni parola di un file da 10 minuti. Non abbiamo misurato quanto questo cambi la precisione sull’arabo; testalo sul tuo audio con il WER.
- Nessuna etichetta dei parlanti. BroadNet non restituisce diarization, quindi i sottotitoli non dicono chi sta parlando.
- Musica e rumore. La musica di sottofondo può nascondere del tutto le pause. A quel punto la maggior parte degli intervalli sono tagli fissi e la temporizzazione peggiora.
Per lezioni, podcast, webinar e video di formazione, sottotitoli entro un secondo dal parlato di solito sono leggibili. Per fiction, videoclip o qualsiasi contenuto con sincronizzazione labiale, usa un provider con timestamp per parola oppure fai sistemare il file a un sottotitolatore.
Quanto costa e quanto è veloce?
Il prezzo segue la durata dell’audio. Un’ora di arabo su BroadNet Transcribe Arabic costa $0.25, che tu la invii come un unico file o come 720 file da cinque secondi. La pagina dei prezzi di BroadNet indica un prezzo per minuto di audio e nessun minimo per file; controlla la pagina di utilizzo dopo il primo episodio per conferma.
La velocità segue il numero di richieste. Una chiave a consumo consente 30 richieste al minuto e 4 in corso. Un’ora di parlato divisa in intervalli da 5 secondi fa circa 720 richieste, che richiedono almeno 720 ÷ 30 minuti. Intervalli più lunghi significano meno richieste. Se ricevi un 429, attendi e riprova come nella guida a errori e retry, e non dividere un job su più chiavi per aggirare i limiti pubblicati.
Dove si colloca BroadNet Inference
BroadNet Transcribe Arabic è adatto alla metà testuale di un lavoro di sottotitolazione: dal parlato arabo al testo arabo a $0.0042 al minuto, con audio e trascrizioni non conservati dopo la richiesta. Il credito iniziale di $5 copre la trascrizione, quindi puoi testare la pipeline su episodi reali prima di ricaricare. Non restituisce timestamp, segmenti, etichette dei parlanti né SRT. Se i tuoi sottotitoli richiedono una temporizzazione a livello di parola, usa un provider che la documenti, oppure allinea il testo di BroadNet all’audio con uno strumento di forced alignment. Formati delle richieste e limiti sono nel riferimento API di BroadNet, e la configurazione è nella guida allo speech-to-text in arabo.
