---
title: "Sottotitoli SRT in arabo da un’API speech-to-text | BroadRouter"
description: "Cosa serve a un file SRT, quali API speech-to-text restituiscono timestamp o SRT per l’arabo e una pipeline testata che crea sottotitoli da un’API solo testo."
url: https://broadrouter.com/it/blog/arabic-subtitles-srt-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/arabic-subtitles-srt-api/) (aggiornato il 2026-11-16).

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

A cura del team di BroadNet Inference · 7 min di lettura · Pubblicato 2026-11-15 · Aggiornato 2026-11-16

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.

## Punti chiave

-   SRT è un elenco numerato di sottotitoli, ciascuno con una riga hh:mm:ss,mmm --> hh:mm:ss,mmm. La Library of Congress osserva che non ha una specifica formale né uno standard di codifica dei caratteri.
-   La risposta di trascrizione documentata da BroadNet è solo {"text": ...}: niente timestamp, niente segmenti e nessun output SRT.
-   OpenAI documenta SRT e timestamp per parola solo su whisper-1, di cui indica lo spegnimento il 26 febbraio 2027. AssemblyAI e Speechmatics documentano l’esportazione SRT; Deepgram ed ElevenLabs documentano i timestamp per parola.
-   La guida di Netflix per l’arabo fissa 42 caratteri per riga, due righe e fino a 20 caratteri al secondo per i programmi per adulti; la sua guida generale limita un sottotitolo a 7 secondi.
-   La temporizzazione a livello di chunk è precisa quanto le tue pause. All’interno di un chunk, i tempi dei sottotitoli sono stimati dalla lunghezza del testo.

**In questa pagina**

1.  Che cosa serve a un file SRT?
2.  Quanto dovrebbe essere lunga una riga di sottotitolo in arabo?
3.  Quali API speech-to-text documentano timestamp o SRT?
4.  Come si creano sottotitoli da un’API solo testo?
5.  La pipeline in Python
6.  Quanto è precisa la temporizzazione a livello di chunk?
7.  Quanto costa e quanto è veloce?
8.  Dove si colloca BroadNet Inference

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.

```text
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](https://broadrouter.com/it/blog/arabic-speech-to-text-api-buyers-guide/) e il [confronto dei prezzi speech-to-text](https://broadrouter.com/it/blog/speech-to-text-api-pricing-compared/). 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](https://broadrouter.com/it/blog/transcribe-long-audio-files-api/), 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](https://broadrouter.com/tools/audio-splitter-ffmpeg/) 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.

```python
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](https://broadrouter.com/it/blog/arabic-asr-wer-explained/).
-   **Nessuna etichetta dei parlanti.** BroadNet non restituisce [diarization](https://broadrouter.com/it/glossary/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](https://broadrouter.com/it/glossary/timestamps-asr/) 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](https://broadrouter.com/it/guides/errors-and-retries/), 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](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-arabic-subtitles-srt-api&utm_content=body), e la configurazione è nella [guida allo speech-to-text in arabo](https://broadrouter.com/it/guides/arabic-speech-to-text-api/).

Strumenti gratuiti sul tema (in inglese)

-   [Arabic token counter](https://broadrouter.com/tools/arabic-token-counter/) Arabic vs English token counts per tokenizer: the "Arabic tax" in tokens and money.
-   [Arabic text normalizer](https://broadrouter.com/tools/arabic-text-normalizer/) Tashkeel, tatweel, alef, ya, ta marbuta, digits and invisible characters, with a matching Python function.
-   [Speech-to-text cost calculator](https://broadrouter.com/tools/speech-to-text-cost-calculator/) Hours, calls or voice notes to a monthly transcription bill, against your current provider.

[Strumenti gratuiti (in inglese)](https://broadrouter.com/tools/)

## Termini in questo articolo

[Sottotitoli SRT (file .srt)](https://broadrouter.com/it/glossary/srt-subtitles/)

SRT (SubRip) è un formato di sottotitoli in testo semplice. Ogni sottotitolo è composto da un numero progressivo, un tempo di inizio e di fine scritto come hh:mm:ss,mmm --> hh:mm:ss,mmm, una o più righe di testo e una riga vuota. WebVTT è il formato web simile usato dai video HTML.

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

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

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

[Timestamp (speech-to-text)](https://broadrouter.com/it/glossary/timestamps-asr/)

I timestamp nello speech-to-text sono tempi di inizio e fine, in secondi, associati a parti di una trascrizione. I timestamp di segmento coprono una frase o un periodo; quelli per parola coprono ogni parola. Servono per sottotitoli, ricerca dentro le registrazioni e allineamento del testo con i parlanti.

[Word error rate (WER)](https://broadrouter.com/it/glossary/word-error-rate/)

Il word error rate (WER, tasso di errore sulle parole) è la misura standard di accuratezza del riconoscimento vocale: il numero di sostituzioni, cancellazioni e inserimenti di parole necessari per trasformare una trascrizione nel riferimento corretto, diviso per il numero di parole del riferimento. Più è basso, meglio è.

[Arabo standard moderno (MSA)](https://broadrouter.com/it/glossary/msa/)

L’arabo standard moderno (MSA) è la forma standardizzata dell’arabo usata nella scrittura, nei notiziari, nell’istruzione e nei discorsi formali in tutto il mondo arabo. Non è la lingua madre quotidiana di nessuno: le persone parlano dialetti regionali, come l’egiziano o l’arabo del Golfo, e passano all’MSA nei contesti formali.

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

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

## Continua a leggere

-   [Trascrivere audio lunghi oltre 25 MB: dividere, inviare, ricucire](https://broadrouter.com/it/blog/transcribe-long-audio-files-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/)
-   [Verbali di riunioni in arabo dalle registrazioni: una pipeline API](https://broadrouter.com/it/blog/arabic-meeting-minutes-from-recordings/)
-   [Prezzi delle API speech-to-text a confronto: costo al minuto (2026)](https://broadrouter.com/it/blog/speech-to-text-api-pricing-compared/)
-   [Aggiungere i diacritici all’arabo con un LLM: prompt, controlli, DER](https://broadrouter.com/it/blog/arabic-diacritization-llm/)
-   [Correzione grammaticale e ortografica dell’arabo con un LLM: guida](https://broadrouter.com/it/blog/arabic-grammar-spelling-correction-llm/)
-   [Guida: API speech-to-text in arabo, passo dopo passo](https://broadrouter.com/it/guides/arabic-speech-to-text-api/)
-   [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-arabic-subtitles-srt-api&utm_content=page-cta) ·

**Fonti**

-   [Riferimento API di BroadNet Inference: richiesta di trascrizione e risposta {"text": ...}, limiti a consumo (verificato il 2026-11-15) (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-arabic-subtitles-srt-api&utm_content=sources)
-   [Library of Congress, Sustainability of Digital Formats: descrizione del formato SubRip (SRT) fdd000569 (verificata il 2026-11-15)](https://www.loc.gov/preservation/digital/formats/fdd/fdd000569.shtml)
-   [Netflix Partner Help Center, Arabic Timed Text Style Guide: 42 caratteri per riga, limiti di velocità di lettura (verificato il 2026-11-15)](https://partnerhelp.netflixstudios.com/hc/en-us/articles/215517947)
-   [Netflix Partner Help Center, Timed Text Style Guide: General Requirements, durata minima e massima (verificato il 2026-11-15)](https://partnerhelp.netflixstudios.com/hc/en-us/articles/215758617-Timed-Text-Style-Guide-General-Requirements)
-   [Riferimento API di OpenAI, create transcription: response\_format e timestamp\_granularities per modello (verificato il 2026-11-15)](https://developers.openai.com/api/reference/resources/audio/subresources/transcriptions/methods/create)
-   [Guida speech-to-text di OpenAI: timestamp\_granularities solo su whisper-1, data di deprecazione (verificata il 2026-11-15)](https://developers.openai.com/api/docs/guides/speech-to-text)
-   [Deprecazioni di OpenAI: whisper-1 e i modelli gpt-4o transcribe si spengono il 26 febbraio 2027; sostituti gpt-transcribe o gpt-live-transcribe (verificato il 2026-11-15)](https://developers.openai.com/api/docs/deprecations)
-   [Riferimento API di AssemblyAI, Get subtitles: l’endpoint dei sottotitoli della trascrizione, formato SRT o VTT (verificato il 2026-11-15)](https://www.assemblyai.com/docs/api-reference/transcripts/get-subtitles)
-   [AssemblyAI, lingue supportate per l’audio preregistrato (verificato il 2026-11-15)](https://www.assemblyai.com/docs/pre-recorded-audio/supported-languages)
-   [Documentazione di Speechmatics, formati di output batch: format=srt e srt\_overrides (verificata il 2026-11-15)](https://docs.speechmatics.com/speech-to-text/batch/output)
-   [Documentazione di Speechmatics, lingue supportate: arabo e il pacchetto bilingue ar\_en (verificata il 2026-11-15)](https://docs.speechmatics.com/speech-to-text/languages)
-   [Documentazione di Deepgram, generazione automatica di sottotitoli WebVTT e SRT (verificata il 2026-11-15)](https://developers.deepgram.com/docs/automatically-generating-webvtt-and-srt-captions)
-   [Documentazione di Deepgram, panoramica di modelli e lingue: arabo su Nova-3 (verificata il 2026-11-15)](https://developers.deepgram.com/docs/models-languages-overview)
-   [Riferimento API di ElevenLabs, speech-to-text: timestamps\_granularity e start/end per parola (verificato il 2026-11-15)](https://elevenlabs.io/docs/api-reference/speech-to-text/convert)
-   [Documentazione dei filtri FFmpeg: filtri silencedetect e whisper (verificata il 2026-11-15)](https://ffmpeg.org/ffmpeg-filters.html)
