---
title: "25 MB से बड़ा ऑडियो API से ट्रांसक्राइब करें: बाँटें, जोड़ें"
description: "speech-to-text API की फ़ाइल सीमा से बड़ी रिकॉर्डिंग कैसे ट्रांसक्राइब करें: फ़ाइल छोटी करें, ffmpeg से ख़ामोशी पर बाँटें, टुकड़े समानांतर भेजें और टेक्स्ट जोड़ें।"
url: https://broadrouter.com/hi/blog/transcribe-long-audio-files-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/transcribe-long-audio-files-api/) (2026-11-15 को अपडेट किया गया).

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

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

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

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

-   सीमा बाइट की है, मिनट की नहीं। 16 kHz मोनो WAV प्रति सेकंड 32,000 बाइट है, इसलिए 26,214,400 बाइट लगभग 13.6 मिनट हैं; 64 kbit/s MP3 लगभग 54 मिनट।
-   समय के हिसाब से, ख़ामोशी पर बाँटें, कभी बाइट ऑफ़सेट पर नहीं। बाइट पर कट ऑडियो फ़्रेम तोड़ देता है, और शब्द के बीच का कट शब्द खो देता है।
-   टुकड़े सीमा से काफ़ी नीचे रखें, जैसे WAV के 10 मिनट, ताकि कोई शोर वाली फ़ाइल कभी 413 न लौटाए।
-   टुकड़े key की सीमा तक समानांतर भेजें: BroadNet की उपयोग के अनुसार भुगतान वाली key पर एक साथ 4 अनुरोध और प्रति मिनट 30।
-   बाँटने से वह ऑडियो लंबाई नहीं बदलती जिसका आप भुगतान करते हैं। BroadNet Transcribe Arabic पर एक घंटे की अरबी की लागत $0.25 है।

**इस पेज पर**

1.  लंबी रिकॉर्डिंग फ़ेल क्यों होती है?
2.  क़दम 1: फ़ाइल छोटी कैसे करें?
3.  क़दम 2: शब्द काटे बिना ऑडियो कैसे बाँटें?
4.  पूरी स्क्रिप्ट कैसी दिखती है?
5.  एक साथ कितने टुकड़े भेज सकते हैं?
6.  क्या टुकड़ों के बीच ओवरलैप चाहिए?
7.  क्या अगला टुकड़ा पिछले टुकड़े का टेक्स्ट कॉन्टेक्स्ट के रूप में ले सकता है?
8.  लंबी फ़ाइल की लागत कितनी है?
9.  किन ग़लतियों से बचें?
10.  चंकिंग कब ग़लत तरीक़ा है?
11.  BroadNet Inference कहाँ काम आता है

ज़्यादातर 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” (अनुवाद: अनुरोध एंडपॉइंट की बाइट या टेक्स्ट सीमा पार करता है), और कुछ भी ट्रांसक्राइब नहीं होता। देखें [एरर कोड गाइड](https://broadrouter.com/hi/guides/errors-and-retries/)।

## क़दम 1: फ़ाइल छोटी कैसे करें?

कुछ भी करने से पहले 16 kHz मोनो में बदलें। एक ffmpeg कमांड काफ़ी है:

```bash
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 दोनों में ट्रांसक्राइब करें और टेक्स्ट मिलाएँ। [सैंपल रेट](https://broadrouter.com/hi/glossary/sample-rate/) वाली एंट्री बताती है कि बोलचाल के लिए 16 kHz क्यों काफ़ी है।

## क़दम 2: शब्द काटे बिना ऑडियो कैसे बाँटें?

समय से बाँटें, बाइट से कभी नहीं। बाइट ऑफ़सेट पर कट किसी ऑडियो फ़्रेम के बीच में पड़ सकता है, और फ़ाइल डिकोड नहीं होगी। तय समय पर कट किसी शब्द के बीच में पड़ सकता है। OpenAI की अपनी गाइड वाक्य के बीच बाँटने से मना करती है, क्योंकि यह “can remove context and reduce accuracy” (अनुवाद: कॉन्टेक्स्ट हटा सकता है और सटीकता घटा सकता है)।

भरोसेमंद तरीक़ा है अपनी टारगेट लंबाई के पास किसी ख़ामोशी के अंदर काटना। अपनी फ़ाइल के आकार और अवधि के लिए तैयार कमांड पाने के लिए मुफ़्त [ऑडियो स्प्लिटर कमांड बिल्डर](https://broadrouter.com/tools/audio-splitter-ffmpeg/) इस्तेमाल करें। हाथ से यह ऐसे होता है:

1.  ख़ामोश हिस्सों की सूची के लिए ffmpeg का [silencedetect](https://ffmpeg.org/ffmpeg-filters.html) फ़िल्टर चलाएँ।
2.  रिकॉर्डिंग में आगे बढ़ें। जब कोई टुकड़ा लगभग 10 मिनट का हो जाए, तो अगली ख़ामोशी पर काटें।
3.  हर टुकड़े को ffmpeg से एक कट पॉइंट से अगले तक काटें।

16 kHz मोनो WAV के दस मिनट 19.2 MB हैं, जिससे सीमा के नीचे जगह बचती है। अगर कोई बोलने वाला बिना रुके देर तक बोलता है, तो नीचे की स्क्रिप्ट सख़्त अधिकतम सीमा पर काटती है।

ffmpeg का [segment muxer](https://ffmpeg.org/ffmpeg-formats.html) भी एक कमांड से फ़ाइल को “of nearly fixed duration” (अनुवाद: लगभग तय अवधि वाले) टुकड़ों में बाँट सकता है। यह तेज़ है, पर ख़ामोशी नहीं ढूँढता, इसलिए इसे तभी इस्तेमाल करें जब हर सीमा पर एक शब्द खोना स्वीकार्य हो, या ओवरलैप जोड़ें (नीचे देखें)।

## पूरी स्क्रिप्ट कैसी दिखती है?

यह Python स्क्रिप्ट फ़ाइल बदलती है, ख़ामोशी पर बाँटती है, एक साथ चार टुकड़े तक भेजती है और टेक्स्ट जोड़ती है। यह BroadNet Inference पर पॉइंट किया हुआ OpenAI SDK इस्तेमाल करती है।

```python
# 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” (अनुवाद: वरना लैटिन अक्षरों में लिप्यंतरित हो सकती है)। अंग्रेज़ी, फ़्रेंच या इसकी किसी और [सपोर्टेड भाषा](https://broadrouter.com/hi/blog/multilingual-speech-to-text-api/) के लिए सही भाषा कोड के साथ `broadnet/cohere-transcribe` इस्तेमाल करें।
-   **थ्रेशोल्ड।** `-35dB` और `0.5` सेकंड शांत कमरे के लिए ठीक हैं। शोर वाले कमरों को ज़्यादा noise वैल्यू चाहिए, जैसे `-30dB`। एक बार कट पॉइंट प्रिंट करके जाँच लें।
-   **क्रम।** `pool.map` नतीजे इनपुट के क्रम में लौटाता है, इसलिए टुकड़े अलग-अलग समय पर पूरे होने पर भी टेक्स्ट सही क्रम में जुड़ता है।

## एक साथ कितने टुकड़े भेज सकते हैं?

जितने आपकी key अनुमति दे। BroadNet की उपयोग के अनुसार भुगतान वाली key एक साथ 4 अनुरोध और प्रति मिनट 30 अनुरोधों की अनुमति देती है, इसीलिए स्क्रिप्ट चार वर्कर इस्तेमाल करती है। उसी समय पाँचवाँ अनुरोध 429 पाता है। 429 और 5xx जवाबों को एक्सपोनेंशियल बैकऑफ़ के साथ रीट्राई करें; 413 को रीट्राई न करें, क्योंकि वही फ़ाइल फिर फ़ेल होगी। [429 एरर कैसे सँभालें](https://broadrouter.com/hi/blog/handle-llm-api-429-rate-limits/) में एक रीट्राई हेल्पर है जिसे आप `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 लागत कैलकुलेटर](https://broadrouter.com/tools/speech-to-text-cost-calculator/) इस्तेमाल करें; प्रोवाइडर्स की तुलना के लिए [speech-to-text API कीमतों का डेटासेट](https://broadrouter.com/data/speech-to-text-api-prices/) देखें।

## किन ग़लतियों से बचें?

-   **मूल फ़ाइल भेजना।** 48 kHz स्टीरियो WAV ज़रूरत से छह गुना बड़ा है।
-   **बाइट ऑफ़सेट पर काटना।** टुकड़ा डिकोड नहीं होगा, या पहला सेकंड शोर होगा।
-   **ठीक सीमा पर टुकड़े।** 25.9 MB का टुकड़ा आज पास होता है और जब रिकॉर्डिंग थोड़ी तेज़ आवाज़ वाली हो तो फ़ेल होता है। गुंजाइश छोड़ें।
-   **बेहिसाब समानांतरता।** एक साथ 50 टुकड़े भेजने पर ज़्यादातर को 429 मिलता है। वर्कर की संख्या key की एक-साथ सीमा पर रोकें।
-   **भाषा भूल जाना।** हर टुकड़ा अलग अनुरोध है, इसलिए हर एक को `language` चाहिए।

## चंकिंग कब ग़लत तरीक़ा है?

अगर आपको स्पीकर लेबल या शब्दों के टाइमस्टैम्प चाहिए, तो सादा-टेक्स्ट API को टुकड़ों में बाँटने से वे नहीं मिलेंगे। BroadNet का ट्रांसक्रिप्शन जवाब सिर्फ़ टेक्स्ट है। जो प्रोवाइडर [डायराइज़ेशन](https://broadrouter.com/hi/glossary/diarization/) और [टाइमस्टैम्प](https://broadrouter.com/hi/glossary/timestamps-asr/) लौटाते हैं, वे लंबी फ़ाइलें भी ज़्यादा सीधे तरीक़े से सँभालते हैं; [अरबी speech-to-text ख़रीदार गाइड](https://broadrouter.com/hi/blog/arabic-speech-to-text-api-buyers-guide/) उनकी तुलना करती है। स्टीरियो कॉल रिकॉर्डिंग के लिए समय की जगह चैनल से बाँटें: [कॉल सेंटर पाइपलाइन](https://broadrouter.com/hi/blog/transcribe-call-center-recordings/) दिखाती है कैसे।

## BroadNet Inference कहाँ काम आता है

BroadNet Transcribe Arabic की कीमत $0.0042 प्रति मिनट है, और BroadNet इसे [Open Universal Arabic ASR Leaderboard](https://huggingface.co/spaces/elmresearchcenter/open_universal_arabic_asr_leaderboard) पर 37 में से #2 (यह सितंबर 2026 का आंकड़ा है; 15 नवंबर 2026 को लाइव लीडरबोर्ड पर यह 39 में से #4 था) बताता है। अनुरोध के बाद ऑडियो और ट्रांसक्रिप्ट रखे नहीं जाते। ऊपर बताए तरीक़े से बाँटने के बाद यह लंबी अरबी रिकॉर्डिंग के बैच ट्रांसक्रिप्शन के लिए ठीक है। अगर आपको उसी API में टाइमस्टैम्प, स्पीकर लेबल या लाइव स्ट्रीमिंग चाहिए, तो यह आपके लिए ठीक नहीं है। [अरबी speech-to-text गाइड](https://broadrouter.com/hi/guides/arabic-speech-to-text-api/) पहला अनुरोध कवर करती है; यह पोस्ट उन फ़ाइलों को कवर करती है जो एक अनुरोध के लिए बहुत बड़ी हैं।

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

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

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

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

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

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

[WAV फ़ाइल (WAV)](https://broadrouter.com/hi/glossary/wav/)

WAV (Waveform Audio File Format, या WAVE) Microsoft और IBM के RIFF फ़ॉर्मैट पर बना एक ऑडियो कंटेनर है। इसमें आम तौर पर बिना कंप्रेशन वाले linear PCM सैंपल होते हैं, इसलिए इसका साइज़ पहले से पता होता है: प्रति सेकंड सैंपल रेट गुणा प्रति सैंपल बाइट गुणा चैनल।

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

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

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

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

[टूल कॉलिंग (tool calling)](https://broadrouter.com/hi/glossary/tool-calling/)

टूल कॉलिंग, जिसे function calling भी कहते हैं, LLM API की वह सुविधा है जिसमें मॉडल डेवलपर के तय किए किसी फ़ंक्शन को चलाने का एक स्ट्रक्चर्ड अनुरोध, JSON आर्ग्युमेंट के साथ, लौटाता है। ऐप्लिकेशन फ़ंक्शन चलाकर नतीजा वापस भेजता है; मॉडल ख़ुद कभी कोड नहीं चलाता।

[रेट लिमिट (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 लगाता है, और आम तौर पर ट्रांसक्रिप्ट के साथ मिलाकर दिखाता है कि हर लाइन किसने कही।

[Prefill और decode](https://broadrouter.com/hi/glossary/prefill-and-decode/)

Prefill और decode LLM इन्फ़रेंस के दो चरण हैं। Prefill में मॉडल पूरा प्रॉम्प्ट समानांतर रूप से प्रोसेस करके अपना KV cache भरता है; decode में वह उसी cache को दोबारा इस्तेमाल करते हुए जवाब एक-एक टोकन करके बनाता है। Prefill मुख्य रूप से पहले टोकन तक का समय तय करता है; decode आउटपुट की रफ़्तार।

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

### 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 पर भरोसा न करें।

## आगे पढ़ें

-   [कॉल सेंटर रिकॉर्डिंग कैसे ट्रांसक्राइब करें: अरबी-रेडी पाइपलाइन](https://broadrouter.com/hi/blog/transcribe-call-center-recordings/)
-   [मल्टीलिंगुअल speech-to-text API: 14 भाषाएँ, एक एंडपॉइंट](https://broadrouter.com/hi/blog/multilingual-speech-to-text-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 की कीमतों की तुलना: 2026 में प्रति मिनट कीमत](https://broadrouter.com/hi/blog/speech-to-text-api-pricing-compared/)
-   [speech-to-text API से अरबी सबटाइटल (SRT): आपको क्या चाहिए](https://broadrouter.com/hi/blog/arabic-subtitles-srt-api/)
-   [ब्राउज़र में ऑडियो रिकॉर्ड करें और speech-to-text API को भेजें](https://broadrouter.com/hi/blog/record-browser-audio-transcription-api/)
-   [API से अरबी ऑडियो का अंग्रेज़ी में अनुवाद: टेस्ट की हुई पाइपलाइन](https://broadrouter.com/hi/blog/translate-arabic-audio-to-english/)
-   [BroadNet का GPU हार्डवेयर और सर्विंग का तरीक़ा, BroadNet के शब्दों में](https://broadrouter.com/hi/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM API रिस्पॉन्स कैश करके लागत घटाएँ: Python में एक्ज़ैक्ट-मैच कैश](https://broadrouter.com/hi/blog/cache-llm-responses-cut-cost/)
-   [गाइड: अरबी speech-to-text API, स्टेप बाय स्टेप](https://broadrouter.com/hi/guides/arabic-speech-to-text-api/)
-   [गाइड: API से WhatsApp वॉइस नोट को टेक्स्ट में बदलें](https://broadrouter.com/hi/guides/transcribe-whatsapp-voice-notes/)
-   [गाइड: 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-transcribe-long-audio-files-api&utm_content=page-cta) ·

**स्रोत**

-   [BroadNet Inference API रेफ़रंस: WAV या MP3, 26,214,400 बाइट तक, language फ़ील्ड, 413 और 429 एरर, उपयोग के अनुसार भुगतान की सीमाएँ (जाँचा गया 2026-11-15) (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-transcribe-long-audio-files-api&utm_content=sources)
-   [BroadNet Inference कीमतों का पेज, प्रति ऑडियो मिनट ट्रांसक्रिप्शन कीमत (जाँचा गया 2026-11-15) (अंग्रेज़ी में)](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-transcribe-long-audio-files-api&utm_content=sources)
-   [OpenAI speech to text गाइड: 25 MB फ़ाइल सीमा, टुकड़ों में बाँटें, वाक्य के बीच में न बाँटें (जाँचा गया 2026-11-15)](https://developers.openai.com/api/docs/guides/speech-to-text)
-   [FFmpeg फ़ॉर्मैट डॉक्युमेंटेशन, segment muxer (जाँचा गया 2026-11-15)](https://ffmpeg.org/ffmpeg-formats.html)
-   [Hugging Face पर Open Universal Arabic ASR Leaderboard (BroadNet की बताई रैंक; BroadRouter ने जाँचा 2026-11-15)](https://huggingface.co/spaces/elmresearchcenter/open_universal_arabic_asr_leaderboard)
-   [FFmpeg फ़िल्टर डॉक्युमेंटेशन, silencedetect (जाँचा गया 2026-11-15)](https://ffmpeg.org/ffmpeg-filters.html)
