BroadRouter

25 MB से बड़ा लंबा ऑडियो ट्रांसक्राइब करें: बाँटें, भेजें, जोड़ें

BroadNet Inference टीम · 6 मिनट में पढ़ें · प्रकाशित

ज़्यादातर ट्रांसक्रिप्शन API लगभग 25 MB से बड़ी एक फ़ाइल को अस्वीकार कर देते हैं। पहले रिकॉर्डिंग को 16 kHz मोनो में बदलें: सिर्फ़ इससे BroadNet की 26,214,400 बाइट की सीमा में लगभग 13 मिनट WAV या 64 kbit/s MP3 के 54 मिनट समा जाते हैं। लंबे ऑडियो को ffmpeg से ख़ामोशी पर बाँटें, टुकड़ों को समानांतर ट्रांसक्राइब करें और टेक्स्ट को क्रम से जोड़ें।

ज़्यादातर 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” (अनुवाद: कॉन्टेक्स्ट हटा सकता है और सटीकता घटा सकता है)।

भरोसेमंद तरीक़ा है अपनी टारगेट लंबाई के पास किसी ख़ामोशी के अंदर काटना। अपनी फ़ाइल के आकार और अवधि के लिए तैयार कमांड पाने के लिए मुफ़्त ऑडियो स्प्लिटर कमांड बिल्डर इस्तेमाल करें। हाथ से यह ऐसे होता है:

  1. ख़ामोश हिस्सों की सूची के लिए ffmpeg का silencedetect फ़िल्टर चलाएँ।
  2. रिकॉर्डिंग में आगे बढ़ें। जब कोई टुकड़ा लगभग 10 मिनट का हो जाए, तो अगली ख़ामोशी पर काटें।
  3. हर टुकड़े को 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 गाइड पहला अनुरोध कवर करती है; यह पोस्ट उन फ़ाइलों को कवर करती है जो एक अनुरोध के लिए बहुत बड़ी हैं।

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

25 MB से बड़ी ऑडियो फ़ाइल कैसे ट्रांसक्राइब करूँ?

पहले उसे 16 kHz मोनो में बदलें, जिससे वह अक्सर सीमा के नीचे आ जाती है। अगर फिर भी बड़ी है, तो ffmpeg से ख़ामोश जगहों पर लगभग 10 मिनट के टुकड़ों में बाँटें, हर टुकड़े को उसी language सेटिंग के साथ ट्रांसक्राइब करें, और टेक्स्ट को क्रम से जोड़ें।

25 MB में कितने मिनट का ऑडियो आता है?

यह फ़ॉर्मैट पर निर्भर है। 16 kHz मोनो 16-bit WAV प्रति सेकंड 32,000 बाइट लेता है, इसलिए 26,214,400 बाइट में लगभग 13.6 मिनट आते हैं। 64 kbit/s MP3 में लगभग 54 मिनट। स्टीरियो या 44.1 kHz WAV में बहुत कम आता है।

सीमा से बड़ी फ़ाइल अपलोड करने पर क्या होता है?

अनुरोध अस्वीकार हो जाता है। BroadNet Inference 413 लौटाता है, जिसे उसके डॉक्स ऐसा अनुरोध बताते हैं जो एंडपॉइंट की बाइट या टेक्स्ट सीमा पार करता है। कुछ भी ट्रांसक्राइब नहीं होता, इसलिए बाँटें और दोबारा भेजें।

क्या टुकड़ों की सीमा पर शब्द खो जाते हैं?

खो सकते हैं, अगर आप बोलने के बीच किसी तय समय पर काटें। इसकी जगह ख़ामोशी के अंदर काटें। अगर तय समय पर ही काटना है, तो टुकड़ों को एक-दो सेकंड ओवरलैप करें और जोड़ते समय दोहराए गए शब्द हटा दें।

क्या फ़ाइल बाँटने से लागत बढ़ती है?

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

क्या मैं पिछले टुकड़े का टेक्स्ट कॉन्टेक्स्ट के रूप में भेज सकता हूँ?

कुछ API इसके लिए prompt लेते हैं; OpenAI पिछले टुकड़े से कॉन्टेक्स्ट आगे ले जाने को अपने prompt पैरामीटर का एक उपयोग बताता है। BroadNet के डॉक्स सिर्फ़ model, language और file लिस्ट करते हैं, इसलिए वहाँ prompt पर भरोसा न करें।

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