SSD Nodes Learn Hosting plans →
మార్గదర్శకాలు Matt Connorద్వారా Matt Connor · అప్‌డేట్ చేయబడింది 2026-10-30

Claudeలో Input, Output Tokens ధర తేడా ఎందుకు?

Claudeలో output tokens ధర input tokens కంటే ఐదు రెట్లు. Prefill, decoding వేగాల తేడా agent నెలవారీ బిల్లును ఎలా మార్చుతుందో నిజమైన ఉదాహరణలతో తెలుసుకోండి.

ఇన్‌పుట్ టోకెన్ల కంటే అవుట్‌పుట్ టోకెన్లకు ఎక్కువ ఖర్చు ఎందుకు అవుతుంది

ప్రస్తుత catalogueలోని ప్రతి Claude modelలో అవుట్‌పుట్ టోకెన్ల ధర, ఇన్‌పుట్ టోకెన్ల ధరకు ఐదు రెట్లు ఉంటుంది. దీనికి కారణం 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 తదుపరి దశ input‌లో భాగమవుతుంది. కాబట్టి దశలు ఒకదాని తర్వాత ఒకటి నడుస్తాయి. ప్రతి output token‌కు ప్రత్యేక forward pass ఉంటుంది. ప్రతి pass ఒకే token‌ను ఉత్పత్తి చేయడానికి model weights మొత్తం, అలాగే KV cache (key/value cache; ఇప్పటివరకు ఉన్న ప్రతి token‌కు నిల్వచేసిన attention state) మొత్తాన్ని high-bandwidth memory నుంచి చదువుతుంది. అందువల్ల decoding సాధారణంగా memory-boundగా ఉంటుంది: weights మరియు cached state‌ను తరలించే వేగమే పరిమితి, వాటిని multiply చేసే వేగం కాదు. Long 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 ఆ ఊహలను క్రమంలోనే అంగీకరిస్తుంది. మొదటి తప్పు ఊహ వద్ద ఆగుతుంది. అందువల్ల పొడవైన reply‌కు ఇంకా అనేక passes అవసరం అవుతాయి.

Serving systems batching ద్వారా దీనికి పరిష్కారం చూపుతాయి. అనేక requests కలిసి decode అవుతాయి. కాబట్టి weights‌ను ఒక్కసారి చదవడం ద్వారా batchలోని ప్రతి request‌కు ఒక్క token ఉత్పత్తి అవుతుంది. Decoding అసలు సాధ్యమయ్యేది అందుకే. పరిమితి మళ్లీ memoryకే సంబంధించినది. ప్రస్తుతం process అవుతున్న ప్రతి request‌కు దాని స్వంత KV cache ఉంటుంది. ఉత్పత్తి అయ్యే ప్రతి token‌తో ఆ cache పెరుగుతుంది. Acceleratorలో అది నిండినప్పుడు batch ఇక పెరగదు.

ఇవేవీ మీకు ఖచ్చితమైన సంఖ్యను ఇవ్వవు. 5x‌ను కొలిచిన hardware ratioగా భావించకూడదు. ఇది Anthropic నిర్ణయించిన, ఆ అసమానత ఆధారంగా రూపొందించిన ధర. మీరు స్వయంగా నిర్ధారించగలది దిశ మాత్రమే. దానికి సుమారు ఒక నిమిషం పడుతుంది.

మీ input మరియు output gap ను స్వయంగా కొలవండి

ఏదైనా Ubuntu box లో tools ను install చేయండి:

sudo apt update && sudo apt install -y curl jq moreutils

ఇప్పుడు long answer కోరే short 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 ను జోడిస్తుంది. ఆ output నుంచి రెండు విషయాలను గమనించాలి. మొదటి content_block_delta line అనేది first token కు పట్టిన సమయం. మొత్తం prefill దాని లోపలే పూర్తవుతుంది. దాని తరువాతి ప్రతి line decoding లోని ఒక చిన్న step ను సూచిస్తుంది. message_stop వచ్చే వరకు time stamps పెరుగుతూనే ఉంటాయి.

ఇప్పుడు ఆకారాన్ని తిప్పండి. Prompt లో long document ను ఉంచి, answer ను కొన్ని 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 tokens input గా వెళ్లినా clock చాలా తక్కువగా కదిలింది. కొన్ని hundred tokens output గా వచ్చినా clock మొత్తం సమయం నడిచింది.

ప్రతి non-streaming response మీకు charge చేసే 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 ప్రకారం charge చేస్తుంది. Request పంపకముందే prompt ధరను అంచనా వేయడానికి POST /v1/messages/count_tokens చాలా requests కోసం అదే request body ను తీసుకుంటుంది. Model ను run చేయకుండా {"input_tokens": N} ను estimate గా తిరిగి ఇస్తుంది. దాని స్వంత rate limit లో ఇది free. Messages API అంగీకరించే కొన్ని bodies ను ఇది తిరస్కరిస్తుంది. ఉదాహరణకు web search వంటి server tools, MCP connector, అలాగే url లేదా file source కలిగిన image లేదా document blocks ఇందులో ఉన్నాయి. అందువల్ల వాటిని count చేసేటప్పుడు images మరియు PDFs ను base64 గా పంపండి. ఖర్చు లేని API భాగం ఇదొక్కటే కాదు. మొదటి project కు budget నిర్ణయించే ముందు Claude API లో మీకు ఎప్పటికీ charge చేయని భాగాలు పరిశీలించడం ఉపయోగకరం.

అక్టోబర్ 2026 నాటికి ప్రతి మిలియన్ tokensకు Claude వసూలు చేసే ధర

చార్ట్Claude API list rates, US dollars per million tokens, October 2026
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "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 కోసం $5 మరియు $25 వసూలు చేస్తారు. అత్యంత ఖరీదైన Fable 5 కోసం $10 మరియు $50 వసూలు చేస్తారు. ఆ పై rowను వెంటనే తిరస్కరించే ముందు ఆ Fable 5 ధరలతో మీకు ఏమి లభిస్తుందో చదవడం ఉపయోగకరం. ఈ శ్రేణిలో పైకి వెళ్లినప్పుడు రెండు వైపుల ధరలు ఒకే factorతో పెరుగుతాయి. అందువల్ల మొత్తం ఖర్చు మారుతుంది, కానీ input-to-output విభజన మాత్రం అదే విధంగా ఉంటుంది.

Sonnet 5 కోసం inputకు $2, outputకు $10 వసూలు చేస్తారు. Anthropic ఈ ధరను introductory pricingగా 31 August 2026 వరకు ప్రకటించింది. 1 September నుంచి ధరలు $3 మరియు $15కు పెరగాల్సి ఉంది. అయితే తరువాత standard priceగా $2 మరియు $10నే నిర్ణయించారు. ఆ పెంపు ఎప్పుడూ అమల్లోకి రాలేదు. కాబట్టి దిగువ worked exampleలన్నింటిలో ఉపయోగించిన ధర మీరు ప్రస్తుతం చెల్లించే ధరే.

ఈ page మొదట ప్రచురించిన తరువాత Anthropic మరిన్ని కొత్త modelsను కూడా విడుదల చేసింది. ఇప్పుడు claude.com/pricing పై పైన పేర్కొన్న నాలుగు modelsను అందుబాటులో ఉన్న 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 వరకు $0.10 మరియు $0.50 వసూలు చేస్తారు. దానిని మించినప్పుడు ధరలు $0.50 మరియు $2.50 అవుతాయి. దిగువ లెక్కించిన 60,000 token agent step ఆ పరిమితికి కింద ఉంటుంది. అయితే agent history పెరుగుతూనే ఉంటే చివరకు ఆ పరిమితిని దాటుతుంది. Haiku 5.5 యొక్క రెండు ధర స్థాయులు నిజమైన పనుల్లో ఎలా ప్రభావితం చేస్తాయో ఆ పెరుగుదల billపై చూపే ప్రభావాన్ని వివరిస్తుంది. Opus 5.5 యొక్క base input మరియు output rates, Opus 5తో పోలిస్తే 20% తక్కువ. అందువల్ల దిగువన cache ఉపయోగించని Opus 5కు చూపిన ప్రతి figure, Opus 5.5లో 20% తక్కువగా ఉంటుంది. Cached figures ఇంకా తక్కువగా ఉంటాయి. Opus 5.5లో cache hitsను ప్రతి మిలియన్ tokensకు $0.20గా లెక్కిస్తారు. Opus 5లో ఇది $0.50, అంటే 60% తగ్గింపు. దిగువన Opus 5లో $0.0725 ఖర్చయ్యే cached agent step, Opus 5.5లో సుమారు $0.047 అవుతుంది. ఇది దాదాపు 35% తక్కువ.

ధరలు మారుతుంటాయి. వాటిని తనిఖీ చేయడానికి ఈ pageను ఆధారంగా తీసుకోకండి. claude.com/pricingనే అధికారిక source of truth. ధర మారినా పద్ధతి మాత్రం మారదు.

ఒక ముఖ్యమైన మినహాయింపు Anthropic ధరల tableలోని notesలో ఉంది. Anthropic pricing page ప్రకారం Claude 4.7 మరియు తరువాతి models కొత్త tokenizerను ఉపయోగిస్తాయి. అదే textకు Sonnet 4.6 మరియు అంతకుముందు models ఉపయోగించే tokenizerతో పోలిస్తే ఈ tokenizer సుమారు 30% ఎక్కువ tokens ఉత్పత్తి చేస్తుంది. ప్రతి మిలియన్ tokens ధరను మాత్రమే పోల్చితే రెండు modelsలో కొత్త model తక్కువ ఖర్చుగా కనిపిస్తుంది. కారణం, అదే document దానిలో ఎక్కువ tokensగా లెక్కించబడుతుంది. పూర్తయిన taskకు అయ్యే cost ఆధారంగా పోల్చండి. మీరు వాస్తవంగా ఉపయోగించబోయే modelపై మీ నిజమైన promptsను లెక్కించండి. Providers మధ్య కూడా ఇదే సమస్య ఉంటుంది, ఎందుకంటే వాటి tokenizers పరస్పరం భిన్నంగా ఉంటాయి. అందువల్ల రెండు rate cardsను పక్కపక్కన పెట్టడం కంటే Claude మరియు ChatGPT రెండింటిలోనూ నిజమైన పనికి అయ్యే ఖర్చును లెక్కించడం ఎక్కువ సమాచారం ఇస్తుంది. ఒక మిలియన్ Claude tokensతో నిజమైన textలో ఏమి చేయగలమో ఆ పరిమాణం వాస్తవ వినియోగంలో ఎలా ఉంటుందో వివరిస్తుంది.

మీ బిల్లులో output ఎప్పుడు ప్రధాన భాగంగా మారుతుంది?

output ధర input కంటే 5 రెట్లు ఉంటే, సమాన ఖర్చు వచ్చే స్థాయిని సులభంగా లెక్కించవచ్చు. మీ 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 ఖర్చు ఎక్కువ.

చార్ట్Share of spend by input to output token ratio, at 5x output pricing
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "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 నిష్పత్తిలో output మొత్తం ఖర్చులో 4.8% ఉంటుంది. ఈ సందర్భంలో prompt ను చిన్నదిగా చేయడమే చేయదగిన ముఖ్యమైన పని. 5 to 1 వద్ద రెండు వైపుల ఖర్చు సమానంగా ఉంటుంది. 1 to 6 వద్ద output 96.8% ఉంటుంది. prompt ఖర్చు rounding error స్థాయిలో ఉంటుంది. చాలామంది తమ స్వంత నిష్పత్తిని తప్పుగా అంచనా వేస్తారు. కాబట్టి ఏదైనా optimization చేయడానికి ముందు దాన్ని మీ logs నుంచి తీసుకోండి.

ఏజెంట్ workload: పెద్ద context లోపలికి, చిన్న సమాధానం బయటకు

ఒక retrieval agent దశను తీసుకుందాం: retrieved documents మరియు conversation history నుంచి 60,000 input tokens, సమాధానంగా 800 tokens. ఇది 75 to 1 నిష్పత్తి. చదివిన తర్వాత రాసే ఏ workload‌కైనా ఇది సాధారణమే.

చార్ట్One agent step, 60,000 input and 800 output tokens, US dollars per call
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "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
  }
]

మొత్తం price list అంతటా ratio స్థిరంగా ఉండటంతో, ప్రతి modelలో ఆ callలో output వాటా 6.25%. ఈ call ఖర్చు Opus 5లో $0.32, Sonnet 5లో $0.128, Haiku 4.5లో $0.064. Opus 5లో రోజుకు అలాంటి 200 దశలు నడిపితే రోజుకు $64 అవుతుంది.

ఈ విభజనను చూసిన తర్వాత ఏ అంశాన్ని మార్చాలో స్పష్టంగా తెలుస్తుంది. సమాధానాన్ని 800 tokens నుంచి 400కి తగ్గిస్తే call ఖర్చులో సుమారు 3% మాత్రమే ఆదా అవుతుంది. prompt నుంచి పాత contextలోని 20,000 tokens తొలగిస్తే ఖర్చులో సుమారు మూడో వంతు ఆదా అవుతుంది. చదవడంపై ఆధారపడే agentలో output పొడవును కుదించడం దాదాపు వృథా ప్రయత్నం. coding agent tokens వాస్తవంగా ఎక్కడ వినియోగిస్తుందో ఆ promptలో మొదట ఏమి చేరుతుందో వివరిస్తుంది.

ఒక generation workload: చిన్న prompt, పొడవైన draft

ఇప్పుడు నిష్పత్తిని మార్చండి. 2,000 token brief, 12,000 token draft, అంటే 1 నుంచి 6 నిష్పత్తి.

చార్ట్One draft, 2,000 input and 12,000 output tokens, US dollars per draft
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "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 లో output వాటా 96.8%. Opus 5 తో ప్రతి draft కు $0.31 ఖర్చవుతుంది. Haiku 4.5 లో అదే draft కు $0.062 ఖర్చవుతుంది. ఈ ఐదు రెట్ల తేడా దాదాపు పూర్తిగా output వైపు నుంచే వస్తుంది. అందుకే తక్కువ ఖర్చు model ఇక్కడ ఎక్కువగా ఆదా చేస్తుంది.

చివరి column ఇదే పనిని Batch API ద్వారా చూపిస్తుంది. ఇది input మరియు output రెండింటిపై 50% తగ్గింపు ఇస్తుంది. Opus 5 లో ప్రతి draft ఖర్చు $0.155 కు తగ్గుతుంది. Batch తక్షణం కాకుండా asynchronous గా పనిచేస్తుంది. చాలా batches ఒక గంటలోపు పూర్తవుతాయని Anthropic చెబుతుంది. అయితే 24 గంటల తర్వాత కూడా processing లో ఉన్న batch expire అవుతుంది. అప్పటికి చేరుకోని ప్రతి request expired గా తిరిగి వస్తుంది. వాటికి bill చేయరు, message కూడా ఉండదు. అందువల్ల overnight report generation మరియు bulk classification కు ఇది అనుకూలం. Expire అయిన వాటిని మళ్లీ submit చేయాలి. వ్యక్తి కూర్చుని ఫలితం కోసం వేచి ఉండే పనులకు ఇది అనుకూలం కాదు.

Agent step లో ఎప్పుడూ లభించని ప్రయోజనం model routing ద్వారా ఇక్కడ లభిస్తుంది. పని యొక్క verbose భాగం mechanical గా ఉంటే, ఉదాహరణకు text ను reformat చేయడం లేదా మీరు ఇప్పటికే ఆమోదించిన outline ను విస్తరించడం, చవకైన model ఆ tokens ను ఐదో వంతు ధరకు ఉత్పత్తి చేస్తుంది. Opus, Sonnet మరియు Haiku మధ్య ఎంపిక ద్వారా నాణ్యతలో వాస్తవంగా ఎక్కడ తేడా కనిపిస్తుందో తెలుసుకోవచ్చు.

Caching input వ్యయాన్ని మాత్రమే తగ్గిస్తుంది

Prompt caching మీ prompt యొక్క ఒక prefix ను serverలో నిల్వ చేసి, దాన్ని మళ్లీ చదివేటప్పుడు input rate లోని కొంత భాగాన్ని మాత్రమే వసూలు చేస్తుంది. 27 October 2026 నాటికి, ఈ పేజీలో ధర నిర్ణయించిన models కోసం multipliers ఇలా ఉన్నాయి: 5 minute cache రాయడానికి base input rate యొక్క 1.25x, 1 hour cache రాయడానికి 2x, మరియు cache hit ను చదవడానికి 0.1x. కొత్త models cache hits ను ఇంకా తక్కువ ధరకు చదువుతాయి: Opus 5.5 మరియు Sonnet 5.5 పై 0.05x, Fable 5.1 పై 0.025x.

Output ఈ విధానంలో భాగం కాదు. Cached output ఉండదు. Promptలో ఎంత భాగం cache hit అయినా, model రాసే ప్రతి tokenకు ప్రతిసారీ పూర్తి output rate ప్రకారమే billing జరుగుతుంది.

Opus 5 పై అదే agent step ను అమలు చేయండి; మొత్తం 60,000 input tokensలో 55,000 tokens warm cache నుంచి అందించబడతాయి.

చార్ట్The same Opus 5 agent step, with and without a warm 55,000 token cache, US dollars
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "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 line మారదు: ముందు $0.02, తరువాత $0.02. Caching billను తగ్గించడంతో పాటు, దాని నిర్మాణాన్ని కూడా మారుస్తుంది. ఆ callలో Output 6.25%గా ఉంది. ఇప్పుడు అది callలో నాలుగో వంతుకంటే ఎక్కువగా ఉంది. అందువల్ల తరువాత ఏ ఖర్చు నియంత్రణ చర్య తీసుకోవడం విలువైనదో మారుతుంది.

మొదటి callలో write ఖర్చు చెల్లించాలి. 5 minute cache write కు base input యొక్క 1.25x ఖర్చవుతుంది. అందువల్ల ఒక్క hit వచ్చిన తర్వాతే దాని ఖర్చు తిరిగి వస్తుంది. 1 hour writeకు 2x ఖర్చవుతుంది. కాబట్టి దీనికి రెండు hits అవసరం. write మరియు read multipliers, అలాగే caching ద్వారా పొదుపు ఆగే స్థానం ఆ లెక్కను వివరిస్తుంది.

మీరు నియంత్రించగల నాలుగు అంశాలు

  1. max_tokens ను model maximum వద్ద కాకుండా, మీ p95 output length వద్ద సెట్ చేయండి.
  2. ఎక్కువ వివరణాత్మక దశలను తక్కువ ఖర్చైన model కు route చేయండి.
  3. ఎవ్వరూ వేచి ఉండాల్సిన అవసరం లేని పనులను batch చేయండి.
  4. replies ను అనవసరంగా పొడిగించే instructions ను తొలగించండి.

max_tokens ఒక hard ceiling. దాన్ని ఎక్కువగా సెట్ చేసినంత మాత్రాన ఖర్చు ఉండదు, ఎందుకంటే మీరు ఉత్పత్తి చేసిన tokens కు మాత్రమే బిల్లు చెల్లిస్తారు; ceiling కు ఎప్పుడూ చెల్లించరు. ఎక్కువ cap వల్ల తప్పుగా సాగిన reply పై పరిమితి తొలగిపోతుంది. మీ logs నుంచి output_tokens distribution ను తీసుకుని, cap ను 95th percentile కంటే కొద్దిగా ఎక్కువగా సెట్ చేయండి. తరువాత stop_reason: "max_tokens" ను code లో నిర్వహించండి: response ను కొనసాగించండి లేదా retry చేయండి. మీరు గుర్తించే truncation కు అయ్యే ఖర్చు, చెల్లించి తర్వాత విస్మరించే 4,000 token ramble కంటే తక్కువ. Thinking కూడా output_tokens లోకి చేరి max_tokens పై లెక్కలోకి వస్తుంది. అందువల్ల అదే ఆధారంతో cap పరిమాణాన్ని నిర్ణయించండి. Adaptive thinking ఉన్న models లో thinking reply ను ఎక్కువగా ఆక్రమిస్తే effort level ను తగ్గించండి.

ఒక దశలో ఖరీదైన భాగం judgement కాకుండా volume అయినప్పుడు routing పనిచేస్తుంది. నిర్ణయం తీసుకునే పనిని బలమైన model వద్ద ఉంచి, typing ను తక్కువ ఖర్చైన model కు అప్పగించండి. ముందుగా మీ స్వంత evaluation set పై routed version ను కొలవండి. ఎందుకంటే పూర్తయిన task కు అయ్యే ఖర్చే ముఖ్యమైన సంఖ్య. పైన పేర్కొన్న agent step లో, రెండు Haiku 4.5 attempts కు $0.128 ఖర్చవుతుంది; ఒక Opus 5 attempt కు $0.32 ఖర్చవుతుంది. కాబట్టి ఈ ధర వ్యత్యాసం ఒకటి లేదా రెండు retries ను భరించగలదు. అయితే ఎవరూ గుర్తించని తప్పు సమాధానాన్ని అది భరించదు.

Output పై discount ఇచ్చే ఏకైక అంశం batching. రెండు వైపులా 50% తగ్గింపు ఉంటుంది. చాలా batches ఒక గంటలో పూర్తవుతాయి. షెడ్యూల్ ఆధారంగా నడిచే ఏ పనికైనా ఇది వర్తిస్తుంది, అయితే 24 hour గడువు వద్ద expire అయ్యే పనిని job మళ్లీ submit చేయాలి.

చివరి అంశాన్ని చాలామంది విస్మరిస్తారు. "be thorough", "explain your reasoning" వంటి phrases మీరు చేసే ప్రతి call లో output length ను పెంచుతాయి. వాటి స్థానంలో కావలసిన output రూపాన్ని స్పష్టంగా చెప్పండి: "Answer in at most three sentences", లేదా "Return only the JSON object, with no preamble". ప్రతి reply కు 300 tokens జోడించే system prompt, prompt లోని అదే 300 tokens కంటే ఐదు రెట్లు ఖర్చవుతుంది. నడుస్తున్న agent ఖర్చులను నియంత్రణలో ఉంచడం monitoring వైపు వివరిస్తుంది. అలాగే మీ pattern కు API లేదా flat subscription లో ఏది చౌకో నిర్ణయించడం కూడా ముఖ్యమే. లేకపోతే subscription భరించగల per-token ఖర్చును సర్దుబాటు చేయడానికి మీరు ఒక వారం వెచ్చించవచ్చు. ఒక developer కోసం, సాధారణంగా ప్రశ్న ఇదే: Claude Pro యొక్క నెలకు $20 ధర మరియు దానితో వచ్చే usage limits మీరు meter చేయాల్సిన పనిని భరించగలవా? మీరు ఇప్పటికే mid-session లో ఆ limits ను చేరుకుంటే, ముందుగా మీరు ఏ window కోసం వేచి ఉన్నారో నిర్ణయించడం అవసరం. ఆ తరువాత పరిష్కారం చిన్న model, తక్కువ context, అదనపు usage credits లేదా ఆ పనిని metered API పైకి మార్చడం కావచ్చు. Metered API ఆ పనికి చౌకైన ఎంపికగా తేలితే, చిన్న plan కు మారడం లేదా దాన్ని cancel చేయడం మీరు ఇప్పటికే చెల్లించిన నెలను ప్రభావితం చేయదు. కాబట్టి మార్పు చేయడానికి అదనపు ఖర్చు ఉండదు. మీరు metered API తో కాకుండా ChatGPT యొక్క plan తో Pro ను పోల్చుతున్నట్లయితే, పక్కపక్కన చూపిన రెండు subscription స్థాయిల ధరలు coding పనికి ఏది చౌకో చూపిస్తాయి. ఈ ప్రశ్న ఒక developer కోసం కాకుండా team కోసం అడుగుతున్నట్లయితే, Claude Enterprise ప్రతి seat కు fee ను, ఇదే API rates వద్ద meter చేసిన tokens తో కలుపుతుంది అని గుర్తుంచుకోండి. అందువల్ల ఈ పేజీలోని ప్రతి అంశం ఆ bill లోని metered భాగానికీ వర్తిస్తుంది.

FAQ

Output tokens input tokens కంటే ఎందుకు ఎక్కువ ఖర్చవుతాయి?

వాటిని ఉత్పత్తి చేయడానికి ప్రతి token‌కు accelerator సమయం చాలా ఎక్కువగా అవసరం అవుతుంది. Prompt‌ను మొత్తం ఒకే forward pass‌లో process చేస్తారు. అందువల్ల model weights‌ను ఒక్కసారి చదవడం ద్వారా వేలాది tokens‌ను కవర్ చేయవచ్చు. ఈ సందర్భంలో hardware సాధారణంగా multiply throughput ద్వారా పరిమితం అవుతుంది. సాధారణ decoding‌లో reply‌ను ఒక్కో token చొప్పున ఉత్పత్తి చేస్తారు. ప్రతి token‌కు model weights మరియు పెరుగుతున్న KV cache‌ను మళ్లీ చదివే ప్రత్యేక forward pass అవసరం అవుతుంది. అందువల్ల hardware సాధారణంగా memory bandwidth ద్వారా పరిమితం అవుతుంది. Speculative decoding వంటి పద్ధతులు ఈ తేడాను తగ్గిస్తాయి, కానీ పూర్తిగా తొలగించవు. Haiku 5.5 నుంచి Fable 5.1 వరకు ప్రస్తుత మొత్తం catalogue‌లో Anthropic output‌ను input కంటే ఐదు రెట్లు ధరగా నిర్ణయిస్తుంది.

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 writes‌కు 5 minute duration కోసం 1.25x, 1 hour duration కోసం 2x ఖర్చవుతుంది. Cache ఏం చేసినా, ప్రతి call‌లో output‌కు పూర్తి rate‌నే వసూలు చేస్తారు. అందుకే caching మీ bill పరిమాణాన్ని మాత్రమే కాకుండా దాని నిర్మాణాన్ని కూడా మారుస్తుంది. Input భాగం తగ్గిపోయిన తర్వాత, తగ్గించాల్సిన ప్రధాన ఖర్చు output అవుతుంది.

అధిక max_tokens ఉంటే reply చిన్నగా వచ్చినప్పుడు కూడా నాకు ఖర్చవుతుందా?

లేదు. Model వాస్తవంగా ఉత్పత్తి చేసిన tokens‌కే మీకు billing జరుగుతుంది. కాబట్టి max_tokens అనేది ceiling మాత్రమే, ముందస్తు reservation కాదు. అయినప్పటికీ ఇది ముఖ్యమే, ఎందుకంటే నియంత్రణ లేకుండా పెరిగే reply‌కు ఇది ఏకైక hard limit. మీరు గమనించిన output_tokens యొక్క 95th percentile కంటే కొద్దిగా ఎక్కువగా దీన్ని సెట్ చేయండి. తరువాత stop_reason: "max_tokens" ను code‌లో handle చేయండి. ఇలా చేస్తే reply మౌనంగా truncated అయ్యే పరిస్థితిని నివారించవచ్చు.

నా input-to-output token ratio‌ను నేను ఎలా కనుగొనాలి?

ప్రతి response‌లోని usage object నుంచి input_tokens, output_tokens, cache_read_input_tokens మరియు cache_creation_input_tokens ను log చేయండి. తరువాత ఒక వారం మొత్తాల ఆధారంగా ratio‌ను లెక్కించండి. Input-to-output నిష్పత్తి 5:1 కంటే ఎక్కువగా ఉంటే, మీ ఖర్చు prompt‌లోనే ఉంది. అందువల్ల స్థిరమైన భాగాన్ని cache చేసి, మిగిలినదాన్ని కుదించండి. దాని కంటే తక్కువగా ఉంటే, మీ ఖర్చు reply‌లో ఉంది. అందువల్ల దాని పొడవును పరిమితం చేయండి. ఎక్కువ output‌ను ఉత్పత్తి చేసే దశలను చౌకైన model‌కు లేదా Batch API‌కు మార్చండి.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?