ज़्यादातर speech-to-text API हर अनुरोध में लगभग 25 MB की एक फ़ाइल लेते हैं। BroadNet Inference 26,214,400 बाइट तक का WAV या MP3 लेता है। लंबी मीटिंग, लेक्चर या पॉडकास्ट इससे आगे निकल जाता है, और अनुरोध 413 के साथ फ़ेल होता है। इसका हल चार क़दमों में है: फ़ाइल छोटी करें, उसे ख़ामोशी पर बाँटें, टुकड़े समानांतर भेजें, और टेक्स्ट वापस जोड़ें।
लंबी रिकॉर्डिंग फ़ेल क्यों होती है?
सीमा बाइट पर है, मिनटों पर नहीं। कितने मिनट समाएँगे, यह फ़ॉर्मैट पर निर्भर है:
| फ़ॉर्मैट | प्रति सेकंड बाइट | 26,214,400 बाइट में कितना |
|---|---|---|
| WAV, 44.1 kHz स्टीरियो, 16-bit | 176,400 | लगभग 2.5 मिनट |
| WAV, 16 kHz मोनो, 16-bit | 32,000 | लगभग 13.6 मिनट |
| MP3, 64 kbit/s | 8,000 | लगभग 54 मिनट |
| MP3, 32 kbit/s | 4,000 | लगभग 109 मिनट |
ये सरल हिसाब हैं: प्रति सेकंड बाइट गुणा सेकंड। फ़ोन या लैपटॉप की रिकॉर्डिंग अक्सर 44.1 या 48 kHz स्टीरियो होती है, जो कुछ ही मिनटों में सीमा भर देती है। बोलचाल के लिए इसकी ज़रूरत नहीं है। सबसे पहले 16 kHz मोनो में बदलना सबसे बड़ा अकेला फ़ायदा है।
जब फ़ाइल फिर भी बहुत बड़ी हो, तो API उसे सीधे अस्वीकार कर देता है। BroadNet पर जवाब 413 है, “the request exceeds the endpoint byte or text limit” (अनुवाद: अनुरोध एंडपॉइंट की बाइट या टेक्स्ट सीमा पार करता है), और कुछ भी ट्रांसक्राइब नहीं होता। देखें एरर कोड गाइड।
क़दम 1: फ़ाइल छोटी कैसे करें?
कुछ भी करने से पहले 16 kHz मोनो में बदलें। एक ffmpeg कमांड काफ़ी है:
ffmpeg -i meeting.m4a -ac 1 -ar 16000 meeting.wav
BroadNet के लिए आउटपुट WAV (audio/wav) या MP3 (audio/mpeg) होना चाहिए। .m4a, .ogg और .webm जैसे फ़ॉर्मैट तो बदलने ही पड़ते हैं, इसलिए रीसैंपलिंग उसी क़दम में कर लें।
WAV चुनें या MP3? WAV लॉसलेस है, कुछ नहीं खोता, पर लगभग 13 मिनट में सीमा भर देता है। 64 kbit/s पर MP3 हर अनुरोध में चार गुना ज़्यादा ऑडियो समा लेता है, पर वह लॉसी है। MP3 इस्तेमाल करें तो एक छोटा टेस्ट चलाएँ: वही पाँच मिनट WAV और MP3 दोनों में ट्रांसक्राइब करें और टेक्स्ट मिलाएँ। सैंपल रेट वाली एंट्री बताती है कि बोलचाल के लिए 16 kHz क्यों काफ़ी है।
क़दम 2: शब्द काटे बिना ऑडियो कैसे बाँटें?
समय से बाँटें, बाइट से कभी नहीं। बाइट ऑफ़सेट पर कट किसी ऑडियो फ़्रेम के बीच में पड़ सकता है, और फ़ाइल डिकोड नहीं होगी। तय समय पर कट किसी शब्द के बीच में पड़ सकता है। OpenAI की अपनी गाइड वाक्य के बीच बाँटने से मना करती है, क्योंकि यह “can remove context and reduce accuracy” (अनुवाद: कॉन्टेक्स्ट हटा सकता है और सटीकता घटा सकता है)।
भरोसेमंद तरीक़ा है अपनी टारगेट लंबाई के पास किसी ख़ामोशी के अंदर काटना। अपनी फ़ाइल के आकार और अवधि के लिए तैयार कमांड पाने के लिए मुफ़्त ऑडियो स्प्लिटर कमांड बिल्डर इस्तेमाल करें। हाथ से यह ऐसे होता है:
- ख़ामोश हिस्सों की सूची के लिए ffmpeg का silencedetect फ़िल्टर चलाएँ।
- रिकॉर्डिंग में आगे बढ़ें। जब कोई टुकड़ा लगभग 10 मिनट का हो जाए, तो अगली ख़ामोशी पर काटें।
- हर टुकड़े को ffmpeg से एक कट पॉइंट से अगले तक काटें।
16 kHz मोनो WAV के दस मिनट 19.2 MB हैं, जिससे सीमा के नीचे जगह बचती है। अगर कोई बोलने वाला बिना रुके देर तक बोलता है, तो नीचे की स्क्रिप्ट सख़्त अधिकतम सीमा पर काटती है।
ffmpeg का segment muxer भी एक कमांड से फ़ाइल को “of nearly fixed duration” (अनुवाद: लगभग तय अवधि वाले) टुकड़ों में बाँट सकता है। यह तेज़ है, पर ख़ामोशी नहीं ढूँढता, इसलिए इसे तभी इस्तेमाल करें जब हर सीमा पर एक शब्द खोना स्वीकार्य हो, या ओवरलैप जोड़ें (नीचे देखें)।
पूरी स्क्रिप्ट कैसी दिखती है?
यह Python स्क्रिप्ट फ़ाइल बदलती है, ख़ामोशी पर बाँटती है, एक साथ चार टुकड़े तक भेजती है और टेक्स्ट जोड़ती है। यह BroadNet Inference पर पॉइंट किया हुआ OpenAI SDK इस्तेमाल करती है।
# pip install openai
import os, re, subprocess, tempfile
from concurrent.futures import ThreadPoolExecutor
from openai import OpenAI
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
TARGET, HARD_MAX = 600, 750 # seconds: aim for 10 min, never above 12.5 min
def run(*args):
return subprocess.run(args, capture_output=True, text=True, check=True)
def silences(path):
"""Midpoints (in seconds) of silent gaps of 0.5 s or more."""
out = run("ffmpeg", "-i", path, "-af", "silencedetect=noise=-35dB:d=0.5",
"-f", "null", "-").stderr
starts = [float(x) for x in re.findall(r"silence_start: ([\d.]+)", out)]
ends = [float(x) for x in re.findall(r"silence_end: ([\d.]+)", out)]
return [(s + e) / 2 for s, e in zip(starts, ends)]
def duration(path):
return float(run("ffprobe", "-v", "error", "-show_entries", "format=duration",
"-of", "csv=p=0", path).stdout)
def cut_points(path):
total, gaps, cuts, last = duration(path), silences(path), [0.0], 0.0
while total - last > HARD_MAX:
ok = [g for g in gaps if last + TARGET <= g <= last + HARD_MAX]
last = ok[0] if ok else last + HARD_MAX # no silence: hard cut
cuts.append(last)
return cuts + [total]
def transcribe(chunk):
with open(chunk, "rb") as f:
return client.audio.transcriptions.create(
model="broadnet/cohere-transcribe-arabic", file=f, language="ar").text
def transcribe_long(src):
with tempfile.TemporaryDirectory() as tmp:
wav = os.path.join(tmp, "full.wav")
run("ffmpeg", "-y", "-i", src, "-ac", "1", "-ar", "16000", wav)
cuts, chunks = cut_points(wav), []
for i, (a, b) in enumerate(zip(cuts, cuts[1:])):
out = os.path.join(tmp, f"part{i:03d}.wav")
run("ffmpeg", "-y", "-i", wav, "-ss", str(a), "-to", str(b), out)
chunks.append(out)
with ThreadPoolExecutor(max_workers=4) as pool: # map() keeps order
return "\n".join(pool.map(transcribe, chunks))
print(transcribe_long("meeting.m4a"))
स्क्रिप्ट पर नोट्स:
- भाषा। BroadNet के डॉक्स कहते हैं कि हमेशा
languageभेजें; इसके बिना अरबी “can otherwise be transliterated into Latin letters” (अनुवाद: वरना लैटिन अक्षरों में लिप्यंतरित हो सकती है)। अंग्रेज़ी, फ़्रेंच या इसकी किसी और सपोर्टेड भाषा के लिए सही भाषा कोड के साथbroadnet/cohere-transcribeइस्तेमाल करें। - थ्रेशोल्ड।
-35dBऔर0.5सेकंड शांत कमरे के लिए ठीक हैं। शोर वाले कमरों को ज़्यादा noise वैल्यू चाहिए, जैसे-30dB। एक बार कट पॉइंट प्रिंट करके जाँच लें। - क्रम।
pool.mapनतीजे इनपुट के क्रम में लौटाता है, इसलिए टुकड़े अलग-अलग समय पर पूरे होने पर भी टेक्स्ट सही क्रम में जुड़ता है।
एक साथ कितने टुकड़े भेज सकते हैं?
जितने आपकी key अनुमति दे। BroadNet की उपयोग के अनुसार भुगतान वाली key एक साथ 4 अनुरोध और प्रति मिनट 30 अनुरोधों की अनुमति देती है, इसीलिए स्क्रिप्ट चार वर्कर इस्तेमाल करती है। उसी समय पाँचवाँ अनुरोध 429 पाता है। 429 और 5xx जवाबों को एक्सपोनेंशियल बैकऑफ़ के साथ रीट्राई करें; 413 को रीट्राई न करें, क्योंकि वही फ़ाइल फिर फ़ेल होगी। 429 एरर कैसे सँभालें में एक रीट्राई हेल्पर है जिसे आप transcribe() के चारों ओर लगा सकते हैं।
चार वर्कर के साथ, 10 मिनट के टुकड़ों में दो घंटे की रिकॉर्डिंग तीन लहरों में 12 अनुरोध बन जाती है। कुल समय लगभग तीन टुकड़ों के आने-जाने जितना है, बारह जितना नहीं।
क्या टुकड़ों के बीच ओवरलैप चाहिए?
नहीं, अगर आप ख़ामोशी के अंदर काटते हैं: सीमा पर कोई बोलचाल ही नहीं है जो खोए। ओवरलैप तय समय वाले कट के लिए है। हर टुकड़ा पिछले टुकड़े के ख़त्म होने से एक-दो सेकंड पहले शुरू करें, फिर टेक्स्ट जोड़ते समय दोहराए गए शब्द हटा दें। आम तरीक़ा है एक टुकड़े के आख़िरी कुछ शब्दों को अगले के पहले कुछ शब्दों से मिलाना और मेल खाने वाला हिस्सा हटा देना।
ओवरलैप की थोड़ी लागत है। हर 10 मिनट के टुकड़े पर दो सेकंड, भुगतान वाले ऑडियो में लगभग 0.3% जोड़ते हैं।
क्या अगला टुकड़ा पिछले टुकड़े का टेक्स्ट कॉन्टेक्स्ट के रूप में ले सकता है?
कुछ API इसकी अनुमति देते हैं। OpenAI अपने prompt पैरामीटर का एक उपयोग “carrying context from a previous chunk of a longer recording” (अनुवाद: लंबी रिकॉर्डिंग के पिछले टुकड़े से कॉन्टेक्स्ट आगे ले जाना) बताता है। BroadNet का API रेफ़रंस ट्रांसक्रिप्शन के लिए सिर्फ़ model, language और file लिस्ट करता है, और text फ़ील्ड वाला JSON लौटाता है। इसलिए BroadNet पर हर टुकड़े को स्वतंत्र मानें, और नाम और शब्द बाद में ठीक करें। एक सस्ता तरीक़ा है जुड़ा हुआ ट्रांसक्रिप्ट लोगों, प्रोडक्ट्स और जगहों की सही वर्तनी की सूची के साथ किसी चैट मॉडल को भेजना।
लंबी फ़ाइल की लागत कितनी है?
speech to text का बिल प्रति ऑडियो मिनट बनता है, इसलिए बाँटने से कुल नहीं बदलता। BroadNet की प्रकाशित दरों पर:
| ऑडियो | BroadNet Transcribe Arabic | BroadNet Transcribe (14 भाषाएँ) |
|---|---|---|
| प्रति मिनट कीमत | $0.0042 | $0.002 |
| एक घंटा | $0.25 | $0.12 |
| 1,000 घंटे | $252.00 | $120.00 |
प्राइसिंग पेज प्रति ऑडियो मिनट कीमत लिस्ट करता है और प्रति फ़ाइल न्यूनतम या राउंडिंग के बारे में कुछ नहीं कहता। पहले बैच के बाद usage पेज देखकर पुष्टि करें कि कुल रक़म ऑडियो की लंबाई से मेल खाती है। दोनों ट्रांसक्रिप्शन मॉडल $5 के मुफ़्त शुरुआती क्रेडिट पर उपलब्ध हैं, जो लगभग 1,190 मिनट की अरबी कवर करता है। अपने वॉल्यूम की कीमत निकालने के लिए speech-to-text लागत कैलकुलेटर इस्तेमाल करें; प्रोवाइडर्स की तुलना के लिए speech-to-text API कीमतों का डेटासेट देखें।
किन ग़लतियों से बचें?
- मूल फ़ाइल भेजना। 48 kHz स्टीरियो WAV ज़रूरत से छह गुना बड़ा है।
- बाइट ऑफ़सेट पर काटना। टुकड़ा डिकोड नहीं होगा, या पहला सेकंड शोर होगा।
- ठीक सीमा पर टुकड़े। 25.9 MB का टुकड़ा आज पास होता है और जब रिकॉर्डिंग थोड़ी तेज़ आवाज़ वाली हो तो फ़ेल होता है। गुंजाइश छोड़ें।
- बेहिसाब समानांतरता। एक साथ 50 टुकड़े भेजने पर ज़्यादातर को 429 मिलता है। वर्कर की संख्या key की एक-साथ सीमा पर रोकें।
- भाषा भूल जाना। हर टुकड़ा अलग अनुरोध है, इसलिए हर एक को
languageचाहिए।
चंकिंग कब ग़लत तरीक़ा है?
अगर आपको स्पीकर लेबल या शब्दों के टाइमस्टैम्प चाहिए, तो सादा-टेक्स्ट API को टुकड़ों में बाँटने से वे नहीं मिलेंगे। BroadNet का ट्रांसक्रिप्शन जवाब सिर्फ़ टेक्स्ट है। जो प्रोवाइडर डायराइज़ेशन और टाइमस्टैम्प लौटाते हैं, वे लंबी फ़ाइलें भी ज़्यादा सीधे तरीक़े से सँभालते हैं; अरबी speech-to-text ख़रीदार गाइड उनकी तुलना करती है। स्टीरियो कॉल रिकॉर्डिंग के लिए समय की जगह चैनल से बाँटें: कॉल सेंटर पाइपलाइन दिखाती है कैसे।
BroadNet Inference कहाँ काम आता है
BroadNet Transcribe Arabic की कीमत $0.0042 प्रति मिनट है, और BroadNet इसे Open Universal Arabic ASR Leaderboard पर 37 में से #2 (यह सितंबर 2026 का आंकड़ा है; 15 नवंबर 2026 को लाइव लीडरबोर्ड पर यह 39 में से #4 था) बताता है। अनुरोध के बाद ऑडियो और ट्रांसक्रिप्ट रखे नहीं जाते। ऊपर बताए तरीक़े से बाँटने के बाद यह लंबी अरबी रिकॉर्डिंग के बैच ट्रांसक्रिप्शन के लिए ठीक है। अगर आपको उसी API में टाइमस्टैम्प, स्पीकर लेबल या लाइव स्ट्रीमिंग चाहिए, तो यह आपके लिए ठीक नहीं है। अरबी speech-to-text गाइड पहला अनुरोध कवर करती है; यह पोस्ट उन फ़ाइलों को कवर करती है जो एक अनुरोध के लिए बहुत बड़ी हैं।
