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

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

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

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

உங்கள் குறியீட்டு அமர்வு ஏன் இந்தச் செலவில் வருகிறது

ஒவ்வொரு Claude பில்லும், அது API இன்வாய்ஸ் ஆக இருந்தாலும் சரி அல்லது சந்தா வரம்பாக இருந்தாலும் சரி, ஒரே ஒரு அளவீட்டிற்கே வருகிறது: உள்ளீட்டு tokens, வெளியீட்டு tokens. விலை நிர்ணயப் பக்கம் இதை எளிதாகக் காட்டுகிறது: ஒரு மில்லியன் உள்ளீட்டு tokens-க்கு இவ்வளவு டாலர்கள், ஒரு மில்லியன் வெளியீட்டு tokens-க்கு இவ்வளவு டாலர்கள். அது உங்களுக்குச் சொல்லாதது என்னவென்றால், ஒரு agentic குறியீட்டு அமர்வில் அளவீட்டின் உள்ளீட்டுப் பக்கம் நம் நினைவிலும் வேகமாக இயங்குகிறது. ஏனெனில் ஒவ்வொரு முறையும் முழு உரையாடலும் மீண்டும் அனுப்பப்படுகிறது. நான் அளவீட்டு அடிப்படையிலான உள்கட்டமைப்பை 15 ஆண்டுகளாக விற்றுள்ளேன். tokens தான் நான் பார்த்த முதல் அளவீடு; இதில் பெரும்பாலான வாடிக்கையாளர்கள் அதை எது இயக்குகிறது என்று உண்மையிலேயே சொல்ல முடியாதவர்களாக இருக்கிறார்கள். இது தான் அளவீட்டு வாசிப்புப் பாடம்: ஒரு agentic அமர்வில் உள்ளீடு மற்றும் வெளியீடு என்ன என்று கணக்கிடப்படுகிறது, மறுஅனுப்பல் சுழற்சி ஏன் இவ்வளவு விலை உயர்ந்தது, prompt caching ஏன் கணக்கீட்டை மாற்றுகிறது, மற்றும் எந்த நெம்புகோல்கள் உண்மையில் எண்ணை மாற்றுகின்றன.

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

நீங்கள் Claude எழுதும் குறியீட்டிற்குத்தான் கட்டணம் செலுத்துகிறீர்கள் என்று மக்கள் நினைக்கிறார்கள். ஒரு முகவர் அமர்வில், அது சிறிய கணக்குப் பகுதிதான். உள்ளீட்டு டோக்கன்கள் — விலை குறைவானவை, ஆனால் அளவில் பெரிது — பின்வருவனவற்றை உள்ளடக்கும்:

• கணினி தூண்டுதல். Claude Code-ன் சொந்த கட்டளை வரையறைகள், உங்கள் CLAUDE.md மற்றும் நினைவக கோப்புகள், அமர்வு தொடங்கும்போது ஏற்றப்பட்டு அதற்குப் பிறகு ஒவ்வொரு கோரிக்கையிலும் இருக்கும்.
• கருவி வரையறைகள். முகவர் அழைக்கக்கூடிய ஒவ்வொரு கருவி திட்டமும். நீங்கள் இணைக்கும் ஒவ்வொரு MCP சேவையகமும் இந்த நிலையான மேல்செலவில் சேர்க்கிறது — ஆயினும் Claude Code இப்போது முழு MCP கருவி வரையறைகளை முன்னதாகவே ஏற்றுவதில்லை, எனவே ஒரு கருவி முதன்முறை பயன்படுத்தப்படும் வரை சூழலில் கருவி பெயர்கள் மட்டுமே இருக்கும், இது செலவைக் குறைக்கிறது ஆனால் நீக்கவில்லை.
• முகவர் படிக்கும் ஒவ்வொரு கோப்பும். ஒரு மூலக் கோப்பின் Read முழு உள்ளடக்கத்தையும் சூழலில் வைக்கிறது, அது அங்கேயே நிரந்தரமாக இருக்கும்.
• ஒவ்வொரு கருவி வெளியீடும். சோதனை ஓட்டங்கள், grep வெளியீடு, முனையத் திரை வெளியீடு, கட்டமைப்புப் பதிவுகள் — இவை அனைத்தும் உள்ளீட்டு டோக்கன்களாகத் திரும்பும். 8,000 வரிகளை அச்சிடும் தோல்வியுற்ற சோதனைத் தொகுப்பு ஒரு சிறிய புத்தகத்திற்கான கட்டணத்தை உங்களுக்கு வசூலித்துவிட்டது.
• இதுவரையிலான முழு உரையாடலும், ஒவ்வொரு முறையும் மீண்டும் அனுப்பப்படுகிறது. இது ஒரு தனி பிரிவைக் கோருகிறது.

யாரும் கணக்கில் எடுத்துக்கொள்ளாத மறுஅனுப்பல்

Claude API நிலையற்றது. கோரிக்கைகளுக்கு இடையில் உங்கள் அமர்வை அது நினைவில் வைத்திருக்காது — எதுவும் வைத்திருக்காது. எனவே இரண்டாம் சுற்றில், வாடிக்கையாளர் முதல் சுற்றையும் அதன் பதிலையும் உங்கள் புதிய செய்தியையும் சேர்த்து அனுப்புகிறது. 50வது சுற்றில், அது 1 முதல் 49 வரையிலான சுற்றுகளை மீண்டும் அனுப்புகிறது — படித்த ஒவ்வொரு கோப்பும், ஒவ்வொரு கருவி முடிவும், ஒவ்வொரு diff-ம் — அத்துடன் 50வது சுற்றையும். ஒவ்வொரு முறையும் முழு உரையாடலையும் மாதிரி மீண்டும் படிக்கிறது. மீண்டும் படிக்கப்படும் ஒவ்வொரு token-ம் உள்ளீடாகக் கணக்கிடப்படுகிறது.

விளைவு: ஒரு சுற்றின் செலவு அமர்வின் நீளத்துடன் ஏறக்குறைய நேர்கோட்டு முறையில் வளர்கிறது. மொத்த அமர்வுச் செலவு ஏறக்குறைய இருபடியாக வளர்கிறது. மூன்றாம் சுற்றில் அரை சென்ட் செலவான செய்தி, 60வது சுற்றில் அதே ஒரு வரி கேள்விக்கு இருபது மடங்கு செலவாகலாம். ஏனெனில் அது அறுபது சுற்றுகளின் சுமையைச் சுமக்கிறது. "எனது பில் ஏன் இவ்வளவு அதிகம்" என்ற பெரும்பாலான புகார்களை விளக்கும் ஒரே உண்மை இதுதான். இது Claude-க்கு மட்டுமான விசித்திரம் அல்ல — நிலையுள்ளது போல் தோன்றும் ஒவ்வொரு LLM தயாரிப்பின் அடியிலும் ஒரு நிலையற்ற 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 இல் முயற்சி நிலையைத் தாழ்த்தவும், அல்லது /config இல் சிந்தனை அமைப்புகளை சரிசெய்யவும். அது உண்மையான செலவு நெம்புக்கோல், மூடநம்பிக்கை அல்ல.

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

Prompt caching தான் resend loop எல்லோரையும் திவாலாக்காததற்குக் காரணம். API உங்கள் prompt-இன் ஒரு நிலையான prefix-ஐ — system prompt, tool definitions, conversation history — cache செய்ய முடியும். அடுத்த request-ல் அதை விலையின் ஒரு பகுதிக்கே serve செய்யும். July 2026 நிலையில் multipliers இவ்வாறு உள்ளன: ஒரு cache write க்கான செலவு base input rate-ஐ விட 1.25× ஆகும் (1-hour variant-க்கு 2×). ஒரு cache read க்கான செலவு 0.1× ஆகும். Writes ஒரு premium ஆகும்; reads ஒரு 90% discount ஆகும். ஒரு முறை read செய்வதே 5-minute write premium-ஐ ஈடுசெய்யப் போதுமானது.

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

ஒரு VPS-இல் உள்ள உங்கள் சொந்த application-இலிருந்து API-ஐ call செய்தால், இதில் எதுவுமே இலவசமாகக் கிடைக்காது. தாங்களே தங்களுக்கு உண்டாக்கிக்கொள்ளும் ஒரு பழைய பிழை என்னவென்றால், system prompt-இல் ஒரு timestamp அல்லது request ID-ஐ interpolate செய்வது தான். இது ஒவ்வொரு request-லும் prefix bytes-ஐ மாற்றிவிடுகிறது. caching-ஐ மௌனமாக disable செய்துவிடுகிறது. அதன் அறிகுறி என்னவென்றால், ஒரே மாதிரியாகத் தெரியும் calls-இல் 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 நிலவரப்படி ஒரு மில்லியன் உள்ளீட்டு token-களுக்கு $5 மற்றும் ஒரு மில்லியன் வெளியீட்டு token-களுக்கு $25. ஒரு நடு-அமர்வு சுற்றில் 80,000 token-கள் திரண்ட சூழல் உள்ளது: 75,000 cache-இலிருந்து படிக்கப்பட்டவை, 3,000 புதிதாக எழுதப்பட்டவை, 2,000 cache செய்யப்படாத புதிய உள்ளீடு, 1,500 வெளியீட்டு token-கள் (thinking உட்பட).

• Cache படிப்புகள்: 75,000 × $0.50/M = $0.0375
• Cache எழுத்துகள்: 3,000 × $6.25/M = $0.019
• Cache செய்யாத உள்ளீடு: 2,000 × $5/M = $0.010
• வெளியீடு: 1,500 × $25/M = $0.0375

இந்தச் சுற்றுக்கு ஏறக்குறைய $0.10; இது போன்ற ஐம்பது சுற்றுகள் ஏறக்குறைய $5. இப்போது cache காலாவதியான பிறகு அதே சுற்று: முழு 80,000 token-களும் $6.25/M விகிதத்தில் மீண்டும் எழுதப்பட்டால் வெளியீட்டுக்கு முன்பே $0.50 ஆகும் — ஒரே வேலைக்கு, முழு வெப்பமான சுற்றை விட ஏறக்குறைய ஐந்து மடங்கு. அந்த இடைவெளிதான் ஒரே ஒரு எண்ணில் முழு cache-யின் கதையும்.

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

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

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

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

மேற்கூறிய காரணத்தால் tiktoken செய்ய வேண்டாம்.

சந்தாத் திட்டங்கள் மற்றும் பயன்பாட்டளவுக் கட்டணம் ஒப்பீடு

இந்த வழிகாட்டியில் உள்ள இயங்கமைப்பு எங்கும் ஒன்றே; வேறுபடுவது கட்டண வசூல் முறை மட்டுமே. API key வழியாக Anthropic பயன்பாட்டளவுக் கட்டணம் வசூலிக்கிறது — ஒரு token க்கு வெளியிடப்பட்ட விகிதத்தில் கட்டணம் வசூலிக்கப்படுகிறது; மேலே உள்ள ஒவ்வொரு எண்ணும் உண்மையான பணம்தான். 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 மூலம் நிர்வகிக்கலாம். நான் வேண்டுமென்றே திட்ட ஒதுக்கீடுகளை அச்சிட மாட்டேன்: அவை இந்தத் தலைப்பின் மிக மாறும் எண்கள், எனவே claude.com/pricing மற்றும் உங்கள் சொந்த /usage பட்டைகளைச் சரிபார்க்கவும். Token இயங்கமைப்பு சந்தாவிலும் முக்கியம் — வீணான ஒரு அமர்வு உங்கள் சாளரத்தை அதேபோல டாலர்களை எரிப்பதுபோல எரிக்கும். சந்தா பக்கத்திற்கு, உங்கள் பயன்பாட்டிற்கு ஏற்ற Claude திட்டம் எது ஐப் பார்க்கவும்.

உண்மையில் செயல்படும் கட்டுப்பாட்டு நெம்புகோல்கள்

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

FAQ

Claude Code-ல் ஒரு கோடிங் செஷன் எத்தனை டோக்கன்களைப் பயன்படுத்துகிறது?

நிலையான எண்ணிக்கை இல்லை — கோப்புகளும் வரலாறும் திரண்டவுடன், ஒரு சாதாரண மத்திய-செஷன் முறை பதினாயிரக்கணக்கான ப்ராம்ப்ட் டோக்கன்களைக் கொண்டிருக்கும். ஒரு வேலை செஷன் பல மில்லியன் டோக்கன்களை எட்டும். அவற்றில் பெரும்பாலானவை கேஷ்ஷிலிருந்து, அடிப்படை விகிதத்தில் பத்தில் ஒரு பங்கு விலைக்கு சேவை செய்யப்படுகின்றன. அளவீட்டுக்காக, ஜூலை 2026 நிலவரப்படி Anthropic-ன் வெளியிடப்பட்ட என்டர்பிரைஸ் புள்ளிவிவரங்கள், ஒரு டெவலப்பருக்கு ஒரு செயல்படும் நாளைக்கு சராசரியாக $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-உடன் அல்ல.