Claude Input vs Output Tokens கட்டண வேறுபாடு
Claude-ல் Output tokens கட்டணம் Input tokens-ஐ விட ஐந்து மடங்கு. Prefill ஒருமுறையும் decoding ஒவ்வொரு token-க்கும் நடப்பதால், agent bill எவ்வாறு மாறும் என்பதை அறியுங்கள்.
Output tokens-க்கான செலவு, input tokens-ஐ விட ஏன் அதிகம்
தற்போதைய Claude model catalogue-ல், ஒவ்வொரு model-க்கும் output tokens-ன் விலை input tokens-ன் விலையை விட 5 மடங்கு அதிகம். இதற்குக் காரணம் computation நடைபெறும் முறை. ஒரு prompt-ஐப் படிக்கும்போது model அதை ஒரே pass-ல் செயல்படுத்துகிறது. Reply-ஐ எழுதும்போது ஒவ்வொரு token-க்கும் ஒரு pass தேவைப்படுகிறது; ஒவ்வொரு pass-உம் அதற்கு முந்தைய pass முடியும் வரை காத்திருக்க வேண்டும்.
Price list-ன் ஒவ்வொரு row-விலும் இந்த விகிதம் ஒரே மாதிரியாக உள்ளது. எனவே, நீங்கள் தேர்ந்தெடுக்கும் model உங்கள் bill-ல் output-க்குச் செல்லும் பங்கை மாற்றாது. அதைத் தீர்மானிப்பது உங்கள் workload-ன் அமைப்பாகும். 60,000 tokens-ஐப் படித்து 800 tokens-ல் பதிலளிக்கும் agent step-ல் output செலவு மிகக் குறைவு. 2,000 tokens-ஐப் படித்து 12,000 tokens-ஐ எழுதும் drafting job-ல் input செலவு மிகக் குறைவு. இந்த இரண்டு நிலைகளும் Anthropic வெளியிட்ட rates-ஐ அடிப்படையாகக் கொண்டு கீழே கணக்கிடப்பட்டுள்ளன; இந்த rates 27 October 2026 அன்று சரிபார்க்கப்பட்டன.
Prefill ஒரு முறை இயங்கும்; decoding ஒவ்வொரு token-க்கும் ஒரு முறை இயங்கும்
ஒரு inference server, ஒரு request-ஐ வெவ்வேறு செலவுகளைக் கொண்ட இரண்டு கட்டங்களில் கையாளும். Prefill, prompt-ஐ வாசிக்கும். Decoding, reply-ஐ உருவாக்கும்.
Prefill, முழு prompt-ஐ ஒரே நேரத்தில் கையாளும். ஒவ்வொரு prompt token-உம் ஒரே forward pass-ல் network-க்குள் செல்கிறது. எனவே attention மற்றும் feed-forward பணிகள், ஒரே நேரத்தில் ஆயிரக்கணக்கான tokens-ஐ கையாளும் சில பெரிய matrix multiplications-ஆக மாறுகின்றன. Model weights-ஐ memory-யிலிருந்து ஒரு முறை வாசித்தாலே முழு prompt-க்கும் அது போதுமானது. Accelerator-ன் matrix units தொடர்ந்து busy-ஆக இருக்கும். இதனால் prefill பொதுவாக compute-bound ஆகும். வரம்பு, chip எவ்வளவு வேகமாக multiplication செய்ய முடியும் என்பதாகும். NVIDIA-ன் serving documentation இரண்டு விதிவிலக்குகளை குறிப்பிடுகிறது: மிகவும் குறுகிய prefills, மற்றும் நீண்ட prefix ஏற்கனவே cache hit ஆக இருக்கும் prefills ஆகியவை memory-bound ஆக மாறும்.
சாதாரண decoding இதே முறையில் இயங்க முடியாது. காரணம், token 2 என்பது token 1-ஐ சார்ந்தது. Model இப்போது உருவாக்கிய token, அடுத்த step-ன் input-ன் ஒரு பகுதியாகிறது. எனவே steps ஒன்றன்பின் ஒன்றாக இயங்கும். ஒவ்வொரு output token-க்கும் தனித்தனி forward pass தேவைப்படும். ஒவ்வொரு pass-உம் ஒரே token-ஐ உருவாக்க, model weights-ன் முழுத் தொகுப்பையும், KV cache-ஐயும் high-bandwidth memory-யிலிருந்து வாசிக்கும். KV cache என்பது இதுவரை உருவாக்கப்பட்ட ஒவ்வொரு token-க்கும் சேமிக்கப்பட்ட attention state ஆகும். இதனால் decoding பொதுவாக memory-bound ஆகும். வரம்பு, weights மற்றும் cached state-ஐ எவ்வளவு வேகமாக நகர்த்த முடியும் என்பதாகும்; அவற்றை எவ்வளவு வேகமாக multiply செய்ய முடியும் என்பதல்ல. நீண்ட contexts-ல் KV cache reads தான் bottleneck என்று NVIDIA குறிப்பாகச் சொல்கிறது. Prefill-ன் போது முழு prompt-ஐ கையாள பயன்படுத்தப்பட்ட அதே weight traffic, decoding-ன் போது ஒரு token-ஐ மட்டுமே உருவாக்குகிறது.
Speculative decoding, இந்த விதியை மீறாமல் அதன் தாக்கத்தைக் குறைக்கிறது. ஒரு சிறிய draft model, அடுத்தடுத்த பல tokens-ஐ முன்கணிக்கிறது. பெரிய model, அவற்றை ஒரே pass-ல் parallel-ஆகச் சரிபார்க்கிறது. இதனால் decode, compute-bound பக்கம் நகரக்கூடும் என்று NVIDIA கூறுகிறது. பெரிய model, அந்த முன்கணிப்புகளை வரிசைப்படி ஏற்றுக்கொள்ளும். முதல் தவறான token-இல் அது நிறுத்தும். எனவே நீண்ட reply-க்கு இன்னும் பல passes தேவைப்படும்.
Serving systems, batching மூலம் இந்தச் சிக்கலைக் குறைக்கின்றன. பல requests ஒன்றாக decode செய்யப்படுகின்றன. எனவே weights-ஐ ஒரு முறை வாசிப்பதன் மூலம் batch-ல் உள்ள ஒவ்வொரு request-க்கும் ஒரு token உருவாக்கப்படுகிறது. Decoding நடைமுறையில் ஏற்றுக்கொள்ளத்தக்கதாக இருப்பதற்கான காரணம் இதுவே. இங்கும் ceiling memory-யே. செயல்பாட்டில் உள்ள ஒவ்வொரு request-மும் தனக்கென ஒரு KV cache-ஐ வைத்திருக்கும். உருவாக்கப்படும் ஒவ்வொரு token-உடனும் அந்த cache பெரிதாகும். அது accelerator-ன் memory-யை நிரப்பியதும் batch மேலும் பெரிதாக முடியாது.
இவை எதுவும் உங்களுக்கு exact number-ஐ வழங்காது. 5x என்பதை measured hardware ratio என்று கருதக்கூடாது. இது Anthropic நிர்ணயித்த ஒரு price; இந்த asymmetry-யை அடிப்படையாகக் கொண்டு அது அமைக்கப்பட்டுள்ளது. நீங்களே சரிபார்க்கக்கூடியது அதன் direction மட்டுமே. அதற்கு சுமார் ஒரு நிமிடம் போதும்.
Input மற்றும் output இடையிலான இடைவெளியை நீங்களே அளவிடுங்கள்
எந்த Ubuntu box-லாவது இந்த tools-ஐ install செய்யவும்:
sudo apt update && sudo apt install -y curl jq moreutilsஇப்போது நீண்ட பதிலை கேட்கும் ஒரு குறுகிய prompt-ஐ stream செய்து, வரும் ஒவ்வொரு line-க்கும் அது வந்த நேரத்தைப் பதிவு செய்யவும்.
curl -sN https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{"model":"claude-sonnet-5","max_tokens":1000,"stream":true,
"messages":[{"role":"user","content":"Count from 1 to 300, one number per line."}]}' \
| ts -s '%.s'ts -s ஒவ்வொரு line-க்கும் command தொடங்கியதிலிருந்து கடந்த seconds-ஐ prefix ஆகச் சேர்க்கிறது. அந்த output-லிருந்து இரண்டு விஷயங்களை கவனிக்கலாம். முதல் content_block_delta line என்பது first token வருவதற்கான நேரம்; prefill முழுவதும் அதற்குள் நடந்துவிடுகிறது. அதற்குப் பிறகு வரும் ஒவ்வொரு line-மும் decoding-ன் ஒரு சிறிய step. message_stop வரும் வரை time stamps தொடர்ந்து அதிகரிக்கும்.
இப்போது இந்த அமைப்பை மாற்றிப் பாருங்கள். Prompt-ல் ஒரு நீண்ட document-ஐ வைத்து, பதிலை சில tokens-க்கு வரம்புபடுத்தவும்.
curl -sN https://api.anthropic.com/v1/messages \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d "$(jq -n --rawfile doc ./long-document.txt \
'{model:"claude-sonnet-5", max_tokens:16, stream:true,
messages:[{role:"user", content:("Answer in one word. Is this document about networking?\n\n" + $doc)}]}')" \
| ts -s '%.s'Short prompt-ஐ பயன்படுத்தியதைவிட முதல் delta அதிக நேரம் எடுக்கிறது. காரணம், prefill செய்ய இன்னும் அதிகமான text-ஐ படிக்க வேண்டும். அது வந்ததும் response கிட்டத்தட்ட உடனே முடிந்துவிடுகிறது. காரணம், decode செய்ய சில tokens மட்டுமே மீதமிருக்கின்றன. Tens of thousands of tokens உள்ளே சென்றாலும் clock மிகக் குறைவாகவே நகர்ந்தது. சில hundred tokens வெளியே வந்தாலும் clock முழு நேரமும் இயங்கியது.
Streaming இல்லாத ஒவ்வொரு response-ன் முடிவிலும், உங்களிடம் bill செய்யப்படும் numbers இருக்கும்.
{
"usage": {
"input_tokens": 41283,
"output_tokens": 6,
"cache_creation_input_tokens": 0,
"cache_read_input_tokens": 0
}
}ஒவ்வொரு request-க்கும் இந்த நான்கு fields-ஐ log செய்யவும். output_tokens thinking tokens-ஐயும் உள்ளடக்குகிறது. எனவே பதிலளிப்பதற்கு முன் model சிந்தித்தால், அந்த thinking output rate-ல் bill செய்யப்படும். Prompt-ஐ அனுப்புவதற்கு முன் அதன் விலையை கணக்கிட, பெரும்பாலான requests-க்கு POST /v1/messages/count_tokens அதே request body-ஐ ஏற்றுக்கொள்கிறது. Model-ஐ இயக்காமல் {"input_tokens": N}-ஐ estimate ஆகத் திருப்பி அளிக்கிறது. அதன் சொந்த rate limit-க்குள் இது free. Messages API ஏற்றுக்கொள்ளும் சில request bodies-ஐ இது ஏற்காது. அவற்றில் web search போன்ற பெரும்பாலான server tools, MCP connector, மேலும் url அல்லது file source கொண்ட image அல்லது document blocks ஆகியவை அடங்கும். எனவே அவற்றை எண்ணும்போது images மற்றும் PDFs-ஐ base64 ஆக அனுப்பவும். API-யில் கட்டணம் இல்லாத ஒரே பகுதி இதுவல்ல. முதல் project-க்கு budget அமைப்பதற்கு முன், Claude API-யில் எந்தப் பகுதிகளுக்கு உங்களிடம் ஒருபோதும் bill செய்யப்படாது என்பதை சரிபார்ப்பது பயனுள்ளதாக இருக்கும்.
October 2026 நிலவரப்படி ஒரு million tokens-க்கு Claude வசூலிக்கும் கட்டணம்
இந்த விளக்கப்படத்தின் தரவு
[
{
"label": "Haiku 4.5",
"input_usd": 1,
"output_usd": 5,
"output_multiple": 5
},
{
"label": "Sonnet 5",
"input_usd": 2,
"output_usd": 10,
"output_multiple": 5
},
{
"label": "Opus 5",
"input_usd": 5,
"output_usd": 25,
"output_multiple": 5
},
{
"label": "Fable 5",
"input_usd": 10,
"output_usd": 50,
"output_multiple": 5
}
]கடைசி column-ல் output-ஐ input-ஆல் வகுத்த மதிப்பு உள்ளது; ஒவ்வொரு row-லும் அது 5 எனக் காட்டப்படுகிறது. Haiku 4.5, input-க்கு $1 மற்றும் output-க்கு $5 வசூலிக்கிறது. Opus 5, input-க்கு $5 மற்றும் output-க்கு $25 வசூலிக்கிறது. அதிக விலை கொண்ட Fable 5, input-க்கு $10 மற்றும் output-க்கு $50 வசூலிக்கிறது. அந்த உயர்ந்த row-ஐ நிராகரிப்பதற்கு முன் அந்த Fable 5 கட்டணங்கள் உங்களுக்கு என்ன வழங்குகின்றன என்பதை படிப்பது பயனுள்ளதாக இருக்கும். இந்த range-ல் மேலே செல்லும்போது இரு பக்கங்களும் ஒரே factor-ஆல் பெருகுகின்றன. எனவே மொத்தக் கட்டணம் மாறும்; ஆனால் input மற்றும் output இடையிலான விகிதம் அப்படியே இருக்கும்.
Sonnet 5, input-க்கு $2 மற்றும் output-க்கு $10 வசூலிக்கிறது. Anthropic இதை 31 August 2026 வரை introductory pricing ஆக அந்தக் கட்டணத்தில் வெளியிட்டது. 1 September அன்று $3 மற்றும் $15 ஆக உயர்த்த திட்டமிடப்பட்டிருந்தது. பின்னர் $2 மற்றும் $10 standard price ஆக நிர்ணயிக்கப்பட்டது. அந்த உயர்வு அமலுக்கு வரவில்லை. எனவே கீழே உள்ள ஒவ்வொரு worked example-லும் இன்று நீங்கள் செலுத்தும் rate பயன்படுத்தப்பட்டுள்ளது.
இந்த page முதலில் வெளியான பிறகு Anthropic புதிய models-ஐயும் வெளியிட்டுள்ளது. இப்போது claude.com/pricing மேலே குறிப்பிடப்பட்ட நான்கு models-ஐ available-ஆக இருந்தாலும் legacy models எனப் பட்டியலிடுகிறது. புதிய models அதே 5x ratio-ஐத் தொடர்கின்றன. Opus 5.5, $4 மற்றும் $20 வசூலிக்கிறது. Sonnet 5.5, $2 மற்றும் $10 வசூலிக்கிறது. Fable 5.1, $10 மற்றும் $50 வசூலிக்கிறது. Haiku 5.5, 100,000 tokens வரையிலான prompts-க்கு $0.10 மற்றும் $0.50 வசூலிக்கிறது; அதற்கு மேல் $0.50 மற்றும் $2.50 ஆக உயர்கிறது. கீழே கணக்கிடப்படும் 60,000 token agent step அந்த வரம்புக்குள் வருகிறது. ஆனால் agent-ன் history தொடர்ந்து பெருகினால், அது இறுதியில் அந்த வரம்பைக் கடக்கும். Haiku 5.5-ன் இரண்டு price tiers உண்மையான jobs-ல் எவ்வாறு செயல்படுகின்றன என்பதை பார்த்தால், அந்த உயர்வு bill-ஐ எவ்வாறு மாற்றுகிறது என்பதை அறியலாம். Opus 5.5-ன் base input மற்றும் output rates, Opus 5-ஐ விட 20% குறைவு. எனவே கீழே உள்ள uncached Opus 5 figures அனைத்தும் Opus 5.5-ல் 20% குறைவாக இருக்கும். Cached figures இன்னும் குறையும். Opus 5.5, cache hits-ஐ ஒரு million tokens-க்கு $0.20 என்ற rate-ல் படிக்கிறது; Opus 5-ல் இது $0.50, அதாவது 60% குறைவு. கீழே Opus 5-ல் $0.0725 செலவாகும் cached agent step, Opus 5.5-ல் சுமார் $0.047 ஆகும். இது சுமார் 35% குறைவு.
Rates மாறக்கூடும். அவற்றைச் சரிபார்க்க இந்த page-ஐ பயன்படுத்த வேண்டாம். claude.com/pricing தான் அதிகாரப்பூர்வ source of truth. Price மாற்றத்துக்குப் பிறகும் நிலைத்திருப்பது method மட்டுமே.
ஒரு caveat, rates-ல் அல்லாமல் Anthropic-ன் price table-க்கு கீழுள்ள notes-ல் உள்ளது. Sonnet 4.6 மற்றும் அதற்கு முந்தைய models-ல் பயன்படுத்தப்படும் tokenizer-ஐ விட, Claude 4.7 மற்றும் அதற்குப் பிந்தைய models பயன்படுத்தும் புதிய tokenizer, அதே text-க்கு சுமார் 30% அதிக tokens உருவாக்கும் என Anthropic-ன் pricing page கூறுகிறது. ஒரு million tokens-க்கான விலையை மட்டும் வைத்து இரண்டு models-ஐ ஒப்பிட்டால், புதிய model சாதகமாகத் தோன்றும். காரணம், அதே document-ல் அதற்கு அதிக tokens தேவைப்படும். Finished task-க்கான cost அடிப்படையில் ஒப்பிடுங்கள். நீங்கள் உண்மையில் பயன்படுத்தத் திட்டமிடும் model-க்கு எதிராக உங்கள் real prompts-ன் அளவை கணக்கிடுங்கள். Providers இடையிலும் இதே பிரச்சினை உள்ளது; அவற்றின் tokenizers ஒன்றுக்கொன்று வேறுபடும். எனவே Claude மற்றும் ChatGPT இரண்டிலும் ஒரு உண்மையான job-ன் cost-ஐ கணக்கிடுவது, இரண்டு rate cards-ஐ அருகருகே வைப்பதைவிட அதிக தகவலை வழங்கும். ஒரு million Claude tokens உண்மையான text-ல் எவ்வளவு மதிப்புடையது என்பதை நடைமுறை அளவில் விளக்குகிறது.
எப்போது output செலவு உங்கள் bill-ல் முக்கியமாகிறது?
output-க்கு input-ஐ விட 5 மடங்கு விலை நிர்ணயிக்கப்பட்டால், break-even கணக்கை எளிதாக நினைவில் வைத்துக்கொள்ளலாம். உங்கள் input tokens-ஐ I என்றும், output tokens-ஐ O என்றும் குறிப்பிடலாம். Input செலவு I ஆகும். Output செலவு 5 times O ஆகும். 5 times O, I-ஐ விட அதிகமாக இருக்கும்போது, உங்கள் மொத்த செலவில் output பாதிக்கும் மேல் ஆகிறது. இதற்கான token ratio, 5 input to 1 output ஆகும்.
அதனால், உங்கள் prompt, reply-ஐ விட ஐந்து மடங்குக்கும் அதிகமாக நீளமாக இருந்தால், input செலவுதான் அதிகமானது. அதற்கு கீழே இருந்தால், output செலவு அதிகமாகும்.
இந்த விளக்கப்படத்தின் தரவு
[
{
"label": "100:1",
"input_share_pct": 95.2,
"output_share_pct": 4.8
},
{
"label": "75:1",
"input_share_pct": 93.75,
"output_share_pct": 6.25
},
{
"label": "20:1",
"input_share_pct": 80,
"output_share_pct": 20
},
{
"label": "10:1",
"input_share_pct": 66.7,
"output_share_pct": 33.3
},
{
"label": "5:1",
"input_share_pct": 50,
"output_share_pct": 50
},
{
"label": "1:1",
"input_share_pct": 16.7,
"output_share_pct": 83.3
},
{
"label": "1:6",
"input_share_pct": 3.2,
"output_share_pct": 96.8
}
]100 to 1 என்ற ratio-ல், மொத்த செலவில் output 4.8% ஆகும். எனவே prompt-ஐச் சுருக்குவது மட்டுமே பயனுள்ள நடவடிக்கையாகும். 5 to 1 என்ற ratio-ல், இரண்டு செலவுப் பகுதிகளும் சமமாக இருக்கும். 1 to 6 என்ற ratio-ல், output 96.8% ஆகும்; prompt செலவு rounding error அளவுக்கு மட்டுமே இருக்கும். பெரும்பாலானவர்கள் தங்களுடைய ratio-ஐ தவறாக மதிப்பிடுகிறார்கள். எனவே எதையும் optimize செய்வதற்கு முன், உங்கள் logs-லிருந்து அந்த ratio-ஐ பெறுங்கள்.
ஏஜென்ட் பணிச்சுமை: நீண்ட உள்ளீடு, சுருக்கமான வெளியீடு
ஒரு retrieval agent செயல்பாட்டை எடுத்துக்கொள்வோம்: 60,000 tokens அளவுள்ள ஆவணங்கள் மற்றும் உரையாடல் வரலாறு உள்ளீடாக வழங்கப்பட்டு, 800 tokens அளவுள்ள பதில் பெறப்படுகிறது. இது 75-க்கு 1 என்ற விகிதமாகும்; எழுதுவதற்கு முன்பு வாசிக்கும் எந்தவொரு செயல்பாட்டிற்கும் இது இயல்பானதே.
இந்த விளக்கப்படத்தின் தரவு
[
{
"label": "Haiku 4.5",
"input_cost": 0.06,
"output_cost": 0.004,
"total_cost": 0.064
},
{
"label": "Sonnet 5",
"input_cost": 0.12,
"output_cost": 0.008,
"total_cost": 0.128
},
{
"label": "Opus 5",
"input_cost": 0.3,
"output_cost": 0.02,
"total_cost": 0.32
},
{
"label": "Fable 5",
"input_cost": 0.6,
"output_cost": 0.04,
"total_cost": 0.64
}
]ஒவ்வொரு model-லும் வெளியீடு என்பது அந்த அழைப்பின் 6.25% ஆகும், ஏனெனில் இந்த விகிதம் விலைப்பட்டியல் முழுவதும் நிலையானது. இந்த அழைப்பிற்கான கட்டணம் Opus 5-ல் $0.32, Sonnet 5-ல் $0.128, மற்றும் Haiku 4.5-ல் $0.064 ஆகும். Opus 5-ல் ஒரு நாளைக்கு இருநூறு முறை இத்தகைய செயல்பாடுகளைச் செய்தால், அதன் செலவு ஒரு நாளைக்கு $64 ஆகும்.
இந்தச் செலவுப் பிரிப்பைப் பார்த்தாலே, எங்கே சேமிக்க முடியும் என்பது தெளிவாகிவிடும். பதிலின் அளவை 800 tokens-லிருந்து 400 tokens-ஆகக் குறைப்பது, அழைப்பின் செலவில் சுமார் 3% மட்டுமே சேமிக்கும். ஆனால், prompt-லிருந்து 20,000 tokens அளவுள்ள தேவையற்ற context-ஐ நீக்குவது, செலவில் மூன்றில் ஒரு பங்கைச் சேமிக்கும். வாசிப்பு அதிகம் தேவைப்படும் ஏஜென்ட் செயல்பாடுகளில், வெளியீட்டு அளவைக் குறைப்பது பெரிய பலனைத் தராது. coding agent-ன் tokens எங்கே செலவாகின்றன என்பது, அந்த prompt-ஐ நிரப்பும் காரணிகளை விரிவாக விளக்குகிறது.
Generation workload: short prompt, long draft
இப்போது மாறுபட்ட வடிவைப் பார்ப்போம். 2,000 token கொண்ட brief மற்றும் 12,000 token கொண்ட draft; விகிதம் 1 முதல் 6.
இந்த விளக்கப்படத்தின் தரவு
[
{
"label": "Haiku 4.5",
"input_cost": 0.002,
"output_cost": 0.06,
"total_cost": 0.062,
"batch_total_cost": 0.031
},
{
"label": "Sonnet 5",
"input_cost": 0.004,
"output_cost": 0.12,
"total_cost": 0.124,
"batch_total_cost": 0.062
},
{
"label": "Opus 5",
"input_cost": 0.01,
"output_cost": 0.3,
"total_cost": 0.31,
"batch_total_cost": 0.155
},
{
"label": "Fable 5",
"input_cost": 0.02,
"output_cost": 0.6,
"total_cost": 0.62,
"batch_total_cost": 0.31
}
]இந்த bill-ன் 96.8% பகுதி output ஆகும். Opus 5-ல் ஒவ்வொரு draft-க்கும் $0.31 செலவாகிறது; Haiku 4.5-ல் இது $0.062. இந்த ஐந்து மடங்கு வித்தியாசம் பெரும்பாலும் output பகுதியால் ஏற்படுகிறது. எனவே குறைந்த விலை model அதிகமாகச் சேமிப்பை வழங்குவது இதில்தான்.
கடைசி column-ல் அதே workload Batch API மூலம் காட்டப்பட்டுள்ளது. இதில் input மற்றும் output இரண்டிற்கும் 50% குறைப்பு கிடைக்கும். Opus 5-ன் விலை draft ஒன்றுக்கு $0.155 ஆகக் குறையும். Batch உடனடி முடிவை வழங்காது; இது asynchronous முறையில் செயல்படும். பெரும்பாலான batches ஒரு மணி நேரத்திற்குள் முடியும் என்று Anthropic கூறுகிறது. ஆனால் 24 மணி நேரத்திற்குப் பிறகும் processing நிலையில் இருக்கும் batch expire ஆகும். அதற்குள் process செய்யப்படாத requests expired நிலையில் திரும்பும்; அவற்றுக்கு bill விதிக்கப்படாது, message-உம் வழங்கப்படாது. எனவே overnight report generation மற்றும் bulk classification போன்ற பணிகளுக்கு இது பொருத்தமானது. Expire ஆகும் requests-க்கு resubmit step தேவைப்படும். ஒருவர் காத்திருக்க வேண்டிய எந்தப் பணிக்கும் இது பொருத்தமல்ல.
Agent step-ல் கிடைக்காத பயன், இங்கு model routing மூலம் கிடைக்கிறது. Workload-ன் verbose பகுதி mechanical ஆக இருந்தால், ஏற்கனவே approve செய்த outline-ஐ reformat செய்வது அல்லது விரிவாக்குவது போன்ற பணிகளுக்கு cheap model அந்த tokens-ஐ ஐந்தில் ஒரு பங்கு விலையில் உருவாக்கும். Opus, Sonnet மற்றும் Haiku இடையே தேர்வு செய்தல் quality line உண்மையில் எங்கு உள்ளது என்பதை விளக்குகிறது.
Caching, input செலவை மட்டும் குறைக்கும்
Prompt caching, உங்கள் prompt-ன் ஒரு prefix-ஐ server-ல் சேமிக்கிறது. அதை மீண்டும் படிக்கும்போது, input rate-ன் ஒரு பகுதி மட்டுமே கட்டணமாக வசூலிக்கப்படுகிறது. 27 October 2026 நிலவரப்படி, இந்தப் பக்கத்தில் விலை குறிப்பிடப்பட்டுள்ள models-க்கு 5 minute cache எழுதுவதற்கான multiplier base input rate-ன் 1.25x ஆகும். 1 hour cache எழுதுவதற்கு அது 2x ஆகும். Cache hit-ஐ படிப்பதற்கு அது 0.1x ஆகும். புதிய models-ல் read hit செலவு இன்னும் குறைவு: Opus 5.5 மற்றும் Sonnet 5.5-க்கு 0.05x; Fable 5.1-க்கு 0.025x.
Output இந்த சலுகையில் சேராது. Cached output என்ற ஒன்று இல்லை. Model எழுதும் ஒவ்வொரு token-க்கும், ஒவ்வொரு முறையும், முழு output rate-படி கட்டணம் வசூலிக்கப்படும். Prompt-ன் எவ்வளவு பகுதி cache hit ஆகத் திரும்பினாலும் இது மாறாது.
55,000 input tokens-களில் 60,000 tokens warm cache-ல் இருந்து வழங்கப்படும் நிலையில், Opus 5-ல் அதே agent step-ஐ எடுத்துக்கொள்ளுங்கள்.
இந்த விளக்கப்படத்தின் தரவு
[
{
"label": "No cache",
"input_cost": 0.3,
"output_cost": 0.02,
"total_cost": 0.32
},
{
"label": "55k prefix cache read",
"input_cost": 0.0525,
"output_cost": 0.02,
"total_cost": 0.0725
}
]Call செலவு $0.32-லிருந்து $0.0725 ஆகக் குறைகிறது. Output வரியில் மாற்றமில்லை: முன்பு $0.02, பின்னர் $0.02. Caching bill-ஐக் குறைப்பதுடன், அதன் செலவு அமைப்பையும் மாற்றுகிறது. அந்த call-ன் 6.25% output ஆக இருந்தது. இப்போது அது call-ன் கால் பங்குக்கும் அதிகமாக உள்ளது. எனவே அடுத்து எந்த செலவுக் கட்டுப்பாட்டு வழிமுறையைப் பயன்படுத்துவது என்பதும் மாறுகிறது.
முதல் call-ல் write செலவு வசூலிக்கப்படும். 5 minute cache write-க்கு base input-ன் 1.25x செலவாகும். எனவே ஒரே ஒரு hit-க்குப் பிறகு அதன் செலவு ஈடாகிவிடும். 1 hour write-க்கு 2x செலவாகும். எனவே அதற்கு இரண்டு hits தேவை. write மற்றும் read multipliers, மேலும் caching எப்போது பயனளிக்காமல் நிற்கிறது என்ற பகுதியில் இந்தக் கணக்கு விளக்கப்பட்டுள்ளது.
நீங்கள் கட்டுப்படுத்தும் நான்கு வழிகள்
max_tokens-ஐ model maximum-ல் அல்ல, உங்கள் p95 output length-ல் அமைக்கவும்.- அதிக விளக்கமான படிகளை குறைந்த செலவுள்ள model-க்கு route செய்யவும்.
- யாரும் காத்திருக்காத பணிகளை batch செய்யவும்.
- பதில்களை நீளமாக்கும் instructions-ஐ நீக்கவும்.
max_tokens என்பது கடுமையான உச்சவரம்பு. இதை உயரமாக அமைத்தாலும் மட்டும் செலவு ஏற்படாது; உருவாக்கப்பட்ட tokens-க்கே கட்டணம் செலுத்த வேண்டும், அந்த உச்சவரம்புக்கு கட்டணம் இல்லை. அதிகமான cap செய்வது, தவறாக நீளும் பதிலுக்கு இருந்த வரம்பை நீக்குகிறது. உங்கள் logs-லிருந்து output_tokens distribution-ஐ பெறவும். cap-ஐ 95th percentile-ஐ விட சற்று அதிகமாக அமைக்கவும். stop_reason: "max_tokens"-ஐ code-ல் கையாளவும்: response-ஐ தொடர்ந்து பெறவும் அல்லது retry செய்யவும். நீங்கள் கண்டறியும் truncation-க்கு ஆகும் செலவு, கட்டணம் செலுத்தி பின்னர் தூக்கி எறியும் 4,000 token நீளமான பதிலைவிட குறைவு. Thinking-உம் output_tokens-ல் சேர்ந்து max_tokens-க்கு எதிராகக் கணக்கிடப்படுகிறது. எனவே அதே ஆதாரத்தின் அடிப்படையில் cap-ஐ அமைக்கவும். Adaptive thinking கொண்ட models-ல் thinking தொடர்ந்து reply-ஐ அதிகமாக எடுத்துக்கொண்டால் effort level-ஐக் குறைக்கவும்.
ஒரு படியின் அதிக செலவு judgement-ல் அல்ல, volume-ல் இருக்கும்போது routing பயனுள்ளதாக இருக்கும். முடிவெடுப்பதற்கு வலுவான model-ஐ வைத்திருக்கவும். எழுதும் பணியை குறைந்த செலவுள்ள model-க்கு ஒப்படைக்கவும். முதலில் உங்கள் சொந்த evaluation set-ல் routed version-ஐ அளவிடவும். ஏனெனில் முக்கியமான அளவுகோல் முடிக்கப்பட்ட task ஒன்றுக்கான செலவாகும். மேலே உள்ள agent step-ல், இரண்டு Haiku 4.5 attempts-க்கு $0.128 செலவாகிறது. ஒரு Opus 5 attempt-க்கு $0.32 செலவாகிறது. எனவே இந்த விலை வித்தியாசம் ஒன்று அல்லது இரண்டு retry-களை ஏற்கும். ஆனால் யாரும் கண்டறியாத தவறான பதிலின் செலவை இது ஈடுசெய்யாது.
Output-க்கு discount வழங்கும் ஒரே வழி batching ஆகும். இரு பக்கங்களிலும் 50% தள்ளுபடி கிடைக்கும். பெரும்பாலான batches ஒரு மணி நேரத்திற்குள் முடிக்கப்படுகின்றன. Schedule-ல் இயங்கும் பணிகளும் தகுதி பெறுகின்றன. ஆனால் 24 hour வரம்பில் expire ஆகும் எதையும் job மீண்டும் submit செய்ய வேண்டும்.
மக்கள் தவிர்க்கும் வழி இதுவே. "be thorough" மற்றும் "explain your reasoning" போன்ற சொற்றொடர்கள், நீங்கள் செய்யும் ஒவ்வொரு call-லும் output length-ஐ அதிகரிக்கின்றன. அவற்றுக்கு பதிலாக நீங்கள் விரும்பும் வடிவத்தைத் தெளிவாகக் குறிப்பிடவும்: "Answer in at most three sentences" அல்லது "Return only the JSON object, with no preamble". ஒவ்வொரு reply-க்கும் system prompt 300 tokens சேர்த்தால், அதே 300 tokens prompt-ல் சேர்வதைவிட ஐந்து மடங்கு செலவாகும். இயங்கிக்கொண்டிருக்கும் agent-ன் செலவுகளை கட்டுப்பாட்டில் வைத்திருத்தல் monitoring பகுதியை விளக்குகிறது. மேலும், உங்கள் usage pattern-க்கு API அல்லது flat subscription எது குறைந்த செலவு என்பதைத் தீர்மானித்தல் அவசியம். Subscription ஏற்கக்கூடிய செலவை, per-token செலவை ஒரு வாரம் fine-tune செய்வதற்கு முன்பே தீர்மானித்துவிடுவது நல்லது. ஒரு developer-க்கு, இது பெரும்பாலும் Claude Pro-வின் மாதத்திற்கு $20 கட்டணமும் அதனுடன் வரும் usage limits-உம் நீங்கள் வேறு வழியில் அளவிட வேண்டிய பணியை உள்ளடக்குகிறதா என்பதிலேயே முடிகிறது. நீங்கள் ஏற்கனவே session நடுவில் அந்த limits-ஐ எட்டினால், நீங்கள் எந்த window-க்காகக் காத்திருக்கிறீர்கள் என்பதைத் தீர்மானித்தல் முதலில் செய்ய வேண்டியது. அதன் பிறகான தீர்வு சிறிய model, குறைந்த context, கூடுதல் usage credits, அல்லது அந்தப் பணியை metered API-க்கு மாற்றுதல் ஆகியவற்றில் ஒன்றாக இருக்கும். Metered API அந்தப் பணிக்கு குறைந்த செலவுள்ள வழி எனத் தெரிய வந்தால், சிறிய plan-க்கு மாறுதல் அல்லது அதை cancel செய்தல் ஏற்கனவே நீங்கள் செலுத்திய மாதத்தைப் பாதிக்காது. எனவே வெளியேறும் போது switch செய்வதற்கான கூடுதல் செலவு இல்லை. நீங்கள் Pro-வை metered API-க்கு பதிலாக ChatGPT-ன் plan-உடன் ஒப்பிடுகிறீர்கள் என்றால், இரண்டு subscription ladders-ஐ அருகருகே விலையிடுதல் coding பணிக்கு எது குறைந்த செலவாகிறது என்பதை காட்டுகிறது. இந்தக் கேள்வி ஒரு developer-க்காக அல்ல, team-க்காகக் கேட்கப்பட்டால், Claude Enterprise ஒவ்வொரு seat-க்கான கட்டணத்தையும் இதே API rates-ல் அளவிடப்படும் tokens-உடன் இணைக்கிறது என்பதை நினைவில் கொள்ளவும். எனவே இந்தப் பக்கத்தில் உள்ள ஒவ்வொரு வழியும் அந்த bill-ன் metered பகுதியிற்கும் பொருந்தும்.
FAQ
Output tokens, input tokens-ஐ விட ஏன் அதிகமாக செலவாகின்றன?
ஒவ்வொரு token-ஐ உருவாக்குவதற்கு accelerator நேரம் அதிகமாக தேவைப்படுகிறது. Prompt முழுவதும் ஒரே forward pass-ல் process செய்யப்படுவதால், model weights-ஐ ஒருமுறை வாசிப்பதன் மூலம் ஆயிரக்கணக்கான tokens கையாளப்படுகின்றன. எனவே hardware பொதுவாக multiply throughput-ஆல் வரையறுக்கப்படுகிறது. சாதாரண decoding-ல் reply ஒரு நேரத்தில் ஒரு token வீதம் உருவாக்கப்படுகிறது. ஒவ்வொரு token-க்கும் தனித்தனி forward pass தேவைப்படுகிறது; இதில் model weights மற்றும் அதிகரித்துக் கொண்டிருக்கும் KV cache மீண்டும் வாசிக்கப்படுகின்றன. எனவே hardware பொதுவாக memory bandwidth-ஆல் வரையறுக்கப்படுகிறது. Speculative decoding போன்ற techniques இந்த இடைவெளியைக் குறைக்கின்றன; ஆனால் முற்றிலும் நீக்குவதில்லை. Haiku 5.5 முதல் Fable 5.1 வரை உள்ள தற்போதைய முழு catalogue-லும், Anthropic output-க்கு input-ஐ விட 5 மடங்கு விலை நிர்ணயிக்கிறது.
Prompt caching செய்தால் output tokens மலிவாகுமா?
இல்லை. Prompt caching input-க்கு மட்டும் பொருந்தும். 27 October 2026 நிலவரப்படி, பெரும்பாலான models-ல் cache read-க்கு base input rate-ன் 0.1x கட்டணம் வசூலிக்கப்படுகிறது. Opus 5.5 மற்றும் Sonnet 5.5-ல் இது 0.05x; Fable 5.1-ல் 0.025x. Cache write-க்கு 5 minute duration-ல் 1.25x கட்டணமும், 1 hour duration-ல் 2x கட்டணமும் வசூலிக்கப்படுகிறது. Cache என்ன செய்திருந்தாலும், ஒவ்வொரு call-லும் output முழு rate-ல் billed செய்யப்படும். அதனால் caching உங்கள் bill-ன் அளவை மட்டுமல்ல, அதன் அமைப்பையும் மாற்றுகிறது. Input பகுதி குறைந்ததும், அதிக கவனம் செலுத்த வேண்டிய பகுதி output ஆகிறது.
Reply சுருக்கமாக வந்தால், அதிக max_tokens எனக்கு கட்டணம் ஏற்படுத்துமா?
இல்லை. Model உண்மையில் உருவாக்கும் tokens-க்கே கட்டணம் வசூலிக்கப்படுகிறது. எனவே max_tokens என்பது ceiling; முன்பதிவு செய்யப்பட்ட அளவு அல்ல. இருந்தாலும் இது முக்கியமானது, ஏனெனில் கட்டுப்பாடின்றி நீளும் reply-க்கு இது மட்டுமே கடினமான வரம்பாகும். நீங்கள் கவனித்த output_tokens மதிப்புகளின் 95th percentile-ஐ விட சற்றே அதிகமாக இதை அமைக்கவும். பின்னர் அமைதியாக truncate செய்யப்பட்ட answer-ஐ வெளியிடுவதற்குப் பதிலாக, code-ல் stop_reason: "max_tokens"-ஐ கையாளவும்.
எனது input-to-output token ratio-ஐ எவ்வாறு கண்டறிவது?
ஒவ்வொரு response-ன் usage object-இலிருந்து input_tokens, output_tokens, cache_read_input_tokens மற்றும் cache_creation_input_tokens values-ஐ log செய்யவும். பின்னர் ஒரு வாரத்திற்கான மொத்தங்களை வகுக்கவும். 1 output-க்கு 5 input-ஐ விட அதிகமாக இருந்தால், உங்கள் செலவு prompt-ல் உள்ளது. எனவே நிலையான பகுதியை cache செய்து, மீதியைச் சுருக்கவும். அதற்கு குறைவாக இருந்தால், உங்கள் செலவு reply-ல் உள்ளது. எனவே அதன் நீளத்திற்கு வரம்பு அமைத்து, அதிக output உருவாக்கும் steps-ஐ மலிவான model அல்லது Batch API-க்கு மாற்றவும்.