Claude में टोकन क्या हैं और कोड सेशन की लागत कैसे समझें

Claude में टोकन क्या हैं?

टोकन वह टेक्स्ट यूनिट है जिसे Claude पढ़ता और लिखता है: यह एक शब्द का अंश होता है, जो लगभग 3.5 अंग्रेजी अक्षरों के बराबर है। यह आंकड़ा Anthropic की अपनी शब्दावली से लिया गया है, और स्पेस तथा विराम चिह्नों को गिनने पर यह प्रति शब्द एक टोकन से काफी अधिक हो जाता है, इसलिए 1,000 शब्दों का गद्य आसानी से 1,300 टोकन से ऊपर चला जाता है। कोड प्रति लाइन अधिक भारी होता है: ब्रेसेस, ऑपरेटर्स, अंडरस्कोर और इंडेंटेशन अंग्रेजी की तुलना में प्रति अक्षर अधिक टोकन में विभाजित होते हैं, और कुछ सौ लाइनों की सोर्स फाइल आमतौर पर कई हजार टोकन की होती है। यदि एजेंट 2,000 लाइनों की फाइल पढ़ने का निर्णय लेता है, तो किसी के द्वारा एक भी नई लाइन लिखने से पहले ही यह पांच अंकों का टोकन खर्च हो जाता है।

टोकनाइज़र के बारे में दो बातें लोगों को भ्रमित करती हैं। पहली, वे मॉडल-विशिष्ट होते हैं। जुलाई 2026 तक, Opus 4.7 और उसके बाद के वर्ज़न, Sonnet 5, और Fable 5 एक नए टोकनाइज़र का उपयोग करते हैं जो पुराने Claude मॉडल्स की तुलना में समान टेक्स्ट के लिए लगभग 30% अधिक टोकन उत्पन्न करता है (सटीक वृद्धि सामग्री के अनुसार बदलती रहती है), जो आपके टोकन बजट को प्रभावित करता है, भले ही प्रति-टोकन कीमतें इसके साथ नहीं बढ़ी हैं। दूसरी, tiktoken, वह लाइब्रेरी जिसका उल्लेख हर ब्लॉग पोस्ट में किया जाता है, OpenAI का टोकनाइज़र है और यह सामान्य टेक्स्ट पर Claude की तुलना में लगभग 15–20% कम टोकन गिनता है, और कोड पर तो और भी कम। एकमात्र विश्वसनीय गणना count_tokens एंडपॉइंट है, जिसे नीचे कवर किया गया है।

आपकी कोडिंग सेशन की लागत इतनी क्यों है

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

सब कुछ इनपुट है: मीटर वास्तव में क्या गिनता है

लोग मानते हैं कि वे उस कोड के लिए भुगतान करते हैं जो Claude लिखता है। एक एजेंटिक सत्र में, यह एक छोटा सा खर्च है। इनपुट टोकन, जिनकी दर सस्ती होती है लेकिन मात्रा बहुत अधिक होती है, उनमें ये शामिल हैं:

• सिस्टम प्रॉम्प्ट। Claude Code के अपने हार्नेस निर्देश, साथ ही आपकी CLAUDE.md और मेमोरी फाइलें, जो सत्र शुरू होने पर लोड होती हैं और उसके बाद हर अनुरोध पर मौजूद रहती हैं।
• टूल डेफिनिशन। हर टूल का स्कीमा जिसे एजेंट कॉल कर सकता है। हर MCP सर्वर जिसे आप कनेक्ट करते हैं इस निश्चित ओवरहेड को बढ़ाता है, हालाँकि Claude Code अब डिफ़ॉल्ट रूप से पूर्ण MCP टूल डेफिनिशन को टाल देता है, इसलिए जब तक किसी टूल का पहली बार उपयोग नहीं किया जाता, तब तक केवल टूल के नाम ही कॉन्टेक्स्ट में रहते हैं, जो लागत को कम तो करता है लेकिन पूरी तरह समाप्त नहीं करता।
• हर फाइल जिसे एजेंट पढ़ता है। किसी सोर्स फाइल का Read पूरी फाइल को कॉन्टेक्स्ट में डाल देता है, और वह वहीं बनी रहती है।
• हर टूल का परिणाम। टेस्ट रन, grep आउटपुट, टर्मिनल का डेटा, बिल्ड लॉग्स, यह सब इनपुट टोकन के रूप में वापस आता है। एक विफल टेस्ट सुइट जो 8,000 लाइनें प्रिंट करता है, उसका बिल एक छोटी किताब के बराबर आता है।
• अब तक की पूरी बातचीत, जिसे हर टर्न पर फिर से भेजा जाता है। यह बिंदु अपने आप में एक अलग सेक्शन का हकदार है।

पुनः भेजने की लागत

Claude API स्टेटलेस (stateless) है। यह requests के बीच आपके session को याद नहीं रखती, कोई भी ऐसा नहीं करता। इसलिए दूसरे टर्न पर, client पहले टर्न, उसके response और आपके नए message को भेजता है। 50वें टर्न पर, यह पहले से 49वें टर्न तक के सभी संदेश, पढ़ी गई हर फाइल, हर टूल का परिणाम, हर diff और 50वां टर्न फिर से भेजता है। मॉडल हर बार पूरे transcript को फिर से पढ़ता है, और उन सभी दोबारा पढ़े गए tokens के लिए input शुल्क लिया जाता है।

परिणाम यह है: प्रति टर्न लागत session की लंबाई के साथ लगभग रैखिक (linearly) रूप से बढ़ती है, और कुल session लागत लगभग द्विघातीय (quadratically) रूप से बढ़ती है। जो message तीसरे टर्न पर आधे सेंट का था, वह 60वें टर्न पर उसी एक लाइन के सवाल के लिए बीस गुना महंगा हो सकता है, क्योंकि यह 60 टर्न का भार ढो रहा है। यह वह एकमात्र तथ्य है जो "मेरा बिल इतना अधिक क्यों आया" वाली अधिकांश शिकायतों का कारण बताता है, और यह Claude की कोई विशेष कमी नहीं है; हर वह LLM product जो stateful महसूस होता है, वास्तव में एक stateless API है जिसके नीचे एक resend loop काम कर रहा है।

आउटपुट: जो आप देखते हैं, और वह थिंकिंग जो आप नहीं देखते

आउटपुट टोकन महंगे होते हैं, जो वर्तमान लाइनअप में इनपुट दर से पांच गुना अधिक हैं (जुलाई 2026 तक Opus 4.8 पर $5/$25, Sonnet 5 पर $3/$15, Haiku 4.5 पर $1/$5)। आउटपुट में Claude द्वारा जेनरेट किया गया टेक्स्ट और कोड, तथा थिंकिंग टोकन शामिल होते हैं: वह आंतरिक तर्क जो मॉडल उत्तर देने से पहले करता है। यहाँ दो तथ्य महत्वपूर्ण हैं। थिंकिंग के लिए आउटपुट दरों पर बिलिंग की जाती है और यह max_tokens के विरुद्ध गिना जाता है, एक API रिस्पॉन्स जो stop_reason: "max_tokens" के साथ समाप्त हो जाता है और एक अधूरा उत्तर अक्सर यह दर्शाता है कि उत्तर से पहले ही थिंकिंग ने बजट का उपभोग कर लिया है। और वर्तमान मॉडलों पर रीजनिंग समरी शायद दिखाई न दे, Opus 4.8, Sonnet 5, और Fable 5 इसे डिफ़ॉल्ट रूप से हटा देते हैं, लेकिन थिंकिंग अभी भी हुई है और उसका बिल भी बनता है। अदृश्य होने का मतलब मुफ्त नहीं है।

Claude Code डिफ़ॉल्ट रूप से विस्तारित थिंकिंग को सक्षम करता है क्योंकि यह बहु-चरणीय कार्यों में मापने योग्य सुधार करता है, और डिफ़ॉल्ट बजट प्रति अनुरोध हजारों टोकन तक जा सकता है। सरल कार्यों पर आप इसे कम कर सकते हैं: /effort के साथ या /model में प्रयास स्तर को कम करें, या /config में थिंकिंग सेटिंग्स को समायोजित करें। यह एक वास्तविक लागत नियंत्रण लीवर है, कोई अंधविश्वास नहीं।

Prompt caching गणित को बदल देता है

Prompt caching ही वह कारण है जिसकी वजह से resend loop हर किसी को दिवालिया नहीं करता। API आपके prompt के स्थिर prefix, system prompt, tool definitions और conversation history को cache कर सकता है। अगली request पर, यह इसे बहुत कम कीमत पर serve कर सकता है। जुलाई 2026 तक, multipliers इस प्रकार हैं: cache write की लागत base input rate का 1.25× है (1-घंटे वाले variant के लिए 2×), और cache read की लागत 0.1× है। Writes महंगे होते हैं; reads पर 90% की छूट मिलती है। एक single read ही 5-मिनट वाले write premium की भरपाई कर देता है।

Claude Code आपके लिए caching को manage करता है, और एक healthy session में उस विशाल resend का लगभग पूरा हिस्सा cache से ही serve होता है। लेकिन default cache अंतिम उपयोग से पांच मिनट तक ही जीवित रहता है। यदि आप कॉफी पीने के लिए लंबे समय के लिए जाते हैं, वापस आते हैं, और एक message भेजते हैं, तो cache expire हो चुका होता है। ऐसे में पूरा accumulated prefix 0.1× पर read होने के बजाय 1.25× पर फिर से write होता है। 150K-token वाले session पर, वह एक cold turn एक दर्जन warm turns से अधिक महंगा पड़ता है। यह वह counterintuitive परिणाम है जिसे समझना आवश्यक है: idle-then-resume की लय निरंतर काम करने से अधिक महंगी हो सकती है, क्योंकि TTL के बाद का हर idle gap आपकी अगली turn को सस्ते read से महंगे re-write में बदल देता है। काम को stints में करें; एक विशाल session में हर दस मिनट में एक message न भेजें।

यदि आप VPS पर अपने स्वयं के application से API call कर रहे हैं, तो आपको यह सब मुफ्त में नहीं मिलता। इसमें होने वाली एक आम गलती system prompt में timestamp या request ID को डालना है, जो हर request पर prefix bytes को बदल देता है और चुपचाप caching को disable कर देता है। इसकी पहचान यह है कि एक जैसे दिखने वाले calls के दौरान भी usage.cache_read_input_tokens शून्य पर बना रहता है।

सूत्र और एक हल किया गया उदाहरण

"एक सेशन की लागत $X है" जैसे सीधे दावों पर ध्यान न दें। सेशन की लागत में 100 गुना तक का अंतर हो सकता है। जो बात सही है, वह यह सूत्र है:

turn cost = (uncached input      x base input price)
          + (cache writes        x 1.25 x base input price)
          + (cache reads         x 0.10 x base input price)
          + (output incl. thinking x output price)

session cost = sum over all turns

Claude Opus 4.8 पर एक हल किया गया उदाहरण, जिसकी जुलाई 2026 तक कीमत $5 प्रति दस लाख इनपुट टोकन और $25 प्रति दस लाख आउटपुट टोकन है। एक मिड-सेशन टर्न जिसमें 80,000 टोकन का संचित संदर्भ (accumulated context) है: 75,000 कैश से पढ़े गए, 3,000 नए लिखे गए, 2,000 बिना कैश वाले नए इनपुट, और 1,500 आउटपुट टोकन (सोचने की प्रक्रिया सहित)।

• कैश रीड्स: 75,000 × $0.50/M = $0.0375
• कैश राइट्स: 3,000 × $6.25/M = $0.019
• बिना कैश वाला इनपुट: 2,000 × $5/M = $0.010
• आउटपुट: 1,500 × $25/M = $0.0375

एक टर्न के लिए लगभग $0.10; ऐसे पचास टर्न की लागत लगभग $5 होगी। अब कैश समाप्त होने के बाद वही टर्न देखें: पूरे 80,000 टोकन $6.25/M की दर से दोबारा लिखे जाने पर आउटपुट से पहले $0.50 के होते हैं, जो समान कार्य के लिए वार्म टर्न की तुलना में लगभग पांच गुना अधिक है। यह अंतर ही कैशिंग की पूरी कहानी को एक संख्या में बयां करता है। ये चार पंक्तियाँ ही वेंडर्स की तुलना करने का एकमात्र ईमानदार तरीका हैं, क्योंकि स्टिकर रेट्स कैश रीड्स और थिंकिंग को पूरी तरह नजरअंदाज कर देते हैं। इन्हें तीन वास्तविक जॉब्स पर चलाने से पता चलता है कि Claude का बिल OpenAI की तुलना में कहाँ कम या ज्यादा बैठता है।

यदि आप एक टर्न के बजाय बिलिंग यूनिट को समझना चाहते हैं, तो दस लाख टोकन का पेजों, फाइलों और डॉलर में क्या अर्थ है लेख में इसी गणित को एक स्तर ऊपर समझाया गया है। अनुमान लगाने के बजाय कैलिब्रेशन के लिए: जुलाई 2026 तक, एंटरप्राइज Claude Code डिप्लॉयमेंट के लिए Anthropic के प्रकाशित आंकड़े बताते हैं कि प्रति सक्रिय दिन एक डेवलपर पर औसतन $13 खर्च होते हैं, जो प्रति माह $150–250 के बीच है, और 90% उपयोगकर्ता प्रतिदिन $30 से कम खर्च करते हैं। आपका खर्च मॉडल के चुनाव, सेशन हाइजीन और कोडबेस के आकार पर निर्भर करता है, और यही कारण है कि नीचे दिए गए विकल्प महत्वपूर्ण हैं।

अपने स्वयं के उपयोग को देखना

Claude Code में, कमांड /usage है (/cost भी काम करता है, यह एक उपनाम है)। शीर्ष पर स्थित Session ब्लॉक वर्तमान सत्र के लिए टोकन आँकड़े और स्थानीय रूप से गणना की गई लागत का अनुमान दिखाता है; सब्सक्रिप्शन प्लान पर, वही स्क्रीन आपकी प्लान-लिमिट बार और हाल के उपयोग को स्किल्स, सब-एजेंट्स, प्लगइन्स और व्यक्तिगत MCP सर्वर्स के बीच विभाजित करके दिखाती है। API खातों पर आधिकारिक बिलिंग के लिए, Claude Console में उपयोग पृष्ठ ही सत्य का स्रोत है, CLI का आंकड़ा केवल एक अनुमान है। /context context window में क्या जगह ले रहा है, सिस्टम प्रॉम्प्ट, टूल्स, MCP परिभाषाएँ, फाइलें और इतिहास का एक रंगीन ग्रिड बनाता है, और यह एक फूले हुए CLAUDE.md या बहुत अधिक डेटा भेजने वाले MCP सर्वर का पता लगाने का सबसे तेज़ तरीका है; पूर्ण प्रति-आइटम विवरण का विस्तार करने के लिए all पास करें।

API से, प्रत्येक प्रतिक्रिया आपको ठीक-ठीक बताती है कि क्या हुआ:

response = client.messages.create(model="claude-sonnet-5", max_tokens=2048,
                                  messages=messages)
u = response.usage
total_prompt = u.input_tokens + u.cache_creation_input_tokens + u.cache_read_input_tokens
print(f"uncached={u.input_tokens} written={u.cache_creation_input_tokens} "
      f"read={u.cache_read_input_tokens} output={u.output_tokens}")

ध्यान दें कि input_tokens केवल बिना कैश किया हुआ शेष भाग है, वास्तविक प्रॉम्प्ट आकार तीनों इनपुट फ़ील्ड का योग है। एक एजेंट जो एक घंटे तक चला और input_tokens: 4000 दिखा रहा है, वह सस्ता नहीं है; अन्य 200,000 टोकन कैश से परोसे गए थे। भेजने से पहले अनुमान लगाने के लिए, टोकन-काउंटिंग एंडपॉइंट का उपयोग करें, इसे कॉल करना निःशुल्क है, इसकी अपनी दर सीमा (rate limit) है, और यह आपके द्वारा नामित किसी भी मॉडल के टोकेनाइज़र के साथ गणना करता है (परिणाम को एक करीबी अनुमान मानें; बिलिंग वास्तविक अनुरोध को दर्शाती है):

count = client.messages.count_tokens(model="claude-sonnet-5",
                                     messages=[{"role": "user", "content": big_file}])
print(count.input_tokens)

ऊपर दिए गए कारण से, कभी भी tiktoken न करें।

Subscription plans बनाम pay-as-you-go

इस गाइड में दी गई कार्यप्रणाली हर जगह एक समान है; केवल भुगतान का तरीका अलग है। API key के साथ, Anthropic pay-as-you-go आधार पर, प्रति token, प्रकाशित दरों के अनुसार बिलिंग करता है। ऊपर दी गई हर संख्या वास्तविक धन है। यह मीटर अधिकांश लोगों की अपेक्षा से पहले शुरू हो जाता है, क्योंकि इसमें कोई free tier उपलब्ध नहीं है। साइनअप पर केवल एक छोटा credit मिलता है और कुछ चुनिंदा endpoints हैं जिन पर कोई शुल्क नहीं लगता, जो कि card details जोड़ने से पहले एक नए API account को वास्तव में क्या मिलता है में बताया गया है। Claude subscription (Pro, Max, Team, Enterprise) पर, Claude Code का उपयोग आपके plan में शामिल allowance से काटा जाता है: जुलाई 2026 तक, यह एक rolling पांच-घंटे की session window और एक साप्ताहिक window है, जो सभी models और claude.ai chat के बीच साझा की जाती है। यहाँ /usage डॉलर की राशि केवल जानकारी के लिए है, न कि बिल के रूप में। यदि आप window की सीमा समाप्त कर देते हैं, तो आपको "You've hit your session limit" या "You've hit your weekly limit" का संदेश दिखाई देगा, जिसमें reset होने का समय भी होगा। /model के साथ models बदलने से access वापस नहीं मिलेगा, क्योंकि ये windows सभी models के लिए साझा होती हैं। ये windows उस client के बजाय account का अनुसरण करती हैं जिसका आप उपयोग कर रहे हैं। यह जानना महत्वपूर्ण है यदि आप अभी भी यह समझ रहे हैं कि Linux पर क्या natively चलता है और कौन सा plan किस surface को कवर करता है। आपने वास्तव में कौन सी दो windows समाप्त की हैं, यह तय करता है कि प्रतीक्षा अवधि कितनी होगी और इस बीच क्या करना उचित है, इसलिए limit तक पहुँचने पर आपके पास क्या विकल्प हैं यह जानना फायदेमंद है। Plans में वैकल्पिक रूप से usage credits को enable किया जा सकता है, जिसे /usage-credits के माध्यम से manage किया जाता है, ताकि सीमा के बाद भी उपयोग जारी रखा जा सके। मैं जानबूझकर plan quotas को यहाँ नहीं लिख रहा हूँ: वे इस पूरे विषय में सबसे अधिक बदलने वाली संख्याएँ हैं, इसलिए claude.com/pricing और अपने स्वयं के /usage bars को देखें। Subscription के बावजूद token mechanics अभी भी मायने रखते हैं; एक wasteful session आपकी window को ठीक उसी तरह खत्म कर देता है जैसे वह डॉलर को खत्म करता। Subscription के बारे में अधिक जानकारी के लिए, देखें कौन सा Claude plan आपके उपयोग के लिए उपयुक्त है।

वे लीवर जो वास्तव में काम करते हैं

• एजेंट क्या पढ़ता है, इसका दायरा तय करें। "auth.py में वैलिडेशन बग ठीक करें" केवल एक फाइल पढ़ता है; "इस कोडबेस को बेहतर बनाएँ" चालीस फाइलें पढ़ता है। CLAUDE.md को संक्षिप्त रखें, क्योंकि यह हर सेशन में लोड होता है। इसे केवल आवश्यक चीजों तक सीमित रखें और वर्कफ्लो-विशिष्ट निर्देशों को उन स्किल्स में ले जाएँ जो जरूरत पड़ने पर लोड होती हैं।
• स्पष्ट और संक्षिप्त रहें। असंबंधित कार्यों के बीच /clear करें, अन्यथा पुराना संदर्भ हर अगले मैसेज के साथ फिर से भेजा जाता है और उसका शुल्क भी लगता है। एक लंबे कार्य के दौरान, /compact Focus on the failing tests and the diff इतिहास को सारांशित करता है और आपको क्वाड्रेटिक कर्व (quadratic curve) की समस्या से बचाता है।
• मॉडल का सही आकार चुनें। Sonnet अधिकांश कोडिंग संभाल लेता है, जिसकी शुरुआती कीमत जुलाई 2026 तक प्रति मिलियन टोकन $2/$10 है ($3/$15 स्टिकर प्राइस, जबकि Opus $5/$25 है), और Haiku $1/$5 पर लॉग ट्राइएज जैसे यांत्रिक सब-एजेंट कार्यों के लिए सही टूल है। Fable 5 दूसरी तरफ $10/$50 पर है, जो मीटर के दोनों तरफ Opus से दोगुना है, इसलिए यह जानना जरूरी है कि कौन से कार्य वास्तव में उस दर को उचित ठहराते हैं इससे पहले कि आप इसे नियमित कार्यों के लिए चुना हुआ छोड़ दें। /model सेशन के बीच में स्विच करें।
• वर्बोस आउटपुट को पहले ही फिल्टर करें। एक हुक जो क्लाउड (Claude) द्वारा देखे जाने से पहले टेस्ट रन को केवल फेलियर तक सीमित (grep) कर देता है, वह टूल रिजल्ट के 20,000 टोकन को 300 में बदल देता है, और यह उस टर्न के हर भविष्य के री-सेंड पर ऐसा ही करता है।
• जो इंटरैक्टिव नहीं है, उसे बैच करें। अपने स्वयं के API पाइपलाइन्स, क्लासिफिकेशन, बल्क रिव्यू और नाइटली जॉब्स के लिए, Batches API एसिंक्रोनस डिलीवरी के बदले में उन्हीं मॉडल्स को 50% छूट पर चलाता है।
• कैश क्लॉक का सम्मान करें। निरंतर अंतराल में काम करें। एक अलग VPS पर tmux में Claude Code सेशन आइडल रहने पर कुछ खर्च नहीं करता, टोकन केवल तभी खर्च होते हैं जब कोई टर्न चलता है, लेकिन आइडल रहने पर वार्म कैश खत्म हो जाता है, और अगले टर्न में उसे फिर से लिखने की लागत चुकानी पड़ती है।

FAQ

Claude Code में एक कोडिंग सत्र कितने टोकन का उपयोग करता है?

इसकी कोई निश्चित संख्या नहीं है। एक बार जब फाइलें और इतिहास जमा हो जाते हैं, तो सत्र के बीच का एक टर्न आमतौर पर हजारों प्रॉम्प्ट टोकन ले लेता है। एक कार्यशील सत्र लाखों टोकन तक पहुँच सकता है, जिनमें से अधिकांश बेस रेट के दसवें हिस्से पर कैश से सर्व किए जाते हैं। अंशांकन (calibration) के लिए, जुलाई 2026 तक एंथ्रोपिक के प्रकाशित एंटरप्राइज आंकड़ों के अनुसार, प्रति सक्रिय दिन प्रति डेवलपर औसत खर्च लगभग $13 है, और 90% उपयोगकर्ता $30 से कम खर्च करते हैं। अपने स्वयं के सत्र में /usage चलाएं; इसे पांच मिनट तक देखना किसी भी प्रकाशित औसत से बेहतर है।

क्या थिंकिंग टोकन के लिए पैसे देने पड़ते हैं, भले ही मैं उन्हें देख न सकूँ?

हाँ। थिंकिंग टोकन को आउटपुट टोकन के रूप में बिल किया जाता है, जो कि महंगी दर है, और ये max_tokens के विरुद्ध गिने जाते हैं। वर्तमान मॉडल इन्हें तब भी बिल करते हैं जब इंटरफ़ेस प्रदर्शन से रीजनिंग सारांश को हटा देता है। यदि कोई प्रतिक्रिया दृश्य उत्तर समाप्त होने से पहले stop_reason: "max_tokens" के साथ कट जाती है, तो संभवतः थिंकिंग ने बजट का उपभोग कर लिया है। Claude Code में, उन कार्यों के लिए /effort के साथ एफर्ट लेवल कम करें जिन्हें गहन रीजनिंग की आवश्यकता नहीं है।

एक लंबा Claude Code सत्र प्रति संदेश अधिक महंगा क्यों हो जाता है?

क्योंकि API स्टेटलेस है: प्रत्येक टर्न पूरी बातचीत, हर पढ़ी गई फाइल, टूल परिणाम और पूर्व आदान-प्रदान को बिल किए गए इनपुट के रूप में फिर से भेजता है। इसलिए टर्न 50 अपने साथ टर्न 1 से 49 तक का भार लेकर चलता है। प्रॉम्प्ट कैशिंग दोहराए गए प्रीफिक्स को बेस इनपुट मूल्य के लगभग दसवें हिस्से पर सर्व करती है, लेकिन प्रीफिक्स खुद बढ़ता रहता है, और कैश TTL के बाद कोई भी निष्क्रिय अंतराल अगले टर्न को पूर्ण-मूल्य वाले री-राइट में बदल देता है। /compact इतिहास को छोटा करता है; /clear इसे रीसेट करता है।

मैं अपने Claude टोकन उपयोग और लागत की जाँच कैसे करूँ?

Claude Code में, /usage सत्र टोकन आँकड़े, एक अनुमानित स्थानीय लागत और सब्सक्रिप्शन पर प्लान-लिमिट बार दिखाता है (/cost इसका एक उपनाम है); /context दिखाता है कि विंडो में क्या भर रहा है। आधिकारिक API बिलिंग के लिए, Claude Console में उपयोग पृष्ठ का उपयोग करें। अपने स्वयं के कोड में, response.usage पढ़ें, input_tokens, cache_creation_input_tokens, और cache_read_input_tokens का योग करने पर वास्तविक प्रॉम्प्ट आकार मिलता है। समय से पहले अनुमान लगाने के लिए count_tokens एंडपॉइंट का उपयोग करें, कभी भी tiktoken का नहीं।