BroadRouter

speech-to-text API से अरबी सबटाइटल (SRT): आपको क्या चाहिए

BroadNet Inference टीम · 7 मिनट में पढ़ें · प्रकाशित · अपडेट किया गया

SRT फ़ाइल को टेक्स्ट के साथ हर कैप्शन का शुरुआती और आख़िरी समय चाहिए। शब्द या segment टाइमस्टैम्प, या सीधे SRT export वाले API सबसे अच्छी टाइमिंग देते हैं। BroadNet Transcribe Arabic सिर्फ़ टेक्स्ट लौटाता है, इसलिए ऑडियो को ठहराव पर काटें, हर chunk ट्रांसक्राइब करें और chunk offsets से कैप्शन का समय तय करें। टॉक और पॉडकास्ट के लिए ठीक, frame-सटीक फ़िल्म सबटाइटल के लिए नहीं।

सबटाइटल समय जुड़ा हुआ टेक्स्ट हैं। अरबी सबटाइटल पाइपलाइन का ज़्यादातर काम वही समय हासिल करना है। कुछ speech-to-text API उन्हें शब्द टाइमस्टैम्प या तैयार SRT फ़ाइल के रूप में दे देते हैं। दूसरे, जिनमें BroadNet Inference भी है, सिर्फ़ ट्रांसक्रिप्ट टेक्स्ट लौटाते हैं। यह पोस्ट बताती है कि SRT फ़ाइल को क्या चाहिए, कौन-से प्रोवाइडर टाइमस्टैम्प दस्तावेज़ित करते हैं, और सिर्फ़-टेक्स्ट API से इस्तेमाल लायक अरबी सबटाइटल कैसे बनाएँ, सीमाओं को साफ़-साफ़ बताते हुए।

BroadRouter, BroadNet की अपनी साइट है। अगर आपको frame-सटीक टाइमिंग चाहिए, तो नीचे का ईमानदार जवाब शब्द टाइमस्टैम्प वाला प्रोवाइडर है, BroadNet नहीं।

SRT फ़ाइल को क्या चाहिए?

SRT (SubRip) फ़ाइल सादा टेक्स्ट है। हर कैप्शन के चार हिस्से होते हैं: एक नंबर, एक समय वाली लाइन, टेक्स्ट की एक या दो लाइनें, और एक खाली लाइन।

1
00:00:00,000 --> 00:00:02,800
مرحباً بكم في الحلقة الأولى

2
00:00:03,600 --> 00:00:07,600
اليوم نتحدث عن تحويل الكلام إلى نص وكيف
نصنع ملف ترجمة مصاحبة

Library of Congress का फ़ॉर्मैट विवरण समय का फ़ॉर्मैट घंटे:मिनट:सेकंड,मिलीसेकंड बताता है और तीर को दो हाइफ़न और एक दायाँ कोण कोष्ठक। यह यह भी कहता है कि SRT “not well standardized” (अनुवाद: ठीक से मानकीकृत नहीं) है और SRT फ़ाइलें “do not have a character encoding standard” (अनुवाद: का कोई character encoding मानक नहीं है)। अरबी के लिए UTF-8 लिखें और अपने लक्षित प्लेयर में टेस्ट करें। WebVTT, इसका वेब उत्तराधिकारी, मिलीसेकंड से पहले कॉमा की जगह फ़ुल स्टॉप इस्तेमाल करता है।

तो सख़्त ज़रूरत हर कैप्शन के लिए शुरुआती और आख़िरी समय है। सिर्फ़ टेक्स्ट काफ़ी नहीं।

अरबी सबटाइटल की लाइन कितनी लंबी होनी चाहिए?

अनुमान लगाने के बजाय कोई प्रकाशित स्टाइल गाइड इस्तेमाल करें। Netflix की Arabic Timed Text Style Guide (change log की तारीख़ 2025-12-19) यह तय करती है:

नियम Netflix का मान
प्रति लाइन कैरेक्टर 42
प्रति कैप्शन लाइनें अधिकतम दो
पढ़ने की गति, वयस्क कार्यक्रम प्रति सेकंड 20 कैरेक्टर तक
पढ़ने की गति, बच्चों के कार्यक्रम प्रति सेकंड 17 कैरेक्टर तक
लाइन तोड़ना क्रिया को उसके कर्ता से, पूर्वसर्ग को उसकी संज्ञा से, या संख्या को गिनी जाने वाली चीज़ से अलग न करें

Netflix की सामान्य ज़रूरतें प्रति कैप्शन न्यूनतम सेकंड का पाँच-छठा हिस्सा और अधिकतम 7 सेकंड जोड़ती हैं। अरबी गाइड अनुवादित सबटाइटल में मानक आधुनिक अरबी भी माँगती है। यह अनुवाद का नियम है; बोली वाली बातचीत का ट्रांसक्रिप्ट बोली में ही रहता है।

ये आँकड़े कोड बन जाते हैं: 42 कैरेक्टर पर लाइन तोड़ें, प्रति कैप्शन दो लाइनें, प्रति सेकंड 20 कैरेक्टर से ऊपर चेतावनी दें, और कोई कैप्शन 7 सेकंड से ज़्यादा न रोकें।

कौन-से speech-to-text API टाइमस्टैम्प या SRT दस्तावेज़ित करते हैं?

हमने 15 नवंबर 2026 को हर प्रोवाइडर के मौजूदा डॉक्स पढ़े। यह सूची बताती है कि वे क्या दस्तावेज़ित करते हैं, यह नहीं कि टाइमिंग कितनी सटीक है।

प्रोवाइडर डॉक्स क्या देते हैं अरबी
OpenAI response_format srt, vtt या verbose_json, और timestamp_granularities[] word या segment, सिर्फ़ whisper-1 पर। gpt-4o-transcribe और gpt-4o-mini-transcribe सिर्फ़ json लौटाते हैं जाँचा नहीं गया। OpenAI का deprecations पेज whisper-1, gpt-4o-transcribe, gpt-4o-mini-transcribe और gpt-4o-transcribe-diarize को deprecated बताता है, सभी 26 फ़रवरी 2027 को बंद होंगे, और इनकी जगह gpt-transcribe या gpt-live-transcribe की सलाह देता है
AssemblyAI GET /v2/transcript/{transcript_id}/srt या /vtt, chars_per_caption के साथ Universal-2 पर अरबी सूचीबद्ध, उसके 10 से 25% WER वाले वर्ग में
Speechmatics transcript endpoint पर format=srt; max_line_length और max_lines के साथ srt_overrides; शब्द आइटम में start_time और end_time अरबी, और एक ar_en अरबी-अंग्रेज़ी पैक
Deepgram शब्द और utterance टाइमस्टैम्प; SRT और WebVTT लिखने वाली आधिकारिक Python और JavaScript कैप्शन लाइब्रेरी Nova-3 पर अरबी और क्षेत्रीय कोड
ElevenLabs timestamps_granularity word या character; हर शब्द का start और end सेकंड में अरबी सूचीबद्ध, उसके 10 से 20% WER वाले वर्ग में
BroadNet Inference सिर्फ़ {"text": ...} अरबी के लिए विशेष मॉडल और 14 भाषाओं वाला मॉडल

अगर आप मॉडल ख़ुद चला सकते हैं, तो whisper.cpp के साथ बना FFmpeg का whisper filter सीधे srt लिख सकता है और छोटी लाइनों के लिए उसमें max_len विकल्प है।

अरबी सटीकता और कीमत की पहली तुलना के लिए अरबी speech-to-text API ख़रीदार गाइड और speech-to-text कीमतों की तुलना देखें। उस फ़ैसले में टाइमस्टैम्प एक पंक्ति है, अकेली नहीं।

सिर्फ़-टेक्स्ट API से सबटाइटल कैसे बनाएँ?

आप ऑडियो जहाँ काटते हैं, वहीं से अपने टाइमस्टैम्प बनाते हैं। चरण:

  1. ठहराव ढूँढें। FFmpeg का silencedetect जहाँ भी स्तर किसी सीमा से नीचे न्यूनतम समय तक रहता है, वहाँ silence_start और silence_end सेकंड में लॉग करता है।
  2. ठहरावों को बोली के हिस्सों में बदलें। दो ख़ामोशियों के बीच का सब कुछ एक हिस्सा है। हिस्सों को लगभग 12 सेकंड पर सीमित करें, ताकि कभी न रुकने वाला वक्ता भी छोटे कैप्शन दे।
  3. हर हिस्सा ट्रांसक्राइब करें। उसे 16 kHz mono WAV में काटें और language=ar के साथ भेजें।
  4. कैप्शन का समय तय करें। हिस्से की शुरुआत और अंत आपके आधार समय हैं। अगर उसके टेक्स्ट को कई लाइनें चाहिए, तो हिस्से का समय उनकी लंबाई के अनुपात में बाँटें।
  5. SRT लिखें और लाइन की लंबाई, पढ़ने की गति और अवधि को स्टाइल नियमों से जाँचें।

यह वही बँटवारा है जो लंबी ऑडियो फ़ाइलें ट्रांसक्राइब करने में है, बस लक्ष्य अलग है। वहाँ chunks लगभग 10 मिनट के होते हैं और आपको सिर्फ़ जुड़े हुए टेक्स्ट की परवाह होती है। यहाँ chunks कुछ सेकंड के होते हैं, क्योंकि हर एक कैप्शन का समय बनता है। अगर आप हाथ से काटना पसंद करते हैं, तो ऑडियो स्प्लिटर टूल FFmpeg कमांड बनाता है।

Python में पाइपलाइन

यह स्क्रिप्ट OpenAI Python SDK और FFmpeg इस्तेमाल करती है। हमने इसे 15 नवंबर 2026 को एक लोकल mock सर्वर पर चलाया, जो BroadNet के दस्तावेज़ित endpoint ({"text": ...}) की तरह जवाब देता है, और टोन व ख़ाली जगहों वाली एक बनाई गई टेस्ट फ़ाइल के साथ। ऊपर वाला SRT इसी का आउटपुट है। कोई BroadNet key इस्तेमाल नहीं हुई, इसलिए अरबी टेक्स्ट mock से आया, मॉडल से नहीं।

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")

BROADNET_API_KEY सेट करके चलाएँ: python make_srt.py episode.wav episode.srt। टेस्ट फ़ाइल पर ठहराव की पहचान ने 0 से 2.8 s, 3.6 से 7.6 s, 8.8 से 28.8 s (12 s पर काटा गया क्योंकि उसमें कोई ठहराव नहीं था) और 29.4 से 30.9 s के हिस्से पाए, जो फ़ाइल बनाने के तरीक़े से मेल खाते थे। आउटपुट Python srt पैकेज से साफ़ पार्स हुआ और FFmpeg से WebVTT में बदल गया।

दो मान अपने ऑडियो के अनुसार ट्यून करें। noise वह स्तर है जिसे ख़ामोशी माना जाता है: साफ़ बोली के लिए -30 से -40 dB आज़माएँ और शोर वाले कमरों के लिए ऊँचा। min_silence यह है कि ख़ाली जगह कितनी देर की होनी चाहिए: 0.3 से 0.5 सेकंड हर साँस पर काटे बिना वाक्यों के बीच के ठहराव पकड़ता है।

chunk-स्तर की टाइमिंग कितनी सटीक है?

यह तरीक़ा क्या कर सकता है और क्या नहीं, इस बारे में साफ़ रहें।

  • हिस्सों के किनारे सबसे अच्छा भाग हैं। असली ठहराव पर पड़ने वाली कैप्शन की शुरुआत और अंत उतनी ही सटीक हैं जितनी ख़ामोशी की पहचान। हमारी सिंथेटिक टेस्ट फ़ाइल पर ये बिल्कुल मेल खाए; साँसों और कमरे के शोर वाली असली रिकॉर्डिंग ज़्यादा उलझी होती हैं।
  • हिस्से के अंदर के समय अनुमान हैं। जब किसी हिस्से में दो या तीन कैप्शन होते हैं, तो स्क्रिप्ट उसका समय कैरेक्टर की गिनती से बाँटती है। वक्ता एक समान गति से नहीं बोलते, इसलिए अंदर की सीमाएँ एक सेकंड या ज़्यादा खिसक सकती हैं।
  • तय कट शब्दों को काट सकते हैं। जब कोई हिस्सा बिना ठहराव के 12 सेकंड की सीमा पार करता है, तो कट जहाँ पड़े, वहीं पड़ता है। कट पर पड़ा शब्द खो सकता है या बिगड़ सकता है। पहले noise बढ़ाएँ या min_silence घटाएँ, ताकि कम हिस्सों को तय कट चाहिए।
  • छोटे chunks मॉडल को कम कॉन्टेक्स्ट देते हैं। 3 सेकंड की क्लिप में हर शब्द के आसपास 10 मिनट की फ़ाइल से कम शब्द होते हैं। हमने नहीं मापा कि इससे अरबी सटीकता कितनी बदलती है; इसे अपने ऑडियो पर WER से टेस्ट करें।
  • स्पीकर लेबल नहीं। BroadNet कोई diarization नहीं लौटाता, इसलिए कैप्शन यह नहीं बताते कि कौन बोल रहा है।
  • संगीत और शोर। बैकग्राउंड संगीत ठहराव पूरी तरह छिपा सकता है। तब ज़्यादातर हिस्से तय कट होते हैं, और टाइमिंग बिगड़ती है।

लेक्चर, पॉडकास्ट, वेबिनार और ट्रेनिंग वीडियो के लिए बोली से एक सेकंड के भीतर के कैप्शन आम तौर पर पढ़ने लायक होते हैं। ड्रामा, म्यूज़िक वीडियो या lip-sync वाली किसी भी चीज़ के लिए शब्द टाइमस्टैम्प वाला प्रोवाइडर इस्तेमाल करें, या किसी सबटाइटलर से फ़ाइल ठीक करवाएँ।

लागत क्या है, और यह कितना तेज़ है?

कीमत ऑडियो की लंबाई के हिसाब से है। BroadNet Transcribe Arabic पर एक घंटे की अरबी की लागत $0.25 है, चाहे आप उसे एक फ़ाइल में भेजें या पाँच-पाँच सेकंड की 720 फ़ाइलों में। BroadNet का कीमत पेज प्रति ऑडियो मिनट कीमत बताता है और प्रति फ़ाइल कोई न्यूनतम नहीं; पुष्टि के लिए पहले एपिसोड के बाद usage पेज देखें।

स्पीड अनुरोधों की संख्या के हिसाब से है। उपयोग के अनुसार भुगतान वाली key प्रति मिनट 30 अनुरोध और 4 in flight देती है। 5 सेकंड के हिस्सों में बँटी एक घंटे की बोली लगभग 720 अनुरोध है, जिसमें कम से कम 720 ÷ 30 मिनट लगते हैं। लंबे हिस्सों का मतलब कम अनुरोध। अगर 429 आए, तो एरर और retry गाइड के अनुसार रुकें, और प्रकाशित सीमाओं से बचने के लिए एक job को कई keys में न फैलाएँ।

BroadNet Inference कहाँ फ़िट होता है

BroadNet Transcribe Arabic सबटाइटल job के टेक्स्ट वाले हिस्से के लिए ठीक है: $0.0042 प्रति मिनट पर अरबी बोली से अरबी टेक्स्ट, और अनुरोध के बाद ऑडियो और ट्रांसक्रिप्ट नहीं रखे जाते। $5 का शुरुआती क्रेडिट ट्रांसक्रिप्शन को कवर करता है, इसलिए टॉप-अप से पहले आप असली एपिसोड पर पाइपलाइन टेस्ट कर सकते हैं। यह टाइमस्टैम्प, segments, स्पीकर लेबल या SRT नहीं लौटाता। अगर आपके सबटाइटल को शब्द-स्तर की टाइमिंग चाहिए, तो उसे दस्तावेज़ित करने वाला प्रोवाइडर इस्तेमाल करें, या forced-alignment टूल से BroadNet के टेक्स्ट को ऑडियो से मिलाएँ। अनुरोध का ढाँचा और सीमाएँ BroadNet API रेफ़रंस में हैं, और सेटअप अरबी speech-to-text गाइड में।

अक्सर पूछे जाने वाले सवाल

क्या BroadNet के ट्रांसक्रिप्शन API से सीधे SRT फ़ाइल मिल सकती है?

नहीं। BroadNet के डॉक्स एक text फ़ील्ड वाला JSON जवाब दिखाते हैं, और कोई SRT, VTT या टाइमस्टैम्प विकल्प नहीं। इसका /v1/models metadata (2026-11-15 को जाँचा गया) json, text और verbose_json जवाब फ़ॉर्मैट गिनाता है, लेकिन कोई स्रोत नहीं कहता कि verbose_json में टाइमस्टैम्प होते हैं। टाइमिंग ख़ुद chunk offsets से बनाएँ, जैसा इस पोस्ट में है, या टाइमस्टैम्प दस्तावेज़ित करने वाला प्रोवाइडर इस्तेमाल करें।

कौन-से speech-to-text API अरबी के लिए SRT export करते हैं?

15 नवंबर 2026 को हमने जिन्हें जाँचा, उनमें AssemblyAI (subtitles endpoint, Universal-2 पर अरबी) और Speechmatics (format=srt, अरबी और एक अरबी-अंग्रेज़ी पैक) SRT export दस्तावेज़ित करते हैं। OpenAI whisper-1 पर SRT दस्तावेज़ित करता है, जो deprecated है। Deepgram अपने टाइमस्टैम्प पर बनी कैप्शन लाइब्रेरी दस्तावेज़ित करता है।

अरबी सबटाइटल में प्रति लाइन कितने कैरेक्टर होने चाहिए?

Netflix की Arabic Timed Text Style Guide प्रति लाइन 42 कैरेक्टर और अधिकतम दो लाइनें तय करती है। वयस्क कार्यक्रमों के लिए इसकी पढ़ने की गति की सीमा प्रति सेकंड 20 कैरेक्टर तक है, और बच्चों के कार्यक्रमों के लिए 17।

ऑडियो chunks से टाइम किए गए सबटाइटल कितने सटीक होते हैं?

हर chunk की शुरुआत और अंत उतने ही सटीक हैं जितनी ठहराव की पहचान, इसलिए इसे अपने ऑडियो पर ट्यून करें। chunk के अंदर के कैप्शन का समय टेक्स्ट की लंबाई से अनुमानित होता है, इसलिए वे एक सेकंड या ज़्यादा खिसक सकते हैं। यह टॉक और पॉडकास्ट के लिए ठीक है, lip-sync वाले ड्रामा के लिए नहीं।

मेरे अरबी SRT में विराम चिह्न ग़लत तरफ़ क्यों दिखते हैं?

SRT में दिशा का कोई markup नहीं होता, इसलिए दाएँ-से-बाएँ टेक्स्ट का लेआउट प्लेयर तय करता है। फ़ाइल को उन प्लेयर में टेस्ट करें जो आपके दर्शक इस्तेमाल करते हैं। अगर विराम चिह्न खिसकते हैं, तो ज़्यादा स्टाइलिंग वाला फ़ॉर्मैट या RTL टेक्स्ट के लिए प्लेयर सेटिंग आज़माएँ।

क्या ऑडियो को छोटे chunks में काटने से लागत बढ़ती है?

BroadNet ट्रांसक्रिप्शन की कीमत प्रति ऑडियो मिनट लगाता है, इसलिए कुल ऑडियो उतना ही रहता है। हाँ, अनुरोध ज़्यादा होते हैं: छोटे chunks उपयोग के अनुसार भुगतान की प्रति मिनट 30 अनुरोधों की सीमा तक जल्दी पहुँचते हैं। बिलिंग की पुष्टि के लिए पहले रन के बाद अपना usage पेज देखें।

Markdown में पढ़ेंChatGPT से पूछेंClaude से पूछेंPerplexity से पूछें

स्रोत