Claude-ல் 1M tokens-க்கான கட்டணத்தை கணக்கிடுவது எப்படி?

Claude-ல் 1M tokens-ன் விலை என்ன?

1M tokens என்பது பத்து லட்சம் tokens-ஐக் குறிக்கும். Claude API (application programming interface) மாதிரிகளின் விலைகள் இந்த அலகின் அடிப்படையிலேயே நிர்ணயிக்கப்படுகின்றன. இதற்கு ஒரே நிலையான விலை கிடையாது, ஏனெனில் input மற்றும் output ஆகியவற்றுக்கு வெவ்வேறு கட்டணங்கள் வசூலிக்கப்படுகின்றன, மேலும் ஒவ்வொரு மாதிரிக்கும் தனித்தனி கட்டண விகிதங்கள் உள்ளன. Claude Haiku 5.5 இரண்டு ஜோடி கட்டணங்களைக் கொண்டுள்ளது: 100,000 tokens வரையிலான prompts-க்கு ஒன்று, அதற்கு மேற்பட்ட prompts-க்கு அதிகப்படியான கட்டணம். அக்டோபர் 2026 நிலவரப்படி, பத்து லட்சம் input tokens-ன் விலை Claude Haiku 4.5-ல் $1, Claude Sonnet 5-ல் $2 மற்றும் Claude Opus 5-ல் $5 ஆகும்.

Output என்பது செலவு அதிகம் கொண்ட பகுதியாகும். தற்போதுள்ள அனைத்து மாதிரிகளிலும், output கட்டணமானது input கட்டணத்தை விட ஐந்து மடங்கு அதிகமாகும். எனவே, ஒட்டுமொத்த விலையைத் தீர்மானிப்பதில், இந்த இரண்டிற்கும் இடையிலான விகிதமே முதன்மைப் பங்கு வகிக்கிறது. நீண்ட ஆவணங்களை அனுப்பி சுருக்கமான பதில்களைப் பெறும் ஒரு செயலியின் செலவு, சுருக்கமான prompt-ஐக் கொண்டு நீண்ட பதில்களை எழுதும் செயலியின் செலவிலிருந்து முற்றிலும் மாறுபடும்.

இந்தப் பக்கம் unit economics பற்றியது: ஒரு token-ன் விலை என்ன மற்றும் ஒரு செயலியை உருவாக்கும் முன் அதற்கான கட்டணத்தை எவ்வாறு மதிப்பீடு செய்வது என்பது குறித்து விளக்குகிறது. நீங்கள் பணிபுரியும் போது tokens எங்கே செலவாகின்றன என்பதை அறிய, Claude Code session-க்குள் tokens எங்கே செல்கின்றன என்பதைப் படிக்கவும்.

1M tokens என்பது எவ்வளவு

Token என்பது ஒரு model வாசிக்கும் அல்லது எழுதும் உரையின் ஒரு பகுதி. Claude 4.7-க்கு முந்தைய model-களில், ஒரு token என்பது தோராயமாக 3.5 ஆங்கில எழுத்துக்களுக்குச் சமம் என்று Anthropic-ன் கலைச்சொல் விளக்கம் கூறுகிறது. Anthropic-ன் model கண்ணோட்டத்தின்படி, அந்த model-களில் ஒரு மில்லியன் tokens என்பது சுமார் 750,000 வார்த்தைகளைக் குறிக்கும். ஒரு token-க்கு 3.5 எழுத்துக்கள் வீதம் கணக்கிட்டால், இது சுமார் 3.5 மில்லியன் எழுத்துக்கள் அல்லது 3.5 MB சாதாரண ஆங்கில உரைக்குச் சமம். Claude Opus 4.7-ல் அறிமுகப்படுத்தப்பட்ட புதிய tokenizer-ல், அதே ஒரு மில்லியன் tokens சுமார் 555,000 வார்த்தைகளை அல்லது 2.5 மில்லியன் எழுத்துக்களைக் கொண்டிருக்கும்.

பொதுவான உள்ளீடுகளுக்கான மதிப்பீடுகள் இதன் அளவைப் புரிந்துகொள்ள உதவும்.

[
  {
    "label": "Average web page (10 kB)",
    "tokens": "2,500"
  },
  {
    "label": "Documentation page (100 kB)",
    "tokens": "25,000"
  },
  {
    "label": "Research paper PDF (500 kB)",
    "tokens": "125,000"
  }
]

இந்த விகிதத்தில், 1M tokens என்பது ஒருமுறை வாசிக்கப்படும் 400 சராசரி இணையப் பக்கங்கள் அல்லது அந்த அளவிலான எட்டு ஆராய்ச்சி கட்டுரைகளுக்குச் சமம். இது நடுத்தர அளவுள்ள ஒரு codebase-ஐ ஒருமுறை முழுமையாகப் பார்ப்பது அல்லது ஒரு நபர் ஒரு மாதம் பயன்படுத்தும் சாதாரண chat உரையாடலுக்குச் சமம்.

இவை அனைத்தையும் ஒரு மதிப்பீடாகவே கருத வேண்டும். Code, JSON மற்றும் ஆங்கிலம் அல்லாத பிற மொழிகளில் உள்ள உரைகள் ஒரு token-க்குள் குறைவான வார்த்தைகளையே கொண்டிருக்கும், எனவே அந்த வார்த்தை எண்ணிக்கைகள் மிகையானவை. மேலும் ஒரு காரணி எண்ணிக்கையை மாற்றுகிறது: Claude Opus 4.7 மற்றும் அதற்குப் பிந்தைய model-கள் (Opus 5 மற்றும் Sonnet 5 உட்பட) புதிய tokenizer-ஐப் பயன்படுத்துகின்றன. இவை Sonnet 4.6 மற்றும் அதற்கு முந்தைய model-களை விட, அதே உரைக்கு சுமார் 30 சதவீதம் கூடுதல் tokens-ஐ உருவாக்குகின்றன. Claude Haiku 4.5 பழைய tokenizer-ஐப் பயன்படுத்துகிறது. எனவே, Haiku 4.5-ல் நீங்கள் அளவிடும் எண்ணிக்கை, அதே உள்ளீட்டிற்கு Sonnet 5-ல் இருக்கும் எண்ணிக்கையை விடக் குறைவாகவே இருக்கும். இதனால், இந்த எல்லைக்கு அப்பால் நேரடியாக ஒரு மில்லியன் tokens-க்கான விலையை ஒப்பிடுவது சரியாக இருக்காது. முடிவெடுக்கும் முன், ஒரே prompt-ஐ இரண்டு model-களிலும் சோதித்துப் பாருங்கள்.

ஒரு மில்லியன் tokens-க்கு Claude வசூலிக்கும் கட்டணம்

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

Claude Sonnet 5-ன் விலை உள்ளீட்டிற்கு (input) $2 மற்றும் வெளியீட்டிற்கு (output) $10 ஆகும். Anthropic முதலில் இந்த விலையை 31 August 2026 வரை அறிமுக விலையாக அறிவித்தது, பின்னர் இதனை நிலையான விலையாக மாற்றியதுடன், திட்டமிடப்பட்டிருந்த $3 மற்றும் $15 என்ற விலை உயர்வை ரத்து செய்தது. Claude Opus 5-ன் விலை உள்ளீட்டிற்கு $5 மற்றும் வெளியீட்டிற்கு $25 ஆகும். Fable மாதிரிகள் இந்த அட்டவணையை விட அதிக விலையுடையவை: Claude Fable 5 மற்றும் புதிய Claude Fable 5.1 ஆகிய இரண்டுமே உள்ளீட்டிற்கு $10 மற்றும் வெளியீட்டிற்கு $50 என நிர்ணயிக்கப்பட்டுள்ளன, எனவே இந்தக் கட்டணங்கள் செலுத்துவதற்குத் தகுதியானவையா என்பது நீங்கள் எந்தப் பணிகளுக்கு இதைப் பயன்படுத்துகிறீர்கள் என்பதைப் பொறுத்தது.

Anthropic-ன் தற்போதைய தயாரிப்புகள் இந்தப் பக்கத்தில் குறிப்பிடப்பட்டுள்ள மாதிரிகளை விட புதியவை. Claude Opus 5.5 உள்ளீட்டிற்கு $4 மற்றும் வெளியீட்டிற்கு $20, Claude Sonnet 5.5 உள்ளீட்டிற்கு $2 மற்றும் வெளியீட்டிற்கு $10, மற்றும் Claude Haiku 5.5 உள்ளீட்டிற்கு $0.10 மற்றும் வெளியீட்டிற்கு $0.50 என நிர்ணயிக்கப்பட்டுள்ளன. Opus 5, Sonnet 5, Haiku 4.5 மற்றும் Fable 5 ஆகியவை தற்போது legacy மாதிரிகளாகக் கருதப்படுகின்றன, இருப்பினும் அவை பயன்பாட்டில் உள்ளன, எனவே கீழே கொடுக்கப்பட்டுள்ள உதாரணங்கள் அப்படியே செயல்படும். Haiku 5.5-ன் விலை மற்றும் அதன் பயன்பாடு புதிய மாதிரிகளில் மலிவானது குறித்த தகவல்களை வழங்குகிறது.

கட்டணங்கள் மாறக்கூடியவை. இந்தப் பக்கத்தில் உள்ள ஒவ்வொரு புள்ளிவிவரத்தையும் October 2026 தேதியிட்ட ஒரு உதாரணம் எனக் கருதி, பட்ஜெட்டை இறுதி செய்வதற்கு முன் அதிகாரப்பூர்வ விலை நிர்ணயப் பக்கத்தில் தற்போதைய எண்களை உறுதிப்படுத்தவும்.

இந்தக் கட்டணங்கள் Claude-ன் விலையை மட்டுமே குறிக்கின்றன, உங்கள் பணிச்சுமைக்கு இது மலிவான விருப்பமா என்பதை அல்ல. Claude மற்றும் ChatGPT ஆகிய இரண்டிலும் கணக்கிடப்பட்ட மூன்று பணிகள் எந்த API அதிக லாபகரமானது என்பதைக் காட்டுகிறது.

கட்டணத்தை மாற்றாத ஒரு விஷயம் context length ஆகும், இதற்கு ஒரு விதிவிலக்கு உண்டு. Claude 4.6 மற்றும் அதற்குப் பிந்தைய மாதிரிகளில், Claude Haiku 5.5-ஐத் தவிர, முழுமையான 1M token context window-க்கு நிலையான விலையே வசூலிக்கப்படுகிறது. எனவே, 900,000 token கோரிக்கையும் 9,000 token கோரிக்கையும் token-க்கு ஒரே விலையையே கொண்டிருக்கும். ஒரு நீண்ட prompt அதிக tokens-ஐக் கொண்டிருப்பதால் அதிக செலவாகும், ஆனால் நீண்ட context-க்கென தனிப்பட்ட கட்டணம் ஏதுமில்லை. Claude Haiku 5.5-ன் விலை prompt-ன் நீளத்தைப் பொறுத்து மாறுபடும்: 100,000 tokens-க்கு மேல் உள்ள prompt-க்கு, $0.10 மற்றும் $0.50-க்கு பதிலாக, உள்ளீட்டிற்கு $0.50 மற்றும் வெளியீட்டிற்கு $2.50 என ஒரு மில்லியனுக்கு வசூலிக்கப்படும். cache reads மற்றும் writes ஆகியவையும் இந்த வரம்பிற்குள் கணக்கிடப்படும்.

விலை மாற்றத்திற்குப் பிறகும் மாறாத கணக்கீடு

ஒவ்வொரு கட்டணமும் இரண்டு பெருக்கல்கள் மற்றும் ஒரு கூட்டலைக் கொண்டது.

cost = (input_tokens  / 1,000,000) * input_rate
     + (output_tokens / 1,000,000) * output_rate

இயக்கக்கூடிய குறியீடாக எழுதினால்:

INPUT_RATE = 2.00    # USD per million input tokens, Sonnet 5, October 2026
OUTPUT_RATE = 10.00  # USD per million output tokens

def cost(input_tokens, output_tokens):
    return (input_tokens * INPUT_RATE + output_tokens * OUTPUT_RATE) / 1_000_000

print(f"{cost(4300, 400):.4f}")

இது 0.0126 என்பதை அச்சிடும். 4,300 input tokens-ஐ அனுப்பி 400 output tokens-ஐப் பெறும் ஒரு கோரிக்கைக்கு, Sonnet 5-ல் சுமார் 1.3 cents செலவாகும். இரண்டு கட்டண விகிதங்களையும் உங்கள் குறியீட்டில் ஒரே இடத்தில் வைத்திருங்கள். விலை மாறும்போது, இரண்டு வரிகளை மட்டும் திருத்தினால் போதும்; உங்கள் கணினியில் உள்ள அனைத்து மதிப்பீடுகளும் அதற்கேற்ப தானாகவே மாறிவிடும்.

ஒரு நிஜமான செயலிக்கான மதிப்பீடு

ஒரு support assistant-ஐ எடுத்துக்கொள்வோம். அதன் system prompt மற்றும் product documentation ஆகியவை 4,000 tokens அளவு கொண்டவை. ஒவ்வொரு கோரிக்கையின் போதும் model இவற்றை வாசிக்கும். இயல்பாக, Messages API அழைப்புகளுக்கு இடையே எந்த நிலையையும் (state) சேமிப்பதில்லை, எனவே உங்கள் client ஒவ்வொரு முறையும் இவற்றை அனுப்பும். Message threads என்பது ஒரு optional beta வசதி; இது system prompt மற்றும் tools-ஐ ஒருமுறை அனுப்ப அனுமதிக்கிறது, அதன் பிறகு புதிய செய்திகளை மட்டும் அனுப்பினால் போதும். ஆனால், API model-ஐ அழைப்பதற்கு முன்பாக முழு உரையாடலையும் மீண்டும் கட்டமைக்கிறது. மேலும், threads பயன்பாடு விலையில் எந்த மாற்றத்தையும் ஏற்படுத்தாது என்று Anthropic கூறுகிறது. எனவே, கீழே உள்ள செலவு இரண்டு முறைகளுக்கும் சமமானதே. ஒரு பயனர் கேட்கும் கேள்வி சுமார் 300 tokens-ஐ சேர்க்கிறது. ஒரு பதில் சுமார் 400 tokens-ஐ உருவாக்குகிறது. இது ஒரு கோரிக்கைக்கு 4,300 input tokens மற்றும் 400 output tokens ஆகும்.

ஒரு மில்லியன் input tokens மூலம் இத்தகைய 232 கோரிக்கைகளைச் செய்ய முடியும். ஒரு நாளைக்கு 1,000 கோரிக்கைகள் வரும்போது, அந்த செயலி தினசரி 4.3 மில்லியன் input tokens-ஐப் பயன்படுத்துகிறது. எனவே, "1M tokens" என்பது ஆறு மணிநேரத்திற்கும் குறைவான traffic-க்கு மட்டுமே போதுமானது.

[
  {
    "label": "Opus 5, list rates",
    "cost_per_1k_usd": "31.50"
  },
  {
    "label": "Sonnet 5, list rates",
    "cost_per_1k_usd": "12.60"
  },
  {
    "label": "Sonnet 5, Batch API",
    "cost_per_1k_usd": "6.30"
  },
  {
    "label": "Haiku 4.5, list rates",
    "cost_per_1k_usd": "6.30"
  },
  {
    "label": "Sonnet 5, warm prompt cache",
    "cost_per_1k_usd": "5.40"
  }
]

Claude Opus 5-ல் அந்த traffic-க்கு 1,000 கோரிக்கைகளுக்கு $31.50 செலவாகும். Sonnet 5-ல் இது $12.60 ஆகும். Claude Haiku 4.5-க்கு மாறினால் இது $6.30 ஆகக் குறையும். Sonnet 5-ல் warm prompt cache-ஐப் பயன்படுத்தினால் செலவு இன்னும் குறைந்து $5.40 ஆகும்.

இந்த traffic-க்கான மாதச் செலவைக் கணக்கிட 30-ஆல் பெருக்க வேண்டும். Sonnet 5-ன் பட்டியல் விலையின்படி மாதம் சுமார் $378 ஆகும். அதே செயலி warm cache வசதியுடன் இருந்தால் மாதம் சுமார் $162 ஆகும். இந்த அளவில் நீங்கள் பேச்சுவார்த்தை மூலம் பெறும் எந்த விலையை விடவும், உங்கள் model தேர்வு மற்றும் caching முடிவு ஆகியவை அதிக முக்கியத்துவம் வாய்ந்தவை. எந்த model-ஐப் பயன்படுத்துவது என்பது தனிப்பட்ட கேள்வி. உங்கள் மதிப்பீடுகளில் (evaluations) தேர்ச்சி பெறும் மிக மலிவான model-ஐத் தேர்ந்தெடுக்க வேண்டும்: Opus, Sonnet மற்றும் Haiku ஆகியவற்றுக்கு இடையே தேர்ந்தெடுத்தல் பகுதியில் இதை எவ்வாறு சரியாகச் சோதிப்பது என்பது விளக்கப்பட்டுள்ளது.

Prompt caching மீண்டும் மீண்டும் வரும் பகுதிகளைக் குறைக்கிறது

அந்த 4,000 token prefix ஒவ்வொரு கோரிக்கையிலும் (request) ஒரே மாதிரியாக இருக்கும், ஆனால் ஒவ்வொரு முறையும் முழு உள்ளீட்டு விலையை நீங்கள் செலுத்த வேண்டியிருக்கும். Prompt caching என்பது செயலாக்கப்பட்ட prefix-ஐச் சேமித்து வைத்து, அதை மீண்டும் பயன்படுத்தும்போது குறைந்த கட்டணத்தை வசூலிக்கிறது.

இந்தத் தாளிலுள்ள விலைப்பட்டியல் மற்றும் உதாரணங்களில் உள்ள model-களில் (Haiku 4.5, Sonnet 5, Sonnet 4.6 மற்றும் Opus 5) மற்றும் Fable 5-ல், cache read என்பது அடிப்படை உள்ளீட்டு விலையில் 0.1 மடங்காகும். சில புதிய model-கள் குறைவான கட்டணத்தையே வசூலிக்கின்றன: Opus 5.5 மற்றும் Sonnet 5.5 ஆகியவை 0.05 மடங்கையும், Fable 5.1 மற்றும் Mythos 5.1 ஆகியவை 0.025 மடங்கையும் வசூலிக்கின்றன. Cache-ஐ எழுதுவதற்கு 5 நிமிட காலாவதிக்கு அடிப்படை விலையை விட 1.25 மடங்கு அல்லது 1 மணிநேர காலாவதிக்கு 2 மடங்கு கட்டணம் வசூலிக்கப்படும். எனவே, 0.1 மடங்கு கட்டணம் கொண்ட model-களில், ஒருமுறை read செய்தாலே 5 நிமிட cache-க்கான செலவு ஈடுசெய்யப்படும்; ஏனெனில் எழுதுவதற்கு 0.25 கூடுதல் செலவானாலும், ஒவ்வொரு read-லும் 0.9 சேமிக்கப்படுகிறது. 1 மணிநேர cache-க்குச் செலவை ஈடுசெய்ய இரண்டு read-கள் தேவைப்படும்.

இதைச் செயல்படுத்துவதற்கான எளிமையான வழி, ஒரு மேல்நிலை field-ஐப் பயன்படுத்துவதாகும்:

curl https://api.anthropic.com/v1/messages \
  -H "content-type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-opus-5",
    "max_tokens": 1024,
    "cache_control": {"type": "ephemeral"},
    "system": "You are a helpful assistant.",
    "messages": [
      {"role": "user", "content": "What are the key themes in Pride and Prejudice?"}
    ]
  }'

பிறகு திரும்ப வரும் usage தொகுப்பை வாசிக்கவும்:

{
  "usage": {
    "cache_creation_input_tokens": 5120,
    "cache_read_input_tokens": 1800,
    "input_tokens": 50,
    "output_tokens": 503
  }
}

அந்த மூன்று உள்ளீட்டு counters-ம் மூன்று வெவ்வேறு விகிதங்களில் கணக்கிடப்பட்டு, உங்கள் உண்மையான உள்ளீட்டு அளவைக் கூட்டுகின்றன: total_input_tokens = cache_read_input_tokens + cache_creation_input_tokens + input_tokens. Caching செயல்பாட்டில் இருக்கும்போது, input_tokens-ஐ மட்டும் வாசிக்கும் செலவு மதிப்பீடு தவறாக இருக்கும்.

இரண்டு காரணங்கள் cache-ன் பலனைத் தடுக்கின்றன, இவை இரண்டும் எந்த எச்சரிக்கையும் இன்றி தோல்வியடையும்.

Prefix கண்டிப்பாக byte-identical ஆக இருக்க வேண்டும். Cache lookup என்பது prefix பொருந்துதலை அடிப்படையாகக் கொண்டது. எனவே, உங்கள் system prompt-ன் தொடக்கத்தில் உள்ள timestamp அல்லது பயனரின் பெயர் ஒவ்வொரு கோரிக்கையிலும் மாறினால், அது ஒவ்வொரு முறையும் புதியதாகக் கருதப்படும். அப்போது நீங்கள் ஒவ்வொரு முறையும் அடிப்படை உள்ளீட்டு விலையை விட 1.25 மடங்கு செலுத்த வேண்டியிருக்கும், ஒருமுறை கூட cache read செய்ய முடியாது. இதன் அறிகுறி என்னவென்றால், cache_creation_input_tokens அதிகமாக இருக்கும்போது cache_read_input_tokens பூஜ்ஜியமாகவே இருக்கும். அனைத்துக் கோரிக்கைகளிலும் உள்ளடக்கத்தில் மாற்றம் இல்லாத கடைசித் தொகுதியில் cache_control-ஐ வைக்கவும், மாறுபடும் அனைத்தையும் அதற்குப் பிறகு வைக்கவும். உங்கள் tools வரையறைகளை மாற்றினால், அதற்குப் பின்னால் உள்ள முழு cache-ம் செல்லாததாகிவிடும்; ஏனெனில் செல்லாததாக்கும் செயல்முறை tools, பிறகு system, பிறகு messages என்ற வரிசையில் நடக்கும்.

Prefix போதுமான நீளத்தில் இருக்க வேண்டும். குறைந்தபட்ச cacheable நீளம் Opus 5-ல் 512 tokens, Sonnet 5-ல் 1,024 tokens மற்றும் Haiku 4.5-ல் 4,096 tokens ஆகும். இதைவிடக் குறைவான நீளம் கொண்ட prompt cache செய்யப்படாது, எந்தப் பிழையும் காட்டப்படாது. மேலே உள்ள உதாரணத்தில் உள்ள 4,000 token prefix Sonnet 5-ல் cache ஆகும், ஆனால் Haiku 4.5-ல் ஆகாது; ஏனெனில் 4,000 என்பது அந்த model-ன் குறைந்தபட்ச வரம்பிற்கு கீழ் உள்ளது. இரண்டு counters-ம் 0 என்று காட்டினால், எதுவும் cache செய்யப்படவில்லை என்று அர்த்தம்.

Batch processing கட்டணத்தை பாதியாகக் குறைக்கிறது

Batch API கோரிக்கைகளை asynchronous முறையில் செயலாக்குகிறது, இது input மற்றும் output ஆகிய இரண்டிற்கும் 50 சதவீத தள்ளுபடியை வழங்குகிறது. மேலே உள்ள உதாரணத்தில், இது 1,000 கோரிக்கைகளுக்கான $12.60 என்ற கட்டணத்தை $6.30 ஆக மாற்றுகிறது. இந்தத் தள்ளுபடி prompt caching வசதியுடனும் இணைந்து செயல்படும், எனவே bulk வேலைகளைச் செய்வதற்கு cached batch job-ஐப் பயன்படுத்துவதே மிகவும் சிக்கனமான வழியாகும். Batch-க்குள் message threads வேலை செய்யாது, எனவே ஒவ்வொரு batch கோரிக்கையும் அதன் முழு உரையாடல் விவரங்களையும் கொண்டிருக்க வேண்டும்.

இதன் மூலம் நீங்கள் இழப்பது latency (தாமதம்) மட்டுமே; எனவே பயனர் ஒருவர் காத்திருக்கும் எந்தவொரு செயலுக்கும் batch பொருத்தமானது அல்ல. இது இரவு நேர வகைப்படுத்துதல் (classification) மற்றும் ஆவணங்களை மீண்டும் நிரப்புதல் (backfills) போன்ற பணிகளுக்கு மிகவும் ஏற்றது.

ஒரே உரையாடலுக்குள் chat செலவுகள் ஏன் அதிகரிக்கின்றன

இயல்பாகவே API எந்தவொரு நிலையையும் (state) சேமிப்பதில்லை, எனவே ஒவ்வொரு முறையும் உங்கள் client முழு உரையாடலையும் மீண்டும் அனுப்புகிறது. விருப்பத்தேர்வாக உள்ள message threads beta, உரையாடலைச் சிறிது காலத்திற்கு server-ல் வைத்திருக்கும்; இதனால் பிற்கால உரையாடல்களில் புதிய செய்திகளை மட்டும் பதிவேற்றினால் போதும். இருப்பினும், model-ஐ அழைப்பதற்கு முன்பு API முழு உரையாடலையும் மீண்டும் கட்டமைக்கிறது. Anthropic-ன் கூற்றுப்படி, threads பயன்பாடு விலையில் எந்த மாற்றத்தையும் ஏற்படுத்தாது. எப்படியிருப்பினும், ஒரு chat-க்குள் token பயன்பாடு நேர்க்கோட்டில் இல்லாமல், அதன் நீளத்தின் வர்க்கத்திற்கு (square of its length) ஏற்ப அதிகரிக்கிறது.

சராசரியாக 500 tokens கொண்ட உரையாடல் சுற்றுகளைக் கருத்தில் கொள்வோம். முதல் சுற்றில் 500 input tokens அனுப்பப்படுகின்றன. இரண்டாவது சுற்றில் 1,000 tokens அனுப்பப்படுகின்றன. 20-வது சுற்றில் 10,000 tokens அனுப்பப்படுகின்றன. n(n+1)/2 சூத்திரத்தின்படி கணக்கிட்டால், 20 சுற்றுகள் கொண்ட ஒரு உரையாடலில் சுமார் 105,000 input tokens அனுப்பப்பட்டிருக்கும், ஆனால் அந்த உரையாடலின் மொத்த நீளம் வெறும் 10,000 tokens மட்டுமே.

இதனால்தான், ஒரு chat வசதியின் செலவு அதன் உரையாடல் நீளம் உணர்த்துவதை விட அதிகமாக உள்ளது. நீண்ட உரையாடல்களில் நிலையான முன்னொட்டுகளை (stable prefix) caching செய்வதோ அல்லது பழைய சுற்றுகளைச் சுருக்கி (summarising) வைப்பதோ செலவைக் குறைக்க உதவும். tool calls-ஐ மீண்டும் மீண்டும் இயக்கும் ஒரு agent-க்கும் இதே நிலைதான், இன்னும் மோசமாக: ஒவ்வொரு tool-ன் முடிவும் வரலாற்றில் தங்கி, அடுத்தடுத்த ஒவ்வொரு சுற்றிலும் மீண்டும் அனுப்பப்படும். நீங்கள் இயக்கும் agent-க்கு கடுமையான செலவு வரம்பை (spending limit) நிர்ணயிப்பது இங்கு மிக முக்கியமானது, ஏனெனில் இந்த வளர்ச்சி தானாகவே நடக்கிறது மற்றும் இதைக் கண்காணிப்பவர் யாரும் இருப்பதில்லை.

Token எண்ணிக்கையை ஊகிக்கும் முன் கணக்கிடுங்கள்

வார்த்தைகளின் எண்ணிக்கையை வைத்து token எண்ணிக்கையைத் தீர்மானிப்பதை நிறுத்துங்கள். API உங்களுக்காகவே இதை இலவசமாகக் கணக்கிடுகிறது, இது செய்தி உருவாக்கத்திற்கான rate limit-லிருந்து தனிப்பட்டது.

curl https://api.anthropic.com/v1/messages/count_tokens \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "content-type: application/json" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-opus-5",
    "system": "You are a scientist",
    "messages": [{
      "role": "user",
      "content": "Hello, Claude"
    }]
  }'

இந்த response ஒரு புலத்தை மட்டுமே கொண்டுள்ளது:

{ "input_tokens": 14 }

உங்கள் உண்மையான system prompt மற்றும் tool வரையறைகளை, ஒரு மாதிரி user message-உடன் சேர்த்து, மேலே உள்ள cost function-ல் உள்ளிடவும். இந்த endpoint, message request-க்குத் தேவையான அதே கட்டமைக்கப்பட்ட உள்ளீடுகளை ஏற்கும்; இதில் system prompts, tools, images மற்றும் PDFs அடங்கும். எனவே base64 வடிவில் அனுப்பப்படும் images மற்றும் PDFs சரியாகவே கணக்கிடப்படும். இருப்பினும், இது அனைத்து message request body-களையும் ஏற்காது. இது web search மற்றும் web fetch போன்ற server tools, MCP connector, URL அல்லது file reference மூலம் அனுப்பப்படும் images அல்லது documents, மற்றும் thread உள்ளடக்கிய எந்தவொரு கோரிக்கையையும் நிராகரிக்கும். ஒரு தொடர்ச்சியான உரையாடலுக்கு, அதன் system prompt மற்றும் tools-உடன் முழு உரையாடலையும் கணக்கிடுங்கள். இதில் இரண்டு எச்சரிக்கைகள் முக்கியமானவை. இந்த எண்ணிக்கை ஒரு மதிப்பீடு மட்டுமே, இது பில் செய்யப்படும் தொகையிலிருந்து சற்று மாறுபடலாம். மேலும், இது நீங்கள் பயன்படுத்தும் model-ன் tokenizer-ஐக் கொண்டே அளவிடப்படுகிறது, எனவே நீங்கள் உண்மையில் இயக்கப்போகும் model-ஐயே உள்ளிடவும்.

Output tokens-ஐ முன்கூட்டியே கணக்கிட முடியாது, ஏனெனில் அவை இன்னும் உருவாக்கப்படவில்லை. அவற்றை max_tokens மூலம் கட்டுப்படுத்துங்கள், பின்னர் நேரடி traffic-ல் usage.output_tokens-லிருந்து உண்மையான பரவலை அளவிடுங்கள்.

கட்டணத்தில் வேறு என்னென்ன அடங்கும்

பெரும்பாலான கட்டணம் டோக்கன்களுக்காகவே (tokens) வசூலிக்கப்படுகிறது. டோக்கன்கள் அல்லாத சில அம்சங்களும் கட்டணத்தில் அடங்கும், இவை பயனர்களுக்கு ஆச்சரியத்தை அளிக்கலாம்.

• கருவி வரையறைகள் (Tool definitions) ஒவ்வொரு கோரிக்கையின் போதும் உள்ளீட்டு டோக்கன்களாக மாறுகின்றன. Opus 5-ல், உங்கள் சொந்த ஸ்கீமாக்களைச் சேர்ப்பதற்கு முன்பே, கருவி பயன்பாட்டு முறைமைத் தூண்டுதல் (system prompt) மட்டும் 286 முதல் 406 டோக்கன்களைச் சேர்க்கிறது. பத்து விரிவான கருவி விளக்கங்கள் ஒரு சிறிய தூண்டுதலின் அளவை இருமடங்காக மாற்றக்கூடும்.
• இணையத் தேடல் (Web search) ஒரு 1,000 தேடல்களுக்கு $10 என்ற விகிதத்தில் கட்டணம் வசூலிக்கப்படுகிறது. இது தேடல் முடிவுகள் சூழலுக்குள் (context) நுழையும்போது நுகரப்படும் டோக்கன்களுக்கு மேலதிகமான கட்டணமாகும்.
• இணையத் தரவு பெறுதலுக்கு (Web fetch) தனியாகக் கட்டணம் இல்லை, ஆனால் பெறப்பட்ட பக்கம் உள்ளீட்டு டோக்கன்களாக மாறுகிறது. 100 kB அளவுள்ள ஒரு ஆவணப் பக்கம் தோராயமாக 25,000 டோக்கன்களைக் கொண்டிருக்கும்.
• Claude 4.6 மற்றும் அதற்குப் பிந்தைய பதிப்புகளில் inference_geo மூலம் அமெரிக்காவிற்குள் மட்டுமே தரவு செயலாக்கம் (US-only inference) செய்யக் கோருவது, கேச் ரீட் (cache reads) மற்றும் ரைட் (writes) உட்பட ஒவ்வொரு டோக்கன் வகைக்கும் 1.1 மடங்குக் கட்டணத்தைப் பெருக்கும்.

API-ஐ வாங்குவது சரியான முடிவா என்பது உங்கள் பயன்பாட்டு அளவைப் பொறுத்தது. ஒரு திட்டத்தின் பயன்பாட்டு உச்ச வரம்பை (usage ceiling) எட்டுவதுதான் பொதுவாக இக்கேள்வியை எழுப்புகிறது. வரம்பிலிருந்து வெளியேறும் வழிகள் என்பது காத்திருப்பு காலம் முடிவடையும் வரை காத்திருப்பது முதல், அந்தப் பணிகளை அளவிடப்பட்ட API அழைப்புகளுக்கு (metered API calls) மாற்றுவது வரை அமையும். ஒரு குறிப்பிட்ட பயன்பாட்டு அளவிற்கு கீழே, நிலையான மாதாந்திரத் திட்டமே சிறந்தது. Claude சந்தாவுடன் API-ஐ ஒப்பிடுதல் என்ற பகுதி, உண்மையான எண்களுடன் அந்த ஒப்பீட்டை விளக்குகிறது.

FAQ

Claude-ல் 1M tokens-க்கு எவ்வளவு செலவாகும்?

இது நீங்கள் பயன்படுத்தும் model மற்றும் tokens உள்ளீடா (input) அல்லது வெளியீடா (output) என்பதைப் பொறுத்தது. அக்டோபர் 2026 நிலவரப்படி, ஒரு மில்லியன் input tokens-க்கான விலை Claude Haiku 4.5-ல் $1, Claude Sonnet 5-ல் $2, மற்றும் Claude Opus 5-ல் $5 ஆகும். புதிய Claude Haiku 5.5-ல், 100,000 tokens வரையிலான prompts-க்கு ஒரு மில்லியன் input tokens-க்கு $0.10-ம், அதற்கு மேல் $0.50-ம் வசூலிக்கப்படுகிறது. ஒவ்வொரு model-லும் output விலை, input விலையை விட ஐந்து மடங்கு அதிகமாக இருக்கும். கட்டணங்கள் மாறக்கூடும் என்பதால், பட்ஜெட்டைத் திட்டமிடும் முன் அதிகாரப்பூர்வ pricing பக்கத்தில் உறுதிப்படுத்திக் கொள்ளவும்.

1M tokens என்பதும் 1M words என்பதும் ஒன்றா?

இல்லை. Claude Opus 4.7-க்கு முந்தைய model-களில், Anthropic ஒரு token-ஐ தோராயமாக 3.5 ஆங்கில எழுத்துக்களாகக் கணக்கிடுகிறது; ஒரு மில்லியன் tokens என்பது சுமார் 750,000 வார்த்தைகளுக்குச் சமம். Claude Opus 4.7 மற்றும் அதற்குப் பிந்தைய பதிப்புகளில் பயன்படுத்தப்படும் புதிய tokenizer-ல், ஒரு மில்லியன் tokens என்பது சுமார் 555,000 வார்த்தைகளைக் கொண்டிருக்கும். ஏனெனில், அதே உரையை Claude Sonnet 4.6 மற்றும் அதற்கு முந்தைய பதிப்புகளை விட இந்த tokenizer சுமார் 30 சதவீதம் அதிக tokens-ஆக மாற்றுகிறது. இந்த விகிதங்கள் ஒரு தோராயமான வழிகாட்டி மட்டுமே. Code, JSON மற்றும் ஆங்கிலம் அல்லாத பிற மொழிகள் ஒரு வார்த்தைக்கு அதிக tokens-ஐப் பயன்படுத்துகின்றன, மேலும் இந்த எண்ணிக்கை model தலைமுறைகளுக்கு இடையே மாறுபடும். நீங்கள் பயன்படுத்தத் திட்டமிட்டுள்ள model-ஐக் கொண்டு, இலவச /v1/messages/count_tokens endpoint மூலம் tokens-ஐ அளவிடவும்.

Prompt caching எப்போதும் பணத்தைச் சேமிக்குமா?

இல்லை. 5 நிமிட cache write என்பது அடிப்படை input விலையை விட 1.25 மடங்கு செலவாகும். எனவே, ஒரு prefix-ஐ எழுதி அதை ஒருமுறை கூட படிக்கவில்லை என்றால், அதைச் சாதாரணமாக அனுப்புவதை விட 25 சதவீதம் கூடுதல் செலவாகும். முதல்முறை படிக்கும்போதே இது லாபகரமாகிவிடும். இது இரண்டு வழிகளில் தோல்வியடையலாம், ஆனால் எந்த எச்சரிக்கையும் வராது. கோரிக்கைகளுக்கு இடையே cached prefix மாறினால், அது துல்லியமான prefix match என்பதால் lookup பொருந்தாது. ஒருவேளை prefix-ன் நீளம் model-ன் குறைந்தபட்ச cacheable அளவை விடக் குறைவாக இருந்தால் (Sonnet 5-ல் 1,024 tokens மற்றும் Haiku 4.5-ல் 4,096 tokens), எதுவும் cache செய்யப்படாது, எந்தப் பிழையும் காட்டப்படாது. cache_creation_input_tokens மற்றும் cache_read_input_tokens ஆகிய இரண்டும் 0 என்று காட்டினால், cache எந்த வேலையும் செய்யவில்லை என்று அர்த்தம்.

எனது message எண்ணிக்கையை விட கட்டணம் ஏன் வேகமாக அதிகரித்தது?

ஏனெனில், ஒவ்வொரு முறையும் model முழு உரையாடலையும் மீண்டும் படிக்கிறது. இயல்பாக, Messages API எந்த நிலையையும் (state) சேமிப்பதில்லை. எனவே, ஒரு உரையாடலின் 20-வது சுற்றில், முந்தைய 19 சுற்றுகளும் மீண்டும் input-ஆக அனுப்பப்படுகின்றன. விருப்பத்தேர்வாக உள்ள message threads beta மூலம் புதிய messages-ஐ மட்டும் பதிவேற்றலாம், ஆனால் threads விலையில் எந்த மாற்றத்தையும் ஏற்படுத்தாது என்று Anthropic கூறுகிறது. ஒரு சுற்றில் சராசரியாக 500 tokens இருந்தால், 20 சுற்றுகள் கொண்ட உரையாடலில் சுமார் 105,000 input tokens அனுப்பப்படும், ஆனால் உரையாடல் நீளம் வெறும் 10,000 tokens மட்டுமே இருக்கும். Agent loops-ம் இதேபோல்தான் செயல்படுகின்றன, ஏனெனில் ஒவ்வொரு tool-ன் முடிவும் வரலாற்றில் (history) அப்படியே இருக்கும். மாறாத prefix-ஐ cache செய்யவும் அல்லது பழைய சுற்றுகளைச் சுருக்கி (summarise) கோரிக்கையிலிருந்து நீக்கவும்.