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

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

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

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

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

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

[
  {
    "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 என மாறும். மாடல் வெளியீடுகளுக்கு ஏற்ப கட்டணங்கள் மாறுபடும், எனவே பட்ஜெட் தயாரிக்கும் முன் தற்போதைய கட்டணங்களைச் சரிபார்க்கவும். இந்த அட்டவணைக்குக் கீழே இலவச அடுக்கு (free tier) எதுவும் இல்லை, இருப்பினும் புதிய கணக்குகள் சிறிய கிரெடிட்டுடன் தொடங்குகின்றன மற்றும் API-ன் சில பகுதிகள் முற்றிலும் இலவசம்.

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

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

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

Output tokens ஒவ்வொன்றாகவே உருவாக்கப்படுகின்றன. ஒவ்வொரு புதிய token-க்கும் model-ல் ஒரு தனிச் செயலாக்கம் தேவைப்படுகிறது, மேலும் அதற்கு முன்னால் உள்ள அனைத்து tokens-ம் 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) பல மடங்கு அதிகமான எண்ணிக்கையிலான 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 டோக்கன்களைக் கொண்டுள்ளது, இதனுடன் நீங்கள் பயன்படுத்தும் கருவித் திட்டங்களின் (tool schemas) டோக்கன்களும் சேரும். சில server-side கருவிகளுக்குத் தனித்தனியாகக் கட்டணம் வசூலிக்கப்படுகிறது. Web search வசதிக்கு, முடிவுகள் பயன்படுத்தும் டோக்கன்களுக்கு மேலதிகமாக, 1,000 தேடல்களுக்கு $10 என்ற விகிதத்தில் கட்டணம் வசூலிக்கப்படுகிறது.

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

ஒரு உண்மையான session-ன் கணக்கீடு

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

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 டோக்கன்களும் ஒருமுறை cache-ல் எழுதப்படுகின்றன. மற்ற 2,300,000 உள்ளீட்டு டோக்கன்கள் 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 மடங்கு கட்டணம் செலுத்த வேண்டியிருக்கும்.

இது வேலை செய்ததா என்பதை response உங்களுக்குத் தெரிவிக்கும். ஒரு கோரிக்கையை அனுப்பி 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"}]
  }'

ஒவ்வொரு response-உம் இது போன்ற ஒரு 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-ல் பெரும்பாலான உரையாடல்கள் கடினமானவை அல்ல. ஒரு file-ஐத் திறப்பது, 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 செய்யுங்கள். இந்த விதி மேல்நோக்கியும் பொருந்தும்: Claude Fable 5, Opus 5-ஐ விட அதிகமாக ஒரு மில்லியனுக்கு $10 மற்றும் $50 என விலை நிர்ணயிக்கப்பட்டுள்ளது. எனவே, ஒரு பணியை அங்கு அனுப்பும் முன் அந்த விலைக்கு என்ன கிடைக்கும் என்பதை வாசிக்கவும். Opus, Sonnet மற்றும் Haiku ஆகியவற்றுக்கு இடையேயான தேர்வு ஒவ்வொரு மாடலும் எங்கு சிறப்பாகச் செயல்படும் என்பதை விளக்குகிறது.

நிலை 3: context hygiene

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

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

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

நிலை 4: ஊடாடும் தன்மையற்ற (non-interactive) பணிகளை batch செய்யவும்

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

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

"Claude ஏன் விலை உயர்ந்ததாக இருக்கிறது" என்ற கேள்விக்கு அடியில் இருக்கும் உண்மையான கேள்வி இதுதான், இதோ அதற்கான நேரடியான பதில். கட்டணங்கள் பொதுவெளியில் வெளியிடப்பட்டுள்ளன, standard tiers-ல் உள்ள அனைவருக்கும் அவை சமமானவை, மேலும் அவை token அடிப்படையில் வசூலிக்கப்படுகின்றன. இதற்கு விதிவிலக்கு ஒப்பந்தம் செய்யப்பட்ட contracts மட்டுமே, அங்கேயும் Claude Enterprise pricing என்பது metered tokens-க்கு மாற்றாக இல்லாமல், அதற்கு மேலதிகமாக ஒரு seat கட்டணத்தை விதிக்கிறது. கட்டணப்பட்டியலில் தன்னிச்சையாக மாற்றக்கூடியது எதுவுமில்லை. ஆனால், இந்த rate card உங்களுக்கு மதிப்புக் கிடைக்கிறதா என்பதைச் சொல்லாது, ஏனெனில் இது tokens-க்கு விலை நிர்ணயிக்கிறது, ஆனால் நீங்கள் முடிவுகளை (outcomes) எதிர்பார்க்கிறீர்கள்.

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

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

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

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

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

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

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

FAQ

ஏஜென்ட் (agent) பயன்படுத்தத் தொடங்கியதும் எனது Claude கட்டணம் ஏன் அதிகரித்தது?

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

பிராம்ட் கேச்சிங் (prompt caching) உண்மையில் கட்டணத்தை அவ்வளவு குறைக்கிறதா?

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

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

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

Claude சந்தாவை விட API மலிவானதா?

இது உங்கள் பயன்பாட்டின் சீரான தன்மையைப் பொறுத்தது. சந்தா என்பது பயன்பாட்டு வரம்புகளுடன் கூடிய நிலையான மாதாந்திரக் கட்டணம். API என்பது token அடிப்படையிலான கட்டணம்; இதற்கு உச்சவரம்பு இல்லை. உங்கள் பயன்பாடு குறைவாகவோ அல்லது அவ்வப்போது மட்டுமே இருந்தாலோ API மலிவானது. ஒவ்வொரு வேலை நாளிலும் அதிகப்படியாகப் பயன்படுத்தினால் சந்தாவே மலிவானது. உங்கள் பயன்பாட்டுப் பிரிவிலிருந்து (usage block) ஒரு நாளுக்கான சராசரி tokens-ஐ எடுத்து, உங்கள் மாடல் விலையுடன் கணக்கிட்டு, சந்தா விலையுடன் ஒப்பிட்டுப் பார்க்கவும். நுழைவு நிலைத் திட்டத்தின் (entry tier) விலை Claude Pro-வின் விலை மற்றும் அதன் பயன்பாட்டு வரம்புகள் பகுதியில் கொடுக்கப்பட்டுள்ளது. கணக்கீட்டின்படி API மலிவாக இருந்தால், திட்டத்தை ரத்து செய்வது அல்லது குறைப்பது நீங்கள் ஏற்கனவே செலுத்திய மாதத்தை வீணாக்காது; ஏனெனில் உங்கள் அணுகல் தற்போதைய பில்லிங் காலம் முடியும் வரை இருக்கும்.