BroadRouter

LLM API ख़र्च पर नियंत्रण: बजट, key सीमाएँ और लूप से बचाव

BroadNet Inference टीम · 5 मिनट में पढ़ें · प्रकाशित · अपडेट किया गया

LLM API ख़र्च को परतों में नियंत्रित करें: अकाउंट की सीमा के रूप में प्रीपेड बैलेंस, हर ऐप की अलग key जो आपके सर्वर IP तक सीमित हो, हर अनुरोध पर max_tokens और स्टेप की सीमा, और कोड में एक बजट जो ज़्यादा ख़र्च से पहले जॉब रोक दे। हर key के टोकन लॉग करें और अपनी संख्याओं पर अलर्ट लगाएँ। फ़्लैट प्लान और घंटे वाली key सबसे बुरे हालात की लागत सीमित करते हैं।

LLM बिल के ज़्यादातर झटकों की एक ही वजह होती है: कोई चीज़ बिना किसी की निगरानी के API को कॉल करती रही। एक रीट्राई लूप, एक एजेंट जो काम पूरा नहीं कर पाया, किसी पब्लिक रिपॉज़िटरी में लीक हुई key। बजट अलर्ट आपको इसके बारे में बाद में बताते हैं। यह पोस्ट अकाउंट से लेकर एक अकेले अनुरोध तक, परतों में ख़र्च नियंत्रण बनाती है, और दिखाती है कि कौन-से हिस्से BroadNet Inference सँभालता है और कौन-से आप कोड में जोड़ते हैं।

सिर्फ़ अलर्ट काफ़ी क्यों नहीं हैं?

अलर्ट, usage दर्ज होने के बाद ख़र्च की तुलना एक सीमा से करता है। एजेंट लूप एक मिनट में दर्जनों अनुरोध कर सकता है। जब तक ईमेल आता है, पैसा जा चुका होता है। अलर्ट को आख़िरी बचाव की तरह इस्तेमाल करें, और सख़्त रोक वहाँ रखें जहाँ अनुरोध बनता है।

LLM ख़र्च नियंत्रण की परतें कौन-सी हैं?

परत नियंत्रण क्या रोकता है कहाँ सेट करें
अकाउंट प्रीपेड बैलेंस जितना पैसा डाला, उससे ज़्यादा ख़र्च प्रोवाइडर अकाउंट
Key हर ऐप या एजेंट की अलग key एक लीक से सब कुछ चले जाना प्रोवाइडर पोर्टल
Key IP allow-list चोरी हुई key का कहीं और इस्तेमाल प्रोवाइडर पोर्टल
अनुरोध max_tokens, reasoning_effort एक बहुत बड़ा जवाब आपका कोड
जॉब स्टेप की सीमा, रीट्राई की सीमा, लूप पहचान बेक़ाबू एजेंट आपका कोड
जॉब हर टास्क और हर दिन का चालू बजट कई कॉल में धीरे-धीरे रिसता ख़र्च आपका कोड या प्रॉक्सी
रिपोर्टिंग टोकन लॉगिंग और अलर्ट ऐसा भटकाव जो आप नोटिस न करें आपके लॉग
कीमत फ़्लैट प्लान या घंटे वाली key ख़ुद टोकन मीटर प्लान का चुनाव

अकाउंट स्तर: प्रीपेड बैलेंस ख़र्च को कैसे सीमित करता है?

BroadNet Inference की उपयोग के अनुसार भुगतान वाली key प्रीपेड अकाउंट बैलेंस से पैसा लेती हैं; नए अकाउंट $5 के क्रेडिट और बिना कार्ड के शुरू होते हैं। जब उपयोग के अनुसार भुगतान वाला अलाउंस ख़त्म हो जाता है, तो अनुरोध 401 लौटाते हैं, और जिस ख़रीद (जैसे घंटे वाली key) का भुगतान बैलेंस नहीं कर सकता, वह 402 insufficient_balance लौटाती है। दोनों को रुकने का संकेत मानें, रीट्राई की चीज़ नहीं। BroadNet का एरर रेफ़रंस 429 की वजहों में ख़र्च की सीमा भी लिस्ट करता है, इसलिए किसी भी 429 को रीट्राई करने से पहले एरर बॉडी पढ़ें। सभी एरर कोड और बैकऑफ़ के साथ 429 कैसे सँभालें।

बैलेंस आपकी बाहरी सीमा है। उसमें उतना ही डालें जितना आप इस महीने खोने को तैयार हैं, पूरे साल का नहीं। यह संख्या तय करने के लिए पहले अपने अनुमानित ट्रैफ़िक को LLM API लागत कैलकुलेटर में चलाएँ।

Key स्तर: लीक हुई key का नुक़सान कैसे सीमित करें?

API key ख़र्च करने का अधिकार है: जिसके पास है, वह आपका बैलेंस इस्तेमाल कर सकता है। हर key के असर का दायरा सीमित करें:

  1. हर ऐप, एजेंट या एनवायरनमेंट की एक key। BroadNet हर अकाउंट पर 10 तक चालू key की अनुमति देता है, हर एक एक साल तक वैध। उन्हें ऐसे नाम दें कि लॉग बताएँ किसने ख़र्च किया।
  2. Key को अपने सर्वर तक सीमित करें। अपने egress IP या CIDR रेंज IP allow-list में जोड़ें, 32 एंट्री तक। दूसरे पतों से आने वाले अनुरोधों को 403 मिलता है।
  3. जल्दी रद्द करें। key रद्द करना और allow-list के बदलाव पाँच सेकंड के अंदर नए अनुरोधों पर लागू होते हैं।
  4. पोर्टल क्रेडेंशियल सर्वर पर न रखें। उनसे key बन सकती हैं और ख़रीद हो सकती है। इन्फ़रेंस key सिर्फ़ मॉडल को कॉल करती हैं।

IP allow-list से API key लॉक करें।

अनुरोध स्तर: हर जवाब की सीमा कैसे तय करें?

हर कॉल पर max_tokens सेट करें। रीज़निंग मॉडलों (DeepSeek V4.1 Flash, GLM 5.3, Qwen3.8 27B) पर इसे 1,000 या ज़्यादा रखें, क्योंकि सोच भी उसी बजट में आती है और बहुत कम वैल्यू ख़ाली जवाब लौटाती है, जिसका भुगतान फिर भी होता है। आसान कामों पर reasoning_effort घटाएँ। रीज़निंग टोकन कैसे बिल होते हैं।

जॉब स्तर: बेक़ाबू एजेंट लूप कैसे रोकें?

बेक़ाबू लूप के लक्षण पहचाने जा सकते हैं: एक ही टूल कॉल का दोहराव, हर टर्न पर बढ़ता कॉन्टेक्स्ट, और बिना सीमा के रीट्राई होते एरर। क्लाइंट के चारों ओर एक गार्ड लगाएँ:

import json, os, urllib.request
from openai import OpenAI

# Per-1M prices from BroadNet's machine-readable rate card
card = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
m = next(x for x in card["models"] if x["id"] == "broadnet/deepseek-v4.1-flash")
PRICE = {"in": m["input_per_m"], "cached": m["cached_input_per_m"], "out": m["output_per_m"]}
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"], max_retries=3)

class BudgetExceeded(Exception): pass

class Guard:
    def __init__(self, budget_usd, max_steps=40):
        self.budget, self.max_steps, self.spent, self.steps, self.last = budget_usd, max_steps, 0.0, 0, []

    def call(self, **kw):
        self.steps += 1
        if self.steps > self.max_steps: raise BudgetExceeded("step cap")
        if self.spent >= self.budget: raise BudgetExceeded("budget")
        r = client.chat.completions.create(max_tokens=kw.pop("max_tokens", 4000), **kw)
        u = r.usage
        cached = (u.prompt_tokens_details.cached_tokens or 0) if u.prompt_tokens_details else 0
        self.spent += ((u.prompt_tokens - cached) * PRICE["in"] + cached * PRICE["cached"]
                       + u.completion_tokens * PRICE["out"]) / 1e6
        calls = [(t.function.name, t.function.arguments) for t in (r.choices[0].message.tool_calls or [])]
        self.last = (self.last + [calls])[-3:]
        if calls and len(self.last) == 3 and all(c == calls for c in self.last):
            raise BudgetExceeded("same tool call three times")
        return r

गार्ड कीमतें हार्ड-कोड करने के बजाय रेट कार्ड से पढ़ता है, इसलिए कीमतें बदलने पर भी सही रहता है। call() को वही मॉडल दें जिसकी कीमत आपने ली है। max_retries छोटा रखें: OpenAI SDK पहले ही 429 और 5xx को रीट्राई करते हैं, और हर रीट्राई फिर से बिल होता है।

टीम के लिए, यही जाँच एक साझा प्रॉक्सी में चलाएँ ताकि हर सर्विस एक ही रोज़ाना बजट से ख़र्च करे। रीट्राई रेट लिमिट से भी टकराते हैं: रेट लिमिट कैलकुलेटर दिखाता है कि आपकी key असल में एक मिनट में कितनी कॉल की अनुमति देती है।

रिपोर्टिंग: क्या लॉग करें और किस पर अलर्ट लगाएँ?

हर अनुरोध पर लॉग करें: key का उपनाम, फ़ीचर या एजेंट का नाम, मॉडल, prompt_tokens, prompt_tokens_details.cached_tokens, completion_tokens, स्टेटस और X-Request-ID। स्ट्रीमिंग में stream_options: {"include_usage": true} सेट करें, वरना usage कभी नहीं आता (स्ट्रीमिंग गाइड)।

उन लॉग से इन पर अलर्ट लगाएँ:

  • हर key की रोज़ाना लागत, जब वह आपके लागत अनुमान की अपेक्षित संख्या से ऊपर जाए;
  • हर टास्क के टोकन, जब वे मीडियन के तीन गुना से ज़्यादा हों;
  • गिरता कैश हिस्सा, जो ज़्यादा ट्रैफ़िक के बिना लागत बढ़ाता है;
  • 429 या 5xx रिस्पॉन्स की बढ़ती दर, जिसका मतलब है रीट्राई।

BroadNet बिना कंटेंट वाले रिकॉर्ड रखता है, जैसे समय, टोकन गिनती और लागत, प्रॉम्प्ट नहीं, इसलिए हर फ़ीचर का ब्योरा आपके अपने लॉग में ही रहता है। अगर आपकी डेटा नीति मना करती है, तो प्रॉम्प्ट कंटेंट लॉग करने से बचें। हर यूज़र और फ़ीचर की लागत के साथ usage लॉगिंग कैसे बनाएँ।

कीमत स्तर: फ़्लैट कीमत बजट से बेहतर कब है?

सबसे भरोसेमंद ख़र्च नियंत्रण है ऐसी कीमत जो बदलती नहीं:

  • प्लान सेशन: अनलिमिटेड DeepSeek V4.1 Flash के लिए $60 प्रति माह (Full Moon), $15 प्रति हफ़्ता (Orbit) या $1 प्रति घंटा (Meteor), एक समय में एक अनुरोध। प्लान key पर अनुरोध आपके बैलेंस से कभी पैसा नहीं लेते।
  • घंटे वाली key: एक स्ट्रीम पर Gemma 4 VL 26B के एक घंटे के लिए $0.50। ऐसी key के लिए अच्छी जो आपके सर्वर से बाहर जाती हैं। घंटे वाली key की व्याख्या।

प्लान पर लूप समय बर्बाद करता है, पैसा नहीं। स्टेप की सीमा फिर भी चाहिए, क्योंकि अटका एजेंट दूसरे कामों के लिए सेशन रोक देता है। प्लान आपके मीटर वाले बिल से सस्ता है या नहीं, यह वॉल्यूम पर निर्भर है; फ़्लैट रेट बनाम प्रति टोकन कैलकुलेटर आपके टोकन मिश्रण का ब्रेक-ईवन बताता है।

प्रति-टोकन दरें आपके रहते भी बढ़ सकती हैं। LLM API कीमतों में 52 दर्ज बढ़ोतरी दिखाती हैं कि ऐसा कितनी बार हुआ, किन प्रोवाइडरों पर और कितना।

एक छोटी चेकलिस्ट

  1. आपकी मासिक सीमा के हिसाब से प्रीपेड बैलेंस।
  2. हर ऐप की एक नाम वाली key, IP allow-list के साथ।
  3. हर अनुरोध पर max_tokens।
  4. हर एजेंट पर स्टेप की सीमा, रीट्राई की सीमा और दोहराई गई कॉल की पहचान।
  5. हर जॉब की चालू लागत, हर कॉल से पहले जाँची हुई।
  6. हर अनुरोध की टोकन लॉगिंग, आपकी सीमाओं पर अलर्ट के साथ।
  7. जहाँ इस्तेमाल लगातार है या key खुली है, वहाँ फ़्लैट प्लान या घंटे वाली key।

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

BroadNet आपको अकाउंट और key की परतें देता है: प्रीपेड बैलेंस, अलग-अलग key, सेकंडों में रद्द होने वाली IP allow-list, और फ़्लैट-कीमत वाले प्लान व घंटे वाली key। इस पोस्ट के जॉब-स्तर के बजट यह नहीं देता; वे आपके कोड या प्रॉक्सी में होते हैं। अगर आपको कई प्रोवाइडरों में हर टीम का बजट चाहिए, तो उन सबके आगे एक गेटवे सही टूल है। कीमतें पढ़ें।

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

LLM API पर ख़र्च की सीमा कैसे सेट करूँ?

बाहरी सीमा के रूप में प्रोवाइडर का प्रीपेड बैलेंस या ख़र्च सीमा इस्तेमाल करें, फिर हर अनुरोध से पहले कोड में हर जॉब और हर दिन का अपना बजट लागू करें, क्योंकि प्रोवाइडर की सीमाएँ और अलर्ट तेज़ लूप से पीछे रह सकते हैं।

AI एजेंट को भारी बिल बनाने से कैसे रोकूँ?

हर टास्क के स्टेप की सीमा रखें, रीट्राई की सीमा रखें, हर अनुरोध पर max_tokens सेट करें, एक जैसी टूल कॉल के दोहराव को पकड़ें, और जब जॉब की चालू लागत बजट पार करे तो उसे रोक दें।

बैलेंस ख़त्म होने पर क्या 401 या 402 एरर को रीट्राई करूँ?

नहीं। BroadNet पर ख़त्म हो चुका उपयोग के अनुसार भुगतान वाला अलाउंस 401 लौटाता है, और 402 insufficient_balance का मतलब है कि अकाउंट घंटे वाली key जैसी ख़रीद का भुगतान नहीं कर सकता। पहले अकाउंट में पैसे डालें। रीट्राई 429 और 5xx पर बैकऑफ़ के साथ करें।

LLM ख़र्च ट्रैक करने के लिए क्या लॉग करूँ?

हर अनुरोध पर key का उपनाम, फ़ीचर या एजेंट का नाम, मॉडल, prompt_tokens, cached_tokens, completion_tokens, स्टेटस कोड और अनुरोध ID लॉग करें। लागत पाने के लिए प्राइस फ़ाइल से गुणा करें।

क्या फ़्लैट-रेट प्लान भी ख़र्च नियंत्रण का एक तरीक़ा है?

हाँ। प्लान सेशन या घंटे वाली key की कीमत उतनी ही रहती है, चाहे वह कितने भी टोकन इस्तेमाल करे, इसलिए लूप का नुक़सान समय में होता है, पैसे में नहीं।

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