Claude API ஏன் அதிக செலவாகிறது? டோக்கன் கணக்கீடு

Claude ஏன் அதிக செலவுடையதாக உள்ளது? சுருக்கமான பதில்

Claude அதிக செலவுடையதாக இருப்பதற்கு ஒன்றன் மேல் ஒன்றாக அடுக்கப்பட்ட நான்கு காரணங்கள் உள்ளன. Output tokens-ன் விலை, input tokens-ன் விலையை விட ஐந்து மடங்கு அதிகமாக நிர்ணயிக்கப்பட்டுள்ளது. API உங்கள் உரையாடலின் நினைவகத்தை சேமித்து வைப்பதில்லை; எனவே, ஒவ்வொரு முறையும் உரையாடலின் முழு வரலாறும் மீண்டும் அனுப்பப்பட்டு, அதற்கான கட்டணம் வசூலிக்கப்படுகிறது. ஒரு agent, ஒரு கேள்வியை டஜன் கணக்கான API அழைப்புகளாக மாற்றுகிறது; ஒவ்வொரு அழைப்பிலும் அந்த வளர்ந்து வரும் வரலாறு மீண்டும் சேர்க்கப்படுகிறது. இவை அனைத்திற்கும் மேலாக, ஒரு சிறிய model-ஐ இயக்குவதற்கான செலவை விட, அது செய்யும் வேலையின் கடினத்தன்மைக்கு ஏற்பவே frontier model-ன் விலை நிர்ணயிக்கப்படுகிறது.

Token என்பது உரையின் ஒரு பகுதி. தோராயமாக, ஒரு token என்பது நான்கு எழுத்துக்கள் அல்லது சுமார் 0.75 ஆங்கிலச் சொற்களுக்குச் சமம். கட்டணங்கள் ஒரு மில்லியன் tokens-க்கு நிர்ணயிக்கப்படுகின்றன, இது MTok (million tokens) என்று குறிப்பிடப்படுகிறது. கீழே கொடுக்கப்பட்டுள்ள ஒவ்வொரு கட்டணமும் ஆகஸ்ட் 2026 நிலவரப்படி வெளியிடப்பட்ட Claude API கட்டணமாகும்.

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

வெளியிடப்பட்ட கட்டணங்கள், எனவே எண்களில் நாம் உடன்படுகிறோம்

[
  {
    "label": "Haiku 4.5",
    "input_usd": 1,
    "output_usd": 5,
    "cache_read_usd": "0.10"
  },
  {
    "label": "Sonnet 5, to Aug 31 2026",
    "input_usd": 2,
    "output_usd": 10,
    "cache_read_usd": "0.20"
  },
  {
    "label": "Sonnet 5, from Sep 1 2026",
    "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"
  }
]

முழுமையான எண்களை விட அதன் விகித அமைப்பைக் கவனியுங்கள். ஒவ்வொரு மாடலும் உள்ளீட்டை (input) விட வெளியீட்டிற்கு (output) சரியாக ஐந்து மடங்கு அதிக கட்டணம் வசூலிக்கிறது. Opus 5, ஒரு மில்லியன் உள்ளீட்டு டோக்கன்களுக்கு 5 டாலர்களும், ஒரு மில்லியன் வெளியீட்டு டோக்கன்களுக்கு 25 டாலர்களும் கட்டணமாக வசூலிக்கிறது. Haiku 4.5, 1 மற்றும் 5 கட்டணத்தைக் கொண்டுள்ளது. எனவே, மலிவான மாடலுக்கும் விலையுயர்ந்த மாடலுக்கும் இடையிலான வித்தியாசம் ஐந்து மடங்காகும், அதேபோல் வாசிப்பதற்கும் (reading) எழுதுவதற்கும் (writing) இடையிலான வித்தியாசமும் ஐந்து மடங்காகும்.

Sonnet 5, ஆகஸ்ட் 31, 2026 வரை ஒரு மில்லியனுக்கு 2 மற்றும் 10 டாலர்கள் என்ற அறிமுக விலையில் கிடைக்கிறது. செப்டம்பர் 1, 2026 முதல், இது 3 மற்றும் 15 என மாற்றமடையும். மாடல் வெளியீடுகளுக்கு ஏற்ப கட்டணங்கள் மாறுபடும், எனவே பட்ஜெட் தயாரிக்கும் முன் தற்போதைய கட்டணங்களைச் சரிபார்க்கவும்.

கடைசி நெடுவரிசை cache read கட்டணத்தைக் குறிக்கிறது. இதுவே பெரும்பாலான கட்டணங்களைத் தீர்மானிக்கிறது. கணக்கீடுகளுக்குப் பிறகு மீண்டும் இதைப் பார்க்கவும்.

Output tokens ஏன் input tokens-ஐ விட ஐந்து மடங்கு அதிக செலவாகின்றன?

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

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

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

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

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) ஒரு கோரிக்கையை உருவாக்குகிறது. ஒரு கோப்பை வாசிப்பது ஒரு படிநிலை. ஒரு சோதனையை (test) இயக்குவது ஒரு படிநிலை. சோதனையின் வெளியீட்டை வாசிப்பது ஒரு படிநிலை. கோப்பைத் திருத்துவது ஒரு படிநிலை. ஒரு coding agent-க்கு ஒரு பணியை முடிக்க நாற்பது படிநிலைகள் எடுப்பது சாதாரணமான ஒன்று.

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

ஒவ்வொரு கருவியின் வெளியீடும் நிரந்தரமான சூழலாக (context) மாறுகிறது. 3,000 வரிகளை அச்சிடும் ஒரு கட்டளை, அந்த 3,000 வரிகளையும் அந்த session-ன் மீதமுள்ள அனைத்து கோரிக்கைகளிலும் சேர்க்கிறது. Claude Code தெரிவிக்கும் per-session token பயன்பாடு இதைத் தெளிவாகக் காட்டுகிறது: அதிகப்படியான வெளியீட்டைக் கொண்ட ஒரு கட்டளைக்குப் பிறகு, உள்ளீட்டு டோக்கன்களின் எண்ணிக்கை உயர்வதைக் கவனியுங்கள்.

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

Opus 5-ல் ஏஜென்ட் மூலம் குறியீட்டு முறை (agentic coding) மேற்கொள்ளப்படும் ஒரு யதார்த்தமான ஒரு மணிநேரச் செயல்பாடு இங்கே உள்ளது. நாற்பது API கோரிக்கைகள். சூழல் (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 மீண்டும் மீண்டும் வாசிக்கப்பட்டன.

நிலை 1: prompt caching, இதுவே மிகப்பெரியது

Prompt caching என்பது உங்கள் prompt-ன் நிலையான முன்னொட்டை (prefix) பதப்படுத்தப்பட்ட வடிவில் சேமித்து வைக்கிறது. அடுத்த கோரிக்கையின் போது, அந்த முன்னொட்டு மீண்டும் பதப்படுத்தப்படாமல் cache-லிருந்து நேரடியாக வாசிக்கப்படும். ஐந்து நிமிட cache-க்கு, உள்ளீட்டு விகிதத்தை விட 1.25 மடங்கு கட்டணமும், ஒரு மணிநேர cache-க்கு 2 மடங்கு கட்டணமும் வசூலிக்கப்படும். இதிலிருந்து வாசிப்பதற்கு உள்ளீட்டு விகிதத்தில் 0.1 மடங்கு மட்டுமே கட்டணம். Opus 5-ல், இது 0.50 டாலர்கள் (ஒரு மில்லியனுக்கு), சாதாரண 5 டாலர்களுக்குப் பதிலாக.

இதை மேலே உள்ள அமர்வுக்குப் பயன்படுத்துங்கள். உரையாடல் வளரும்போது, அந்த 100,000 tokens-ம் ஒருமுறை cache-ல் எழுதப்படுகின்றன. மற்ற 2,300,000 உள்ளீட்டு tokens-ம் cache வாசிப்புகளாக மாறுகின்றன.

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 புலத்தைக் கொண்டு குறிக்க வேண்டும். ஒவ்வொரு முறை கோரிக்கை அனுப்பும்போதும் மாறாத உள்ளடக்கத்திற்குப் பிறகு breakpoint-ஐ வைக்கவும்: அதாவது system prompt மற்றும் tool definitions. நீங்கள் அடிக்கடி குறிப்பிடும் நீண்ட ஆவணமும் அதே நிலையான தொகுப்பிற்குள் இருக்க வேண்டும்.

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

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

அது வேலை செய்ததா என்பதை பதில் உங்களுக்குத் தெரிவிக்கும். ஒரு கோரிக்கையை அனுப்பி usage தொகுப்பை வாசிக்கவும்.

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"}]
  }'

ஒவ்வொரு பதிலும் இது போன்ற ஒரு usage பொருளைக் கொண்டிருக்கும்:

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

மீண்டும் அனுப்பப்படும் கோரிக்கையில் cache_read_input_tokens-க்குள் 0 என்று காட்டினால், cache hit ஆகவில்லை என்று அர்த்தம். உங்கள் breakpoint-க்கு முன்னால் ஏதோ ஒன்று மாறியிருப்பதே இதற்கு பொதுவான காரணம். ஐந்து நிமிட cache காலாவதியாகிவிடும் என்பதால், ஆறு நிமிடங்கள் கழித்து அனுப்பப்படும் கோரிக்கை miss ஆகி, மீண்டும் புதியதாக எழுதப்படும்.

நிலை 2: எளிமையான பணிகளை சிறிய மாடலுக்கு அனுப்புதல்

ஒரு agent session-ல் பெரும்பாலான செயல்பாடுகள் கடினமானவை அல்ல. ஒரு கோப்பைத் திறப்பது, formatter-ஐ இயக்குவது, diff-ஐ வாசிப்பது போன்றவை இதில் அடங்கும். இவற்றுக்கு frontier model தேவையில்லை. இவற்றை Haiku 4.5-க்கு அனுப்புவதன் மூலம், input rate-ஐ 5 டாலர்களிலிருந்து (ஒரு மில்லியனுக்கு) 1 டாலர்களாகக் குறைக்கலாம்.

[
  {
    "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"
  }
]

அதே session-க்கு Opus 5-ல் caching இல்லாமல் 12.70 டாலர்களும், caching-உடன் 2.48 டாலர்களும் செலவாகின்றன. Sonnet 5-ல் caching-உடன் 0.99 டாலர்களும், Haiku 4.5-ல் caching-உடன் 0.50 டாலர்களும் செலவாகின்றன. Caching மட்டுமே கட்டணத்தில் சுமார் எண்பது சதவீதத்தைக் குறைக்கிறது. மீதமுள்ள செலவில் பெரும்பகுதியை மாடல் தேர்வு குறைக்கிறது.

இதிலுள்ள முக்கிய எச்சரிக்கை இதுதான்: ஒரு மலிவான மாடல் தவறான பதிலை அளித்தால், அந்த முழு session-க்கும் மீண்டும் செலவு செய்ய வேண்டியிருக்கும், அத்துடன் உங்கள் நேரமும் வீணாகும். விலையை மட்டும் பார்க்காமல், பணியின் கடினத்தன்மைக்கு ஏற்ப routing செய்யுங்கள். Opus, Sonnet மற்றும் Haiku ஆகியவற்றுக்கு இடையேயான தேர்வு ஒவ்வொரு மாடலும் எங்கு சிறப்பாகச் செயல்படும் என்பதை விளக்குகிறது.

நிலை 3: சூழல் சுகாதாரம் (context hygiene)

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

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

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

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

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

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

"Claude ஏன் விலை உயர்ந்ததாக இருக்கிறது" என்ற கேள்விக்கு அடியில் இருக்கும் உண்மையான கேள்வி இதுதான், இதோ அதற்கான நேரடியான பதில். கட்டணங்கள் வெளியிடப்பட்டுள்ளன, அவை standard tiers-ல் உள்ள அனைவருக்கும் சமமானவை, மேலும் அவை token அடிப்படையிலேயே வசூலிக்கப்படுகின்றன. கட்டணப் பட்டியலில் தன்னிச்சையான கட்டணங்கள் எதுவும் இல்லை. கட்டண அட்டை உங்களுக்கு மதிப்பை வழங்குகிறதா என்பதைச் சொல்ல முடியாது, ஏனெனில் அது token-களுக்கு விலை நிர்ணயிக்கிறது, ஆனால் நீங்கள் முடிவுகளையே எதிர்பார்க்கிறீர்கள்.

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

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

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

பட்டியின் தொகையைக் குறைக்காதவை

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

பெரிய context window என்பது தானாகவே ஒரு செலவு அல்ல. Claude 4.6 மற்றும் அதற்குப் பிந்தைய பதிப்புகளில், முழுமையான ஒரு மில்லியன் token window-ம் நிலையான per-token விகிதத்திலேயே கணக்கிடப்படுகிறது. எனவே, 900,000 token கொண்ட கோரிக்கையும், 9,000 token கொண்ட கோரிக்கையும் ஒரே per-token விலையையே கொண்டிருக்கும். Window-ன் அளவு விலையைத் தீர்மானிப்பதில்லை; நீங்கள் அதில் எதைச் சேர்க்கிறீர்கள் என்பதுதான் விலையைத் தீர்மானிக்கிறது.

இன்னும் இரண்டு விஷயங்களை ஒரு தனி session-ல் செய்வதை விட, திட்டமிடலில் சேர்க்க வேண்டும். உங்கள் பயன்பாடு தினசரி மற்றும் ஊடாடும் வகையில் (interactive) இருந்தால், pay-per-token முறையை ஒரு flat plan-உடன் ஒப்பிட்டுப் பாருங்கள்: API மற்றும் சந்தா கட்டண ஒப்பீடு அந்த கணக்கீட்டைச் செய்கிறது. ஒரு agent server-ல் தானாக இயங்குகிறது என்றால், வேறு எதையும் மாற்றியமைக்கும் முன் ஒரு கடினமான செலவு வரம்பை (hard spend cap) நிர்ணயம் செய்யுங்கள்; இதைத்தான் VPS-ல் உள்ள AI agent-க்கான செலவுக் கட்டுப்பாடுகள் விளக்குகிறது. அளவீடு குறித்த தெளிவான புரிதலுக்கு, ஒரு மில்லியன் Claude token-கள் உண்மையில் எதைக் குறிக்கின்றன என்ற கட்டுரை, கட்டண விவரங்களை எத்தனை பக்கங்கள் உரைக்குச் சமம் என்று விளக்குகிறது.

FAQ

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

ஏனெனில், ஒரு agent ஒவ்வொரு கேள்விக்குமான பல கோரிக்கைகளை (requests) அனுப்புகிறது, மேலும் ஒவ்வொரு கோரிக்கையும் இதுவரை நடந்த உரையாடல் முழுவதையும் உள்ளடக்கியிருக்கும். ஒரு சாதாரண chat, கேள்விக்கு ஒரு கோரிக்கையை மட்டுமே அனுப்பும். ஒரு coding agent ஒவ்வொரு படிநிலைக்கும் ஒரு கோரிக்கையை அனுப்பும்; ஒரு பணிக்கு நாற்பது படிநிலைகள் என்பது சாதாரணமானது. அந்த ஒவ்வொரு கோரிக்கைக்கும் முழு context-க்குமான கட்டணம் வசூலிக்கப்படுகிறது, எனவே 100,000 tokens-ல் முடியும் ஒரு session-க்கு மொத்தம் இரண்டு மில்லியனுக்கும் அதிகமான input tokens-க்கு கட்டணம் விதிக்கப்படலாம். இதை நேரடியாகப் பார்க்க API response-ல் உள்ள input_tokens மற்றும் cache_read_input_tokens-ஐப் படிக்கவும்.

Prompt caching உண்மையிலேயே கட்டணத்தை அவ்வளவு குறைக்கிறதா?

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

நான் எல்லாவற்றிற்கும் Haiku-வையே பயன்படுத்தலாமா?

இல்லை. Haiku 4.5-ன் விலை மில்லியன் input tokens-க்கு 1 டாலர்கள், அதே சமயம் Opus 5-க்கு 5 டாலர்கள். எனவே, வகைப்படுத்துதல் (classification) மற்றும் routing போன்ற எளிமையான, அதிக அளவுள்ள பணிகளில் சேமிப்பு உண்மையானது. கடினமான பணிகளில் தவறான பதில் கிடைத்தால், அது சேமித்த தொகையை விட அதிக செலவை ஏற்படுத்தும், ஏனெனில் நீங்கள் மீண்டும் முயற்சி செய்வதற்கும், அதற்காகச் செலவிடும் உங்கள் நேரத்திற்கும் சேர்த்து கட்டணம் செலுத்த வேண்டியிருக்கும். இயந்திரத்தனமான பணிகளுக்குச் சிறிய மாதிரியையும் (small model), தீர்ப்பு தேவைப்படும் பணிகளுக்கு உயர்தர மாதிரியையும் (frontier model) பயன்படுத்தும் கலப்பு முறையே சிறந்தது.

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

இது உங்கள் பயன்பாடு எவ்வளவு சீராக இருக்கிறது என்பதைப் பொறுத்தது. Subscription என்பது பயன்பாட்டு வரம்புகளைக் கொண்ட ஒரு நிலையான மாதாந்திரக் கட்டணம். API என்பது token-க்கு ஏற்ப கட்டணம் செலுத்தும் முறை, இதற்கு உச்சவரம்பு இல்லை. உங்கள் பயன்பாடு குறைவாகவோ அல்லது அவ்வப்போது அதிகமாகவோ இருக்கும்போது இது மலிவானது, ஆனால் ஒவ்வொரு வேலை நாளிலும் அதிகப்படியாகப் பயன்படுத்தும்போது இது செலவு அதிகம். usage block-லிருந்து உங்கள் சராசரி தினசரி tokens-ஐ எடுத்து, உங்கள் மாதிரியின் விலையுடன் கணக்கிட்டு, அந்தத் தொகையைத் திட்டத்தின் விலையுடன் ஒப்பிட்டுப் பார்க்கவும்.