---
title: "Batch API के बिना LLM बैच प्रोसेसिंग: runner और हिसाब"
description: "Batch API के बिना chat-completions API से 10,000 से 1,000,000 प्रॉम्प्ट चलाएँ: concurrency सीमा, रेट पेसिंग, retry, दोबारा शुरू होने वाले checkpoint और समय का हिसाब।"
url: https://broadrouter.com/hi/blog/llm-batch-processing-without-batch-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/llm-batch-processing-without-batch-api/) (2026-11-16 को अपडेट किया गया).

# Batch API के बिना LLM बैच प्रोसेसिंग: दोबारा शुरू होने वाला runner

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

Batch API न हो, तो job ख़ुद चलाएँ: JSONL फ़ाइल से आइटम पढ़ें, एक साथ चलने वाले अनुरोध key की सीमा पर रोकें, अनुरोधों की शुरुआत प्रति मिनट सीमा के भीतर रखें, 429 और 5xx को सीमित backoff के साथ retry करें, और हर नतीजा उसकी ID के साथ जोड़ते जाएँ। दोबारा शुरू करने पर पूरे हो चुके ID छोड़ दें। ख़त्म होने का समय आम तौर पर मॉडल नहीं, रेट लिमिट तय करती है।

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

-   BroadNet Inference सिर्फ़ chat completions और transcriptions दस्तावेज़ित करता है। न Batch API है, न बैच छूट, इसलिए बड़ा job सामान्य अनुरोधों का एक लूप है।
-   ख़त्म होने का समय = आइटम ÷ दो दरों में से धीमी दर: in-flight सीमा ÷ लेटेंसी, या प्रति मिनट अनुरोध। उपयोग के अनुसार भुगतान वाली key 4 in flight और 30 प्रति मिनट देती है, इसलिए प्रति अनुरोध एक आइटम पर अधिकतम 43,200 प्रति दिन।
-   हर आइटम के लिए उसकी ID के साथ एक नतीजा लाइन लिखें और flush करें। वही लाइन checkpoint है: क्रैश में ज़्यादा से ज़्यादा वे अनुरोध जाते हैं जो उस समय चल रहे थे।
-   प्लान सेशन एक समय में एक अनुरोध चलाता है। उसका थ्रूपुट 86,400 ÷ आपके मापे गए प्रति आइटम सेकंड है, प्रति दिन, प्रति सेशन।
-   अगर काम एक दिन रुक सकता है और 50% बैच छूट मायने रखती है, तो OpenAI और Anthropic के Batch API सस्ते साबित हो सकते हैं। दोनों की कीमत निकालें।

**इस पेज पर**

1.  क्या BroadNet Inference में Batch API है?
2.  job में कितना समय लगेगा?
3.  दोबारा शुरू होने वाला runner कैसा दिखता है?
4.  asyncio.gather की जगह worker pool क्यों?
5.  retry सुरक्षित कैसे रहते हैं?
6.  checkpointing कैसे काम करती है?
7.  लागत क्या है: उपयोग के अनुसार भुगतान या प्लान सेशन?
8.  BroadNet Inference कहाँ फ़िट होता है

कुछ LLM jobs चैट नहीं होते। आपके पास लेबल करने के लिए 50,000 सपोर्ट टिकट हैं, अनुवाद करने के लिए 200,000 प्रोडक्ट विवरण, या स्कोर करने के लिए दस लाख रिव्यू। OpenAI और Anthropic जैसे प्रोवाइडर इसके लिए [Batch API](https://broadrouter.com/hi/glossary/batch-api/) बेचते हैं। कई OpenAI-compatible API, जिनमें BroadNet Inference भी है, ऐसा नहीं करते। यह पोस्ट दिखाती है कि job ख़ुद कैसे चलाएँ: अंदाज़ा लगाएँ कि कितना समय लगेगा, सीमाओं का पालन करने वाला runner लिखें, और उसे रोकने और दोबारा शुरू करने लायक सुरक्षित बनाएँ।

BroadRouter, BroadNet की अपनी साइट है, इसलिए उदाहरण के आँकड़े BroadNet की प्रकाशित सीमाओं पर हैं। यह तरीक़ा किसी भी chat-completions API पर चलता है; अपने प्रोवाइडर के आँकड़े डालें।

## क्या BroadNet Inference में Batch API है?

नहीं। 15 नवंबर 2026 को जाँचा गया [API रेफ़रंस](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-llm-batch-processing-without-batch-api&utm_content=body) `POST /v1/chat/completions`, `POST /v1/audio/transcriptions` और `GET /v1/models` (मॉडल लिस्ट) दस्तावेज़ित करता है, साथ में `/portal/` के तहत अकाउंट endpoint। कोई बैच या फ़ाइल-अपलोड endpoint नहीं है और कोई बैच छूट नहीं। बड़ा job सामान्य अनुरोधों का एक लूप है।

होस्टेड Batch API आपको क्या देता है, यह रहा, ताकि पता रहे कि आप क्या दोबारा बना रहे हैं:

|  | OpenAI Batch API | Anthropic Message Batches | आपका अपना runner |
| --- | --- | --- | --- |
| कीमत | synchronous से 50% कम | 50% कम | सामान्य कीमत |
| लौटने का समय | 24 घंटे के भीतर | ज़्यादातर 1 घंटे के भीतर; 24 के बाद समाप्त | आपकी रेट लिमिट से तय |
| प्रति बैच आकार | 50,000 अनुरोध या 200 MB | 100,000 अनुरोध या 256 MB | कोई भी आकार |
| रेट लिमिट | प्रति-मॉडल सीमाओं से अलग | queue में रखे अनुरोधों पर लागू | आपकी key की सीमाएँ |
| नतीजों का क्रम | अलग हो सकता है; `custom_id` से मिलाएँ | `custom_id` से मिलाएँ | आप नतीजे ID से जोड़ते हैं |

दो सबक़ यहाँ भी लागू होते हैं। दोनों प्रोवाइडर हर अनुरोध पर एक ID लगवाते हैं, क्योंकि नतीजे क्रम में वापस नहीं आते। कोई भी सेकंडों में जवाब का वादा नहीं करता। आपका runner भी ऐसे ही चले: हर चीज़ पर ID, और घंटों में मापी गई योजना।

अगर लौटने के समय से ज़्यादा 50% छूट मायने रखती है, और आपके ज़रूरी मॉडल वहाँ हैं, तो होस्टेड Batch API सस्ता औज़ार हो सकता है। बनाने से पहले दोनों की कीमत [LLM API लागत कैलकुलेटर](https://broadrouter.com/tools/llm-api-cost-calculator/) से निकालें।

## job में कितना समय लगेगा?

कोड लिखने से पहले यह हिसाब लगाएँ। दो सीमाएँ थ्रूपुट रोकती हैं, और धीमी वाली जीतती है:

-   **In-flight सीमा ÷ लेटेंसी।** 4 अनुरोध in flight और प्रति अनुरोध 2 सेकंड हों, तो आप प्रति सेकंड 2 पूरे कर सकते हैं।
-   **प्रति मिनट अनुरोध।** प्रति मिनट 30 पर आप प्रति सेकंड 0.5 शुरू कर सकते हैं, मॉडल कितना भी तेज़ हो।

BroadNet की [उपयोग के अनुसार भुगतान](https://broadrouter.com/hi/glossary/pay-as-you-go/) वाली key 4 अनुरोध in flight और 30 प्रति मिनट देती है। जब हमने API रेफ़रंस देखा (2026-11-15), तब के मानों पर (प्रति मिनट 30 और 4 in flight), जब तक हर अनुरोध 8 सेकंड से ज़्यादा न ले, [रेट लिमिट](https://broadrouter.com/hi/glossary/rate-limit/) ही बाँधती है, और नीचे की टेबल प्रति मिनट 30 मानकर चलती है:

| आइटम | प्रति अनुरोध एक आइटम | प्रति अनुरोध 20 आइटम |
| --- | --- | --- |
| 10,000 | 5.6 घंटे | 17 मिनट |
| 100,000 | 2.3 दिन | 2.8 घंटे |
| 1,000,000 | 23 दिन | 28 घंटे |

प्रति मिनट 30 अनुरोध पर एक key घंटे में 1,800 अनुरोध करती है, यानी दिन में 43,200। retry भी गिने जाते हैं: आपका हर 429 एक स्लॉट ख़र्च करता है।

दूसरा कॉलम सबसे बड़ा लीवर है। छोटे आइटम, जैसे रिव्यू या टिकट के विषय, क्रमांकित लिस्ट के रूप में प्रति अनुरोध 10 से 50 जा सकते हैं, और जवाब में JSON array आता है। जाँचें कि array में हर इनपुट के लिए एक entry है और हर entry पर उसका नंबर है। [अरबी टेक्स्ट वर्गीकरण पोस्ट](https://broadrouter.com/hi/blog/arabic-text-classification-llm/) यह पैटर्न दिखाती है। लंबे आइटम पैक नहीं होते: हर अनुरोध को फिर भी मॉडल की [कॉन्टेक्स्ट विंडो](https://broadrouter.com/hi/glossary/context-window/) में समाना होता है, और लिस्ट बढ़ने पर गुणवत्ता गिर सकती है। भरोसा करने से पहले 200 आइटम पर पैकिंग टेस्ट करें।

प्रति-key सीमा को मात देने के लिए बिना पूछे एक job को कई keys में न फैलाएँ। BroadNet की [Acceptable Use Policy](https://www.broadnet.ai/aup) रेट, concurrency या बजट सीमाओं से बचने की मनाही करती है। ज़्यादा चाहिए, तो BroadNet से पूछें, या नीचे बताए प्लान सेशन इस्तेमाल करें। [बैच job प्लानर](https://broadrouter.com/tools/llm-batch-job-planner/) आपकी आइटम संख्या, लेटेंसी और सीमाओं के लिए यही हिसाब करता है।

## दोबारा शुरू होने वाला runner कैसा दिखता है?

यह runner `items.jsonl` पढ़ता है (हर लाइन में एक `{"id", "text"}` ऑब्जेक्ट) और हर आइटम के लिए एक नतीजा लाइन `results.jsonl` में जोड़ता है। इसे सिर्फ़ OpenAI Python SDK चाहिए।

```python
import asyncio, json, os, random, time
from openai import AsyncOpenAI, APIStatusError, APIConnectionError, APITimeoutError

client = AsyncOpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
                     api_key=os.environ["BROADNET_API_KEY"],
                     max_retries=0,        # we retry ourselves, with a cap we can see
                     timeout=120)
MODEL = os.environ.get("MODEL", "broadnet/deepseek-v4.1-flash")
IN_FLIGHT = int(os.environ.get("IN_FLIGHT", "4"))     # PAYG key: 4 in flight. Plan: 1 per session.
RPM = int(os.environ.get("RPM", "30"))                # PAYG key: 30 requests a minute
MAX_ATTEMPTS = 6

class Pacer:
    """Spaces request starts at least 60/RPM seconds apart, across all workers."""
    def __init__(self, rpm):
        self.gap, self.next, self.lock = 60 / rpm, 0.0, asyncio.Lock()
    async def wait(self):
        async with self.lock:
            now = time.monotonic()
            delay = max(0.0, self.next - now)
            self.next = max(now, self.next) + self.gap
        await asyncio.sleep(delay)

def retryable(e):
    if isinstance(e, (APIConnectionError, APITimeoutError)):
        return True
    return isinstance(e, APIStatusError) and e.status_code in (429, 500, 502, 503, 504)

async def call(item, pacer):
    for attempt in range(MAX_ATTEMPTS):
        await pacer.wait()                          # every attempt counts against the rate limit
        try:
            r = await client.chat.completions.create(
                model=MODEL, max_tokens=1500, reasoning_effort="low",
                messages=[{"role": "system", "content": "Classify the review as positive, negative or mixed. Reply with one word."},
                          {"role": "user", "content": item["text"]}])
            c = r.choices[0]
            return {"id": item["id"], "ok": True, "finish_reason": c.finish_reason,
                    "output": c.message.content, "usage": r.usage.model_dump() if r.usage else None}
        except Exception as e:
            if not retryable(e) or attempt == MAX_ATTEMPTS - 1:
                return {"id": item["id"], "ok": False, "error": repr(e)[:300]}
            await asyncio.sleep(random.uniform(0, min(60, 2 ** attempt)))   # full jitter, capped

async def run(in_path, out_path):
    done = set()
    if os.path.exists(out_path):                    # resume: skip ids that already succeeded
        with open(out_path) as f:
            done = {json.loads(l)["id"] for l in f if l.strip() and json.loads(l).get("ok")}
    todo = [it for it in map(json.loads, open(in_path)) if it["id"] not in done]
    print(f"{len(done)} done, {len(todo)} to go")
    pacer, queue = Pacer(RPM), asyncio.Queue()
    for it in todo:
        queue.put_nowait(it)
    with open(out_path, "a") as out:
        async def worker():
            while True:
                try:
                    it = queue.get_nowait()
                except asyncio.QueueEmpty:
                    return
                res = await call(it, pacer)
                out.write(json.dumps(res, ensure_ascii=False) + "\n")
                out.flush()                         # one line per finished item = the checkpoint
        await asyncio.gather(*(worker() for _ in range(IN_FLIGHT)))

if __name__ == "__main__":
    import sys
    asyncio.run(run(sys.argv[1], sys.argv[2]))
```

इसे `python batch_run.py items.jsonl results.jsonl` से चलाएँ। हमने यही फ़ाइल एक लोकल mock सर्वर पर टेस्ट की, जो बेतरतीब 429 (8%) और 500 (5%) लौटाता था और 4 से ज़्यादा in flight या प्रति मिनट 30 से ज़्यादा शुरुआत को अस्वीकार करता था। 25 आइटम 28 अनुरोधों (3 retry) के साथ 55 सेकंड में पूरे हुए, और किसी भी 60 सेकंड की विंडो में 30 से ज़्यादा शुरुआत नहीं हुई। समय बचाने के लिए mock की सीमा प्रति मिनट 300 करने पर, 10 सेकंड बाद रोका गया 120 आइटम का रन 39 सेव किए गए नतीजों से दोबारा शुरू हुआ और 120 अनोखी IDs के साथ, बिना किसी दोहराव के, पूरा हुआ।

## asyncio.gather की जगह worker pool क्यों?

[429 गाइड](https://broadrouter.com/hi/blog/handle-llm-api-429-rate-limits/) `asyncio.gather` के चारों ओर semaphore इस्तेमाल करती है। कुछ सौ कॉल के लिए यह ठीक है। बड़े job के लिए queue से आइटम लेने वाले workers का तय pool बेहतर है:

-   **मेमोरी।** `gather` शुरू में ही हर आइटम के लिए एक task बनाता है। pool सिर्फ़ in flight आइटम रखता है।
-   **Concurrency ही pool का आकार है।** चार workers के कभी पाँच अनुरोध खुले नहीं हो सकते।
-   **नतीजे डिस्क पर बहते हैं** जैसे-जैसे वे पूरे होते हैं, किसी भी क्रम में, ID के साथ।

`Pacer` दूसरी सीमा संभालता है। अकेला semaphore आपको 4 in flight से आगे जाने से रोकता है, लेकिन अगर अनुरोध एक सेकंड लें, तो चार workers प्रति मिनट 240 शुरू करेंगे और ज़्यादातर पर 429 पाएँगे। pacer सभी workers में, retry समेत, शुरुआत के बीच 2 सेकंड का अंतर रखता है।

## retry सुरक्षित कैसे रहते हैं?

सिर्फ़ वही retry करें जो दूसरी कोशिश में सफल हो सकता है:

| जवाब | कार्रवाई |
| --- | --- |
| 429 | रुकें और retry करें; BroadNet के डॉक्स कहते हैं “use response details and bounded backoff” (अनुवाद: जवाब के ब्योरे और सीमित backoff इस्तेमाल करें) |
| 500, 502, 503, 504, timeout, टूटे कनेक्शन | सीमित exponential backoff के साथ retry करें |
| 400, 422 | अनुरोध ठीक करें; retry वही एरर भेजता है |
| 401, 402, 403 | job रोकें; key, बैलेंस या नीति पर ध्यान चाहिए |
| 413 | आइटम छोटा करें |

runner SDK के अपने retry बंद करता है (`max_retries=0`), ताकि ठीक एक retry नीति हो, दिखने वाली सीमा के साथ। Backoff फ़ुल jitter के साथ [exponential](https://broadrouter.com/hi/glossary/exponential-backoff/) है, 60 सेकंड पर सीमित, ताकि साथ विफल हुए workers साथ retry न करें। छह कोशिशों के बाद आइटम `"ok": false` के रूप में लिखा जाता है और job आगे बढ़ता है। एक ख़राब आइटम कभी दस लाख को नहीं रोकता।

मॉडल कॉल का कोई side effect नहीं होता, इसलिए यहाँ डिलीवरी कम से कम एक बार है: अगर अनुरोध के बीच प्रोसेस मर जाए, तो वह आइटम दोबारा शुरू होने पर फिर भेजा जाता है, और आप उसके लिए दो बार भुगतान करते हैं। यही एकमात्र बर्बादी है। अगर job किसी दूसरे सिस्टम में भी लिखता है, जैसे टिकट या ईमेल, तो उस लेखन को आइटम ID के आधार पर [idempotent](https://broadrouter.com/hi/glossary/idempotency-key/) बनाएँ और उसे `results.jsonl` पर एक अलग पास में करें। [लंबे चलने वाले एजेंट वाली पोस्ट](https://broadrouter.com/hi/blog/long-running-agents-timeouts-retries/) idempotent side effect विस्तार से बताती है।

## checkpointing कैसे काम करती है?

आउटपुट फ़ाइल ही checkpoint है। हर पूरा हुआ आइटम एक flush की गई लाइन है, इसलिए क्रैश, deploy या Ctrl-C के बाद अगला रन फ़ाइल पढ़ता है, `"ok": true` वाली IDs इकट्ठा करता है और सिर्फ़ बाक़ी को queue में डालता है। पहले विफल हुए आइटम अगले रन में retry होते हैं, और उनकी नई लाइन जुड़ती है। नतीजे पढ़ते समय हर ID की आख़िरी लाइन लें।

तीन आदतें इसे दिनों तक टिकाऊ बनाती हैं:

1.  **स्थिर IDs।** डेटाबेस key या इनपुट का hash इस्तेमाल करें, कभी लाइन नंबर नहीं, जो इनपुट फ़ाइल बदलने पर खिसक जाता है।
2.  **`finish_reason` जाँचें।** `max_tokens` पर कटा जवाब `"ok": true` है, लेकिन बेकार। DeepSeek V4.1 Flash, GLM 5.3 और Qwen3.8 27B जवाब से पहले reasoning करते हैं, और [reasoning max\_tokens में गिनी जाती है](https://broadrouter.com/hi/guides/reasoning-tokens-empty-response/)। runner `reasoning_effort="low"` सेट करता है, जिसे BroadNet दस्तावेज़ित करता है, और 1,500 टोकन छोड़ता है।
3.  **हर लाइन पर usage लॉग करें।** `results.jsonl` से `usage` जोड़ने पर असली टोकन बिल मिलता है, जिसे आप अपने अनुमान से मिला सकते हैं।

## लागत क्या है: उपयोग के अनुसार भुगतान या प्लान सेशन?

उपयोग के अनुसार भुगतान में लागत टोकन है। मान लें 100,000 रिव्यू, 150 टोकन का सिस्टम प्रॉम्प्ट, 150 टोकन का रिव्यू और कम reasoning के साथ 100 आउटपुट टोकन। यह 30 मिलियन इनपुट और 10 मिलियन आउटपुट टोकन हैं। [DeepSeek V4.1 Flash](https://broadrouter.com/hi/models/deepseek-v4.1-flash/) पर इसकी लागत 30 × $0.175 + 10 × $0.52 है। सिस्टम प्रॉम्प्ट पहले और byte-दर-byte एक जैसा रखें, तो जहाँ कैश hit होता है वहाँ उसके 15 मिलियन टोकन $0.0055 प्रति 1M की [कैश्ड इनपुट](https://broadrouter.com/hi/blog/cached-input-tokens-explained/) दर पर बिल हो सकते हैं। आपकी `usage` लाइनें दिखाती हैं कि ऐसा कितनी बार हुआ।

प्लान पर टोकन मुफ़्त हैं और लागत समय है। DeepSeek V4.1 Flash का प्लान सेशन “runs one request at a time” (अनुवाद: एक समय में एक अनुरोध चलाता है), इसलिए हर सेशन के लिए `IN_FLIGHT=1` रखें। प्रति सेशन थ्रूपुट 86,400 ÷ प्रति आइटम सेकंड है, प्रति दिन। BroadNet सामान्य स्पीड लगभग 100 टोकन प्रति सेकंड बताता है, लेकिन आपकी लेटेंसी प्रॉम्प्ट की लंबाई और reasoning पर निर्भर है, इसलिए 50 आइटम पर मापें। अगर आप प्रति आइटम 3 सेकंड मापते हैं, तो एक सेशन दिन में 28,800 करता है:

| Job | सेशन | 3 s/आइटम पर समय | प्लान |
| --- | --- | --- | --- |
| 100,000 आइटम | 1 | लगभग 3.5 दिन | एक Orbit हफ़्ता, प्रति सेशन $15 |
| 100,000 आइटम | 4 | लगभग 21 घंटे | चार Orbit हफ़्ते, हर सेशन के लिए एक; या प्रति सेशन लगभग 21 Meteor घंटे, हर एक $1 पर |
| 1,000,000 आइटम | 6 | लगभग 6 दिन | छह Orbit हफ़्ते |

प्लान “best effort under fair use” (अनुवाद: fair use के तहत best effort) दिए जाते हैं, और BroadNet प्लान keys के लिए प्रति मिनट अनुरोध सीमा प्रकाशित नहीं करता; लागू सीमाएँ आपके अकाउंट में दिखती हैं। `RPM` अंदाज़े से नहीं, उन्हीं से सेट करें। [सेशन प्लानर गाइड](https://broadrouter.com/hi/guides/unlimited-llm-api-sessions/) बताती है कि सेशन को keys में कैसे बाँटें।

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

BroadNet Inference में Batch API नहीं है, इसलिए यह बड़े jobs के लिए तब सही है जब आप runner पर ख़ुद नियंत्रण रखना और सामान्य प्रति-टोकन कीमत देना पसंद करें, या DeepSeek V4.1 Flash प्लान सेशन से लागत तय करना चाहें। बजट वाले छोटे jobs के लिए [Gemma 4 VL 26B](https://broadrouter.com/hi/models/gemma-4-vl-26b/), प्रति 1M $0.10 इनपुट और $0.22 आउटपुट पर, $5 के शुरुआती क्रेडिट पर चलता है। हर अनुरोध के बाद प्रॉम्प्ट और आउटपुट नहीं रखे जाते। अगर आपका job एक दिन रुक सकता है और आपके ज़रूरी मॉडल 50% बैच छूट वाले प्रोवाइडर पर हैं, तो वह सस्ता पड़ सकता है; तय करने से पहले तुलना करें। प्लान और सीमाएँ [inference.broadnet.ai/plans](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-llm-batch-processing-without-batch-api&utm_content=body) पर हैं।

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

-   [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/)

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

[टोकन (token)](https://broadrouter.com/hi/glossary/token/)

टोकन टेक्स्ट की वह इकाई है जिसे लैंग्वेज मॉडल पढ़ता और लिखता है: कोई शब्द, शब्द का हिस्सा, विराम चिह्न या बाइट का क्रम, जो मॉडल का टोकनाइज़र बनाता है। LLM API इस्तेमाल को टोकन में गिनते हैं, उसी में लिमिट लगाते हैं और आम तौर पर बिल भी बनाते हैं।

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

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

[Batch API (बैच API)](https://broadrouter.com/hi/glossary/batch-api/)

Batch API एक asynchronous LLM एंडपॉइंट है जो एक साथ कई अनुरोध लेता है, आम तौर पर एक फ़ाइल के रूप में, उन्हें तुरंत नहीं बल्कि एक तय समय-सीमा में प्रोसेस करता है, और नतीजे एक साथ लौटाता है। OpenAI और Anthropic जैसे प्रोवाइडर batch अनुरोधों की कीमत अपने सामान्य API से कम रखते हैं।

[कॉन्करेंसी (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 के साथ, जब तक इस्तेमाल फिर सीमा के नीचे न आ जाए।

[एक्सपोनेंशियल बैकऑफ़ (exponential backoff)](https://broadrouter.com/hi/glossary/exponential-backoff/)

एक्सपोनेंशियल बैकऑफ़ री-ट्राई की एक रणनीति है जिसमें क्लाइंट हर नाकाम कोशिश के बाद, दोबारा कोशिश करने से पहले, ज़्यादा देर इंतज़ार करता है, आम तौर पर देरी को एक सीमा तक दोगुना करते हुए। हर इंतज़ार में रैंडम jitter जोड़ने से कई क्लाइंट के री-ट्राई बिखर जाते हैं, ताकि वे एक ही पल सर्वर पर न पहुँचें।

[लेटेंसी (latency)](https://broadrouter.com/hi/glossary/latency/)

लैंग्वेज मॉडल API के लिए लेटेंसी वह समय है जो किसी अनुरोध के भेजे जाने से अंतिम आउटपुट टोकन मिलने तक लगता है। यह पहले टोकन तक के समय और जनरेशन टाइम का जोड़ है, और आम तौर पर औसत के बजाय p50 और p95 जैसे परसेंटाइल में बताई जाती है।

[इनपुट और आउटपुट टोकन (input and output tokens)](https://broadrouter.com/hi/glossary/input-and-output-tokens/)

इनपुट टोकन वे टोकन हैं जिन्हें लैंग्वेज मॉडल किसी अनुरोध में पढ़ता है, जिनमें सिस्टम प्रॉम्प्ट, बातचीत का इतिहास, टूल डेफ़िनिशन और इमेज शामिल हैं। आउटपुट टोकन वे हैं जो वह जवाब में बनाता है, रीज़निंग समेत। LLM API आम तौर पर दोनों की कीमत अलग रखते हैं, और आउटपुट आम तौर पर महँगा होता है।

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

### क्या BroadNet Inference में Batch API है?

नहीं। 15 नवंबर 2026 को जाँचा गया उसका API रेफ़रंस POST /v1/chat/completions, POST /v1/audio/transcriptions और GET /v1/models दस्तावेज़ित करता है, कोई बैच या फ़ाइल-अपलोड endpoint नहीं और कोई बैच छूट नहीं। बड़े jobs को अपनी key की सीमाओं के भीतर सामान्य अनुरोधों की तरह चलाएँ।

### LLM API से 100,000 प्रॉम्प्ट कैसे प्रोसेस करूँ?

आइटम को JSONL फ़ाइल में रखें, हर एक के साथ एक ID। key की in-flight सीमा के बराबर तय संख्या में workers चलाएँ, अनुरोधों की शुरुआत प्रति मिनट सीमा के भीतर रखें, 429 और 5xx को सीमित backoff के साथ retry करें, और हर नतीजा ID के साथ आउटपुट फ़ाइल में जोड़ें, ताकि job दोबारा शुरू हो सके।

### दस लाख अनुरोधों के बैच में कितना समय लगेगा?

आइटम को अपनी असली दर से भाग दें। प्रति मिनट 30 अनुरोध और प्रति अनुरोध एक आइटम पर एक key दिन में 43,200 करती है, इसलिए दस लाख में लगभग 23 दिन लगते हैं। प्रति अनुरोध 20 छोटे आइटम पैक करने से यह लगभग 28 घंटे रह जाता है, अगर मॉडल लंबा प्रॉम्प्ट ठीक से संभाले।

### बैच LLM कॉल के लिए asyncio.gather इस्तेमाल करूँ या worker pool?

दसियों हज़ार आइटम के लिए queue से आइटम लेने वाले workers का एक तय pool इस्तेमाल करें। semaphore के साथ gather छोटे jobs के लिए चलता है, लेकिन यह शुरू में ही हर task बना देता है और दोबारा शुरू करना व प्रगति ट्रैक करना मुश्किल बनाता है।

### क्या तेज़ी के लिए कई API key इस्तेमाल कर सकता हूँ?

पहले जाँच लें। BroadNet की Acceptable Use Policy रेट या concurrency सीमाओं से बचने की मनाही करती है, इसलिए प्रति-key सीमा पार करने के लिए एक job को कई keys में बाँटने से पहले BroadNet से पूछें। प्रति अनुरोध ज़्यादा आइटम पैक करना और प्लान सेशन थ्रूपुट बढ़ाने के दस्तावेज़ित तरीक़े हैं।

### क्या फ़्लैट प्लान बैच jobs के लिए अच्छा है?

DeepSeek V4.1 Flash के लिए हो सकता है। सेशन बिना टोकन मीटर के एक समय में एक अनुरोध चलाता है, इसलिए लागत तय है और सवाल समय का है। प्रति आइटम सेकंड मापें, फिर अवधि के भीतर काम ख़त्म करने लायक सेशन ख़रीदें।

## आगे पढ़ें

-   [LLM API में 429 एरर कैसे सँभालें: बैकऑफ़, जिटर और लिमिटर](https://broadrouter.com/hi/blog/handle-llm-api-429-rate-limits/)
-   [लंबे चलने वाले एजेंट: टिकाऊ timeout, retry और checkpoint](https://broadrouter.com/hi/blog/long-running-agents-timeouts-retries/)
-   [LLM से अरबी टेक्स्ट classification: sentiment, intent, triage](https://broadrouter.com/hi/blog/arabic-text-classification-llm/)
-   [फ़्लैट-रेट LLM API पर पैरेलल कोडिंग एजेंट कैसे चलाएँ](https://broadrouter.com/hi/blog/run-parallel-coding-agents-flat-rate/)
-   [छोटे प्रोजेक्ट के लिए साप्ताहिक LLM प्लान: Orbit बनाम घंटा बनाम महीना](https://broadrouter.com/hi/blog/weekly-llm-plan-short-projects/)
-   [फ़ीचर लॉन्च से पहले LLM API की लागत का अनुमान कैसे लगाएँ](https://broadrouter.com/hi/blog/estimate-llm-api-cost-before-launch/)
-   [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/)
-   [गाइड: BroadNet Inference के एरर कोड और रीट्राई कब करें](https://broadrouter.com/hi/guides/errors-and-retries/)
-   [गाइड: BroadNet Inference के साथ OpenAI Python SDK इस्तेमाल करें](https://broadrouter.com/hi/guides/openai-python-sdk/)
-   [गाइड: एजेंट के लिए अनलिमिटेड LLM API प्लान कैसे काम करते हैं](https://broadrouter.com/hi/guides/unlimited-llm-api-sessions/)

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

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

**स्रोत**

-   [BroadNet Inference API रेफ़रंस: endpoint, उपयोग के अनुसार भुगतान की सीमाएँ (प्रति मिनट 30, 4 in flight), घंटे वाली key की सीमाएँ, 429 और 5xx retry सलाह, reasoning\_effort (2026-11-15 को जाँचा गया) (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [BroadNet Inference प्लान पेज: हर सेशन में एक समय में एक अनुरोध, सामान्य स्पीड, प्लान की कीमतें (2026-11-15 को जाँचा गया) (अंग्रेज़ी में)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [BroadNet Acceptable Use Policy, खंड 3 और 4: रेट या concurrency सीमाओं से बचने की मनाही; प्लान fair use के तहत best effort (2026-11-15 को जाँचा गया) (अंग्रेज़ी में)](https://www.broadnet.ai/aup)
-   [OpenAI Batch API गाइड: 50% छूट, 24 घंटे की विंडो, प्रति बैच 50,000 अनुरोध या 200 MB, आउटपुट का क्रम अलग हो सकता है, custom\_id (2026-11-15 को जाँचा गया)](https://developers.openai.com/api/docs/guides/batch)
-   [Anthropic Message Batches API डॉक्स: 50% छूट, 100,000 अनुरोध या 256 MB, ज़्यादातर बैच 1 घंटे के भीतर, 24 घंटे बाद समाप्त (2026-11-15 को जाँचा गया)](https://platform.claude.com/docs/en/build-with-claude/batch-processing)
