Des sous-titres, c’est du texte auquel on associe des temps. L’essentiel du travail d’un pipeline de sous-titres arabes consiste à obtenir ces temps. Certaines API de transcription vous les fournissent sous forme d’horodatages par mot ou d’un fichier SRT prêt à l’emploi. D’autres, dont BroadNet Inference, ne renvoient que le texte de la transcription. Cet article explique ce qu’exige un fichier SRT, quels fournisseurs documentent des horodatages, et comment construire des sous-titres arabes utilisables à partir d’une API texte seul, en énonçant clairement les limites.
BroadRouter est le site de BroadNet. Si vous avez besoin d’un minutage à l’image près, la réponse honnête ci-dessous est un fournisseur avec horodatages par mot, pas BroadNet.
Qu’exige un fichier SRT ?
Un fichier SRT (SubRip) est du texte brut. Chaque sous-titre a quatre parties : un numéro, une ligne de temps, une ou deux lignes de texte, et une ligne vide.
1
00:00:00,000 --> 00:00:02,800
مرحباً بكم في الحلقة الأولى
2
00:00:03,600 --> 00:00:07,600
اليوم نتحدث عن تحويل الكلام إلى نص وكيف
نصنع ملف ترجمة مصاحبة
La description du format par la Library of Congress donne le format de temps heures:minutes:secondes,millisecondes, et la flèche comme deux tirets suivis d’un chevron fermant. Elle indique aussi que le SRT n’est « not well standardized » (traduction : « pas bien normalisé ») et que les fichiers SRT « do not have a character encoding standard » (traduction : « n’ont pas de norme d’encodage des caractères »). Pour l’arabe, écrivez en UTF-8 et testez dans votre lecteur cible. WebVTT, son successeur pour le web, utilise un point au lieu de la virgule avant les millisecondes.
L’exigence incontournable est donc une heure de début et de fin pour chaque sous-titre. Le texte seul ne suffit pas.
Quelle longueur pour une ligne de sous-titre arabe ?
Appuyez-vous sur un guide de style publié plutôt que de deviner. Le Arabic Timed Text Style Guide de Netflix (journal des modifications daté du 2025-12-19) fixe :
| Règle | Valeur Netflix |
|---|---|
| Caractères par ligne | 42 |
| Lignes par sous-titre | Deux au maximum |
| Vitesse de lecture, programmes adultes | Jusqu’à 20 caractères par seconde |
| Vitesse de lecture, programmes jeunesse | Jusqu’à 17 caractères par seconde |
| Retours à la ligne | Ne pas séparer un verbe de son sujet, une préposition de son nom, ni un nombre de ce qu’il compte |
Les exigences générales de Netflix ajoutent une durée minimale de cinq sixièmes de seconde et une durée maximale de 7 secondes par sous-titre. Le guide arabe demande aussi l’arabe standard moderne pour les sous-titres traduits. C’est une règle de traduction ; la transcription d’un discours en dialecte reste en dialecte.
Ces chiffres se traduisent en code : retour à la ligne à 42 caractères, deux lignes par sous-titre, alerte au-delà de 20 caractères par seconde, et jamais un sous-titre affiché plus de 7 secondes.
Quelles API de transcription documentent horodatages ou SRT ?
Nous avons lu la documentation actuelle de chaque fournisseur le 15 novembre 2026. Ce tableau recense ce qui est documenté, pas la précision du minutage.
| Fournisseur | Ce que propose la documentation | Arabe |
|---|---|---|
| OpenAI | response_format srt, vtt ou verbose_json, et timestamp_granularities[] par mot ou par segment, sur whisper-1 uniquement. gpt-4o-transcribe et gpt-4o-mini-transcribe ne renvoient que du json |
Non vérifié. La page des abandons d’OpenAI liste whisper-1, gpt-4o-transcribe, gpt-4o-mini-transcribe et gpt-4o-transcribe-diarize comme abandonnés, tous arrêtés le 26 février 2027, et recommande gpt-transcribe ou gpt-live-transcribe à la place |
| AssemblyAI | GET /v2/transcript/{transcript_id}/srt ou /vtt, avec chars_per_caption |
Arabe listé sur Universal-2, dans sa tranche de WER de 10 à 25 % |
| Speechmatics | format=srt sur le point de terminaison de transcription ; srt_overrides avec max_line_length et max_lines ; les éléments de mot portent start_time et end_time |
Arabe, plus un pack arabe-anglais ar_en |
| Deepgram | Horodatages par mot et par énoncé ; bibliothèques officielles de sous-titres en Python et JavaScript qui écrivent du SRT et du WebVTT | Arabe et codes régionaux sur Nova-3 |
| ElevenLabs | timestamps_granularity par mot ou par caractère ; chaque mot a start et end en secondes |
Arabe listé, dans sa tranche de WER de 10 à 20 % |
| BroadNet Inference | {"text": ...} uniquement |
Modèle spécifique à l’arabe et modèle à 14 langues |
Si vous pouvez faire tourner des modèles vous-même, le filtre whisper de FFmpeg, compilé avec whisper.cpp, peut écrire directement du srt et dispose d’une option max_len pour des lignes plus courtes.
Pour une première comparaison de précision et de prix en arabe, voir le guide d’achat des API de transcription arabe et les tarifs de transcription comparés. Les horodatages sont une ligne de cette décision, pas la seule.
Comment créer des sous-titres à partir d’une API texte seul ?
Vous fabriquez vos propres horodatages à partir des endroits où vous coupez l’audio. Les étapes :
- Trouver les pauses. Le
silencedetectde FFmpeg journalisesilence_startetsilence_enden secondes partout où le niveau reste sous un seuil pendant une durée minimale. - Transformer les pauses en plages de parole. Tout ce qui se trouve entre deux silences forme une plage. Plafonnez les plages à environ 12 secondes, pour qu’un orateur qui ne marque jamais de pause produise quand même des sous-titres courts.
- Transcrire chaque plage. Découpez-la en WAV mono 16 kHz et envoyez-la avec
language=ar. - Minuter les sous-titres. Le début et la fin de la plage sont vos temps d’ancrage. Si son texte demande plusieurs lignes, répartissez le temps de la plage entre elles au prorata de leur longueur.
- Écrire le SRT et vérifier longueur de ligne, vitesse de lecture et durée par rapport aux règles de style.
C’est le même découpage que pour transcrire de longs fichiers audio, avec un autre objectif. Là-bas, les segments durent environ 10 minutes et seul compte le texte assemblé. Ici, les segments durent quelques secondes, car chacun devient des temps de sous-titres. L’outil de découpage audio génère les commandes FFmpeg si vous préférez découper à la main.
Le pipeline en Python
Ce script utilise le SDK Python d’OpenAI et FFmpeg. Nous l’avons lancé le 15 novembre 2026 contre un serveur fictif local qui répond comme le point de terminaison documenté de BroadNet ({"text": ...}), avec un fichier de test généré fait de tonalités et de blancs. Le SRT ci-dessus en est la sortie. Aucune clé BroadNet n’a été utilisée : le texte arabe vient donc du serveur fictif, pas du modèle.
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")
Lancez-le avec BROADNET_API_KEY défini : python make_srt.py episode.wav episode.srt. Sur le fichier de test, la détection des pauses a trouvé des plages de 0 à 2,8 s, de 3,6 à 7,6 s, de 8,8 à 28,8 s (coupée à 12 s faute de pause) et de 29,4 à 30,9 s, ce qui correspondait à la construction du fichier. La sortie a été analysée sans erreur par le paquet Python srt et convertie en WebVTT avec FFmpeg.
Réglez deux valeurs selon votre audio. noise est le niveau considéré comme du silence : essayez -30 à -40 dB pour une parole propre, et plus haut pour des salles bruyantes. min_silence est la durée minimale d’un blanc : 0,3 à 0,5 seconde attrape les pauses entre les phrases sans couper à chaque respiration.
Quelle est la précision d’un minutage par segment ?
Soyez clair sur ce que cette méthode peut faire ou non.
- Les bords des plages sont la partie la plus fiable. Les débuts et fins de sous-titres qui tombent sur une vraie pause sont aussi précis que la détection des silences. Sur notre fichier de test synthétique, ils correspondaient exactement ; les vrais enregistrements, avec respirations et bruit de salle, sont plus désordonnés.
- Les temps à l’intérieur d’une plage sont des estimations. Quand une plage contient deux ou trois sous-titres, le script répartit son temps selon le nombre de caractères. Les orateurs ne parlent pas à débit constant : ces limites internes peuvent être décalées d’une seconde ou plus.
- Les coupes fixes peuvent couper des mots. Quand une plage dépasse le plafond de 12 secondes sans pause, la coupe tombe où elle tombe. Un mot à la coupe peut être perdu ou déformé. Montez d’abord
noiseou baissezmin_silence, pour que moins de plages aient besoin d’une coupe fixe. - Les segments courts donnent moins de contexte au modèle. Un extrait de 3 secondes offre moins de mots autour de chaque mot qu’un fichier de 10 minutes. Nous n’avons pas mesuré à quel point cela change la précision en arabe ; testez-le sur votre propre audio avec le WER.
- Pas d’étiquettes de locuteur. BroadNet ne renvoie pas de diarisation : les sous-titres n’indiquent pas qui parle.
- Musique et bruit. Une musique de fond peut masquer entièrement les pauses. La plupart des plages deviennent alors des coupes fixes, et le minutage se dégrade.
Pour des cours, des podcasts, des webinaires et des vidéos de formation, des sous-titres à moins d’une seconde de la parole sont généralement lisibles. Pour la fiction, les clips musicaux ou tout ce qui est synchronisé sur les lèvres, utilisez un fournisseur avec horodatages par mot, ou faites ajuster le fichier par un sous-titreur.
Combien ça coûte, et à quelle vitesse ?
Le prix suit la durée de l’audio. Une heure d’arabe avec BroadNet Transcribe Arabic coûte $0.25, que vous l’envoyiez en un seul fichier ou en 720 morceaux de cinq secondes. La page des tarifs de BroadNet indique un prix par minute d’audio et aucun minimum par fichier ; consultez la page d’utilisation après votre premier épisode pour confirmer.
La vitesse suit le nombre de requêtes. Une clé en paiement à l’usage autorise 30 requêtes par minute et 4 simultanées. Une heure de parole découpée en plages de 5 secondes représente environ 720 requêtes, soit au moins 720 ÷ 30 minutes. Des plages plus longues signifient moins de requêtes. Si vous recevez un 429, temporisez comme dans le guide des erreurs et nouvelles tentatives, et ne répartissez pas un traitement sur plusieurs clés pour contourner les limites publiées.
Où se situe BroadNet Inference
BroadNet Transcribe Arabic convient à la moitié texte d’un travail de sous-titrage : de la parole arabe vers du texte arabe à $0.0042 la minute, sans conservation de l’audio ni des transcriptions après la requête. Le crédit de départ de $5 couvre la transcription : vous pouvez tester le pipeline sur de vrais épisodes avant de recharger. Il ne renvoie ni horodatages, ni segments, ni étiquettes de locuteur, ni SRT. Si vos sous-titres demandent un minutage au mot près, utilisez un fournisseur qui le documente, ou alignez le texte de BroadNet sur l’audio avec un outil d’alignement forcé. Formats de requête et limites dans la référence de l’API BroadNet, configuration dans le guide de transcription vocale arabe.
