मुख्य कंटेंट तक स्किप करें

AI की असली लागत क्या है (प्रोवाइडरों में)

मध्यम

"AI की लागत कितनी है?" का कोई एक जवाब नहीं है — यह इस पर निर्भर करता है कि आप कौन-सा प्राइसिंग आर्किटाइप खरीद रहे हैं और आप उसे असल में कितना इस्तेमाल करते हैं। डॉलर के आँकड़े हर कुछ महीनों में बदलते हैं; लागत की संरचना शायद ही बदलती है। यह पृष्ठ टिकाऊ आकार सिखाता है: AI की कीमत तय करने के तीन तरीके, बनाने से पहले किसी वर्कलोड का अनुमान कैसे लगाएँ, बिल घटाने वाले लीवर, और API किराए पर लेने बनाम सेल्फ-होस्टिंग के बीच का असली मोड़।

What you'll learn
  • तीन लागत आर्किटाइप में फ़र्क करें: per-token API, फ्लैट सब्सक्रिप्शन, और ओपन/सेल्फ-होस्टेड
  • किसी भी वर्कलोड की लागत का अनुमान tokens × rate × volume से लगाएँ — शिप करने से पहले
  • गुणवत्ता को चोट पहुँचाए बिना खर्च घटाने वाले बड़े लीवर खींचें
  • जानें कब ओपन/सेल्फ-होस्टेड लागत में API को हराता है, और कब API जीतता है
  • जानें कौन-से आँकड़े तेज़ी से पुराने पड़ते हैं — और आज का सच कहाँ जाँचें

तीन लागत आर्किटाइप​

AI के लिए भुगतान का लगभग हर तरीका तीन आकारों में से एक में सिमट जाता है। आकार सीखें, कीमतें नहीं।

  • Per-token API (उपयोग-आधारित)। आप एक होस्टेड मॉडल को API पर कॉल करते हैं और प्रति टोकन भुगतान करते हैं — और इनपुट और आउटपुट की कीमत अलग-अलग तय होती है, जिसमें आउटपुट लगभग हमेशा दोनों में महँगा होता है। बड़े/स्मार्ट मॉडल प्रति टोकन अधिक लागत लेते हैं; छोटे मॉडल कहीं कम। ज़्यादातर प्रोवाइडर डिस्काउंट भी देते हैं: आपके द्वारा फिर से भेजे गए कैश्ड इनपुट के लिए एक घटी हुई दर, और गैर-अत्यावश्यक async जॉब्स के लिए एक फ्लैट बैच डिस्काउंट। जब आप Claude, GPT, या Gemini पर कोई प्रोडक्ट बनाते हैं तो आप इसी तरह भुगतान करते हैं। लागत सीधे उपयोग के साथ बढ़ती है — छोटे पैमाने पर पैसे-कौड़ी, बड़े पैमाने पर सबसे बड़ी लाइन आइटम।
  • फ्लैट कंज़्यूमर/सीट सब्सक्रिप्शन। किसी चैट ऐप या IDE असिस्टेंट के लिए एक निश्चित मासिक शुल्क (Claude / ChatGPT / Gemini कंज़्यूमर प्लान, Copilot-शैली सीटें)। आप टोकन नहीं देखते; आपको एक उपयोग भत्ता और रेट लिमिट मिलती हैं। कीबोर्ड पर बैठे इंसान के लिए पूर्वानुमेय और सस्ता — लेकिन यह प्रोग्रामेटिक/उच्च-आयतन काम के लिए स्केल नहीं करता, और प्रति-सीट लागत एक टीम में जुड़ती जाती है।
  • ओपन / लोकल (सेल्फ-होस्टेड)। आप एक ओपन-वेट मॉडल (Llama, Mistral, Qwen, DeepSeek) अपने हार्डवेयर या किराए के GPU पर चलाते हैं। कोई प्रति-कॉल कीमत नहीं है — आप हार्डवेयर (या प्रति-घंटा GPU किराया) + बिजली + ops के लिए भुगतान करते हैं, चाहे मॉडल व्यस्त हो या निष्क्रिय। एक और कॉल की सीमांत लागत बड़े पैमाने पर लगभग-शून्य होती है, पर आप निश्चित लागत और परिचालन बोझ उठाते हैं। देखें Run Models Locally with Ollama।
Pro tip
  • मुख्य विभाजन: API और सब्सक्रिप्शन सीमांत (MARGINAL) लागत हैं (आप प्रति-उपयोग भुगतान करते हैं); सेल्फ-होस्टिंग ज़्यादातर निश्चित (FIXED) लागत है (आप क्षमता बनाए रखने के लिए भुगतान करते हैं, चाहे इस्तेमाल हो या न हो)।
  • API पर, सबसे बड़ा आश्चर्य यह है कि OUTPUT टोकन आमतौर पर इनपुट से कई गुना अधिक लागत लेते हैं — बातूनी जवाब असली पैसा खर्च कराते हैं।
  • फ्लैट सब्सक्रिप्शन एक इंसान के चैट करने का सही औज़ार है; per-token API एक ऐप द्वारा लूप में मॉडल कॉल करने का सही औज़ार है।

किसी वर्कलोड की लागत का अनुमान कैसे लगाएँ​

आप प्रोडक्शन कोड की एक लाइन लिखने से पहले एक API बिल का आकार आँक सकते हैं। पूरा मॉडल एक फ़ॉर्मूला है:

cost ≈ (input tokens × input rate) + (output tokens × output rate), per call × number of calls

दरें प्रति मिलियन टोकन पर उद्धृत होती हैं, और इनपुट व आउटपुट की अलग-अलग दरें होती हैं — इसलिए दोनों हिस्सों का अलग-अलग अनुमान लगाएँ और जोड़ें। टोकन का एक मोटा नियम: ~1 token ≈ अंग्रेज़ी के 4 अक्षर, या ~0.75 शब्द। सटीक गिनती के लिए Token Estimator क्षेत्र का उपयोग करें और Tokens & Pricing पढ़ें। टोकन कहाँ छिपते हैं इसका पूरा तंत्र The Token Economy में रहता है।

Guided walkthrough1 of 5
  1. इनपुट जोड़ें: system prompt + tools + retrieved context + history + यूज़र टर्न। फिर उस आउटपुट का अनुमान लगाएँ जो आप माँगते हैं। इनपुट और आउटपुट अलग-अलग गिनें — इनकी कीमत अलग है।

Back-of-envelope estimate (fill in today's rates)

Per call:
input_tokens  = system + tools + context + history + user_turn
output_tokens = the answer you ask for
call_cost = (input_tokens  * input_rate_per_million  / 1e6)
          + (output_tokens * output_rate_per_million / 1e6)

Per month:
monthly_cost = call_cost * calls_per_day * 30

Then adjust:
- cached repeated input -> use the (lower) cache-read rate for that slice
- offline / non-urgent  -> apply the batch discount to the whole job
Rates change monthly — pull today's numbers from the provider's pricing page.

बिल घटाने के बड़े लीवर​

ज़्यादातर असली वर्कलोड में बेकार बोझ होता है। ये लीवर, मोटे तौर पर लीवरेज के क्रम में, गुणवत्ता को छुए बिना खर्च काटते हैं — पहले सस्ते संरचनात्मक लीवर खींचें।

  • मॉडल को सही आकार दें। एक ऐसे काम के लिए फ्लैगशिप दर न चुकाएँ जिसे एक छोटा/सस्ता मॉडल ठीक-ठाक कर देता है। क्लासिफ़िकेशन, एक्सट्रैक्शन, राउटिंग, और सरल फ़ॉर्मैटिंग आमतौर पर सबसे छोटे टियर पर प्रति-टोकन कीमत के एक अंश पर बढ़िया चलते हैं। बड़े मॉडल को सचमुच कठिन तर्क के लिए आरक्षित रखें, और routing पर विचार करें: सस्ता मॉडल आसान बहुमत संभालता है, केवल कठिन मामलों को एस्केलेट करें। देखें Choosing a Model।
  • जो कॉन्टेक्स्ट आप भेजते हैं उसे छाँटें। सबसे सस्ता टोकन वह है जो आप कभी भेजते ही नहीं। फूले हुए system prompts छाँटें, लंबे इतिहास को एक चलती हुई सारांश में संघनित करें, और केवल वही tools दिखाएँ जो काम को चाहिए — हर एक इनपुट है जिसका आप हर कॉल में फिर से भुगतान करते हैं।
  • विशाल कॉन्टेक्स्ट ठूँसने के बजाय RAG। एक सवाल का जवाब देने के लिए 50-पन्नों का दस्तावेज़ चिपकाना हर कॉल में 50 पन्नों का भुगतान करता है। Retrieval केवल कुछ प्रासंगिक अंश लाता है — उसी (अक्सर बेहतर) जवाब के लिए बहुत कम इनपुट टोकन। किसी विशाल कॉन्टेक्स्ट विंडो की ओर तभी हाथ बढ़ाएँ जब आपको सचमुच पूरे कॉर्पस को एक साथ नज़र में चाहिए।
  • प्रॉम्प्ट कैशिंग। अगर कई कॉल एक बड़ा अपरिवर्तित उपसर्ग साझा करते हैं (system prompt, tool catalog, reference doc), तो कैशिंग उसे एक बार प्रोसेस करती है और हर बाद की कॉल पर उसे तीव्र छूट पर फिर से परोसती है। चैट और एजेंट वर्कलोड के लिए सबसे अधिक-लीवरेज वाला संरचनात्मक बदलाव, क्योंकि यह हर टर्न में भुगतान लौटाता है।
  • गैर-अत्यावश्यक को बैच करें। Evals, बल्क लेबलिंग, किसी आर्काइव का सारांश — कुछ भी जहाँ आपको जवाब सेकंडों में नहीं चाहिए — ज़्यादातर प्रोवाइडरों पर एक फ्लैट छूट पर एक async बैच पथ से चलता है। तात्कालिकता का सौदा एक भौतिक रूप से कम बिल के लिए करें।
  • आउटपुट छोटा करें। आउटपुट महँगा पक्ष है। बातूनी पैराग्राफ़ के बजाय JSON या एक तंग स्कीमा माँगें: कम आउटपुट टोकन और कोई डाउनस्ट्रीम पार्सिंग अनुमान नहीं।
  • आसान हिस्से के लिए छोटे / ओपन मॉडल। कॉल के उच्च-आयतन, कम-कठिनाई वाले बहुमत के लिए, एक ओपन या छोटा मॉडल प्रति-कॉल नाटकीय रूप से सस्ता हो सकता है — कभी-कभी लगभग-मुफ़्त अगर आप पहले से सेल्फ-होस्ट करते हैं। फ्लैगशिप मॉडल उन मामलों के लिए रखें जिन्हें सचमुच उसकी ज़रूरत है।
Pro tip
  • ये गुणात्मक रूप से जुड़ते हैं: कैश्ड इनपुट × सही-आकार मॉडल × कसा हुआ आउटपुट × बैच डिस्काउंट एक आसान काम पर एक बड़ी कुल कटौती में जुड़ जाते हैं — गुणवत्ता अपरिवर्तित रहते हुए।
  • शब्दावली को सूक्ष्म-अनुकूलित करने से पहले संरचनात्मक लीवर (सही-आकार, कैश, RAG, बैच) खींचें — वे बिल को कहीं अधिक हिलाते हैं।
  • बदलाव को हमेशा असली बिल के विरुद्ध MEASURE करें, अनुमान के नहीं। गहरा प्लेबुक The Token Economy है।

कब ओपन/सेल्फ-होस्टेड API को हराता है — और कब API जीतता है​

यह वह फ़ैसला है जो असल में आपके AI बजट को हिलाता है। यह एक fixed-vs-marginal-cost क्रॉसओवर है, और आयतन वह चर है जो इसे तय करता है।

  • ओपन / सेल्फ-होस्टेड HIGH, स्थिर आयतन पर जीतता है। एक बार जब आप एक GPU को अधिकांश समय व्यस्त रखने भर की कॉल चला रहे होते हैं, तो प्रति-कॉल लगभग-शून्य सीमांत लागत हमेशा प्रति टोकन भुगतान करने से बेहतर होती है। आप निश्चित हार्डवेयर/किराया लागत को कॉल की एक विशाल संख्या में परिशोधित करते हैं, डेटा गोपनीयता और पूर्ण अनुकूलन पाते हैं — और परिचालन बोझ (प्रोविज़निंग, स्केलिंग, अपटाइम, MLOps) को प्रवेश की कीमत के रूप में स्वीकार करते हैं।
  • API LOW या SPIKY आयतन पर, या बिना infra के जीतता है। अगर ट्रैफ़िक छोटा, फटकीला, या अप्रत्याशित है, तो प्रति टोकन भुगतान का मतलब है कि आप केवल जो इस्तेमाल करते हैं उसी का भुगतान करते हैं और निष्क्रिय होने पर कुछ नहीं — कोई GPU रात 3 बजे गरम बैठा नहीं। आप सारे ops भी छोड़ देते हैं। किसी प्रोडक्ट को शिप करने, प्रोटोटाइप करने, या फटकीले ट्रैफ़िक वाली अधिकांश टीमों के लिए, API दोनों सस्ता और कहीं कम काम है।
Watch out
  • सेल्फ-होस्टिंग शायद ही 'मुफ़्त' होती है। मॉडल वेट मुफ़्त हो सकते हैं, पर GPU, बिजली, और इसे चलाते रखने के इंजीनियर-घंटे नहीं — बचत का दावा करने से पहले इन्हें ईमानदारी से गिनें।
  • निष्क्रिय GPU शुद्ध नुकसान हैं: निश्चित-लागत infra प्रति-टोकन प्राइसिंग को तभी हराता है जब उपयोग HIGH हो। कम या फटकीला ट्रैफ़िक हर बार API के पक्ष में है।
  • क्रॉसओवर बिंदु तब हिलता है जब भी API कीमतें गिरती हैं या हार्डवेयर सस्ता होता है — गणित को समय-समय पर फिर से चलाएँ, एक बार तय करके भूल न जाएँ।
AI cost vocabulary
कार्ड पलटने के लिए Enter या Space दबाएँ। कार्ड बदलने के लिए बाएँ और दाएँ तीर कुंजियों का उपयोग करें।शब्द दिखाया गया।
1 / 6

Check yourself

0/3
  1. किसी per-token API पर, बिल का कौन-सा पक्ष लगभग हमेशा अधिक महँगा होता है?
  2. आपके पास कम, फटकीला, अप्रत्याशित ट्रैफ़िक है और कोई ML इन्फ्रास्ट्रक्चर नहीं। आमतौर पर कौन-सा सस्ता है?
  3. किसी आसान, उच्च-आयतन काम पर API बिल काटने का सबसे भरोसेमंद तरीका क्या है?
Key takeaways
  • तीन आर्किटाइप: per-token API (उपयोग-आधारित, इनपुट बनाम आउटपुट अलग-अलग तय), फ्लैट सब्सक्रिप्शन (पूर्वानुमेय, उच्च आयतन के लिए स्केल नहीं करता), और ओपन/सेल्फ-होस्टेड (निश्चित लागत, प्रति कॉल लगभग-शून्य)।
  • बनाने से पहले अनुमान लगाएँ: (input × input rate) + (output × output rate), per call × volume — फिर कैश और बैच डिस्काउंट लागू करें।
  • सबसे बड़े लीवर: मॉडल को सही-आकार दें, कॉन्टेक्स्ट छाँटें, विशाल कॉन्टेक्स्ट पर RAG, प्रॉम्प्ट कैशिंग, गैर-अत्यावश्यक को बैच करें, आउटपुट छोटा करें।
  • सेल्फ-होस्टिंग HIGH स्थिर आयतन पर जीतती है (निश्चित लागत परिशोधित करें); API LOW/फटकीले आयतन पर या बिना infra के जीतता है (केवल उपयोग का भुगतान)।
  • हर डॉलर आँकड़ा तेज़ी से पुराना पड़ता है — प्रोवाइडर के प्राइसिंग पेज और एक ट्रैकर पर सत्यापित करें, और अपने खुद के आँकड़े Cost Calculator में चलाएँ।

स्रोत और आगे पढ़ें​

  • Anthropic — Pricing — वर्तमान Claude प्रति-टोकन दरें, कैश और बैच डिस्काउंट।
  • OpenAI — API Pricing · OpenAI — Pricing overview — वर्तमान GPT प्रति-टोकन दरें और टियर।
  • Google — Gemini API Pricing — वर्तमान Gemini दरें, फ्री टियर, और पेड टियर।
  • Mistral — Pricing — ओपन-वेट + API प्राइसिंग, एक दक्षता-केंद्रित संदर्भ बिंदु।
  • Artificial Analysis — स्वतंत्र, बार-बार अपडेट होने वाली क्रॉस-प्रोवाइडर price/speed/quality तुलनाएँ (किसी भी उद्धृत आँकड़े को सैनिटी-चेक करने वाला ट्रैकर)।
  • Ollama — प्रति-कॉल कीमत को बड़े पैमाने पर शून्य की ओर ले जाने के लिए ओपन-वेट मॉडल लोकल चलाएँ।

आगे​

  • सही (और सही-कीमत वाला) मॉडल चुनें → Choosing a Model
  • टोकन कहाँ असल में लीक होते हैं ढूँढें → The Token Economy
  • प्रति-टोकन तंत्र गहराई में → Tokens & Pricing
  • अपने खुद के आँकड़े चलाएँ → Cost Calculator