Claude मध्ये tokens म्हणजे काय?

Claude मध्ये tokens म्हणजे काय?

Token ही Claude द्वारे वाचली आणि लिहिली जाणारी मजकुराची एक युनिट आहे: हा शब्दाचा एक भाग असतो, जो अंदाजे 3.5 English characters इतका असतो. ही माहिती Anthropic च्या स्वतःच्या glossary मधून घेतली आहे. spaces आणि punctuation धरले असता, एका शब्दासाठी एकापेक्षा जास्त tokens लागतात; त्यामुळे 1,000 शब्दांच्या मजकुरासाठी सहजपणे 1,300 पेक्षा जास्त tokens लागतात. Code मध्ये प्रति ओळ अधिक भार येतो: braces, operators, underscores आणि indentation मुळे English च्या तुलनेत प्रति character अधिक tokens तयार होतात. काही शेकडो ओळींच्या source file साठी साधारणपणे काही हजार tokens लागतात. जर agent ने 2,000 ओळींची file वाचण्याचे ठरवले, तर नवीन code लिहिण्यापूर्वीच तो पाच अंकी (five-figure) token खर्च असेल.

Tokenizer बद्दल दोन गोष्टी गोंधळ निर्माण करतात. पहिली म्हणजे, ते model-specific असतात. July 2026 पर्यंत, Opus 4.7 आणि त्यानंतरचे, Sonnet 5, आणि Fable 5 हे नवीन tokenizer वापरतात. हे नवीन tokenizer पूर्वीच्या Claude models च्या तुलनेत समान मजकुरासाठी अंदाजे 30% जास्त tokens तयार करतात (वाढ मजकुरावर अवलंबून असते), ज्यामुळे तुमचा token budget बदलतो, जरी per-token किमती वाढलेल्या नाहीत तरीही. दुसरी गोष्ट म्हणजे tiktoken, जे सर्व blog posts मध्ये वापरले जाते, ते OpenAI चे tokenizer आहे. ते सामान्य मजकुरासाठी Claude पेक्षा अंदाजे 15–20% कमी tokens दाखवते, आणि code साठी हे प्रमाण अधिक असते. एकमेव विश्वासार्ह गणना count_tokens endpoint द्वारे मिळते, ज्याबद्दल खाली माहिती दिली आहे.

तुमच्या कोडिंग सेशनचा खर्च का जास्त येतो

प्रत्येक Claude बिल, मग ते API invoice असो किंवा subscription limit, एकाच गोष्टीवर अवलंबून असते: tokens in आणि tokens out. pricing page वर हे सोपे वाटते: प्रति million input tokens इतके डॉलर्स आणि प्रति million output इतके डॉलर्स. परंतु, agentic coding session मध्ये input बाजूचा वापर अंदाजापेक्षा खूप जास्त होतो, कारण प्रत्येक turn मध्ये संपूर्ण conversation पुन्हा पाठवली जाते. मी पंधरा वर्षांपासून metered infrastructure विकत आहे, आणि tokens ही अशी पहिली meter आहे जिथे बहुतेक ग्राहकांना नेमका खर्च कशामुळे वाढत आहे हे सांगता येत नाही. या meter-reading धड्यामध्ये आपण पाहणार आहोत: agentic session मध्ये input आणि output म्हणजे काय, resend loop इतके महाग का आहे, prompt caching मुळे गणित कसे बदलते, आणि प्रत्यक्षात खर्च कमी करण्यासाठी कोणते levers वापरता येतात.

सर्व काही input आहे: मीटर प्रत्यक्षात काय मोजते

लोकांना वाटते की ते Claude ने लिहिलेल्या code साठी पैसे देतात. agentic session मध्ये, तो खर्च खूप कमी असतो. Input tokens — ज्याचा दर कमी आहे, पण प्रमाण खूप जास्त असते — त्यामध्ये खालील गोष्टींचा समावेश होतो:

• The system prompt. Claude Code च्या स्वतःच्या harness instructions, तसेच तुमचे CLAUDE.md आणि memory files, जे session च्या सुरुवातीला लोड केले जातात आणि त्यानंतर प्रत्येक request मध्ये असतात.
• Tool definitions. agent ज्या प्रत्येक tool schema ला call करू शकतो. तुम्ही connect केलेल्या प्रत्येक MCP server मुळे हा fixed overhead वाढतो — जरी Claude Code आता default प्रमाणे पूर्ण MCP tool definitions नंतर लोड करते, त्यामुळे जोपर्यंत एखादे tool वापरले जात नाही तोपर्यंत फक्त tool names context मध्ये असतात; यामुळे खर्च कमी होतो पण पूर्णपणे थांबत नाही.
• Agent वाचत असलेली प्रत्येक file. source file चा Read घेतल्यास संपूर्ण file context मध्ये येते आणि ती तिथेच राहते.
• प्रत्येक tool result. Test runs, grep output, terminal spew, build logs — या सर्वांचा समावेश input tokens मध्ये होतो. जर एखादी test suite fail झाली आणि तिने 8,000 lines print केल्या, तर त्याचा खर्च एका लहान पुस्तकाएवढा येऊ शकतो.
• आतापर्यंतची संपूर्ण conversation, जी प्रत्येक turn मध्ये पुन्हा पाठवली जाते. या विषयासाठी स्वतंत्र विभाग आवश्यक आहे.

पुन्हा पुन्हा डेटा पाठवल्यामुळे वाढणारे खर्च

Claude API हे stateless आहे. विनंत्यांच्या (requests) दरम्यान ते तुमचे session लक्षात ठेवत नाही — काहीही लक्षात ठेवत नाही. त्यामुळे turn 2 मध्ये, client turn 1, त्याचा प्रतिसाद आणि तुमचा नवीन संदेश पाठवतो. turn 50 मध्ये, तो turn 1 ते turn 49 पर्यंतचा सर्व डेटा पुन्हा पाठवतो — प्रत्येक file read, प्रत्येक tool result, प्रत्येक diff — आणि त्यासोबत turn 50 पाठवतो. मॉडेल प्रत्येक वेळी संपूर्ण transcript पुन्हा वाचते, आणि त्यातील प्रत्येक re-read token साठी billing आकारले जाते.

परिणाम: turn नुसार येणारा खर्च session च्या लांबीनुसार रेषीय (linearly) पद्धतीने वाढतो, आणि एकूण session खर्च अंदाजे वर्ग (quadratically) पद्धतीने वाढतो. turn 3 मध्ये ज्या संदेशाचा खर्च अर्धा cent होता, तोच संदेश turn 60 मध्ये वीस पटीने महाग असू शकतो, कारण तो 60 turns चा डेटा सोबत घेऊन जातो. "माझे बिल इतके जास्त का आले?" या तक्रारींचे हे मुख्य कारण आहे. ही Claude ची वैशिष्ट्ये नसून, प्रत्येक stateful वाटणारे LLM उत्पादन प्रत्यक्षात stateless API असते, ज्याच्या मागे resend loop कार्यरत असतो.

Output: तुम्हाला जे दिसते ते, आणि जे दिसत नाही त्यातील विचार प्रक्रिया

Output tokens महाग असतात — सध्याच्या लाइनअपमध्ये input rate पेक्षा ते पाच पट जास्त आहेत ($5/$25 Opus 4.8 वर, $3/$15 Sonnet 5 वर, आणि July 2026 पर्यंत $1/$5 Haiku 4.5 वर). Output मध्ये Claude ने तयार केलेले text आणि code समाविष्ट असते, तसेच thinking tokens देखील असतात: उत्तर देण्यापूर्वी मॉडेल करत असलेली अंतर्गत विचार प्रक्रिया. येथे दोन गोष्टी महत्त्वाच्या आहेत. Thinking साठी output rates नुसार शुल्क आकारले जाते आणि ते max_tokens मध्ये मोजले जाते — जर API response stop_reason: "max_tokens" मुळे थांबले, तर याचा अर्थ उत्तर देण्यापूर्वीच thinking ने बजेट संपवले आहे. तसेच, सध्याच्या मॉडेल्समध्ये reasoning summary कदाचित दिसणार नाही — Opus 4.8, Sonnet 5, आणि Fable 5 मध्ये ते default ने बंद असते — परंतु thinking प्रक्रिया घडते आणि त्यासाठी शुल्क आकारले जाते. अदृश्य असणे म्हणजे ते मोफत असणे नव्हे.

Claude Code मध्ये default ने extended thinking सक्षम असते कारण ते multi-step कामांमध्ये मोजता येण्याजोग्या प्रमाणात सुधारणा करते; आणि default budget प्रति request हजारो tokens पर्यंत असू शकते. सोप्या कामांसाठी तुम्ही ते कमी करू शकता: /effort किंवा /model मध्ये effort level कमी करा, किंवा /config मध्ये thinking settings ॲडजस्ट करा. हा एक वास्तविक खर्च कमी करण्याचे साधन (cost lever) आहे, केवळ अंधश्रद्धा नाही.

Prompt caching मुळे गणित बदलते

Prompt caching मुळे वारंवार लागणारे requests खर्चिक ठरत नाहीत. API तुमच्या prompt चा स्थिर prefix — जसे की system prompt, tool definitions, आणि conversation history — cache करू शकते. पुढच्या request मध्ये हे content कमी किमतीत उपलब्ध होते. July 2026 पर्यंतचे multipliers खालीलप्रमाणे आहेत: cache write साठी base input rate च्या 1.25× (1-hour variant साठी 2×) खर्च येतो, आणि cache read साठी 0.1× खर्च येतो. Writes साठी जास्त शुल्क आहे; reads मध्ये 90% सूट मिळते. एक single read मुळे 5-minute write premium पेक्षा जास्त बचत होते.

Claude Code तुमच्यासाठी caching व्यवस्थापित करते. एका चांगल्या session मध्ये बहुतेक माहिती cache मधूनच सर्व्ह केली जाते. परंतु, default cache शेवटच्या वापरापासून five minutes साठी असते. जर तुम्ही थोडा जास्त वेळ ब्रेक घेतला आणि परत आल्यावर message पाठवला, तर cache expire झालेले असते. अशा वेळी संपूर्ण accumulated prefix 0.1× किमतीऐवजी 1.25× किमतीत पुन्हा re-write करावा लागतो. 150K-token च्या session मध्ये, एक 'cold turn' हा डझनभर 'warm turns' पेक्षा जास्त खर्चिक असतो. हे लक्षात घेणे महत्त्वाचे आहे: काही वेळ थांबून पुन्हा काम सुरू केल्यास (idle-then-resume) खर्च वाढू शकतो, कारण TTL संपल्यानंतरचा प्रत्येक अंतराल तुमच्या पुढच्या turn ला स्वस्त read ऐवजी महागड्या re-write मध्ये रूपांतरित करतो. कामाचे तुकडे करून काम करा; एक मोठी session दर दहा मिनिटांनी एक message पाठवून हळूहळू पूर्ण करू नका.

जर तुम्ही your own application on a VPS मधून API वापरत असाल, तर तुम्हाला ही सुविधा मोफत मिळत नाही. एक सामान्य चूक म्हणजे system prompt मध्ये timestamp किंवा request ID समाविष्ट करणे. यामुळे प्रत्येक request मध्ये prefix bytes बदलतात आणि caching आपोआप बंद होते. जर identical-looking calls मध्ये usage.cache_read_input_tokens शून्य असेल, तर याचा अर्थ caching काम करत नाहीये.

सूत्र आणि एक उदाहरण

"एका सेशनचा खर्च $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 प्रति मिलियन input tokens आणि $25 प्रति मिलियन output tokens आहे. 80,000 accumulated context tokens असलेले एक मध्यम सेशन टर्न: 75,000 cache मधून वाचलेले, 3,000 नवीन लिहिलेले, 2,000 uncached fresh input, आणि thinking सह 1,500 output tokens.

• Cache reads: 75,000 × $0.50/M = $0.0375
• Cache writes: 3,000 × $6.25/M = $0.019
• Uncached input: 2,000 × $5/M = $0.010
• Output: 1,500 × $25/M = $0.0375

एका टर्नसाठी अंदाजे $0.10; असे 50 टर्न असल्यास सुमारे $5 खर्च होईल. आता cache संपल्यानंतर त्याच टर्नचा विचार करा: पूर्ण 80,000 tokens $6.25/M दराने पुन्हा लिहिले गेले तर output च्या आधीच $0.50 खर्च होईल — म्हणजेच समान कामासाठी warm turn च्या तुलनेत साधारण पाचपट जास्त खर्च. हा फरकच caching चे महत्त्व दर्शवतो.

अंदाज वर्तवण्यापेक्षा कॅलिब्रेशनसाठी: Anthropic ने जुलै 2026 पर्यंत enterprise Claude Code deployments साठी प्रसिद्ध केलेली आकडेवारी सांगते की, प्रति डेव्हलपर प्रति सक्रिय दिवस सरासरी खर्च सुमारे $13 आहे — म्हणजेच $150–250 प्रति महिना — आणि 90% वापरकर्त्यांचा खर्च $30 प्रति दिवसाच्या खाली राहतो. तुमचा खर्च हा model choice, session hygiene आणि codebase size वर अवलंबून असतो, म्हणूनच खालील घटक महत्त्वाचे आहेत.

तुमचा वापर पाहणे

Claude Code मध्ये, कमांड /usage आहे (/cost अजूनही काम करते — ते एक alias आहे). वरचा Session block सध्याच्या session साठी token statistics आणि स्थानिक पातळीवर काढलेला cost estimate दाखवतो; subscription plans मध्ये, याच स्क्रीनवर तुमच्या plan-limit bars आणि अलीकडील वापराचे skills, subagents, plugins, आणि वैयक्तिक MCP servers नुसार वर्गीकरण दिसते. API accounts च्या अधिकृत billing साठी, Claude Console मधील usage page हाच अधिकृत स्रोत आहे — CLI मधील आकडा हा केवळ एक अंदाज आहे. /context द्वारे context window मध्ये काय आहे याचा रंगीत grid मिळतो — system prompt, tools, MCP definitions, files, history — आणि bloated CLAUDE.md किंवा जास्त संवाद साधणारा MCP server शोधण्याचा हा सर्वात वेगवान मार्ग आहे; प्रत्येक item चा सविस्तर तपशील पाहण्यासाठी all वापरा.

API कडून, प्रत्येक response तुम्हाला नेमके काय घडले ते सांगते:

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 हा केवळ uncached remainder आहे — खरा prompt size हा तिन्ही input fields च्या बेरजेइतका असतो. जर एखादा agent एक तास चालला आणि input_tokens: 4000 दाखवत असेल, तर तो स्वस्त नाही; इतर 200,000 tokens cache मधून वापरले गेले होते. संदेश पाठवण्यापूर्वी अंदाज लावण्यासाठी, token-counting endpoint वापरा — ते वापरण्यासाठी कोणतेही शुल्क लागत नाही, त्याचा स्वतःचा rate limit आहे, आणि तुम्ही दिलेल्या कोणत्याही model च्या tokenizer नुसार ते मोजते (निकाल हा जवळचा अंदाज मानला जावा; billing प्रत्यक्ष request वर आधारित असते):

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

वरील कारणांमुळे कधीही tiktoken करू नका.

Subscription plans versus pay-as-you-go

या मार्गदर्शिकेतील कार्यपद्धती सर्वत्र सारखीच आहे; फक्त पेमेंटची पद्धत वेगळी आहे. API key वापरताना, Anthropic प्रत्येक token साठी प्रसिद्ध दराप्रमाणे pay-as-you-go पद्धतीने शुल्क आकारते — वरील सर्व आकडे प्रत्यक्ष पैशांशी संबंधित आहेत. Claude subscription (Pro, Max, Team, Enterprise) मध्ये, Claude Code चा वापर तुमच्या प्लॅनमध्ये दिलेल्या मर्यादेतून (allowance) वजा होतो: July 2026 पासून, यामध्ये पाच तासांची rolling session window आणि एक weekly window समाविष्ट आहे, जी सर्व models आणि claude.ai chat साठी सामायिक (shared) आहे. यामध्ये /usage ही रक्कम केवळ माहितीसाठी आहे, ते बिल नाही. जर तुमची window संपली, तर तुम्हाला "You've hit your session limit" किंवा "You've hit your weekly limit" असा संदेश आणि रिसेट होण्याची वेळ दिसेल — तसेच /model वापरून model बदलल्याने प्रवेश पुन्हा मिळणार नाही, कारण सर्व models साठी window सामायिक असते. मर्यादेपलीकडे वापर करण्यासाठी तुम्ही /usage-credits द्वारे व्यवस्थापित केलेले usage credits पर्यायीरित्या सक्षम करू शकता. मी प्लॅनच्या quotas छापणार नाही: कारण या विषयातील ते सर्वात अस्थिर आकडे आहेत, त्यामुळे त्याऐवजी claude.com/pricing आणि तुमचे स्वतःचे /usage bars तपासा. Subscription मध्ये देखील token mechanics महत्त्वाचे आहेत — एक अनावश्यक session तुमच्या window मधून तितकीच मर्यादा संपवते जितके पैसे खर्च होतात. Subscription बद्दल अधिक माहितीसाठी, which Claude plan fits your usage पहा.

प्रभावी ठरणारे घटक

• Agent काय वाचतो याची व्याप्ती मर्यादित ठेवा. "auth.py मधील validation bug फिक्स करा" या कमांडमध्ये एक फाईल वाचली जाते; "या codebase मध्ये सुधारणा करा" या कमांडमध्ये 40 फाईल्स वाचल्या जातात. CLAUDE.md नेहमी कमीत कमी ठेवा — कारण ते प्रत्येक session मध्ये लोड होते — त्यामुळे फक्त आवश्यक गोष्टींचाच समावेश करा आणि workflow-specific सूचना अशा skills मध्ये हलवा ज्या गरजेनुसार load होतात.
• स्पष्ट आणि संक्षिप्त ठेवा. असंबद्ध कामांमध्ये /clear वापरा — कारण जुना context प्रत्येक पुढील message सोबत पुन्हा पाठवला जातो आणि त्याचे शुल्क पुन्हा आकारले जाते. एका मोठ्या कामाच्या दरम्यान, /compact Focus on the failing tests and the diff इतिहासाचा सारांश तयार करते आणि खर्च मर्यादित ठेवण्यास मदत करते.
• योग्य मॉडेल निवडा. Sonnet बहुतेक कोडिंगसाठी योग्य आहे ज्याची किंमत जुलै 2026 च्या सुरुवातीच्या किमतीनुसार $2/$10 प्रति मिलियन tokens आहे ($3/$15 स्टिकर प्राईस, Opus च्या $5/$25 च्या तुलनेत), आणि log triage सारख्या यांत्रिक उप-एजंट कामांसाठी Haiku ($1/$5) हे योग्य साधन आहे. /model सेशनच्या दरम्यान बदलता येते.
• जादा आउटपुट आधीच फिल्टर करा. Claude कडे पाठवण्यापूर्वी test run मधील फक्त failures शोधण्यासाठी (grep) वापरलेला hook, 20,000 tokens च्या tool result ला 300 tokens मध्ये रूपांतरित करतो; आणि हे प्रत्येक पुढील resend वेळी घडते.
• Non-interactive कामांसाठी Batching वापरा. तुमच्या स्वतःच्या API pipelines साठी — जसे की classification, bulk review, किंवा nightly jobs — Batches API asynchronous डिलिव्हरीच्या बदल्यात तेच मॉडेल्स 50% सवलतीत चालवते.
• Cache वेळेचा आदर करा. सलग कामाच्या तुकड्यांमध्ये काम करा. VPS वर tmux मध्ये चालणारे Claude Code session रिकामे असताना (idle) काहीही खर्च करत नाही — tokens फक्त turn रन होतानाच खर्च होतात — परंतु idle वेळेमुळे warm cache गमावला जातो, आणि पुढील turn मध्ये तो पुन्हा लिहिण्यासाठी शुल्क द्यावे लागते.

FAQ

Claude Code मधील कोडिंग सेशनमध्ये किती tokens वापरले जातात?

यासाठी कोणताही निश्चित आकडा नाही — फाईल्स आणि हिस्ट्री जमा झाल्यावर, सेशनच्या मधल्या एका टर्नमध्ये सामान्यतः हजारो prompt tokens येतात. पूर्ण सेशनमध्ये लाखो tokens वापरले जाऊ शकतात, ज्यातील बहुतेक cache मधून बेस रेटच्या 10% दराने वापरले जातात. संदर्भासाठी, Anthropic ने जुलै 2026 पर्यंत प्रसिद्ध केलेल्या एंटरप्राइझ आकडेवारीनुसार, दर सक्रिय दिवशी प्रति डेव्हलपर सरासरी $13 खर्च येतो, आणि 90% युजर्सचा खर्च $30 पेक्षा कमी असतो. तुमच्या स्वतःच्या सेशनमध्ये /usage चालवून पहा; पाच मिनिटे त्याचे निरीक्षण करणे कोणत्याही प्रसिद्ध सरासरीपेक्षा अधिक अचूक माहिती देईल.

Thinking tokens दिसत नसले तरी त्यासाठी पैसे लागतात का?

हो. Thinking tokens साठी output tokens प्रमाणेच शुल्क आकारले जाते — जो महागडा रेट आहे — आणि ते max_tokens मध्ये मोजले जातात. सध्याचे मॉडेल्स इंटरफेसमध्ये reasoning summary न दाखवताही त्यांचे शुल्क आकारतात. जर उत्तर पूर्ण होण्यापूर्वी stop_reason: "max_tokens" मुळे प्रतिसाद कापला गेला (truncate), तर याचा अर्थ thinking ने बजेट संपवले आहे. Claude Code मध्ये, ज्या कामांसाठी सखोल reasoning ची गरज नाही, त्यांच्यासाठी /effort वापरून effort level कमी करा.

Claude Code मधील लांब सेशनमध्ये प्रति मेसेज खर्च का वाढतो?

कारण API हे stateless आहे: प्रत्येक टर्नमध्ये संपूर्ण संभाषण — प्रत्येक फाईल रीडिंग, tool result आणि मागील संवाद — पुन्हा input म्हणून पाठवले जाते. त्यामुळे 50 व्या टर्नमध्ये 1 ते 49 टर्नचा भार असतो. Prompt caching मुळे वारंवार येणारा prefix बेस इनपुट किमतीच्या 10% दराने मिळतो, परंतु prefix स्वतः वाढत जातो. तसेच, cache TTL नंतर कोणताही वेळ वाया गेल्यास, पुढचा टर्न पूर्ण किमतीत येतो. /compact मुळे history कमी होते; /clear मुळे ते रिसेट होते.

मी माझा Claude token वापर आणि खर्च कसा तपासू शकतो?

Claude Code मध्ये, /usage सेशन token statistics, स्थानिक खर्च अंदाज आणि सबस्क्रिप्शनवरील plan-limit bars दाखवते (/cost हा एक alias आहे); /context विंडोमध्ये काय भरत आहे ते दाखवते. अधिकृत API billing साठी, Claude Console मधील usage page वापरा. तुमच्या स्वतःच्या कोडमध्ये, response.usage वाचा — input_tokens, cache_creation_input_tokens आणि cache_read_input_tokens यांची बेरीज केल्यास खरा prompt size समजतो — आणि count_tokens endpoint वापरून आधीच अंदाज घ्या, tiktoken वापरू नका.