Claude Code में टोकन क्या है? सेशन की लागत

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

टोकन वह इकाई है जिसमें Claude टेक्स्ट पढ़ता और लिखता है: एक शब्द का टुकड़ा, अंग्रेज़ी के लगभग 3.5 अक्षरों जितना। यह आँकड़ा Anthropic की अपनी शब्दावली से आता है, और स्पेस तथा विराम-चिह्न गिन लेने पर यह प्रति शब्द एक टोकन से काफ़ी ऊपर बैठता है, इसलिए एक हज़ार शब्दों का सादा टेक्स्ट आराम से 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 के अपने harness के निर्देश, साथ में आपकी CLAUDE.md और मेमोरी फ़ाइलें, जो सेशन शुरू होते समय लोड होती हैं और उसके बाद हर रिक्वेस्ट में मौजूद रहती हैं।
• टूल की परिभाषाएँ। हर वह टूल स्कीमा जिसे एजेंट कॉल कर सकता है। आप जितने भी MCP सर्वर जोड़ते हैं, हर एक इस तयशुदा ओवरहेड में इज़ाफ़ा करता है। Claude Code अब डिफ़ॉल्ट रूप से पूरी MCP टूल परिभाषाएँ टाल देता है, इसलिए किसी टूल के पहली बार इस्तेमाल होने तक कॉन्टेक्स्ट में सिर्फ़ टूल के नाम बैठते हैं। इससे लागत घटती है, ख़त्म नहीं होती।
• एजेंट जो भी फ़ाइल पढ़ता है। किसी सोर्स फ़ाइल का एक Read पूरी फ़ाइल को कॉन्टेक्स्ट में डाल देता है, और वह वहीं बनी रहती है।
• हर टूल का नतीजा। टेस्ट रन, grep का आउटपुट, टर्मिनल की बकबक, बिल्ड लॉग, यह सब इनपुट टोकन बनकर वापस आता है। 8,000 पंक्तियाँ छापने वाला एक नाकाम टेस्ट सुइट आपको एक छोटी किताब का बिल थमा चुका है।
• अब तक की पूरी बातचीत, हर टर्न पर दोबारा भेजी हुई। यह अपने अलग सेक्शन की हक़दार है।

वह दोबारा भेजना जिसे कोई क़ीमत में नहीं जोड़ता

Claude API stateless है। वह दो रिक्वेस्ट के बीच आपका सेशन याद नहीं रखता। कोई भी नहीं रखता। इसलिए टर्न 2 पर क्लाइंट टर्न 1, उसका जवाब और आपका नया संदेश भेजता है। टर्न 50 पर वह टर्न 1 से 49 तक सब कुछ दोबारा भेजता है: पढ़ी गई हर फ़ाइल, हर टूल नतीजा, हर diff, और साथ में टर्न 50। मॉडल हर बार पूरी ट्रांसक्रिप्ट दोबारा पढ़ता है, और दोबारा पढ़ा गया हर टोकन इनपुट के तौर पर बिल होता है।

इसका नतीजा यह है: प्रति टर्न लागत सेशन की लंबाई के साथ लगभग सीधी रेखा में बढ़ती है, और कुल सेशन लागत लगभग वर्ग के अनुपात में। टर्न 3 पर जिस संदेश की क़ीमत आधा सेंट थी, वही एक-पंक्ति का सवाल टर्न 60 पर बीस गुना पड़ सकता है, क्योंकि वह साठ टर्न का माल ढो रहा है। यही अकेला तथ्य "मेरा बिल इतना ज़्यादा क्यों आया" वाले ज़्यादातर टिकटों के पीछे बैठा है, और यह Claude की कोई ख़ास आदत नहीं है। हर वह LLM प्रोडक्ट जो stateful महसूस होता है, भीतर से एक stateless API ही है, जिसके नीचे दोबारा भेजने का लूप चलता रहता है।

आउटपुट: जो आप देखते हैं, और वह सोचना जो आप नहीं देखते

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

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

प्रॉम्प्ट कैशिंग पूरा गणित बदल देती है

प्रॉम्प्ट कैशिंग ही वजह है कि दोबारा भेजने का लूप सबको दिवालिया नहीं कर देता। API आपके प्रॉम्प्ट का स्थिर शुरुआती हिस्सा कैश कर सकता है, यानी सिस्टम प्रॉम्प्ट, टूल परिभाषाएँ और बातचीत का इतिहास, और अगली रिक्वेस्ट पर उसे क़ीमत के एक अंश में परोस सकता है। जुलाई 2026 तक गुणक ये हैं: एक कैश write की लागत बेस इनपुट दर की 1.25× है (1 घंटे वाले वैरिएंट के लिए 2×), और एक कैश read की 0.1×। write पर प्रीमियम लगता है, read पर 90% छूट मिलती है। एक ही read उस 5 मिनट वाले write प्रीमियम की भरपाई कर देता है, बल्कि उससे भी ज़्यादा।

Claude Code कैशिंग आपके लिए संभालता है, और ठीक-ठाक चल रहे सेशन में दोबारा भेजा जाने वाला वह विशाल हिस्सा लगभग पूरा कैश से परोसा जाता है। पर डिफ़ॉल्ट कैश आख़िरी इस्तेमाल के बाद सिर्फ़ पाँच मिनट टिकता है। कॉफ़ी के लिए उठे, देर हो गई, लौटकर एक संदेश भेजा: कैश ख़त्म हो चुका है, और जमा हुआ पूरा शुरुआती हिस्सा 0.1× पर पढ़े जाने के बजाय 1.25× पर दोबारा लिखा जाता है। 150K टोकन वाले सेशन में वह एक ठंडा टर्न एक दर्जन गर्म टर्न से ज़्यादा महँगा पड़ता है। यही वह उलटा नतीजा है जिसे गाँठ बाँध लेना चाहिए: रुक-रुककर काम करने की लय लगातार काम करने से महँगी पड़ सकती है, क्योंकि TTL के आगे बीता हर ख़ाली अंतराल आपके अगले टर्न को सस्ते read से महँगे re-write में बदल देता है। एक बार बैठें तो लगातार काम करें। किसी बड़े सेशन को दस-दस मिनट पर एक संदेश की बूँदों में मत चलाएँ।

अगर आप API को अपने VPS पर चल रहे अपने ही एप्लिकेशन से कॉल कर रहे हैं, तो इसमें से कुछ भी मुफ़्त नहीं मिलता, और सबसे आम आत्मघाती ग़लती है सिस्टम प्रॉम्प्ट में कोई टाइमस्टैम्प या रिक्वेस्ट ID जोड़ देना, जो हर रिक्वेस्ट पर शुरुआती बाइट बदल देता है और चुपचाप कैशिंग बंद कर देता है। पहचान यह है कि एक जैसी दिखने वाली कॉलों में usage.cache_read_input_tokens शून्य पर बैठा रहता है।

फ़ॉर्मूला, एक हल किए हुए उदाहरण के साथ

"एक सेशन की लागत $X होती है" जैसा सपाट आँकड़ा देने वाले किसी भी व्यक्ति को नज़रअंदाज़ करें। सेशनों में सौ गुना तक का फ़र्क़ होता है। जो हर हाल में टिकता है, वह फ़ॉर्मूला है:

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 टोकन का जमा कॉन्टेक्स्ट ढो रहा है: 75,000 कैश से पढ़े गए, 3,000 नए लिखे गए, 2,000 बिना कैश वाला ताज़ा इनपुट, और थिंकिंग समेत 1,500 आउटपुट टोकन।

• कैश read: 75,000 × $0.50/M = $0.0375
• कैश write: 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 Code डिप्लॉयमेंट के लिए Anthropic के प्रकाशित आँकड़े, जुलाई 2026 तक, प्रति डेवलपर प्रति सक्रिय दिन औसतन क़रीब $13 बैठते हैं, यानी $150–250 प्रति महीना, और 90% उपयोगकर्ता एक दिन में $30 से नीचे रहते हैं। आपका अपना ख़र्च मॉडल के चुनाव, सेशन की साफ़-सफ़ाई और कोडबेस के आकार से तय होता है, और ठीक इसीलिए नीचे दिए लीवर मायने रखते हैं।

अपनी ख़ुद की खपत देखना

Claude Code में कमांड है /usage (/cost अब भी चलता है, वह उसी का दूसरा नाम है)। ऊपर वाला Session ब्लॉक मौजूदा सेशन के टोकन आँकड़े और स्थानीय रूप से निकाला गया लागत अनुमान दिखाता है। सब्सक्रिप्शन प्लान पर वही स्क्रीन आपकी प्लान-सीमा की पट्टियाँ भी दिखाती है, और हाल की खपत का ब्यौरा skills, subagents, plugins और अलग-अलग MCP सर्वरों के नाम लिखकर देती है। API अकाउंट पर आधिकारिक बिलिंग के लिए Claude Console का usage पेज ही सच्चाई का स्रोत है, क्योंकि CLI का आँकड़ा एक अनुमान है। /context एक रंगीन ग्रिड बनाकर दिखाता है कि कॉन्टेक्स्ट विंडो में क्या-क्या बैठा है, यानी सिस्टम प्रॉम्प्ट, टूल, 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 टोकन कैश से परोसे गए थे। भेजने से पहले अनुमान लगाना हो, तो टोकन गिनने वाला एंडपॉइंट इस्तेमाल करें। उसे कॉल करना मुफ़्त है, उसकी अपनी अलग रेट लिमिट है, और वह उसी मॉडल के टोकनाइज़र से गिनता है जिसका नाम आप देते हैं (नतीजे को एक क़रीबी अनुमान मानें, बिल असली रिक्वेस्ट के हिसाब से बनता है):

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

tiktoken कभी नहीं, ऊपर बताई वजह से।

सब्सक्रिप्शन प्लान बनाम pay-as-you-go

इस गाइड का तंत्र हर जगह एक जैसा है, फ़र्क़ सिर्फ़ हिसाब चुकाने के तरीक़े का है। API कुंजी के साथ Anthropic प्रकाशित दरों पर, प्रति टोकन, इस्तेमाल के हिसाब से बिल भेजता है, और ऊपर की हर संख्या असली पैसा है। Claude सब्सक्रिप्शन (Pro, Max, Team, Enterprise) पर Claude Code की खपत इसके बजाय आपके प्लान में शामिल भत्ते से कटती है। जुलाई 2026 तक वह भत्ता एक चलती हुई पाँच घंटे की सेशन विंडो और एक साप्ताहिक विंडो है, जो सभी मॉडलों और claude.ai चैट के बीच साझा है, और /usage का डॉलर आँकड़ा बिल नहीं, सिर्फ़ जानकारी है। कोई विंडो ख़त्म कर दें, तो रीसेट समय के साथ "You've hit your session limit" या "You've hit your weekly limit" दिखता है, और /model से मॉडल बदलने पर पहुँच वापस नहीं आती, क्योंकि विंडो सभी मॉडलों में साझा हैं। प्लान चाहें तो usage credits चालू कर सकते हैं, जिन्हें /usage-credits से संभाला जाता है, ताकि सीमा से आगे की खपत ख़रीदी जा सके। प्लान के कोटे मैं जान-बूझकर नहीं छाप रहा, क्योंकि इस पूरे विषय में वही संख्याएँ सबसे तेज़ी से बदलती हैं। उनके लिए claude.com/pricing और अपनी /usage पट्टियाँ देखें। सब्सक्रिप्शन पर भी टोकन का तंत्र मायने रखता है, क्योंकि फ़िज़ूलख़र्च सेशन आपकी विंडो को ठीक उसी तरह जलाता है जैसे वह डॉलर जलाता है। सब्सक्रिप्शन वाले पहलू के लिए कौन-सा Claude प्लान आपके इस्तेमाल पर फिट बैठता है देखें।

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

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

FAQ

Claude Code में एक कोडिंग सेशन कितने टोकन इस्तेमाल करता है?

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

क्या थिंकिंग टोकन तब भी पैसे लेते हैं जब वे मुझे दिखते ही नहीं?

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

लंबे Claude Code सेशन में हर संदेश महँगा क्यों होता जाता है?

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

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

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