Claude API கட்டணம் ஏன் அதிகமாக உள்ளது? கணக்கீடு இதோ

Claude ஏன் அதிகச் செலவாகிறது? சுருக்கமான பதில்

Claude அதிகச் செலவாகும் காரணங்கள் ஒன்றின் மீது ஒன்று சேரும் 4 காரணங்களாகும். Output tokens-க்கு, input tokens-ன் rate-ஐவிட 5 மடங்கு rate வசூலிக்கப்படுகிறது. API உங்கள் conversation-ஐ memory-ஆக வைத்திருக்காது. எனவே ஒவ்வொரு turn-லும் முழு history மீண்டும் அனுப்பப்பட்டு, மீண்டும் billing செய்யப்படும். ஒரு agent, ஒரு கேள்வியை dozens of API calls-ஆக மாற்றும். ஒவ்வொரு call-உம் பெரிதாகிக் கொண்டிருக்கும் அந்த history-ஐக் கொண்டிருக்கும். இதற்கு மேலாக, frontier model-ன் விலை சிறிய model-ஐ இயக்கும் செலவை அடிப்படையாகக் கொண்டதல்ல; அது செய்யும் பணியின் difficulty-ஐ அடிப்படையாகக் கொண்டது.

Token என்பது text-ன் ஒரு பகுதி. அது எவ்வளவு text-ஐக் குறிக்கிறது என்பது model-ஐப் பொறுத்தது. Opus 5, Sonnet 5, Fable 5 மற்றும் 5.1, மேலும் 5.5 model-கள் அனைத்தும் Claude 4.7 உடன் வந்த புதிய tokenizer-ஐப் பயன்படுத்துகின்றன. Anthropic கணக்குப்படி, அந்த tokens-ல் 1 million என்பது தோராயமாக 555,000 English words அல்லது 2.5 million characters ஆகும். எனவே ஒரு token என்பது சுமார் இரண்டரை characters அல்லது அரை word-ஐவிட சற்றே அதிகம். Sonnet 4.6 மற்றும் Haiku 4.5 போன்ற பழைய model-கள் முந்தைய tokenizer-ஐப் பயன்படுத்துகின்றன. அதில் ஒரு token என்பது சுமார் 3.5 English characters ஆகும்; 1 million tokens-ல் சுமார் 750,000 words அடங்கும். அதே text, புதிய model-களில் சுமார் 30 percent அதிக tokens-ஆகக் கணக்கிடப்படும். எனவே பழைய estimate-ஐ மீண்டும் பயன்படுத்தாமல், பயன்படுத்தத் திட்டமிட்டுள்ள model மூலம் அதை மீண்டும் கணக்கிடவும். Rates, million tokens-க்கு மேற்கோளிடப்படுகின்றன. அவை MTok (million tokens) என எழுதப்படுகின்றன. கீழே உள்ள ஒவ்வொரு rate-உம் October 2026 நிலவரப்படி வெளியிடப்பட்ட Claude API rate ஆகும்.

இந்தப் பட்டியலில் உள்ள 2வது மற்றும் 3வது காரணங்களிலிருந்தே பெரும்பாலான எதிர்பாராத bills உருவாகின்றன. Claude எழுதும் answers-க்குத்தான் பணம் செலவாகிறது என்று பலர் பொதுவாக நினைத்தே தொடங்குகின்றனர். ஆனால் ஒரு agent session-ல், எழுதப்படும் text பெரும்பாலும் மொத்த bill-ன் 10 percent-க்கும் குறைவாக இருக்கும்.

வெளியிடப்பட்ட rates, எனவே numbers குறித்து நாம் ஒரே கருத்தில் இருக்கிறோம்

[
  {
    "label": "Haiku 4.5",
    "input_usd": 1,
    "output_usd": 5,
    "cache_read_usd": "0.10"
  },
  {
    "label": "Sonnet 5",
    "input_usd": 2,
    "output_usd": 10,
    "cache_read_usd": "0.20"
  },
  {
    "label": "Sonnet 4.6",
    "input_usd": 3,
    "output_usd": 15,
    "cache_read_usd": "0.30"
  },
  {
    "label": "Opus 5",
    "input_usd": 5,
    "output_usd": 25,
    "cache_read_usd": "0.50"
  }
]

முழுமையான numbers-ஐ விட அவற்றின் அமைப்பைப் பாருங்கள். ஒவ்வொரு model-மும் input-ஐ விட output-க்கு சரியாக ஐந்து மடங்கு அதிகமாக வசூலிக்கிறது. Opus 5-ன் விலை, ஒரு million input tokens-க்கு 5 dollars; ஒரு million output tokens-க்கு 25 dollars. Haiku 4.5-ன் விலை 1 மற்றும் 5. எனவே, இந்த table-ல் குறைந்த விலை model-க்கும் அதிக விலை model-க்கும் இடையிலான வித்தியாசம் ஐந்து மடங்கு. அதேபோல், படிப்பதற்கும் எழுதுவதற்கும் இடையிலான வித்தியாசமும் ஐந்து மடங்கு.

Sonnet 5-ன் விலை ஒரு million-க்கு 2 மற்றும் 10 dollars. Anthropic முதலில் இந்த விலையை August 31, 2026 வரை introductory rate-ஆக வழங்கியது. பின்னர் இதையே standard price-ஆக மாற்றி, விலையை 3 மற்றும் 15 dollars ஆக உயர்த்தும் திட்டத்தை ரத்து செய்தது. Model releases-க்கு ஏற்ப rates மாறும். எனவே, அவற்றை அடிப்படையாகக் கொண்டு budget உருவாக்குவதற்கு முன் தற்போதைய rates-ஐ சரிபார்க்கவும். புதிய models-லும் இதே ஐந்து மடங்கு அமைப்பு தொடர்கிறது: Opus 5.5 ஒரு million-க்கு 4 மற்றும் 20 dollars என பட்டியலிடப்பட்டுள்ளது; Sonnet 5.5-க்கு 2 மற்றும் 10; October 7, 2026 அன்று வெளியிடப்பட்ட Haiku 5.5-க்கு 0.10 மற்றும் 0.50. இந்த table-க்கு கீழே free tier எதுவும் இல்லை. இருப்பினும், புதிய accounts-க்கு சிறிய credit கிடைக்கும்; மேலும் API-யின் சில பகுதிகளுக்கு எந்தக் கட்டணமும் இல்லை.

கடைசி column-ல் cache read rate உள்ளது. பெரும்பாலான bills-ஐ இது தீர்மானிக்கும். Arithmetic முடிந்த பிறகு இதற்குத் திரும்புவோம்.

உள்ளீட்டு டோக்கன்களை விட வெளியீட்டு டோக்கன்கள் ஏன் ஐந்து மடங்கு அதிக செலவாகின்றன?

வாசிப்பதும் எழுதுவதும் ஒரே அளவிலான பணி அல்ல. உள்ளீட்டு டோக்கன்கள் ஒரே முறையில் செயலாக்கப்படுகின்றன. மாதிரி (model) முழு prompt-ஐயும் ஒரே நேரத்தில் வாசிக்கிறது, மேலும் அந்தப் பணி முழுவதும் இணையாக (parallel) நடைபெறுகிறது. இதனால்தான் 60,000 டோக்கன் கொண்ட prompt, 1,000 டோக்கன் கொண்ட prompt-ஐ விட 60,000 மடங்கு அதிக நேரம் எடுத்துக்கொள்வதில்லை.

வெளியீட்டு டோக்கன்கள் ஒவ்வொன்றாக உருவாக்கப்படுகின்றன. ஒவ்வொரு புதிய டோக்கனும் மாதிரி வழியாகத் தனியாகச் செல்ல வேண்டும், மேலும் அதற்கு முன்னால் உள்ள அனைத்து டோக்கன்களும் அதற்குச் சூழலாக (context) தேவைப்படுகின்றன. 1,000 டோக்கன்களை எழுதுவது என்பது, ஒவ்வொன்றாக 1,000 முறை செயலாக்குவதாகும். வாசிப்பதைப் போல இந்தத் தொடர் பணியைப் (serial work) பரவலாக்க முடியாது, எனவே ஒவ்வொரு வெளியீட்டு டோக்கனும் வன்பொருளை (hardware) அதிக நேரம் ஆக்கிரமித்துக்கொள்கிறது.

இதனால்தான் "பதிலைச் சுருக்கமாகக் கொடு" என்பது மக்கள் எதிர்பார்ப்பதை விடக் குறைவான தாக்கத்தையே ஏற்படுத்துகிறது. இது ஒரு ஏஜென்ட் கட்டணத்தின் சிறிய பகுதியில் மட்டுமே மாற்றத்தை ஏற்படுத்துகிறது.

ஒவ்வொரு முறை உரையாடும்போதும் ஏன் முழு உரையாடலுக்கும் கட்டணம் வசூலிக்கப்படுகிறது?

Claude API என்பது stateless முறையில் இயங்குகிறது. Anthropic-ன் தரப்பில் நீங்கள் ஒரு செய்தியை மட்டும் சேர்க்கும் வகையில் உரையாடல் சேமிக்கப்படுவதில்லை. ஒவ்வொரு கோரிக்கையும் (request) முழு உரையாடல் வரலாற்றையும் தன்னகத்தே கொண்டுள்ளது; எதையும் எழுதுவதற்கு முன்பு model அந்த முழு வரலாற்றையும் வாசிக்கும். எனவே, 30-வது சுற்றில் (turn) 1 முதல் 29 வரையிலான சுற்றுகளுக்கும் சேர்த்து கட்டணம் வசூலிக்கப்படுகிறது.

இதன் பொருள், உரையாடலின் நீளம் அதிகரிக்க அதிகரிக்க அதன் செலவும் அதைவிட வேகமாக அதிகரிக்கிறது. முதல் சுற்றில் சிறிய அளவிலான context-க்கு கட்டணம் வசூலிக்கப்படும். 40-வது சுற்றில் பெரிய அளவிலான context-க்கு கட்டணம் வசூலிக்கப்படும். நாற்பது சுற்றுகளையும் கூட்டினால், உண்மையில் எழுதப்பட்டதை விட பல மடங்கு அதிகமான tokens-களுக்கு நீங்கள் பணம் செலுத்தியிருப்பீர்கள்.

[
  {
    "turn": 1,
    "context_tokens": "20,000"
  },
  {
    "turn": 5,
    "context_tokens": "32,000"
  },
  {
    "turn": 10,
    "context_tokens": "45,000"
  },
  {
    "turn": 15,
    "context_tokens": "55,000"
  },
  {
    "turn": 20,
    "context_tokens": "64,000"
  },
  {
    "turn": 25,
    "context_tokens": "74,000"
  },
  {
    "turn": 30,
    "context_tokens": "84,000"
  },
  {
    "turn": 35,
    "context_tokens": "92,000"
  },
  {
    "turn": 40,
    "context_tokens": "100,000"
  }
]

மேலே உள்ள session 20,000 tokens-ல் தொடங்குகிறது; இது system prompt, tool definitions மற்றும் agent முதலில் திறந்த கோப்புகளை உள்ளடக்கியது. 40 சுற்றின் முடிவில், context-ல் 100,000 tokens உள்ளன. நாற்பது சுற்றுகளுக்கும் இதைச் சராசரி செய்தால், ஒரு கோரிக்கைக்கு தோராயமாக 60,000 tokens வாசிக்கப்படுகின்றன.

ஒரு chat-ஐ விட agent ஏன் அதிகமாகச் செலவாகிறது?

ஒரு chat-ல் ஒவ்வொரு கேள்விக்கும் ஒரு request மட்டுமே இருக்கும். ஒரு agent-ல் ஒவ்வொரு step-க்கும் ஒரு request இருக்கும். ஒரு file-ஐ வாசிப்பது ஒரு step. ஒரு test-ஐ இயக்குவது ஒரு step. Test output-ஐ வாசிப்பது ஒரு step. File-ஐத் திருத்துவது ஒரு step. ஒரு task-ஐ முடிக்க 40 steps தேவைப்படுவது coding agent-க்கு சாதாரணமானது.

Tool பயன்பாட்டுடன் மேலும் இரண்டு செலவுகள் சேர்கின்றன. Tool definitions ஒவ்வொரு request-லுமே input tokens ஆகும். ஏனெனில் ஒவ்வொரு முறையும் எந்த tools உள்ளன என்பதை model-க்குத் தெரிவிக்க வேண்டும். Anthropic வெளியிட்டுள்ள overhead விவரப்படி, tool_choice-ஐ auto-ஆக அமைத்திருக்கும்போது Opus 5-ல் tool use system prompt 286 tokens ஆகும். இதனுடன் உங்கள் சொந்த tool schemas-ன் tokens-உம் சேரும். சில server-side tools-க்கு தனிக் கட்டணமும் இருக்கலாம். Web search-க்கு, results பயன்படுத்தும் tokens-ன் கட்டணத்திற்கு மேலாக, 1,000 searches-க்கு $10 வசூலிக்கப்படுகிறது.

ஒவ்வொரு tool result-உம் நிரந்தர context ஆகிறது. ஒரு command 3,000 lines-ஐ print செய்தால், session முடியும் வரை அல்லது history compact அல்லது clear செய்யப்படும் வரை, அதற்குப் பிறகு வரும் ஒவ்வொரு request-லும் அந்த 3,000 lines சேர்க்கப்படும். Claude Code காட்டும் ஒவ்வொரு session-க்குமான token usage இதைத் தெளிவாகக் காட்டுகிறது: noisy command-ஐ இயக்கிய உடனேயே input எண்ணிக்கை உயர்வதை கவனிக்கவும்.

ஒரு உண்மையான அமர்வின் கணக்கீடு

Opus 5-ல் ஏஜென்ட் மூலம் குறியீட்டு முறை (agentic coding) மேற்கொள்ளப்பட்ட ஒரு யதார்த்தமான ஒரு மணிநேர செயல்பாட்டின் விவரம் இதோ. இதில் 40 API கோரிக்கைகள் (requests) உள்ளன. சூழல் (context) 20,000-லிருந்து 100,000 tokens வரை வளர்கிறது, எனவே ஒரு கோரிக்கைக்கு சராசரியாக 60,000 tokens பயன்படுத்தப்படுகின்றன. மாதிரி (model) ஒரு கோரிக்கைக்கு சுமார் 700 tokens எழுதுகிறது; இதில் குறுகிய tool calls மற்றும் சில நீண்ட குறியீட்டுத் தொகுதிகள் அடங்கும்.

Requests in the session:      40
Average context per request:  60,000 tokens

Total input tokens billed:    40 x 60,000                    = 2,400,000
Input cost on Opus 5:         2,400,000 x $5 / 1,000,000     = $12.00

Total output tokens:          40 x 700                       =    28,000
Output cost on Opus 5:        28,000 x $25 / 1,000,000       =  $0.70

Session total                                                = $12.70

[
  {
    "label": "Input, context re-read",
    "billed_tokens": "2,400,000",
    "cost_usd": "12.00"
  },
  {
    "label": "Output, code and tool calls",
    "billed_tokens": "28,000",
    "cost_usd": "0.70"
  }
]

இதன் பிரிப்பைப் பாருங்கள். வாசிப்புச் செலவு 12.00 டாலர்கள் மற்றும் எழுத்துச் செலவு 0.70 டாலர்கள். எனவே, நீங்கள் உண்மையில் வாசிக்கும் வெளியீடு கட்டணத்தில் ஐந்து சதவீதம் மட்டுமே. மாதிரி 28,000 tokens-ஐ எழுதியது மற்றும் வாசிப்பிற்காக 2,400,000 tokens-க்கு கட்டணம் வசூலிக்கப்பட்டது. யாரும் 2.4 மில்லியன் tokens-ஐத் தட்டச்சு செய்யவில்லை. அதே 100,000 tokens மீண்டும் மீண்டும் வாசிக்கப்பட்டன.

Lever 1: prompt caching, which is the largest one

Prompt caching மூலம் உங்கள் prompt-ன் நிலையான prefix-ன் processed வடிவம் சேமிக்கப்படுகிறது. அடுத்த request-ல் அந்த prefix மீண்டும் process செய்யப்படாமல் cache-லிருந்து வாசிக்கப்படுகிறது. Five minute cache-க்கு cache-ல் எழுதுவதற்கான கட்டணம் input rate-ன் 1.25 மடங்கு; one hour cache-க்கு 2 மடங்கு. பெரும்பாலான models-ல், Opus 5 உட்பட, cache-லிருந்து வாசிப்பதற்கான கட்டணம் input rate-ன் 0.1 மடங்கு. Opus 5.5 மற்றும் Sonnet 5.5-க்கு இது 0.05 மடங்கு; Fable 5.1-க்கு 0.025 மடங்கு. Opus 5-ல், ஒரு million tokens-க்கு 0.50 dollars ஆகும்; 5 dollars அல்ல.

மேலே உள்ள session-க்கு இதைப் பயன்படுத்துங்கள். Conversation வளரும்போது, ஒவ்வொரு 100,000 tokens-உம் ஒருமுறை cache-ல் எழுதப்படும். மீதமுள்ள 2,300,000 input tokens cache reads ஆகும்.

Tokens written to cache:      100,000
Cache write at 1.25x input:   100,000 x $6.25 / 1,000,000    = $0.63

Tokens read from cache:       2,300,000
Cache read at 0.1x input:     2,300,000 x $0.50 / 1,000,000  = $1.15

Output cost, unchanged                                       = $0.70

Session total                                                = $2.48

Cache செய்யக்கூடிய பகுதியை cache_control field மூலம் குறிக்கவும். Turns-க்கு இடையில் மாறாத content முடிந்ததும் breakpoint-ஐ வைக்கவும்: system prompt மற்றும் tool definitions-க்குப் பிறகு. தொடர்ந்து reference செய்யும் நீண்ட document-ஐயும் அதே stable block-ல் வைக்கவும்.

{
  "model": "claude-opus-5",
  "system": [
    {
      "type": "text",
      "text": "<long, stable instructions>",
      "cache_control": {"type": "ephemeral"}
    }
  ],
  "messages": [{"role": "user", "content": "..."}]
}

இப்போது உங்கள் prompt-ன் order பணத்தை நிர்ணயிக்கிறது. Cache hit ஆக, prompt-ன் தொடக்கத்திலிருந்து exact match தேவை. எனவே, ஒவ்வொரு request-லும் மாறும் எதுவும், மாறாத அனைத்திற்கும் பிறகு வர வேண்டும். உங்கள் system prompt-ன் தொடக்கத்தில் timestamp-ஐ வைத்தால், ஒவ்வொரு turn-லும் cache உடையும்: முழு prefix-ம் miss ஆகி, அதை மீண்டும் எழுத input rate-ன் 1.25 மடங்கு கட்டணம் செலுத்த வேண்டும்.

இது செயல்பட்டதா என்பதை response தெரிவிக்கும். ஒரு request அனுப்பி usage block-ஐப் படிக்கவும்.

curl 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-opus-5",
    "max_tokens": 256,
    "messages": [{"role": "user", "content": "Hello"}]
  }'

ஒவ்வொரு response-லும் இதைப் போன்ற usage object இருக்கும்:

{
  "usage": {
    "input_tokens": 105,
    "cache_creation_input_tokens": 7345,
    "cache_read_input_tokens": 7123,
    "output_tokens": 239
  }
}

மீண்டும் அனுப்பிய request-ல் இன்னும் 0, cache_read_input_tokens என்று காட்டப்பட்டால், cache hit ஆகவில்லை. வழக்கமான காரணம், உங்கள் breakpoint-க்கு முன் உள்ள ஏதாவது மாறியிருப்பதாகும். Five minute cache-க்கும் expiration உண்டு. எனவே, ஆறு minutes கழித்து அனுப்பப்படும் request miss ஆகி, அதன்பின் புதிய write நிகழும்.

Lever 2: எளிய turns-ஐ சிறிய model-க்கு அனுப்புதல்

Agent session-இல் பெரும்பாலான turns கடினமானவை அல்ல. ஒரு file-ஐத் திறத்தல், formatter-ஐ இயக்குதல், diff-ஐப் படித்தல் போன்ற பணிகளுக்கு frontier model தேவையில்லை. அவற்றை Haiku 4.5-க்கு route செய்வதால் input rate ஒரு million tokens-க்கு 5 dollars என்பதிலிருந்து 1 dollars ஆகக் குறைகிறது. Haiku 5.5-ன் பட்டியலிடப்பட்ட rate இதைவிடக் குறைவு; 100,000 tokens வரை உள்ள prompts-க்கு 0.10 dollars. ஆனால் prompt அந்த வரம்பைத் தாண்டியவுடன் அதன் ஒவ்வொரு rate-உம் ஐந்து மடங்கு உயரும். நீண்ட agent context அந்த வரம்பை அடையும். Haiku 5.5-ன் செலவும் அது பொருந்தும் சூழல்களும் இரண்டு tiers-ஐயும் விளக்குகிறது.

[
  {
    "label": "Opus 5, no caching",
    "session_cost_usd": "12.70"
  },
  {
    "label": "Opus 5, cached",
    "session_cost_usd": "2.48"
  },
  {
    "label": "Sonnet 5, cached",
    "session_cost_usd": "0.99"
  },
  {
    "label": "Haiku 4.5, cached",
    "session_cost_usd": "0.50"
  }
]

Caching இல்லாமல் Opus 5-ல் அதே session-ன் செலவு 12.70 dollars. Caching-உடன் அதன் செலவு 2.48 dollars. Caching-உடன் Sonnet 5-ல் 0.99 dollars. Caching-உடன் Haiku 4.5-ல் 0.50 dollars. Caching மட்டும் bill-ஐ சுமார் 80 percent குறைக்கிறது. மீதமுள்ள செலவின் பெரும்பகுதியை model தேர்வு குறைக்கிறது. Rates-ஐ நியாயமாக ஒப்பிடுவதற்காக Haiku 4.5 row-ல் மற்றவற்றைப் போன்ற அதே token totals பயன்படுத்தப்பட்டுள்ளன. Haiku 4.5 பழைய tokenizer-ஐப் பயன்படுத்துகிறது. புதிய tokenizer அதே text-க்கு சுமார் 30 percent அதிக tokens கணக்கிடுகிறது. எனவே அதே வேலை Haiku 4.5-ல் சுமார் 23 percent குறைவான tokens-ல் முடியும். இதனால் அந்த session-ன் செலவு சுமார் 0.38 dollars ஆகக் குறையும்.

இங்கே ஒரு முக்கியமான வரம்பு உள்ளது. குறைந்த விலை model தவறான பதிலை அளித்தால், முழு session-ஐ மீண்டும் இயக்க வேண்டிய செலவும், உங்கள் சொந்த நேரமும் சேரும். Price அடிப்படையில் அல்ல; task எவ்வளவு கடினம் என்பதன் அடிப்படையில் route செய்யவும். இந்த விதி மேல்நிலைக்கும் பொருந்தும். Claude Fable 5 மற்றும் Fable 5.1 ஆகியவற்றின் பட்டியலிடப்பட்ட rates, Opus 5-ஐவிட அதிகம்: ஒரு million-க்கு $10 மற்றும் $50. எனவே அங்கு ஒரு turn-ஐ அனுப்புவதற்கு முன் அந்த rates உங்களுக்கு என்ன பயன் தருகின்றன என்பதைப் படிக்கவும். Opus, Sonnet மற்றும் Haiku இடையே தேர்வு செய்தல் ஒவ்வொரு model எந்த சூழலில் நன்றாகச் செயல்படுகிறது என்பதை விளக்குகிறது.

நிலை 3: context hygiene

Context-ல் நீங்கள் விட்டுச்செல்லும் ஒவ்வொரு token-க்கும் மீதமுள்ள அனைத்து turn-களிலும் கட்டணம் வசூலிக்கப்படும். எனவே, ஒரு token-ஐ ஆரம்பத்திலேயே நீக்குவது, தாமதமாக நீக்குவதை விட அதிக மதிப்புடையது. 40 turn-கள் கொண்ட ஒரு session-ன் 5-வது turn-ல் 5,000 token அளவுள்ள ஒரு கோப்பை உள்ளீடு செய்தால், அது மேலும் 35 முறை வாசிக்கப்படும். இது 175,000 கூடுதல் input token-களை உருவாக்குகிறது. கவனக்குறைவாகச் செய்யப்படும் ஒரு paste-க்கு Opus 5-ல் இது கிட்டத்தட்ட ஒரு டாலர் செலவாகும்.

இந்த எண்ணிக்கையைக் குறைக்க உதவும் நான்கு பழக்கங்கள்:

• புதிய பணிக்கு, முந்தைய நாள் session-ஐத் தொடராமல், புதிய session-ஐத் தொடங்கவும்.
• வெளியீடு model-ஐ அடைவதற்கு முன்பே, head -50 போன்ற ஏதேனும் ஒன்றைப் பயன்படுத்தி தேவையற்ற command-களை வடிகட்டவும்.
• முழு கோப்பையும் கேட்காமல், உங்களுக்குத் தேவையான அந்த ஒரு function-ஐ மட்டும் கேட்கவும்.
• நீண்ட session-ல் முன்னேற்றம் இல்லாதபோது, ஒரு சுருக்கத்தைக் (summary) கேட்டுவிட்டு, அதிலிருந்து புதிய session-ஐத் தொடங்கவும். சுருக்கம் என்பது சில நூறு token-கள் மட்டுமே. ஆனால் transcript என்பது ஒரு லட்சம் token-கள் வரை இருக்கலாம்.

நிலை 4: ஊடாடும் தன்மை இல்லாத எதையும் batch செய்யவும்

Batch API கோரிக்கைகளை ஒத்திசைவற்ற முறையில் (asynchronously) செயலாக்குகிறது மற்றும் உள்ளீடு (input) மற்றும் வெளியீடு (output) ஆகிய இரண்டிற்கும் 50 சதவீத தள்ளுபடியை வழங்குகிறது. ஒரு பணிக்கு அடுத்த நொடியே பதில் தேவையில்லை என்றால், அதை batch செய்யவும். வகைப்படுத்துதல் (classification), பிரித்தெடுத்தல் (extraction), நிலுவையில் உள்ளவற்றைச் சுருக்குதல் (summarising a backlog) மற்றும் மதிப்பீட்டு ஓட்டங்கள் (evaluation runs) ஆகிய அனைத்தும் இதில் அடங்கும். Batch தள்ளுபடியானது prompt caching-உடன் இணைந்து செயல்படும். இது ஊடாடும் அமர்வுகளுக்கு (interactive session) பொருந்தாது, ஏனெனில் அங்கு காத்திருப்பதற்கு எதுவும் இல்லை.

நான் ஏமாற்றப்படுகிறேனா?

"Claude ஏன் விலை அதிகமாக உள்ளது" என்ற கேள்விக்கு அடியில் இருக்கும் உண்மையான கேள்வி இதுதான், எனவே இதற்கான நேரடியான பதில் இதோ. கட்டணங்கள் பகிரங்கமாக வெளியிடப்பட்டுள்ளன, அவை standard tiers-ல் உள்ள அனைவருக்கும் சமமானவை, மேலும் அவை token அடிப்படையில் வசூலிக்கப்படுகின்றன. இதற்கு விதிவிலக்கு பேச்சுவார்த்தை மூலம் பெறப்பட்ட ஒப்பந்தங்கள் மட்டுமே, அங்கேயும் Claude Enterprise pricing என்பது metered tokens-க்கு பதிலாக, ஒரு seat-க்கு இவ்வளவு என்று கட்டணத்தை நிர்ணயிக்கிறது. உங்கள் மனதில் இருப்பது மற்றொரு திட்டம் அல்ல, மற்றொரு vendor என்றால், the same jobs priced on the Claude and ChatGPT APIs எந்த இடத்தில் எது மலிவானது என்பதைக் காட்டுகிறது. கட்டணப் பட்டியலில் தன்னிச்சையான கட்டணங்கள் எதுவும் இல்லை. கட்டணப் பட்டியல் உங்களுக்கு மதிப்பைத் தருகிறதா என்று சொல்லாது, ஏனெனில் அது tokens-க்கு விலை நிர்ணயிக்கிறது, ஆனால் நீங்கள் முடிவுகளைப் பற்றி மட்டுமே கவலைப்படுகிறீர்கள்.

எனவே, முடிவுகளுக்கு விலை நிர்ணயம் செய்யுங்கள். மேலே உள்ள session-ன் விலை uncached நிலையில் 12.70 டாலர்கள். இது உங்களுக்கு ஒரு மணிநேரம் எடுக்கக்கூடிய ஒரு feature-ஐ உருவாக்கியிருந்தால், அது மலிவானது. இது நாற்பது முறை வட்டமடித்துக்கொண்டே இருந்தால், அதே 12.70 டாலர்களுக்கு எந்தப் பயனும் இல்லை, அங்கு கட்டணம் ஒரு பிரச்சினையே அல்ல.

இதை நினைவில் கொள்வது அவசியம். உங்கள் கட்டணம் tokens-ஐப் பொறுத்து உயருமே தவிர, மதிப்பைச் சார்ந்து அல்ல. ஒரே நீளமுள்ள பயனுள்ள session மற்றும் வீணான session ஆகிய இரண்டிற்கும் ஒரே செலவுதான். அதனால்தான் rate card-ஐ விட நான்கு levers முக்கியம்: நீங்கள் token-க்கான விலையை மாற்ற முடியாது, ஆனால் அந்த வேலைக்கு எத்தனை tokens தேவை என்பதை நீங்களே தீர்மானிக்கிறீர்கள்.

எனவே, மாதத்திற்கு எத்தனை டாலர்கள் என்று பார்க்காமல், ஒரு பணிக்கு எத்தனை டாலர்கள் என்று கணக்கிடுங்கள். நீங்கள் caching மற்றும் routing-ஐச் சரிசெய்யும்போது அந்த எண் குறைந்தால், உங்கள் setup மேம்படுகிறது என்று அர்த்தம். மாதந்திர மொத்தத் தொகை உயர்ந்தாலும், அதிக வேலைகளைச் செய்வதால் அது உயர்கிறது என்பதைப் புரிந்துகொள்ளுங்கள்.

உங்கள் bill-ஐ குறைக்காதவை

சில பிரபலமான ஆலோசனைகள் பெரிய பயன் அளிப்பதில்லை. Model-க்கு "be concise" என்று கூறினால் output குறையும். ஆனால் எடுத்துக்காட்டு bill-ல் output வெறும் ஐந்து சதவீதம் மட்டுமே. உங்கள் சொந்த கேள்வியைச் சுருக்கினால், 60,000 token context-க்கு எதிராக சில நூறு tokens மட்டுமே சேமிக்கப்படும். Extended thinking-ஐ முடக்குவது, thinking tokens உங்கள் output-ல் கணிசமான பங்காக இருந்தால் மட்டுமே உதவும். அதை ஊகிக்க வேண்டியதில்லை; usage block அதைக் காட்டும்.

பெரிய context window இருப்பது மட்டும் கூடுதல் செலவு அல்ல. Haiku 5.5-ஐத் தவிர, Claude 4.6 மற்றும் அதற்குப் பிந்தைய versions-ல் முழு one million token window-க்கும் வழக்கமான per-token rate-படியே bill செய்யப்படும். ஆகவே, 900,000 token request-க்கும் 9,000 token request-க்கும் ஒவ்வொரு token-க்கான செலவு ஒன்றே. Haiku 5.5 மட்டும் விதிவிலக்கு. அது prompt length அடிப்படையில் விலை நிர்ணயிக்கப்படுகிறது. 100,000 tokens-ஐ மீறும் prompt-க்கு input, output மற்றும் cache ஆகிய அனைத்திற்கும் ஐந்து மடங்கு அதிகமாக செலுத்த வேண்டும். எனவே, input விலை ஒரு million-க்கு 0.10 dollars-இலிருந்து 0.50 ஆகவும், output விலை 0.50-இலிருந்து 2.50 ஆகவும் உயரும். தற்போதைய பிற ஒவ்வொரு model-லும் window size விலையை நிர்ணயிக்காது. அந்த window-ல் நீங்கள் எதைச் சேர்க்கிறீர்கள் என்பதே விலையை நிர்ணயிக்கும்.

மேலும் இரண்டு விஷயங்கள் ஒரு தனி session-ல் அல்ல, planning நிலையில் பரிசீலிக்கப்பட வேண்டும். உங்கள் பயன்பாடு தினசரி மற்றும் interactive ஆக இருந்தால், pay per token முறையை flat plan-உடன் ஒப்பிடுங்கள்: API மற்றும் subscription செலவு ஒப்பீடு அந்தக் கணக்கைச் செய்கிறது. Flat plan குறைந்த செலவாக இருந்தால், அதே நேரத்தில் மற்றொரு vendor-ஐயும் பரிசீலித்து வருகிறீர்கள் என்றால், Claude மற்றும் ChatGPT plans-ன் பக்கவாட்டு விலை ஒப்பீடு இரண்டிற்கும் அதே ஒப்பீட்டைச் செய்கிறது. Agent ஒன்று server-ல் unattended ஆக இயங்கினால், வேறு எதையும் tune செய்வதற்கு முன் hard spend cap அமைக்கவும். இதையே VPS-ல் இயங்கும் AI agent-க்கான cost controls விளக்குகிறது. அளவை எளிதாகப் புரிந்துகொள்ள, one million Claude tokens மூலம் உண்மையில் எதைப் பெறலாம் rate card-ஐ text pages-ஆக மாற்றிக் காட்டுகிறது.

FAQ

எனது agent-ஐப் பயன்படுத்தத் தொடங்கியபோது Claude bill ஏன் அதிகரித்தது?

ஒரு கேள்விக்கு agent பல requests-ஐ அனுப்புகிறது. ஒவ்வொரு request-உடனும் அதுவரையிலான முழு conversation அனுப்பப்படுகிறது. ஒரு chat, ஒவ்வொரு கேள்விக்கும் ஒரு request-ஐ மட்டுமே அனுப்புகிறது. ஒரு coding agent, ஒவ்வொரு step-க்கும் ஒரு request-ஐ அனுப்புகிறது. ஒரே task-க்கு 40 steps இருப்பது வழக்கமானது. அந்த requests ஒவ்வொன்றிலும் முழு context-க்கான கட்டணம் விதிக்கப்படும். எனவே, 100,000 tokens-ல் முடியும் ஒரு session-க்கு மொத்தமாக 2 million input tokens-க்கும் அதிகமாக bill வரலாம். இதை நேரடியாகப் பார்க்க API response-ல் input_tokens மற்றும் cache_read_input_tokens-ஐப் பார்க்கவும்.

Prompt caching bill-ஐ உண்மையிலேயே இவ்வளவு குறைக்குமா?

கொடுக்கப்பட்ட example-ல், session cost 12.70 dollars-லிருந்து 2.48 dollars-ஆகக் குறைந்தது. காரணம், Opus 5-ல் cache read-க்கான கட்டணம் input rate-ன் பத்தில் ஒரு பங்கு மட்டுமே. சேமிப்பு முழுவதும் உங்கள் hit rate-ஐப் பொறுத்தது. Five minute cache-ல், ஒரே read-க்குப் பிறகு அது தன் செலவை ஈட்டிவிடும். ஏனெனில் write-க்கான கட்டணம் input rate-ன் 1.25 மடங்கு, read-க்கான கட்டணம் 0.1 மடங்கு அல்லது அதற்கும் குறைவு. ஒவ்வொரு request-லும் prompt-ன் தொடக்கப் பகுதியை மாற்றினால், எந்த hit-உம் கிடைக்காது. அப்போது எந்தப் பயனும் இல்லாமல் write premium-ஐச் செலுத்துவீர்கள். அது செயல்படுகிறது என்று கருதுவதற்கு முன் cache_read_input_tokens மூலம் உறுதிப்படுத்தவும்.

எல்லாவற்றுக்கும் Haiku-ஐ மட்டும் பயன்படுத்தலாமா?

இல்லை. ஒரு million input tokens-க்கு Haiku 4.5-ன் கட்டணம் 1 dollars. Opus 5-க்கு அது 5 dollars. எனவே classification மற்றும் routing போன்ற எளிய, அதிக volume கொண்ட பணிகளில் சேமிப்பு உண்மையானது. கடினமான பணியில் தவறான பதில் கிடைத்தால், model சேமித்த தொகையைவிட அதிகமாகச் செலவாகும். காரணம், retry-க்கான கட்டணத்துடன் உங்கள் நேரத்திற்கான செலவும் சேரும். நிலையான நடைமுறை mixed பயன்பாடாகும்: இயந்திரமயமான turns-க்கு சிறிய model-ஐப் பயன்படுத்தவும்; judgement தேவைப்படும் turn-க்கு frontier model-ஐப் பயன்படுத்தவும்.

Claude subscription-ஐவிட API மலிவானதா?

உங்கள் usage எவ்வளவு நிலையானது என்பதைப் பொறுத்தது. Subscription என்பது usage limits உடன் வரும் fixed monthly price ஆகும். API என்பது எந்த ceiling-உம் இல்லாமல் token அடிப்படையில் pay per token முறையில் கட்டணம் வசூலிக்கும். உங்கள் usage குறைவாகவோ bursts வடிவிலோ இருந்தால் API மலிவாக இருக்கும். ஒவ்வொரு working day-யிலும் அதிகமாகப் பயன்படுத்தினால் அது அதிகச் செலவாகும். usage block-லிருந்து ஒரு நாளுக்கான average tokens-ஐ எடுத்துக்கொள்ளவும். அவற்றை உங்கள் model-ன் rate-ல் கணக்கிடவும். நீங்கள் ஒரு மாதத்தில் பயன்படுத்தும் நாட்களின் எண்ணிக்கையால் பெருக்கவும். பின்னர், அந்த monthly figure-ஐ plan price-உடன் ஒப்பிடவும். Entry tier-க்கான விலை Claude Pro-ன் விலை மற்றும் அதன் usage limits உங்களை எங்கு கட்டுப்படுத்துகின்றன பகுதியில் கொடுக்கப்பட்டுள்ளது. கணக்கின் முடிவு API-க்கு சாதகமாக இருந்தால், ஏற்கனவே செலுத்திய மாதம் வீணாகாது. Cancellation தற்போதைய billing period முடிவில் அமலுக்கு வரும். அதுவரை plan தொடரும். Plan-ஐ நிறுத்துதல் அல்லது குறைந்த tier-க்கு மாறுதல் ஆகிய இரு வழிகளையும் விளக்குகிறது.