BroadRouter

Sottotitoli in arabo (SRT) da un’API speech-to-text: cosa serve

A cura del team di BroadNet Inference · 7 min di lettura · Pubblicato · Aggiornato

Un file SRT ha bisogno di testo più un tempo di inizio e di fine per ogni sottotitolo. Le API con timestamp per parola o per segmento, o con esportazione SRT diretta, danno la temporizzazione migliore. BroadNet Transcribe Arabic restituisce solo testo, quindi dividi l’audio nelle pause, trascrivi ogni chunk e temporizza i sottotitoli dagli offset dei chunk. Va bene per talk e podcast, non per sottotitoli di film precisi al fotogramma.

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:

  1. Trova le pause. silencedetect di FFmpeg registra silence_start e silence_end in secondi ovunque il livello resti sotto una soglia per un tempo minimo.
  2. 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.
  3. Trascrivi ogni intervallo. Taglialo in un WAV mono a 16 kHz e invialo con language=ar.
  4. 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.
  5. 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 noise o abbassa min_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.

Domande frequenti

Posso ottenere un file SRT direttamente dall’API di trascrizione di BroadNet?

No. La documentazione di BroadNet mostra una risposta JSON con un solo campo text, senza opzioni per SRT, VTT o timestamp. I metadati di /v1/models (verificati il 2026-11-15) elencano i formati di risposta json, text e verbose_json, ma nessuna fonte dice che verbose_json contenga timestamp. Costruisci tu la temporizzazione dagli offset dei chunk, come in questo articolo, oppure usa un provider che documenti i timestamp.

Quali API speech-to-text esportano SRT per l’arabo?

Tra quelle che abbiamo verificato il 15 novembre 2026, AssemblyAI (un endpoint per i sottotitoli, arabo su Universal-2) e Speechmatics (format=srt, arabo e un pacchetto arabo-inglese) documentano l’esportazione SRT. OpenAI documenta SRT su whisper-1, che è deprecato. Deepgram documenta librerie per sottotitoli basate sui suoi timestamp.

Quanti caratteri per riga dovrebbero avere i sottotitoli in arabo?

L’Arabic Timed Text Style Guide di Netflix fissa 42 caratteri per riga e un massimo di due righe. Il limite di velocità di lettura per i programmi per adulti è fino a 20 caratteri al secondo, e 17 per i programmi per bambini.

Quanto sono precisi i sottotitoli temporizzati dai chunk audio?

Inizio e fine di ogni chunk sono precisi quanto il rilevamento delle pause, quindi taralo sul tuo audio. I sottotitoli all’interno di un chunk ricevono tempi stimati dalla lunghezza del testo, quindi possono sfasare di un secondo o più. Va bene per talk e podcast, non per una fiction con sincronizzazione labiale.

Perché nel mio SRT in arabo la punteggiatura finisce dalla parte sbagliata?

SRT non ha markup per la direzione del testo, quindi è il player a decidere come disporre il testo da destra a sinistra. Prova il file nei player usati dal tuo pubblico. Se la punteggiatura si sposta, prova un formato con uno stile più ricco o un’impostazione del player per il testo RTL.

Dividere l’audio in chunk brevi costa di più?

BroadNet fattura la trascrizione per minuto di audio, quindi l’audio totale è lo stesso. Significa però più richieste: i chunk brevi raggiungono prima il limite a consumo di 30 richieste al minuto. Controlla la pagina di utilizzo dopo una prima esecuzione per confermare la fatturazione.

Leggi in MarkdownChiedi a ChatGPTChiedi a ClaudeChiedi a Perplexity

Fonti