Claude-ல் tokens என்றால் என்ன? Code session செலவுகள்

Claude-ல் tokens என்றால் என்ன?

Token என்பது Claude வாசிக்கும் மற்றும் எழுதும் உரையின் அடிப்படை அலகு ஆகும்; இது ஒரு சொல்லின் ஒரு பகுதி, தோராயமாக 3.5 ஆங்கில எழுத்துக்களுக்குச் சமம். இந்த அளவு Anthropic-ன் சொந்த கலைச்சொல் அகராதியிலிருந்து பெறப்பட்டது. இடைவெளிகள் மற்றும் நிறுத்தற்குறிகளைக் கணக்கிடும்போது, ஒரு சொல்லுக்கு ஒரு token-க்கும் மேல் தேவைப்படும். எனவே, 1,000 சொற்கள் கொண்ட உரை 1,300 tokens-க்கும் அதிகமாக இருக்கும். நிரலாக்கக் குறியீடுகள் (code) அதிக tokens-ஐ எடுத்துக்கொள்ளும்: braces, operators, underscores மற்றும் indentation போன்றவை ஆங்கிலத்தை விட அதிக tokens-ஆகப் பிரிக்கப்படுகின்றன. சில நூறு வரிகள் கொண்ட source file பொதுவாகப் பல ஆயிரம் tokens-ஐக் கொண்டிருக்கும். ஒரு agent வாசிக்கத் தீர்மானிக்கும் 2,000 வரிகள் கொண்ட file, புதிய குறியீடு எதையும் எழுதும் முன்பே ஐந்து இலக்க token செலவை ஏற்படுத்திவிடும்.

Tokenizers குறித்து இரண்டு விஷயங்கள் பயனர்களைக் குழப்பமடையச் செய்கின்றன. முதலாவதாக, இவை model-க்கு model மாறுபடும். ஜூலை 2026 நிலவரப்படி, Opus 4.7 மற்றும் அதற்குப் பிந்தைய பதிப்புகள், Sonnet 5, மற்றும் Fable 5 ஆகியவை புதிய tokenizer-ஐப் பயன்படுத்துகின்றன. இது முந்தைய Claude model-களை விட அதே உரைக்குத் தோராயமாக 30% அதிக tokens-ஐ உருவாக்குகிறது (இந்த அதிகரிப்பு உள்ளடக்கத்தைப் பொறுத்து மாறுபடும்). இதனால், token-க்கான விலை அதிகரிக்காவிட்டாலும், நீங்கள் திட்டமிட்ட token பட்ஜெட்டில் மாற்றம் ஏற்படும். இரண்டாவதாக, tiktoken, அதாவது ஒவ்வொரு வலைப்பதிவிலும் பரிந்துரைக்கப்படும் library, OpenAI-ன் tokenizer ஆகும். இது சாதாரண உரையில் Claude-ன் எண்ணிக்கையை விட 15–20% குறைவாகவும், குறியீடுகளில் இன்னும் குறைவாகவும் கணக்கிடுகிறது. கீழே விவரிக்கப்பட்டுள்ள count_tokens endpoint மட்டுமே நம்பகமான எண்ணிக்கையை வழங்கும்.

உங்கள் coding session-க்கான கட்டணம் ஏன் அவ்வாறு கணக்கிடப்படுகிறது

ஒவ்வொரு Claude கட்டணமும், அது API invoice ஆக இருந்தாலும் அல்லது subscription limit ஆக இருந்தாலும், tokens in மற்றும் tokens out ஆகிய அளவீடுகளையே அடிப்படையாகக் கொண்டது. Pricing பக்கத்தில் இது எளிமையாகத் தெரியும்: ஒரு மில்லியன் input tokens-க்கு இத்தனை டாலர்கள், ஒரு மில்லியன் output tokens-க்கு இத்தனை டாலர்கள் என இருக்கும். ஆனால், ஒரு agentic coding session-ல், ஒவ்வொரு முறை உரையாடல் நடக்கும்போதும் முழு உரையாடலும் மீண்டும் அனுப்பப்படுவதால், input அளவு நாம் எதிர்பார்ப்பதை விட மிக அதிகமாக இருக்கும் என்பதை அது குறிப்பிடுவதில்லை. நான் பதினைந்து ஆண்டுகளாக metered infrastructure விற்பனை செய்து வருகிறேன்; இதில் tokens என்பதுதான் பெரும்பாலான வாடிக்கையாளர்கள் எதனால் செலவாகிறது என்று சரியாகக் கூற முடியாத முதல் அளவீடு ஆகும். இதுவே அந்த அளவீட்டைப் புரிந்துகொள்வதற்கான பாடம்: ஒரு agentic session-ல் எவை input மற்றும் output எனக் கருதப்படுகின்றன, resend loop ஏன் இவ்வளவு செலவு மிக்கதாக இருக்கிறது, prompt caching எவ்வாறு கணக்கீட்டை மாற்றுகிறது, மற்றும் எந்தெந்த காரணிகள் உண்மையில் கட்டணத்தை மாற்றியமைக்கின்றன என்பதைப் புரிந்துகொள்வது அவசியம்.

அனைத்தும் உள்ளீடுதான்: மீட்டர் உண்மையில் எதைக் கணக்கிடுகிறது

Claude எழுதும் குறியீட்டிற்கு (code) நீங்கள் பணம் செலுத்துவதாக மக்கள் நினைக்கிறார்கள். ஒரு agentic அமர்வில், அது மிகச்சிறிய செலவு மட்டுமே. உள்ளீட்டு டோக்கன்கள் (input tokens) விலை குறைந்தவை, ஆனால் அவற்றின் அளவு மிக அதிகம். இதில் அடங்குபவை:

• System prompt. Claude Code-ன் சொந்த வழிகாட்டுதல்கள், அத்துடன் உங்கள் CLAUDE.md மற்றும் நினைவகக் கோப்புகள் (memory files). இவை அமர்வு தொடங்கும்போதே ஏற்றப்பட்டு, அதன் பிறகு ஒவ்வொரு கோரிக்கையிலும் இடம்பெறும்.
• Tool definitions. ஏஜென்ட் அழைக்கக்கூடிய ஒவ்வொரு கருவியின் schema-வும் இதில் அடங்கும். நீங்கள் இணைக்கும் ஒவ்வொரு MCP server-ம் இந்த நிலையான செலவை (fixed overhead) அதிகரிக்கும். இருப்பினும், Claude Code இப்போது முழுமையான MCP கருவி வரையறைகளைத் தள்ளிப்போடுவதால் (defer), ஒரு கருவி முதன்முதலில் பயன்படுத்தப்படும் வரை அதன் பெயர் மட்டுமே context-ல் இருக்கும். இது செலவைக் குறைக்குமே தவிர, முழுமையாக நீக்காது.
• ஏஜென்ட் வாசிக்கும் ஒவ்வொரு கோப்பும். ஒரு source file-ஐ Read செய்யும்போது, அதன் முழு உள்ளடக்கமும் context-க்குள் சென்றுவிடும், அது அங்கேயே தங்கிவிடும்.
• ஒவ்வொரு கருவியின் முடிவும் (tool result). சோதனை ஓட்டங்கள் (test runs), grep வெளியீடு, terminal-ல் வரும் தகவல்கள், build logs என அனைத்தும் உள்ளீட்டு டோக்கன்களாகவே கணக்கிடப்படும். 8,000 வரிகளை அச்சிடும் ஒரு தோல்வியுற்ற test suite, ஒரு சிறிய புத்தகத்திற்கான கட்டணத்தை உங்களுக்கு வசூலிக்கும்.
• இதுவரை நடந்த முழு உரையாடலும், ஒவ்வொரு முறையும் மீண்டும் அனுப்பப்படுதல். இது தனிப் பிரிவில் விவாதிக்கப்பட வேண்டிய ஒன்று.

மீண்டும் அனுப்பப்படும் தரவுகளுக்கான கட்டணங்கள்

Claude API ஒரு stateless அமைப்பாகும். இது கோரிக்கைகளுக்கு இடையே உங்கள் session-ஐ நினைவில் வைத்துக்கொள்ளாது; எந்தவொரு API-யும் அவ்வாறு செய்வதில்லை. எனவே, இரண்டாவது சுற்றில் (turn 2), client முந்தைய சுற்றின் தரவுகள், அதன் பதில் மற்றும் உங்கள் புதிய செய்தியை சேர்த்து அனுப்பும். 50-வது சுற்றில், அது 1 முதல் 49 வரையிலான அனைத்து சுற்றுகள், வாசிக்கப்பட்ட ஒவ்வொரு கோப்பு, ஒவ்வொரு tool-ன் முடிவு, ஒவ்வொரு diff மற்றும் 50-வது சுற்றின் தரவு என அனைத்தையும் மீண்டும் அனுப்பும். ஒவ்வொரு முறையும் model முழு உரையாடலையும் மீண்டும் வாசிக்கும்; அவ்வாறு மீண்டும் வாசிக்கப்படும் ஒவ்வொரு token-க்கும் input கட்டணம் வசூலிக்கப்படும்.

இதன் விளைவு: ஒரு சுற்றிற்கான செலவு session-ன் நீளத்திற்கு ஏற்ப நேரியல் (linearly) முறையில் அதிகரிக்கிறது, மேலும் மொத்த session செலவு இருபடி (quadratically) முறையில் அதிகரிக்கிறது. மூன்றாவது சுற்றில் அரை சென்ட் செலவான ஒரு செய்தி, 60-வது சுற்றில் அதே ஒரு வரி கேள்வியாக இருந்தாலும், இருபது மடங்கு அதிக செலவை ஏற்படுத்தலாம். ஏனெனில், அது முந்தைய 60 சுற்றுகளின் தரவுகளையும் சுமந்து செல்கிறது. "எனது கட்டணம் ஏன் இவ்வளவு அதிகமாக உள்ளது" என்று வரும் பெரும்பாலான புகார்களுக்கு இந்த ஒரு காரணமே விளக்கமாகும். இது Claude-ன் தனிப்பட்ட அம்சம் அல்ல; stateful போலத் தோன்றும் ஒவ்வொரு LLM தயாரிப்பும், பின்னணியில் தரவுகளை மீண்டும் அனுப்பும் (resend loop) ஒரு stateless API-யையே பயன்படுத்துகிறது.

வெளியீடு: நீங்கள் காண்பது மற்றும் நீங்கள் காணாத சிந்தனை செயல்முறை

வெளியீட்டு டோக்கன்கள் (output tokens) அதிக செலவு கொண்டவை. ஜூலை 2026 நிலவரப்படி, Opus 4.8-ல் $5/$25, Sonnet 5-ல் $3/$15, மற்றும் Haiku 4.5-ல் $1/$5 என தற்போதைய வரிசையில் உள்ளீடு கட்டணத்தை விட ஐந்து மடங்கு அதிகமாக உள்ளது. வெளியீட்டில் Claude உருவாக்கும் உரை மற்றும் குறியீடு மட்டுமல்லாமல், சிந்தனை டோக்கன்களும் (thinking tokens) அடங்கும்: அதாவது, பதிலளிப்பதற்கு முன்பு மாதிரி (model) மேற்கொள்ளும் உள்நிலை பகுப்பாய்வு. இதில் இரண்டு உண்மைகள் முக்கியமானவை. சிந்தனை செயல்முறை வெளியீட்டு கட்டணத்திலேயே கணக்கிடப்படுகிறது மற்றும் அது max_tokens-க்கு எதிராகக் கணக்கிடப்படுகிறது. ஒரு API பதில் stop_reason: "max_tokens" மூலம் முடிவடைந்தால் அல்லது பதில் பாதியிலேயே துண்டிக்கப்பட்டால், பதிலுக்கு முன்பே சிந்தனை செயல்முறைக்கான பட்ஜெட் தீர்ந்துவிட்டது என்று பொருள். தற்போதைய மாதிரிகளில், இந்த பகுப்பாய்வு சுருக்கம் காட்டப்படாமல் இருக்கலாம்; Opus 4.8, Sonnet 5, மற்றும் Fable 5 ஆகியவை இயல்பாகவே இதைத் தவிர்க்கின்றன, ஆனால் சிந்தனை செயல்முறை நடந்தே தீரும், அதற்கான கட்டணமும் வசூலிக்கப்படும். கண்ணுக்குத் தெரியாதது இலவசமானது அல்ல.

Claude Code இயல்பாகவே நீட்டிக்கப்பட்ட சிந்தனை செயல்முறையை (extended thinking) செயல்படுத்துகிறது, ஏனெனில் இது பல படிகளைக் கொண்ட பணிகளில் துல்லியத்தை மேம்படுத்துகிறது. ஒரு கோரிக்கைக்கு இயல்புநிலை பட்ஜெட் பல்லாயிரக்கணக்கான டோக்கன்கள் வரை செல்லலாம். எளிமையான பணிகளுக்கு நீங்கள் இதை குறைக்கலாம்: /effort மூலமாகவோ அல்லது /model-ல் உள்ளீடு செய்தோ முயற்சி அளவைக் குறைக்கலாம், அல்லது /config-ல் சிந்தனை அமைப்புகளை மாற்றியமைக்கலாம். இது வெறும் நம்பிக்கை சார்ந்ததல்ல, உண்மையான செலவைக் கட்டுப்படுத்தும் ஒரு கருவியாகும்.

Prompt caching கணக்கீட்டை மாற்றியமைக்கிறது

Prompt caching என்பதுதான் resend loop அனைவரையும் திவாலாக்காமல் தடுப்பதற்கான வழியாகும். உங்கள் prompt-ன் நிலையான முன்னொட்டு (prefix), system prompt, tool definitions, உரையாடல் வரலாறு ஆகியவற்றை API cache செய்து வைத்துக்கொள்ளும். அடுத்தடுத்த கோரிக்கைகளின்போது, மிகக் குறைந்த செலவில் அந்தத் தகவல்களை அது வழங்கும். ஜூலை 2026 நிலவரப்படி, இதற்கான பெருக்கிகள் (multipliers) பின்வருமாறு: cache write என்பது அடிப்படை உள்ளீட்டு விலையை விட 1.25× அதிகம் (1-மணிநேர வகைக்கு 2×), மற்றும் cache read என்பது 0.1× மட்டுமே. Write செய்வதற்கு கூடுதல் கட்டணம் வசூலிக்கப்படுகிறது; ஆனால் read செய்வதற்கு 90% தள்ளுபடி கிடைக்கிறது. ஒரே ஒருமுறை read செய்தாலே, 5-நிமிட write பிரீமியம் கட்டணத்தை விட அதிக சேமிப்பு கிடைத்துவிடும்.

Claude Code உங்களுக்காக caching-ஐ நிர்வகிக்கிறது. ஒரு சீரான அமர்வில் (session), அந்த பிரம்மாண்டமான resend-ன் பெரும்பகுதி cache-லிருந்தே வழங்கப்படுகிறது. ஆனால், இயல்பான cache காலம் கடைசியாகப் பயன்படுத்தப்பட்டதிலிருந்து ஐந்து நிமிடங்கள் மட்டுமே. நீண்ட நேரம் காபி குடிக்கச் சென்றுவிட்டுத் திரும்பி வந்து ஒரு செய்தியை அனுப்பினால், cache காலாவதியாகிவிடும். அப்போது, முழு முன்னொட்டும் 0.1× விலையில் read செய்யப்படுவதற்குப் பதிலாக, 1.25× விலையில் மீண்டும் எழுதப்படும் (re-written). 150K-token கொண்ட ஒரு அமர்வில், அந்த ஒரு cold turn-க்கான செலவு, ஒரு டஜன் warm turn-களை விட அதிகமாக இருக்கும். இது புரிந்துகொள்ள வேண்டிய ஒரு முரணான உண்மை: தொடர்ச்சியான வேலையை விட, அவ்வப்போது இடைவெளி விட்டுச் செய்வது அதிக செலவை ஏற்படுத்தும். ஏனெனில், TTL காலத்தைத் தாண்டிய ஒவ்வொரு இடைவெளியும், உங்கள் அடுத்த கட்டத்தை மலிவான read-லிருந்து விலையுயர்ந்த re-write-ஆக மாற்றிவிடுகிறது. எனவே, வேலையைத் திட்டமிட்டுச் செய்யுங்கள்; பத்து நிமிடங்களுக்கு ஒரு செய்தி என ஒரு பெரிய அமர்வை மெதுவாகச் செயல்படுத்த வேண்டாம்.

நீங்கள் VPS-ல் உள்ள உங்கள் சொந்த application மூலம் API-ஐ அழைத்தால், இந்த வசதிகள் தானாகக் கிடைக்காது. இதில் பொதுவாகச் செய்யப்படும் தவறு, system prompt-க்குள் timestamp அல்லது request ID-ஐச் சேர்ப்பதுதான். இது ஒவ்வொரு கோரிக்கையின்போதும் முன்னொட்டு பைட்டுகளை (prefix bytes) மாற்றி, caching-ஐத் தெரியாமலேயே முடக்கிவிடும். ஒரே மாதிரியான அழைப்புகளுக்குப் பிறகும் usage.cache_read_input_tokens பூஜ்ஜியமாகவே இருப்பதுதான் இதற்கான அறிகுறி.

சூத்திரமும், ஒரு செயல்முறை உதாரணமும்

"ஒரு session-க்கு $X செலவாகும்" என்று யாராவது கூறினால் அதை நம்ப வேண்டாம். Session-களின் செலவு நூறு மடங்கு வரை மாறுபடலாம். பின்வரும் சூத்திரமே உண்மையானது:

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 நிலவரப்படி, இதன் விலை 1 மில்லியன் input tokens-க்கு $5 மற்றும் 1 மில்லியன் output tokens-க்கு $25. ஒரு session-ன் இடையில் 80,000 tokens கொண்ட context இருப்பதாகக் கொள்வோம்: 75,000 cache-லிருந்து வாசிக்கப்படுகிறது, 3,000 புதிதாக எழுதப்படுகிறது, 2,000 cache செய்யப்படாத புதிய 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

இந்த ஒரு turn-க்கு சுமார் $0.10 செலவாகும்; இது போன்ற ஐம்பது turn-களுக்கு சுமார் $5 ஆகும். இப்போது, cache காலாவதியான பிறகு அதே turn-ஐக் கணக்கிடுவோம்: முழு 80,000 tokens-ம் $6.25/M விலையில் மீண்டும் எழுதப்பட்டால், output-க்கு முன்பே $0.50 செலவாகும். இது, அதே வேலைக்கு cache இருக்கும்போது ஆகும் செலவை விட ஐந்து மடங்கு அதிகம். இந்த வித்தியாசமே caching-ன் முக்கியத்துவத்தை ஒரே எண்ணில் விளக்குகிறது. விற்பனையாளர்களை ஒப்பிடுவதற்கு இந்த நான்கு வரிகளே சரியான வழி; ஏனெனில், பொதுவான விலைப்பட்டியல்கள் cache reads மற்றும் thinking செலவுகளைக் கணக்கில் கொள்வதில்லை. மூன்று உண்மையான பணிகளுக்கு இவற்றைச் செயல்படுத்திப் பார்த்தால், Claude-ன் கட்டணம் OpenAI-ஐ விட எங்கே அதிகம் அல்லது குறைவு என்பது தெரியும்.

ஒரு turn-ஐ மட்டும் பார்க்காமல், கட்டண அலகைப் பற்றிப் புரிந்துகொள்ள விரும்பினால், ஒரு மில்லியன் tokens என்பது எத்தனை பக்கங்கள், கோப்புகள் மற்றும் டாலர்கள் மதிப்புடையது என்ற கணக்கீடு உங்களுக்கு உதவும். கணிப்புக்காக அல்லாமல், ஒரு தோராயமான மதிப்பீட்டிற்கு: ஜூலை 2026 நிலவரப்படி, நிறுவனங்களுக்கான Claude Code பயன்பாட்டில், ஒரு developer-க்கு ஒரு நாளைக்கு சராசரியாக $13, மாதத்திற்கு $150–250 வரை செலவாகிறது. 90% பயனர்கள் ஒரு நாளைக்கு $30-க்கும் குறைவாகவே செலவு செய்கிறார்கள். உங்கள் செலவு என்பது நீங்கள் தேர்ந்தெடுக்கும் model, session-ஐ நிர்வகிக்கும் முறை மற்றும் codebase-ன் அளவு ஆகியவற்றைப் பொறுத்தது; இதனால்தான் கீழே உள்ள காரணிகள் முக்கியமானவை.

உங்கள் பயன்பாட்டைப் பார்த்தல்

Claude Code-ல், இதற்கான கட்டளை /usage ஆகும் (/cost என்பதும் வேலை செய்யும், இது ஒரு மாற்றுப் பெயர்). திரையின் மேற்புறத்தில் உள்ள Session பகுதி, தற்போதைய அமர்வுக்கான டோக்கன் புள்ளிவிவரங்களையும், உள்ளூர் கணக்கீட்டின்படி தோராயமான செலவையும் காட்டுகிறது; சந்தா திட்டங்களில், அதே திரையில் உங்கள் திட்ட வரம்புகள் மற்றும் சமீபத்திய பயன்பாட்டைத் திறன்கள் (skills), துணை முகவர்கள் (subagents), செருகுநிரல்கள் (plugins) மற்றும் தனிப்பட்ட MCP servers எனப் பிரித்துக் காட்டும். API கணக்குகளின் அதிகாரப்பூர்வ கட்டண விவரங்களுக்கு, Claude Console-ல் உள்ள பயன்பாட்டுப் பக்கமே (usage page) உண்மையான ஆதாரமாகும்; CLI-ல் காட்டப்படும் எண்ணிக்கை ஒரு தோராயமான மதிப்பீடு மட்டுமே. /context என்பது context window-ல் எவை ஆக்கிரமித்துள்ளன என்பதைக் குறிக்கும் வண்ணமயமான கட்டத்தை உருவாக்குகிறது; இதில் system prompt, கருவிகள், MCP வரையறைகள், கோப்புகள் மற்றும் வரலாறு ஆகியவை அடங்கும். இது அதிகப்படியான CLAUDE.md அல்லது அதிகத் தகவல்களை அனுப்பும் MCP server-ஐக் கண்டறிய வேகமான வழியாகும்; ஒவ்வொரு உருப்படியின் முழுமையான விவரங்களைப் பெற 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 என்பது cache செய்யப்படாத மீதமுள்ள பகுதி மட்டுமே என்பதைக் கவனத்தில் கொள்ளவும்; உண்மையான prompt அளவு என்பது மூன்று உள்ளீட்டுப் புலங்களின் கூட்டுத்தொகையாகும். ஒரு மணிநேரம் இயங்கிய முகவர் input_tokens: 4000-ஐக் காட்டினால் அது மலிவானது அல்ல; மற்ற 200,000 டோக்கன்கள் cache-லிருந்து வழங்கப்பட்டவை. நீங்கள் அனுப்புவதற்கு முன்பு மதிப்பீடு செய்ய, token-counting endpoint-ஐப் பயன்படுத்தவும். இது இலவசமானது, இதற்கெனத் தனி rate limit உள்ளது, மேலும் நீங்கள் குறிப்பிடும் எந்த மாதிரியின் (model) tokenizer-ஐயும் கொண்டு இது கணக்கிடும் (இதன் முடிவை ஒரு நெருக்கமான மதிப்பீடாகக் கருதவும்; கட்டணம் உண்மையான கோரிக்கையின் அடிப்படையிலேயே அமையும்):

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 key மூலம், Anthropic பயன்பாட்டிற்கு ஏற்ப (pay-as-you-go) ஒவ்வொரு token-க்கும் நிர்ணயிக்கப்பட்ட விலையில் கட்டணம் வசூலிக்கிறது, மேலே உள்ள ஒவ்வொரு எண்ணும் உண்மையான பண மதிப்பைக் குறிக்கும். பெரும்பாலானோர் எதிர்பார்ப்பதை விட இந்த கட்டண கணக்கீடு விரைவாகத் தொடங்கும், ஏனெனில் இதில் இலவச அடுக்கு (free tier) கிடையாது. பதிவு செய்யும் போது வழங்கப்படும் சிறிய அளவிலான credit மற்றும் கட்டணம் வசூலிக்கப்படாத ஒரு சில endpoints மட்டுமே உள்ளன, இதுவே புதிய API கணக்கிற்கு அட்டை விவரங்களைச் சேர்ப்பதற்கு முன்பு கிடைக்கும் சலுகை. Claude சந்தாவில் (Pro, Max, Team, Enterprise), Claude Code பயன்பாடு உங்கள் திட்டத்தில் உள்ள ஒதுக்கீட்டிலிருந்து (allowance) கழிக்கப்படும்: ஜூலை 2026 நிலவரப்படி, இது ஐந்து மணிநேர சுழலும் அமர்வு (rolling five-hour session) மற்றும் வாராந்திர ஒதுக்கீடு ஆகும். இது அனைத்து models மற்றும் claude.ai chat ஆகியவற்றுடன் பகிரப்படுகிறது, மேலும் /usage டாலர் மதிப்பு என்பது கட்டணத்திற்கான ரசீது அல்ல, தகவலுக்காக மட்டுமே. ஒதுக்கீடு தீர்ந்துவிட்டால், "You've hit your session limit" அல்லது "You've hit your weekly limit" என்ற செய்தி மற்றும் மீண்டும் தொடங்கும் நேரம் காட்டப்படும். /model மூலம் models-ஐ மாற்றினாலும் அணுகல் கிடைக்காது, ஏனெனில் இந்த ஒதுக்கீடு அனைத்து models-க்கும் பொதுவானது. இந்த ஒதுக்கீடுகள் நீங்கள் பயன்படுத்தும் client-ஐ விட உங்கள் கணக்கையே அடிப்படையாகக் கொண்டவை. நீங்கள் எவை Linux-ல் இயங்குகின்றன மற்றும் எந்தத் திட்டம் எந்தச் சேவையை உள்ளடக்கியது என்பதைத் தெரிந்துகொள்ளும்போது இது முக்கியமானது. நீங்கள் எந்த ஒதுக்கீட்டை முடித்துவிட்டீர்கள் என்பதுதான் காத்திருப்பு நேரத்தையும், அந்த இடைவெளியில் என்ன செய்யலாம் என்பதையும் தீர்மானிக்கும், எனவே பணி பாதியில் இருக்கும்போது வரம்பை எட்டினால் உங்கள் விருப்பங்கள் என்ன என்பதைத் தெரிந்துகொள்வது பயனுள்ளது. திட்டங்களில் விருப்பத்தேர்வாக usage credits-ஐச் சேர்க்கலாம், இதை /usage-credits மூலம் நிர்வகித்து, வரம்பிற்கு மேல் பயன்பாட்டைப் பெறலாம். திட்ட ஒதுக்கீடுகளை நான் வேண்டுமென்றே இங்கே குறிப்பிடவில்லை: இவை இந்தத் தலைப்பிலேயே அடிக்கடி மாறக்கூடிய எண்கள், எனவே claude.com/pricing மற்றும் உங்கள் /usage பட்டிகளைச் சரிபார்க்கவும். சந்தாவிலும் token செயல்பாடுகள் முக்கியம், தேவையற்ற அமர்வுகள் உங்கள் ஒதுக்கீட்டை டாலர்களைப் போலவே விரைவாகக் குறைக்கும். சந்தா தொடர்பான விவரங்களுக்கு, உங்கள் பயன்பாட்டிற்கு எந்த Claude திட்டம் பொருத்தமானது என்பதைப் பார்க்கவும்.

உண்மையில் பலனளிக்கும் உத்திகள்

• Agent எவற்றைப் படிக்க வேண்டும் என்பதைக் கட்டுப்படுத்துங்கள். "auth.py-ல் உள்ள validation பிழையைச் சரிசெய்" என்பது ஒரு கோப்பை மட்டுமே படிக்கும்; "இந்த codebase-ஐ மேம்படுத்து" என்பது நாற்பது கோப்புகளைப் படிக்கும். CLAUDE.md-ஐச் சுருக்கமாக வைத்திருங்கள், இது ஒவ்வொரு session-லும் ஏற்றப்படும். எனவே, முக்கியமானவற்றை மட்டும் அதில் வைத்துவிட்டு, குறிப்பிட்ட பணிகளுக்கான வழிமுறைகளைத் தேவைப்படும்போது மட்டும் ஏற்றப்படும் skills-க்கு மாற்றுங்கள்.
• தெளிவாகவும் சுருக்கமாகவும் இருங்கள். தொடர்பில்லாத பணிகளுக்கு இடையே /clear செய்யுங்கள்; பழைய context ஒவ்வொரு செய்தியிலும் மீண்டும் அனுப்பப்பட்டு, அதற்கான கட்டணமும் வசூலிக்கப்படும். நீண்ட பணி ஒன்றின் போது, /compact Focus on the failing tests and the diff வரலாற்றைச் சுருக்கி, உங்களை quadratic curve-ல் சிக்காமல் பாதுகாக்கும்.
• சரியான model-ஐத் தேர்ந்தெடுங்கள். Sonnet பெரும்பாலான coding பணிகளைக் கையாளும், ஜூலை 2026 நிலவரப்படி இதன் அறிமுக விலை ஒரு மில்லியன் tokens-க்கு $2/$10 ஆகும் ($3/$15 என்பது சாதாரண விலை, Opus-ன் விலை $5/$25). log triage போன்ற இயந்திரத்தனமான subagent பணிகளுக்கு Haiku ($1/$5) சரியான கருவியாகும். Fable 5-ன் விலை $10/$50, இது Opus-ஐ விட இரு மடங்கு அதிகம். எனவே, வழக்கமான பணிகளுக்கு அதைத் தேர்ந்தெடுக்கும் முன், எந்தப் பணிகளுக்கு அந்த விலை நியாயமானது என்பதை அறிவது அவசியம். /model மூலம் session-க்கு இடையிலேயே நீங்கள் மாறலாம்.
• அதிகப்படியான வெளியீட்டை முன்கூட்டியே வடிகட்டுங்கள். ஒரு test run-ன் முடிவுகளை Claude பார்ப்பதற்கு முன்பே, தோல்வியடைந்தவற்றை மட்டும் grep மூலம் பிரித்தெடுக்கும் hook-ஐப் பயன்படுத்துங்கள். இது 20,000 tokens அளவிலான tool முடிவை 300 tokens-ஆகக் குறைக்கும், மேலும் அந்தத் திருப்பத்தின் ஒவ்வொரு மறுபதிப்பிலும் இது சேமிப்பைத் தரும்.
• interactive அல்லாத பணிகளைத் தொகுப்பாகச் செய்யுங்கள். உங்கள் சொந்த API pipelines, வகைப்படுத்துதல், மொத்த ஆய்வு (bulk review), மற்றும் nightly jobs ஆகியவற்றிற்கு, Batches API-ஐப் பயன்படுத்துங்கள். இது asynchronous delivery-க்கு ஈடாக அதே model-களை 50% தள்ளுபடியில் வழங்குகிறது.
• cache clock-ஐக் கவனத்தில் கொள்ளுங்கள். தொடர்ச்சியான இடைவெளிகளில் பணியாற்றுங்கள். tmux-ல் இயங்கும் Claude Code session சும்மா இருக்கும்போது எந்தச் செலவையும் ஏற்படுத்தாது. ஒரு turn இயங்கும்போது மட்டுமே tokens செலவாகும். ஆனால், idle நேரத்தில் warm cache இழக்கப்படும், அடுத்த turn-ல் அதை மீண்டும் எழுத வேண்டியிருக்கும்.

FAQ

Claude Code-ல் ஒரு coding session-க்கு எத்தனை tokens பயன்படுத்தப்படுகின்றன?

இதற்கு நிலையான எண்ணிக்கை என்று எதுவும் இல்லை. கோப்புகள் மற்றும் வரலாறு சேரும்போது, ஒரு session-ன் இடைப்பட்ட பகுதியில் பல்லாயிரக்கணக்கான prompt tokens பயன்படுத்தப்படலாம். ஒரு முழுமையான வேலை session-ல் மில்லியன் கணக்கான tokens வரை செல்லலாம்; இதில் பெரும்பாலானவை base rate-ல் பத்தில் ஒரு பங்கு விலையில் cache-லிருந்து வழங்கப்படுகின்றன. கணக்கீட்டிற்காக, ஜூலை 2026 நிலவரப்படி Anthropic வெளியிட்ட enterprise தரவுகளின்படி, ஒரு developer-க்கு ஒரு நாளைக்கு சராசரியாக $13 செலவாகிறது, 90% பயனர்களுக்கு இது $30-க்கும் குறைவாகவே உள்ளது. உங்கள் session-ல் /usage-ஐ இயக்கிப் பாருங்கள்; ஐந்து நிமிடங்கள் கவனிப்பது எந்தவொரு சராசரி புள்ளிவிவரத்தையும் விடத் துல்லியமான புரிதலைத் தரும்.

என்னால் பார்க்க முடியாதபோதும் thinking tokens-க்கு கட்டணம் வசூலிக்கப்படுகிறதா?

ஆம். Thinking tokens, output tokens-ஆகவே கணக்கிடப்படுகின்றன, அதாவது அதிக கட்டண விகிதத்தில் வசூலிக்கப்படும். இவை max_tokens-ன் வரம்பிற்குள் அடங்கும். இடைமுகத்தில் (interface) reasoning summary காட்டப்படாதபோதும், தற்போதைய மாதிரிகள் (models) இதற்கான கட்டணத்தை வசூலிக்கின்றன. ஒரு பதில் முழுமையடைவதற்கு முன்பே stop_reason: "max_tokens" மூலம் துண்டிக்கப்பட்டால், thinking tokens-க்கு ஒதுக்கப்பட்ட வரம்பு தீர்ந்துவிட்டது என்று அர்த்தம். Claude Code-ல், ஆழ்ந்த சிந்தனை தேவைப்படாத பணிகளுக்கு /effort மூலம் effort level-ஐக் குறைக்கவும்.

நீண்ட Claude Code session-ல் ஒவ்வொரு செய்திக்கும் ஏன் செலவு அதிகரிக்கிறது?

ஏனெனில் API-க்கு state கிடையாது (stateless): ஒவ்வொரு முறையும் முழு உரையாடலையும், வாசிக்கப்பட்ட அனைத்து கோப்புகளையும், tool-ன் முடிவுகளையும், முந்தைய பரிமாற்றங்களையும் மீண்டும் அனுப்ப வேண்டும். எனவே, 50-வது turn-ல் 1 முதல் 49 வரையிலான அனைத்துத் தகவல்களும் மீண்டும் அனுப்பப்படுகின்றன. Prompt caching மூலம் மீண்டும் மீண்டும் வரும் தகவல்கள் base input விலையில் பத்தில் ஒரு பங்கிற்கு வழங்கப்படுகின்றன, ஆனால் அந்தத் தகவல்களின் அளவு தொடர்ந்து அதிகரித்துக்கொண்டே இருக்கும். cache TTL-ஐத் தாண்டி நீண்ட இடைவெளி ஏற்பட்டால், அடுத்த turn முழு விலையில் மீண்டும் அனுப்பப்படும். /compact வரலாற்றைச் சுருக்குகிறது; /clear அதை மீட்டமைக்கிறது (reset).

எனது Claude token பயன்பாடு மற்றும் செலவை எவ்வாறு சரிபார்ப்பது?

Claude Code-ல், /usage மூலம் session token புள்ளிவிவரங்கள், தோராயமான செலவு மற்றும் சந்தா வரம்புகளைக் காணலாம் (/cost இதற்கான மாற்று கட்டளை); /context மூலம் window-வில் என்னென்ன தகவல்கள் உள்ளன என்பதைப் பார்க்கலாம். அதிகாரப்பூர்வமான API கட்டண விவரங்களுக்கு, Claude Console-ல் உள்ள usage பக்கத்தைப் பயன்படுத்தவும். உங்கள் சொந்தக் குறியீட்டில், response.usage-ஐ வாசிக்கவும்; input_tokens, cache_creation_input_tokens, மற்றும் cache_read_input_tokens ஆகியவற்றைக் கூட்டுவதன் மூலம் சரியான prompt அளவைப் பெறலாம். முன்கூட்டியே கணிக்க tiktoken-ஐப் பயன்படுத்தாமல், count_tokens endpoint-ஐப் பயன்படுத்தவும்.