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 के असर का दायरा सीमित करें:
- हर ऐप, एजेंट या एनवायरनमेंट की एक key। BroadNet हर अकाउंट पर 10 तक चालू key की अनुमति देता है, हर एक एक साल तक वैध। उन्हें ऐसे नाम दें कि लॉग बताएँ किसने ख़र्च किया।
- Key को अपने सर्वर तक सीमित करें। अपने egress IP या CIDR रेंज IP allow-list में जोड़ें, 32 एंट्री तक। दूसरे पतों से आने वाले अनुरोधों को 403 मिलता है।
- जल्दी रद्द करें। key रद्द करना और allow-list के बदलाव पाँच सेकंड के अंदर नए अनुरोधों पर लागू होते हैं।
- पोर्टल क्रेडेंशियल सर्वर पर न रखें। उनसे 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 दर्ज बढ़ोतरी दिखाती हैं कि ऐसा कितनी बार हुआ, किन प्रोवाइडरों पर और कितना।
एक छोटी चेकलिस्ट
- आपकी मासिक सीमा के हिसाब से प्रीपेड बैलेंस।
- हर ऐप की एक नाम वाली key, IP allow-list के साथ।
- हर अनुरोध पर
max_tokens। - हर एजेंट पर स्टेप की सीमा, रीट्राई की सीमा और दोहराई गई कॉल की पहचान।
- हर जॉब की चालू लागत, हर कॉल से पहले जाँची हुई।
- हर अनुरोध की टोकन लॉगिंग, आपकी सीमाओं पर अलर्ट के साथ।
- जहाँ इस्तेमाल लगातार है या key खुली है, वहाँ फ़्लैट प्लान या घंटे वाली key।
BroadNet Inference कहाँ फ़िट होता है
BroadNet आपको अकाउंट और key की परतें देता है: प्रीपेड बैलेंस, अलग-अलग key, सेकंडों में रद्द होने वाली IP allow-list, और फ़्लैट-कीमत वाले प्लान व घंटे वाली key। इस पोस्ट के जॉब-स्तर के बजट यह नहीं देता; वे आपके कोड या प्रॉक्सी में होते हैं। अगर आपको कई प्रोवाइडरों में हर टीम का बजट चाहिए, तो उन सबके आगे एक गेटवे सही टूल है। कीमतें पढ़ें।
