---
title: "speech-to-text API से अरबी SRT सबटाइटल | BroadRouter"
description: "SRT फ़ाइल को क्या चाहिए, कौन-से speech-to-text API अरबी के लिए टाइमस्टैम्प या SRT देते हैं, और सिर्फ़-टेक्स्ट API से सबटाइटल बनाने वाली टेस्ट की गई पाइपलाइन।"
url: https://broadrouter.com/hi/blog/arabic-subtitles-srt-api/
lang: hi
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

यह पेज अंग्रेज़ी से AI की मदद से अनुवाद किया गया है। [अंग्रेज़ी मूल पढ़ें](https://broadrouter.com/blog/arabic-subtitles-srt-api/) (2026-11-16 को अपडेट किया गया).

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

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

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

## मुख्य बातें

-   SRT कैप्शन की क्रमांकित सूची है, हर एक के साथ hh:mm:ss,mmm --> hh:mm:ss,mmm वाली लाइन। Library of Congress नोट करती है कि इसका कोई औपचारिक specification नहीं और कोई character-encoding मानक नहीं।
-   BroadNet का दस्तावेज़ित ट्रांसक्रिप्शन जवाब सिर्फ़ {"text": ...} है: न टाइमस्टैम्प, न segments, न SRT आउटपुट।
-   OpenAI सिर्फ़ whisper-1 पर SRT और शब्द टाइमस्टैम्प दस्तावेज़ित करता है, जिसे वह 26 फ़रवरी 2027 को बंद होने वालों में गिनाता है। AssemblyAI और Speechmatics SRT export दस्तावेज़ित करते हैं; Deepgram और ElevenLabs शब्द टाइमस्टैम्प।
-   Netflix की अरबी गाइड वयस्क कार्यक्रमों के लिए प्रति लाइन 42 कैरेक्टर, दो लाइनें और प्रति सेकंड 20 कैरेक्टर तक तय करती है; उसकी सामान्य गाइड एक कैप्शन को 7 सेकंड तक सीमित करती है।
-   chunk-स्तर की टाइमिंग उतनी ही सटीक है जितने आपके ठहराव। chunk के अंदर कैप्शन का समय टेक्स्ट की लंबाई से अनुमानित होता है।

**इस पेज पर**

1.  SRT फ़ाइल को क्या चाहिए?
2.  अरबी सबटाइटल की लाइन कितनी लंबी होनी चाहिए?
3.  कौन-से speech-to-text API टाइमस्टैम्प या SRT दस्तावेज़ित करते हैं?
4.  सिर्फ़-टेक्स्ट API से सबटाइटल कैसे बनाएँ?
5.  Python में पाइपलाइन
6.  chunk-स्तर की टाइमिंग कितनी सटीक है?
7.  लागत क्या है, और यह कितना तेज़ है?
8.  BroadNet Inference कहाँ फ़िट होता है

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

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

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

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

```text
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 ख़रीदार गाइड](https://broadrouter.com/hi/blog/arabic-speech-to-text-api-buyers-guide/) और [speech-to-text कीमतों की तुलना](https://broadrouter.com/hi/blog/speech-to-text-api-pricing-compared/) देखें। उस फ़ैसले में टाइमस्टैम्प एक पंक्ति है, अकेली नहीं।

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

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

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

यह वही बँटवारा है जो [लंबी ऑडियो फ़ाइलें ट्रांसक्राइब करने](https://broadrouter.com/hi/blog/transcribe-long-audio-files-api/) में है, बस लक्ष्य अलग है। वहाँ chunks लगभग 10 मिनट के होते हैं और आपको सिर्फ़ जुड़े हुए टेक्स्ट की परवाह होती है। यहाँ chunks कुछ सेकंड के होते हैं, क्योंकि हर एक कैप्शन का समय बनता है। अगर आप हाथ से काटना पसंद करते हैं, तो [ऑडियो स्प्लिटर टूल](https://broadrouter.com/tools/audio-splitter-ffmpeg/) FFmpeg कमांड बनाता है।

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

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

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

`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](https://broadrouter.com/hi/blog/arabic-asr-wer-explained/) से टेस्ट करें।
-   **स्पीकर लेबल नहीं।** BroadNet कोई [diarization](https://broadrouter.com/hi/glossary/diarization/) नहीं लौटाता, इसलिए कैप्शन यह नहीं बताते कि कौन बोल रहा है।
-   **संगीत और शोर।** बैकग्राउंड संगीत ठहराव पूरी तरह छिपा सकता है। तब ज़्यादातर हिस्से तय कट होते हैं, और टाइमिंग बिगड़ती है।

लेक्चर, पॉडकास्ट, वेबिनार और ट्रेनिंग वीडियो के लिए बोली से एक सेकंड के भीतर के कैप्शन आम तौर पर पढ़ने लायक होते हैं। ड्रामा, म्यूज़िक वीडियो या lip-sync वाली किसी भी चीज़ के लिए शब्द [टाइमस्टैम्प](https://broadrouter.com/hi/glossary/timestamps-asr/) वाला प्रोवाइडर इस्तेमाल करें, या किसी सबटाइटलर से फ़ाइल ठीक करवाएँ।

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

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

स्पीड अनुरोधों की संख्या के हिसाब से है। उपयोग के अनुसार भुगतान वाली key प्रति मिनट 30 अनुरोध और 4 in flight देती है। 5 सेकंड के हिस्सों में बँटी एक घंटे की बोली लगभग 720 अनुरोध है, जिसमें कम से कम 720 ÷ 30 मिनट लगते हैं। लंबे हिस्सों का मतलब कम अनुरोध। अगर 429 आए, तो [एरर और retry गाइड](https://broadrouter.com/hi/guides/errors-and-retries/) के अनुसार रुकें, और प्रकाशित सीमाओं से बचने के लिए एक job को कई keys में न फैलाएँ।

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

BroadNet Transcribe Arabic सबटाइटल job के टेक्स्ट वाले हिस्से के लिए ठीक है: $0.0042 प्रति मिनट पर अरबी बोली से अरबी टेक्स्ट, और अनुरोध के बाद ऑडियो और ट्रांसक्रिप्ट नहीं रखे जाते। $5 का शुरुआती क्रेडिट ट्रांसक्रिप्शन को कवर करता है, इसलिए टॉप-अप से पहले आप असली एपिसोड पर पाइपलाइन टेस्ट कर सकते हैं। यह टाइमस्टैम्प, segments, स्पीकर लेबल या SRT नहीं लौटाता। अगर आपके सबटाइटल को शब्द-स्तर की टाइमिंग चाहिए, तो उसे दस्तावेज़ित करने वाला प्रोवाइडर इस्तेमाल करें, या forced-alignment टूल से BroadNet के टेक्स्ट को ऑडियो से मिलाएँ। अनुरोध का ढाँचा और सीमाएँ [BroadNet API रेफ़रंस](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-arabic-subtitles-srt-api&utm_content=body) में हैं, और सेटअप [अरबी speech-to-text गाइड](https://broadrouter.com/hi/guides/arabic-speech-to-text-api/) में।

इस विषय के मुफ़्त टूल (अंग्रेज़ी में)

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

[मुफ़्त टूल (अंग्रेज़ी में)](https://broadrouter.com/tools/)

## इस लेख के शब्द

[SRT सबटाइटल (SRT subtitles)](https://broadrouter.com/hi/glossary/srt-subtitles/)

SRT (SubRip) एक प्लेन-टेक्स्ट सबटाइटल फ़ॉर्मैट है। हर कैप्शन में एक क्रम संख्या, hh:mm:ss,mmm --> hh:mm:ss,mmm रूप में लिखा शुरू और अंत का समय, टेक्स्ट की एक या ज़्यादा लाइनें और एक ख़ाली लाइन होती है। WebVTT इससे मिलता-जुलता वेब फ़ॉर्मैट है, जिसे HTML वीडियो इस्तेमाल करता है।

[स्पीच-टू-टेक्स्ट (speech-to-text)](https://broadrouter.com/hi/glossary/speech-to-text/)

स्पीच-टू-टेक्स्ट, जिसे automatic speech recognition (ASR) भी कहते हैं, बोले गए ऑडियो को लिखित टेक्स्ट में बदलने की तकनीक है। speech-to-text API ऑडियो फ़ाइल या स्ट्रीम लेकर ट्रांसक्रिप्ट लौटाता है, आम तौर पर प्रति ऑडियो मिनट की कीमत पर। सटीकता वर्ड एरर रेट से मापी जाती है और लहजे, बोली और रिकॉर्डिंग क्वालिटी के साथ बदलती है।

[उपयोग के अनुसार भुगतान (pay-as-you-go)](https://broadrouter.com/hi/glossary/pay-as-you-go/)

उपयोग के अनुसार भुगतान (pay-as-you-go) एक प्राइसिंग मॉडल है जिसमें आप सिर्फ़ उतना देते हैं जितना इस्तेमाल करते हैं, जिसे टोकन, अनुरोध या ऑडियो मिनट जैसी इकाइयों में मापा जाता है, बिना सब्सक्रिप्शन या न्यूनतम प्रतिबद्धता के। ज़्यादातर LLM API इसी तरह बिल बनाते हैं, प्रीपेड बैलेंस या समय-समय पर बनने वाले इनवॉइस से।

[वर्ड एरर रेट (WER)](https://broadrouter.com/hi/glossary/word-error-rate/)

वर्ड एरर रेट (WER) स्पीच रिकग्निशन की सटीकता का मानक पैमाना है: ट्रांसक्रिप्ट को सही रेफ़रंस में बदलने के लिए ज़रूरी शब्दों के substitutions, deletions और insertions की संख्या, जिसे रेफ़रंस के कुल शब्दों से भाग दिया जाता है। जितना कम, उतना बेहतर।

[कॉन्करेंसी (concurrency)](https://broadrouter.com/hi/glossary/concurrency/)

कॉन्करेंसी, किसी क्लाइंट के एक ही समय पर चल रहे (in-flight) अनुरोधों की संख्या है। LLM API अक्सर इसकी सीमा हर key या प्लान पर, प्रति मिनट अनुरोधों से अलग रखते हैं, क्योंकि हर खुला अनुरोध जवाब पूरा होने तक GPU क्षमता घेरे रहता है।

[रेट लिमिट (rate limit)](https://broadrouter.com/hi/glossary/rate-limit/)

रेट लिमिट वह सीमा है जो कोई API तय करता है कि एक क्लाइंट किसी समय-अवधि में उसका कितना इस्तेमाल कर सकता है, जैसे प्रति मिनट अनुरोध या प्रति मिनट टोकन। सीमा से ऊपर के अनुरोध ठुकरा दिए जाते हैं, आम तौर पर HTTP 429 Too Many Requests के साथ, जब तक इस्तेमाल फिर सीमा के नीचे न आ जाए।

[स्पीकर डायराइज़ेशन (speaker diarization)](https://broadrouter.com/hi/glossary/diarization/)

स्पीकर डायराइज़ेशन ऑडियो रिकॉर्डिंग को बोलने वालों के हिसाब से हिस्सों में बाँटने का काम है, जो बताता है कि "कौन कब बोला"। यह बोली के हर हिस्से पर SPEAKER\_00 जैसा गुमनाम स्पीकर ID लगाता है, और आम तौर पर ट्रांसक्रिप्ट के साथ मिलाकर दिखाता है कि हर लाइन किसने कही।

[अरबी बोलियाँ (dialectal Arabic)](https://broadrouter.com/hi/glossary/dialectal-arabic/)

अरबी बोलियाँ किसी क्षेत्र या शहर में रोज़ बोली जाने वाली अरबी हैं, जैसे मिस्री, खाड़ी, लेवेंटाइन या मग़रिबी अरबी। ये आधुनिक मानक अरबी से आवाज़ों, शब्दों और व्याकरण में अलग हैं, इनकी कोई मानक वर्तनी नहीं, और ऑनलाइन इन्हें तेज़ी से लिखा जा रहा है, जिससे लैंग्वेज मॉडल के लिए ये मुश्किल हैं।

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

### क्या 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 पेज देखें।

## आगे पढ़ें

-   [25 MB से बड़ा लंबा ऑडियो ट्रांसक्राइब करें: बाँटें, भेजें, जोड़ें](https://broadrouter.com/hi/blog/transcribe-long-audio-files-api/)
-   [अरबी speech-to-text API: 2026 में सही API कैसे चुनें](https://broadrouter.com/hi/blog/arabic-speech-to-text-api-buyers-guide/)
-   [Whisper API का विकल्प: कब बदलें, और उसे कैसे टेस्ट करें](https://broadrouter.com/hi/blog/whisper-api-alternative/)
-   [अरबी रिकॉर्डिंग से मीटिंग मिनट्स: एक API पाइपलाइन](https://broadrouter.com/hi/blog/arabic-meeting-minutes-from-recordings/)
-   [स्पीच-टू-टेक्स्ट API की कीमतों की तुलना: 2026 में प्रति मिनट कीमत](https://broadrouter.com/hi/blog/speech-to-text-api-pricing-compared/)
-   [LLM से अरबी टेक्स्ट में हरकतें (तश्कील) लगाना: प्रॉम्प्ट, जाँच, DER](https://broadrouter.com/hi/blog/arabic-diacritization-llm/)
-   [LLM से अरबी व्याकरण और वर्तनी सुधार: एक how-to](https://broadrouter.com/hi/blog/arabic-grammar-spelling-correction-llm/)
-   [गाइड: अरबी speech-to-text API, स्टेप बाय स्टेप](https://broadrouter.com/hi/guides/arabic-speech-to-text-api/)
-   [गाइड: BroadNet Inference के एरर कोड और रीट्राई कब करें](https://broadrouter.com/hi/guides/errors-and-retries/)

इसे अपने असली वर्कलोड पर आज़माएँ। नए अकाउंट Gemma और ट्रांसक्रिप्शन के लिए US$5 के क्रेडिट से शुरू होते हैं। DeepSeek, GLM, और Qwen3.8 के लिए टॉप-अप ज़रूरी है।

[शुरू करें](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-arabic-subtitles-srt-api&utm_content=page-cta) ·

**स्रोत**

-   [BroadNet Inference API रेफ़रंस: ट्रांसक्रिप्शन अनुरोध और {"text": ...} जवाब, उपयोग के अनुसार भुगतान की सीमाएँ (2026-11-15 को जाँचा गया) (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-arabic-subtitles-srt-api&utm_content=sources)
-   [Library of Congress, Sustainability of Digital Formats: SubRip (SRT) फ़ॉर्मैट विवरण fdd000569 (2026-11-15 को जाँचा गया)](https://www.loc.gov/preservation/digital/formats/fdd/fdd000569.shtml)
-   [Netflix Partner Help Center, Arabic Timed Text Style Guide: प्रति लाइन 42 कैरेक्टर, पढ़ने की गति की सीमाएँ (2026-11-15 को जाँचा गया)](https://partnerhelp.netflixstudios.com/hc/en-us/articles/215517947)
-   [Netflix Partner Help Center, Timed Text Style Guide: General Requirements, न्यूनतम और अधिकतम अवधि (2026-11-15 को जाँचा गया)](https://partnerhelp.netflixstudios.com/hc/en-us/articles/215758617-Timed-Text-Style-Guide-General-Requirements)
-   [OpenAI API रेफ़रंस, create transcription: मॉडल के अनुसार response\_format और timestamp\_granularities (2026-11-15 को जाँचा गया)](https://developers.openai.com/api/reference/resources/audio/subresources/transcriptions/methods/create)
-   [OpenAI speech to text गाइड: timestamp\_granularities सिर्फ़ whisper-1 पर, deprecation की तारीख़ (2026-11-15 को जाँचा गया)](https://developers.openai.com/api/docs/guides/speech-to-text)
-   [OpenAI deprecations: whisper-1 और gpt-4o transcribe मॉडल 26 फ़रवरी 2027 को बंद; विकल्प gpt-transcribe या gpt-live-transcribe (2026-11-15 को जाँचा गया)](https://developers.openai.com/api/docs/deprecations)
-   [AssemblyAI API रेफ़रंस, Get subtitles: transcript subtitles endpoint, SRT या VTT फ़ॉर्मैट (2026-11-15 को जाँचा गया)](https://www.assemblyai.com/docs/api-reference/transcripts/get-subtitles)
-   [AssemblyAI, pre-recorded ऑडियो के लिए समर्थित भाषाएँ (2026-11-15 को जाँचा गया)](https://www.assemblyai.com/docs/pre-recorded-audio/supported-languages)
-   [Speechmatics डॉक्स, batch आउटपुट फ़ॉर्मैट: format=srt और srt\_overrides (2026-11-15 को जाँचा गया)](https://docs.speechmatics.com/speech-to-text/batch/output)
-   [Speechmatics डॉक्स, समर्थित भाषाएँ: अरबी और ar\_en द्विभाषी पैक (2026-11-15 को जाँचा गया)](https://docs.speechmatics.com/speech-to-text/languages)
-   [Deepgram डॉक्स, WebVTT और SRT कैप्शन अपने-आप बनाना (2026-11-15 को जाँचा गया)](https://developers.deepgram.com/docs/automatically-generating-webvtt-and-srt-captions)
-   [Deepgram डॉक्स, मॉडल और भाषाओं का अवलोकन: Nova-3 पर अरबी (2026-11-15 को जाँचा गया)](https://developers.deepgram.com/docs/models-languages-overview)
-   [ElevenLabs API रेफ़रंस, speech to text: timestamps\_granularity और शब्द start/end (2026-11-15 को जाँचा गया)](https://elevenlabs.io/docs/api-reference/speech-to-text/convert)
-   [FFmpeg filters डॉक्यूमेंटेशन: silencedetect और whisper filters (2026-11-15 को जाँचा गया)](https://ffmpeg.org/ffmpeg-filters.html)
