# AI टोकन कॉस्ट: अपने मासिक LLM बिल का अनुमान लगाएँ

> AI टोकन कॉस्ट हर मिलियन इनपुट और आउटपुट टोकन की कीमत है। वर्कलोड, मॉडल दरों, कैश उपयोग और रीज़निंग से मासिक LLM बिल का अनुमान लगाएँ, फिर उसकी तुलना मापे गए उपयोग से करें।

AI टोकन कॉस्ट तब तक छोटी लगती है जब तक कोई फीचर एक ही लंबा कॉन्टेक्स्ट बार-बार न भेजने लगे। तब सवाल यह नहीं होता कि "एक टोकन की कीमत क्या है?" सवाल यह होता है कि आपका फीचर एक महीने में कितने बिल-योग्य टोकन बनाता है।

**संक्षिप्त उत्तर:** वर्कलोड के अनकैश्ड इनपुट, कैश्ड इनपुट, कैश-राइट और आउटपुट टोकन के कुल योग को संगत प्रति-टोकन दरों से गुणा करें, फिर एक मिलियन से भाग दें। जहाँ प्रोवाइडर रीज़निंग टोकन को आउटपुट में बिल करता है वहाँ उन्हें आउटपुट में शामिल करें, और कोई भी पात्र बैच दर लागू करें। एक साधारण सपोर्ट-उत्तर फीचर के लिए जो महीने में 10,000 टिकट संभालता है, प्रत्येक में 2,000 इनपुट और 350 आउटपुट टोकन, यह अनुमान मानक दरों पर चार मौजूदा API मॉडल ID के बीच $8.20 से $75 तक है, गैर-टोकन शुल्कों से पहले। लॉन्च के बाद, मान्यताओं को प्रतिक्रिया उपयोग से बदलें और प्रोवाइडर की कॉस्ट रिपोर्ट से उनका मिलान करें।

नीचे दी गई कीमतें अक्टूबर 2026 में जाँची गई थीं। ये USD में API सूची कीमतें हैं; इस गाइड का AI टोकन कॉस्ट कैलकुलेटर अनुमान लगाने के लिए है, होस्टेड उत्पादों या रीसेलर एंडपॉइंट के लिए कोटेशन नहीं।

## एक AI टोकन की कीमत कितनी होती है?

कोई एक AI टोकन कॉस्ट नहीं होती। प्रोवाइडर इनपुट टोकन और आउटपुट टोकन के लिए अलग-अलग दरें तय करते हैं, और कैश रीड, कैश राइट, लंबे कॉन्टेक्स्ट या सर्विस टियर के लिए कोई और दर ले सकते हैं। उस सटीक मॉडल ID और एंडपॉइंट की कीमतों की तुलना करें जिसे आप कॉल करने की योजना बनाते हैं।

यहाँ चार मौजूदा टेक्स्ट मॉडल्स की प्रति टोकन लागत है, प्रति मिलियन टोकन के हिसाब से:

| प्रोवाइडर और सटीक मॉडल ID             | इनपुट |          कैश्ड इनपुट/रीड |                             कैश राइट | आउटपुट |
| ------------------------------------- | ----: | -----------------------: | -----------------------------------: | -----: |
| OpenAI `gpt-5.6-luna`                 | $0.20 |                    $0.02 |                                $0.25 |  $1.20 |
| Anthropic `claude-sonnet-5-5`         | $2.00 |                    $0.20 |                 $2.50 (5m) / $4 (1h) | $10.00 |
| Anthropic `claude-haiku-4-5-20251001` | $1.00 |                    $0.10 |                 $1.25 (5m) / $2 (1h) |  $5.00 |
| Google `gemini-3.1-flash-lite`        | $0.25 | $0.025 कैश्ड कॉन्टेक्स्ट | प्रोवाइडर की कैश/स्टोरेज शर्तें लागू |  $1.50 |

दरें वेंडरों के मौजूदा [OpenAI मॉडल प्राइसिंग](https://developers.openai.com/api/docs/models/gpt-5.6-luna), [Claude Sonnet 5.5 मॉडल पेज](https://platform.claude.com/docs/en/models/sonnet-5-5/overview), [Claude Haiku 4.5 मॉडल पेज](https://platform.claude.com/docs/en/models/haiku-4-5/overview), और [Gemini API प्राइसिंग](https://ai.google.dev/gemini-api/docs/pricing) से ली गई हैं। ये क्षमता रैंकिंग नहीं हैं। कम इनपुट कीमत यह नहीं बताती कि आपके काम को कितनी कॉल या कितने आउटपुट टोकन चाहिए होंगे।

अंग्रेज़ी के लिए टोकन-से-शब्द का एक मोटा रूपांतरण प्रॉम्प्ट का आकार तय करने में मदद करता है, पर उसकी सटीक कीमत बताने में नहीं: OpenAI की गाइड [100 टोकन को लगभग 75 शब्द](https://help.openai.com/en/articles/4936856-understanding-and-counting-tokens) बताती है, जबकि Google कहता है कि [100 Gemini टोकन लगभग 60–80 अंग्रेज़ी शब्द](https://ai.google.dev/gemini-api/docs/tokens) होते हैं। इन्हें योजना-सीमा मानें। असली प्रॉम्प्ट के लिए, चुने गए मॉडल का टोकन काउंटर या प्रोवाइडर द्वारा लौटाया गया उपयोग देखें।

## मासिक AI टोकन कॉस्ट की गणना कैसे करें?

अलग-अलग टोकन बकेट इस्तेमाल करें ताकि कैश हिट पर सामान्य इनपुट दर से दोबारा शुल्क न लगे। ऐसे प्रोवाइडर के लिए जिसकी कीमतें प्रति मिलियन टोकन में बताई जाती हैं:

```text
standard-rate token cost =
  (uncached_input × input_rate
 + cached_input × cache_read_rate
 + cache_write × cache_write_rate
 + billed_output × output_rate) / 1,000,000

eligible batch cost = eligible standard-rate token cost × batch_multiplier
```

`billed_output` में दिखने वाले उत्तर टोकन और वे सभी रीज़निंग टोकन शामिल हैं जिन्हें प्रोवाइडर आउटपुट के रूप में बिल करता है। `batch_multiplier` मानक अनुरोधों के लिए 1 है और 0.5 वहाँ जहाँ वेंडर 50% बैच छूट दस्तावेज़ित करता है; इसे केवल बैच-पात्र टोकन शुल्कों पर लागू करें। अगर कैश और बैच संशोधक आपस में क्रिया करते हैं, तो मिश्रित उप-योग को गुणा करने के बजाय हर टोकन श्रेणी के लिए वेंडर की अंतिम दर इस्तेमाल करें। निश्चित टूल-कॉल, सर्च, स्टोरेज, ऑडियो या अन्य उपयोग शुल्क अलग से जोड़ें। उदाहरण के लिए, OpenAI अपने Responses और Chat Completions API को चुने गए मॉडल की टोकन दरों पर सूचीबद्ध करता है और कुछ बिल्ट-इन टूल की कीमत अलग से अपनी [API मूल्य सूची](https://developers.openai.com/api/docs/pricing) में बताता है।

विस्तृत रूप दो आसान गलतियों से बचाता है: इनपुट और आउटपुट दोनों पर एक मिश्रित दर लागू करना, और सभी इनपुट को नया मानना जबकि कुछ कैश से पढ़ा गया था।

Claude कैश निर्माण और कैश रीड को स्पष्ट रूप से अलग-अलग बताता है; इसकी [प्राइसिंग गाइड](https://platform.claude.com/docs/en/about-claude/pricing) पाँच-मिनट राइट, एक-घंटा राइट और कैश हिट के लिए अलग-अलग गुणक देती है। OpenAI के प्रॉम्प्ट कैश की अलग कैश्ड-इनपुट दर है और यह अपनी [प्रॉम्प्ट कैशिंग गाइड](https://developers.openai.com/api/docs/guides/prompt-caching) में GPT-5.6 और बाद के लिए कैश-राइट दर दस्तावेज़ित करता है। Google [Gemini प्राइसिंग](https://ai.google.dev/gemini-api/docs/pricing) में कैश्ड कॉन्टेक्स्ट को अलग से सूचीबद्ध करता है।

## मासिक सपोर्ट बॉट की लागत कितनी होगी?

इन मान्यताओं के तहत, मासिक सपोर्ट-बॉट टोकन शुल्क मॉडल के आधार पर $8.20 से $75 तक होते हैं। एक सपोर्ट-उत्तर फीचर लें जिसमें प्रति माह 10,000 टिकट हों। मान लें कि प्रति टिकट ठीक एक मॉडल कॉल होती है, प्रति कॉल 2,000 इनपुट टोकन (सिस्टम निर्देश, पुनःप्राप्त स्निपेट और ग्राहक संदेश मिलाकर), और प्रति कॉल 350 बिल-योग्य आउटपुट टोकन। यानी मासिक 20 मिलियन इनपुट टोकन और 3.5 मिलियन आउटपुट टोकन।

350 आउटपुट-टोकन की मान्यता में रीज़निंग शामिल है अगर API रीज़निंग को आउटपुट गिनती में बिल करता है। मानक सिंक्रोनस अनुरोध मानें, कोई कैश हिट या राइट नहीं, कोई रीट्राई नहीं, अलग से बिल होने वाले कोई टूल नहीं, और कोई कर या अनुबंध छूट नहीं।

| मॉडल ID                     | गणना                     | अनुमानित मासिक टोकन कॉस्ट |
| --------------------------- | ------------------------ | ------------------------: |
| `gpt-5.6-luna`              | 20 × $0.20 + 3.5 × $1.20 |                 **$8.20** |
| `gemini-3.1-flash-lite`     | 20 × $0.25 + 3.5 × $1.50 |                **$10.25** |
| `claude-haiku-4-5-20251001` | 20 × $1 + 3.5 × $5       |                **$37.50** |
| `claude-sonnet-5-5`         | 20 × $2 + 3.5 × $10      |                **$75.00** |

हर गुणक मिलियन टोकन इस्तेमाल करता है: 20 मिलियन इनपुट टोकन × प्रति मिलियन $0.20 = $4; 3.5 मिलियन आउटपुट टोकन × प्रति मिलियन $1.20 = $4.20; GPT-5.6 Luna के लिए कुल $8.20। बाकी पंक्तियाँ वही मात्राएँ और उनकी जुड़ी वेंडर दरें इस्तेमाल करती हैं। यह एक बिलिंग तुलना है, यह दावा नहीं कि मॉडल समतुल्य उत्तर देते हैं। उन्हीं प्रतिनिधि सपोर्ट केस को उम्मीदवार मॉडल्स पर चलाएँ और एक चुनने से पहले गुणवत्ता और उपयोग मापें।

बैच-सक्षम ऑफ़लाइन जॉब के लिए, सूचीबद्ध बैच दरों के साथ दोबारा गणना करें। [Claude मॉडल पेज](https://platform.claude.com/docs/en/models/sonnet-5-5/overview) इनपुट और आउटपुट पर 50% बैच छूट सूचीबद्ध करते हैं, और Google का [Gemini Batch API दस्तावेज़](https://ai.google.dev/gemini-api/docs/batch-api) भी कहता है कि वह मानक समतुल्य-मॉडल लागत का आधा शुल्क लेता है। उस छूट को इंटरैक्टिव अनुरोध पर सिर्फ इसलिए लागू न करें क्योंकि आपने अपने कोड में अनुरोधों को समूहित किया है।

## 1,000 टोकन में कितना टेक्स्ट होता है?

सामान्य अंग्रेज़ी के लिए, ऊपर दिए गए वेंडर अनुमानों से 1,000 टोकन लगभग 600–800 शब्द होते हैं। यह एक मोटा आकार-रूपांतरण है, सार्वभौमिक नियम नहीं: कोड, टेबल, विराम चिह्न, गैर-अंग्रेज़ी लेखन और मॉडल टोकनाइज़र गिनती बदल देते हैं। एक पेज के प्रॉम्प्ट में टूल स्कीमा और पिछले संदेश भी हो सकते हैं जो उपयोगकर्ता द्वारा टाइप किए गए टेक्स्ट से स्पष्ट नहीं होते।

लॉन्च से पहले, प्रोवाइडर के टूल से असली प्रॉम्प्ट आकार गिनें: Google की [टोकन गाइड](https://ai.google.dev/gemini-api/docs/tokens) इनपुट के लिए `count_tokens` और प्रतिक्रियाओं पर उपयोग फ़ील्ड बताती है। ऐसा कई सामान्य और असामान्य रूप से लंबे टिकटों के लिए करें। औसत और उच्च-प्रतिशतक केस को अपेक्षित मासिक टिकट मात्रा से गुणा करें; उच्च केस दिखाता है कि लंबे अनुरोध आम होने पर आपके बजट को कितनी गुंजाइश चाहिए।

## वास्तविक उपयोग के मुकाबले अनुमान की पुष्टि कैसे करें?

प्रति मॉडल अनुरोध एक रिकॉर्ड लॉग करें, न कि केवल प्रति ग्राहक बातचीत एक कुल योग। एक अनुरोध ID, तारीख, फीचर या टेनेंट कुंजी, मॉडल ID, इनपुट-टोकन श्रेणियाँ, आउटपुट टोकन, और मौजूद होने पर रिपोर्ट की गई लागत सहेजें। एक एजेंट एक उपयोगकर्ता-दृश्य उत्तर के लिए कई प्रोवाइडर कॉल कर सकता है, इसलिए बातचीत की हर कॉल का योग करें।

फिर अनुरोध-स्तर के लॉग की तुलना प्रोवाइडर के अपने उपयोग और बिलिंग दृश्य से करें:

| प्रोवाइडर | सुरक्षित रखने योग्य अनुरोध-स्तर फ़ील्ड                                                                                        | मासिक मिलान                                                                                                                                            |
| --------- | ----------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| OpenAI    | `input_tokens`, `input_tokens_details.cached_tokens`, `output_tokens`, लौटाए जाने पर `output_tokens_details.reasoning_tokens` | Organization Usage API और उसका Costs एंडपॉइंट (`GET /organization/costs`), या Usage डैशबोर्ड।                                                          |
| Anthropic | `input_tokens`, `cache_creation_input_tokens`, `cache_read_input_tokens`, `output_tokens`                                     | Usage और Cost Admin API: `/v1/organizations/usage_report/messages` और `/v1/organizations/cost_report`; Admin API क्रेडेंशियल आवश्यक।                   |
| Gemini    | `total_input_tokens`, `total_output_tokens`, `total_thought_tokens`, लौटाए जाने पर `total_cached_tokens`                      | प्रतिक्रिया उपयोग की तुलना उसी प्रोजेक्ट और तारीख-सीमा के बिलिंग दृश्य से करें। `count_tokens` का उपयोग केवल प्रीफ़्लाइट इनपुट अनुमान के रूप में करें। |

स्कीमा और रिपोर्टिंग पथ [OpenAI Usage API संदर्भ](https://developers.openai.com/api/reference/resources/admin/subresources/organization/subresources/usage), [Anthropic Messages API](https://platform.claude.com/docs/en/api/messages/create), [Anthropic Usage और Cost API](https://platform.claude.com/docs/en/manage-claude/usage-cost-api), और [Gemini टोकन गाइड](https://ai.google.dev/gemini-api/docs/tokens) में दस्तावेज़ित हैं।

OpenAI के रीज़निंग टोकन आउटपुट के रूप में बिल होते हैं भले ही API उनका टेक्स्ट उजागर नहीं करता, जैसा इसकी [रीज़निंग गाइड](https://developers.openai.com/api/docs/guides/reasoning) में बताया गया है; Google स्पष्ट रूप से थिंकिंग टोकन को मॉडल आउटपुट प्राइसिंग में शामिल करता है। आउटपुट कुल योग में पहले से शामिल रीज़निंग के ऊपर अलग रीज़निंग शुल्क न जोड़ें।

प्रोवाइडर डैशबोर्ड आपको प्रोवाइडर का लेखांकन दृश्य देता है। गेटवे कॉलरों के बीच प्रति-अनुरोध एट्रिब्यूशन जोड़ सकता है, पर उसका आँकड़ा उतना ही ठोस है जितने उसके मॉडल रेट और उपयोग पार्सिंग। LiteLLM खर्च लॉग दस्तावेज़ित करता है और चेतावनी देता है जब किसी डिप्लॉयमेंट में उसकी [कॉस्ट-ट्रैकिंग गाइड](https://docs.litellm.ai/docs/proxy/cost_tracking) के अनुसार इनपुट/आउटपुट प्राइसिंग प्रविष्टि नहीं होती। हम Muvon में OctoHub बनाते हैं; यह हर completion को कॉल करने वाली API कुंजी, सत्र, मॉडल और प्रोवाइडर, और इनपुट, आउटपुट, कैश रीड व राइट, और रीज़निंग टोकन में बँटे उपयोग के साथ संग्रहीत करता है, और जहाँ ज्ञात हो वहाँ लागत भी ([OctoHub LLM प्रॉक्सी अवलोकन](/blog/introducing-octohub-llm-proxy-for-observability))। प्रोवाइडर डैशबोर्ड और अन्य दस्तावेज़ित प्रॉक्सी उचित विकल्प हैं अगर वे आपके स्टैक में फिट बैठते हैं।

## जब असली बिल अलग हो तो क्या करना चाहिए?

पहले टोकन-मात्रा की चूक को दर या एट्रिब्यूशन की चूक से अलग करें। ठीक उन्हीं तारीखों के लिए अनुरोध संख्या, औसत इनपुट/आउटपुट उपयोग, कैश बकेट, मॉडल ID और रीट्राई की तुलना करें। अनुरोध लॉग में अंतर का आमतौर पर मतलब है कि कॉल आपके प्रॉक्सी से बचकर गईं या उपयोग फ़ील्ड रिकॉर्ड नहीं हुईं; अनुमानित लागत और वेंडर रिपोर्ट के बीच अंतर का मतलब पुरानी दरें, बिना कीमत वाले टूल, या अलग सर्विस टियर हो सकता है।

पहले महीने अनुमान और देखे गए बिल को साथ-साथ रखें। एक बार जब प्रति काम मात्रा और लागत वास्तविक हो जाए, अगला कदम हमारी [मॉडल-रूटिंग गाइड](/blog/running-one-ai-agent-across-many-models) में मॉडल और रूट चुनना है। अगर आपको व्यापक अनुरोध ट्रेस चाहिए, तो हमारे [एजेंट ऑब्ज़र्वेबिलिटी नोट्स](/blog/debugging-ai-agents-the-observability-we-wanted) या [एकीकृत प्रोवाइडर परत से सीखे गए सबक](/blog/lessons-building-a-unified-llm-provider-layer-in-rust) देखें।

— Don

---

_अगर आपको प्रोवाइडर द्वारा लौटाए गए उपयोग और उसकी मासिक कॉस्ट रिपोर्ट के बीच बेमेल दिखे, तो शामिल मॉडल और फ़ील्ड नामों के साथ [OctoHub पर इशू खोलें](https://github.com/Muvon/octohub/issues)._