लेखक: Matt Connor 2026-10-27 · अपडेट किया गया: 2026-10-28

Claude में output tokens महंगे क्यों होते हैं?

Q: मैं अपना input-to-output token ratio कैसे पता करूँ?

प्रत्येक response के usage object से input_tokens, output_tokens, cache_read_input_tokens और cache_creation_input_tokens को log करें, फिर एक सप्ताह के कुल योग को विभाजित करें। यदि ratio 5 input से 1 output से अधिक है, तो आपका पैसा prompt में खर्च हो रहा है, इसलिए स्थिर हिस्से को cache करें और बाकी को trim करें। यदि यह उससे कम है, तो आपका पैसा उत्तर में खर्च हो रहा है, इसलिए इसकी लंबाई को सीमित करें और उन steps को, जो सबसे अधिक output generate करते हैं, किसी सस्ते model या Batch API पर ले जाएँ।

Claude के output tokens की कीमत input से पांच गुना अधिक क्यों है? इस लेख में decoding और prefill की प्रक्रिया और आपके मासिक बिल पर इसके वास्तविक प्रभाव को विस्तार से समझें।

आउटपुट टोकन की लागत इनपुट टोकन से अधिक क्यों होती है

वर्तमान कैटलॉग के प्रत्येक Claude मॉडल पर आउटपुट टोकन की लागत इनपुट टोकन की तुलना में पांच गुना अधिक है। इसका कारण कंप्यूटेशन का स्वरूप है। प्रॉम्प्ट को पढ़ना मॉडल पर एक बार की प्रक्रिया है। उत्तर लिखना प्रति टोकन एक बार की प्रक्रिया है, और प्रत्येक प्रक्रिया को अपने से पहले वाली प्रक्रिया के पूरा होने का इंतजार करना पड़ता है।

यह अनुपात मूल्य सूची की प्रत्येक पंक्ति पर समान है, इसलिए आप जो मॉडल चुनते हैं, वह आपके बिल में आउटपुट के हिस्से को नहीं बदलता है। यह आपके वर्कलोड का स्वरूप तय करता है। एक एजेंट स्टेप जो 60,000 टोकन पढ़ता है और 800 में उत्तर देता है, वह आउटपुट पर लगभग कुछ भी खर्च नहीं करता है। एक ड्राफ्टिंग कार्य जो 2,000 टोकन पढ़ता है और 12,000 लिखता है, वह इनपुट पर लगभग कुछ भी खर्च नहीं करता है। दोनों मामलों का विश्लेषण नीचे Anthropic की प्रकाशित दरों के आधार पर किया गया है, जिसे 27 October 2026 को जाँचा गया था।

Prefill एक बार चलता है, decoding प्रति token एक बार चलती है

एक inference server दो चरणों में request को handle करता है, जिनकी लागत बहुत अलग होती है। Prefill prompt को पढ़ता है। Decoding उत्तर लिखता है।

Prefill पूरे prompt को एक साथ लेता है। हर prompt token एक ही forward pass में network में प्रवेश करता है, इसलिए attention और feed-forward का काम एक बार में हजारों tokens को कवर करने वाले कुछ बड़े matrix multiplications बन जाता है। memory से model weights को एक बार पढ़ना पूरे prompt के लिए पर्याप्त होता है। accelerator की matrix units व्यस्त रहती हैं, जिसका अर्थ है कि prefill आमतौर पर compute-bound होता है: सीमा यह है कि chip कितनी तेजी से गुणा कर सकती है। NVIDIA का serving documentation इसके अपवाद बताता है: बहुत छोटे prefills, और ऐसे prefills जहाँ एक लंबा prefix पहले से ही cache hit है, वे memory-bound हो जाते हैं।

सामान्य decoding उस तरह काम नहीं कर सकती, क्योंकि token 2, token 1 पर निर्भर करता है। model द्वारा अभी-अभी उत्पन्न किया गया token अगले चरण के input का हिस्सा बन जाता है, इसलिए ये चरण एक के बाद एक चलते हैं। प्रत्येक output token को अपना forward pass मिलता है, और उन passes में से प्रत्येक, एक single token उत्पन्न करने के लिए high-bandwidth memory से model weights के पूरे set और KV cache (key/value cache, अब तक के प्रत्येक token के लिए संग्रहीत attention state) को पढ़ता है। यह आमतौर पर decoding को memory-bound बना देता है: सीमा यह है कि weights और cached state को कितनी तेजी से move किया जा सकता है, न कि उन्हें कितनी तेजी से गुणा किया जा सकता है, और लंबे contexts पर NVIDIA, KV cache reads को bottleneck के रूप में चिन्हित करता है। वही weight traffic जो prefill के दौरान पूरे prompt को consume करता था, decoding के दौरान आपको केवल एक token देता है।

Speculative decoding उस नियम को तोड़े बिना उसे बदल देता है। एक छोटा draft model कई tokens आगे का अनुमान लगाता है, और बड़ा model एक ही pass में उन सभी की समानांतर (parallel) जाँच करता है, जिसे NVIDIA के अनुसार decode को compute-bound की ओर ले जाने की संभावना है। बड़ा model अभी भी अनुमानों को क्रम में स्वीकार करता है और पहले गलत अनुमान पर रुक जाता है, इसलिए एक लंबे उत्तर की लागत अभी भी कई passes के बराबर होती है।

Serving systems batching के जरिए इसका मुकाबला करते हैं। कई requests एक साथ decode होती हैं, इसलिए weights को एक बार पढ़ने से batch में मौजूद प्रत्येक request के लिए एक token उत्पन्न होता है। यही कारण है कि decoding किफायती है। सीमा फिर से memory है। flight में मौजूद प्रत्येक request का अपना KV cache होता है, वह cache हर उत्पन्न token के साथ बढ़ता है, और जब यह accelerator को भर देता है, तो batch और अधिक नहीं बढ़ सकता।

इनमें से कोई भी आपको सटीक संख्या नहीं देता है, और आपको 5x को मापे गए hardware ratio के रूप में नहीं पढ़ना चाहिए। यह Anthropic द्वारा निर्धारित एक मूल्य है, जो उस विषमता (asymmetry) पर आधारित है। आप स्वयं जो जाँच सकते हैं वह दिशा है, और इसमें लगभग एक मिनट का समय लगता है।

इनपुट और आउटपुट गैप को स्वयं मापें

किसी भी Ubuntu मशीन पर ये टूल्स इंस्टॉल करें:

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

अब एक छोटा प्रॉम्प्ट स्ट्रीम करें जो लंबे उत्तर की मांग करता हो, और प्रत्येक लाइन पर उसके आने का समय अंकित करें।

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 प्रत्येक लाइन के आगे कमांड शुरू होने के बाद से बीता हुआ समय सेकंड में जोड़ता है। उस आउटपुट से दो चीजें पढ़ना महत्वपूर्ण है। पहली content_block_delta लाइन आपका 'टाइम टू फर्स्ट टोकन' (time to first token) है, और सारा प्रीफिल (prefill) इसी के भीतर हुआ है। उसके बाद की हर लाइन डिकोडिंग का एक छोटा चरण है, और message_stop के आने तक टाइम स्टैम्प बढ़ते रहते हैं।

अब स्थिति को उलट दें। प्रॉम्प्ट में एक लंबा दस्तावेज़ डालें और उत्तर को कुछ ही टोकन तक सीमित रखें।

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'

पहला डेल्टा छोटे प्रॉम्प्ट की तुलना में अधिक समय लेता है, क्योंकि प्रीफिल को पढ़ने के लिए बहुत अधिक टेक्स्ट होता है। इसके आने के बाद प्रतिक्रिया लगभग तुरंत समाप्त हो जाती है, क्योंकि डिकोड करने के लिए केवल कुछ ही टोकन बचे होते हैं। हज़ारों टोकन इनपुट में गए और घड़ी मुश्किल से हिली। कुछ सौ टोकन आउटपुट में आए और घड़ी पूरे समय चलती रही।

प्रत्येक नॉन-स्ट्रीमिंग प्रतिक्रिया उन नंबरों के साथ समाप्त होती है जिनके लिए आपसे शुल्क लिया जाता है।

{
  "usage": {
    "input_tokens": 41283,
    "output_tokens": 6,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0
  }
}

प्रति अनुरोध चारों फ़ील्ड्स को लॉग करें। output_tokens में थिंकिंग टोकन शामिल होते हैं, इसलिए जो मॉडल उत्तर देने से पहले सोचता है, वह उस सोच के लिए आउटपुट दर पर शुल्क लेता है। भेजने से पहले प्रॉम्प्ट की कीमत का अनुमान लगाने के लिए, POST /v1/messages/count_tokens अधिकांश अनुरोधों के लिए समान रिक्वेस्ट बॉडी लेता है, मॉडल को चलाए बिना {"input_tokens": N} को अनुमान के रूप में लौटाता है, और अपनी रेट लिमिट के भीतर यह मुफ्त है। यह कुछ ऐसी बॉडीज़ को अस्वीकार कर देता है जिन्हें Messages API स्वीकार कर लेता है: जैसे अधिकांश सर्वर टूल्स (वेब सर्च, MCP कनेक्टर) और url या file सोर्स वाले इमेज या डॉक्यूमेंट ब्लॉक। इसलिए इमेज और PDF को गिनते समय उन्हें base64 के रूप में भेजें। यह API का एकमात्र हिस्सा नहीं है जो मुफ्त है, और Claude API के किन हिस्सों के लिए आपसे कभी शुल्क नहीं लिया जाता को अपने पहले प्रोजेक्ट का बजट बनाने से पहले देख लेना उचित है।

अक्टूबर 2026 तक प्रति मिलियन टोकन Claude का शुल्क

चार्टClaude API list rates, US dollars per million tokens, October 2026

label

input_usd

output_usd

output_multiple

Haiku 4.5

Sonnet 5

Opus 5

Fable 5

इस चार्ट के पीछे का डेटा

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

अंतिम कॉलम इनपुट द्वारा विभाजित आउटपुट है, और यह हर पंक्ति पर 5 दर्शाता है। Haiku 4.5 के लिए इनपुट शुल्क $1 और आउटपुट शुल्क $5 है। Opus 5 का शुल्क $5 इनपुट और $25 आउटपुट है। Fable 5, जो सबसे महंगा है, $10 इनपुट और $50 आउटपुट लेता है, और Fable 5 की उन दरों से आपको क्या मिलता है इसे पढ़ना उपयोगी है, इससे पहले कि आप उस शीर्ष पंक्ति को नजरअंदाज करें। रेंज में ऊपर जाने पर दोनों तरफ एक ही फैक्टर से गुणा होता है, इसलिए यह आपके कुल खर्च को बदल देता है लेकिन इनपुट और आउटपुट का अनुपात वही रहता है।

Sonnet 5 का शुल्क $2 इनपुट और $10 आउटपुट है। Anthropic ने इसे 31 अगस्त 2026 तक शुरुआती मूल्य निर्धारण के रूप में लॉन्च किया था, जिसमें 1 सितंबर से $3 और $15 तक की वृद्धि निर्धारित थी, लेकिन बाद में इसे $2 और $10 का मानक मूल्य बना दिया गया। वह वृद्धि कभी लागू नहीं हुई, इसलिए नीचे दिए गए प्रत्येक कार्य उदाहरण में वही दर है जो आप आज चुकाते हैं।

इस पेज के पहली बार लाइव होने के बाद से Anthropic ने नए मॉडल भी जारी किए हैं, और claude.com/pricing अब ऊपर दिए गए चार मॉडलों को legacy मॉडल के रूप में सूचीबद्ध करता है जो अभी भी उपलब्ध हैं। नए मॉडल भी वही 5x अनुपात बनाए रखते हैं। Opus 5.5 का शुल्क $4 इनपुट और $20 आउटपुट है, Sonnet 5.5 का $2 इनपुट और $10 आउटपुट है, Fable 5.1 का $10 इनपुट और $50 आउटपुट है, और Haiku 5.5 का शुल्क 100,000 टोकन तक के प्रॉम्प्ट के लिए $0.10 इनपुट और $0.50 आउटपुट है, जो उससे ऊपर जाने पर $0.50 और $2.50 हो जाता है। नीचे दिया गया 60,000 टोकन वाला agent step उस सीमा के नीचे आता है, लेकिन एक agent जिसका इतिहास लगातार बढ़ रहा है, वह अंततः इसे पार कर जाएगा, और वास्तविक कार्यों पर Haiku 5.5 के दो मूल्य स्तर कैसे काम करते हैं यह दिखाता है कि वह उछाल बिल पर क्या असर डालता है। Opus 5.5 की आधार इनपुट और आउटपुट दरें Opus 5 से 20% कम हैं, इसलिए नीचे दिए गए सभी uncached Opus 5 आंकड़े Opus 5.5 पर 20% कम हैं। Cached आंकड़े और भी कम हो जाते हैं, क्योंकि Opus 5.5 cache hits को $0.50 के बजाय $0.20 प्रति मिलियन टोकन पर पढ़ता है, जो कि 60% की कटौती है। नीचे दिया गया cached agent step जो Opus 5 पर $0.0725 का है, Opus 5.5 पर लगभग $0.047 का पड़ता है, जो लगभग 35% कम है।

दरें बदलती रहती हैं, और यह पेज वह जगह नहीं है जहाँ आपको उन्हें चेक करना चाहिए। claude.com/pricing ही सत्य का स्रोत है। जो चीज मूल्य परिवर्तन के बाद भी बनी रहती है, वह है तरीका।

एक चेतावनी Anthropic के मूल्य तालिका के नीचे नोट्स में दी गई है, न कि दरों में। Anthropic का मूल्य निर्धारण पेज बताता है कि Claude 4.7 और बाद के मॉडल एक नए tokenizer का उपयोग करते हैं जो Sonnet 4.6 और उससे पहले के tokenizer की तुलना में समान टेक्स्ट के लिए लगभग 30% अधिक टोकन उत्पन्न करता है। केवल प्रति मिलियन टोकन मूल्य पर तुलना करने पर नए मॉडल बेहतर दिखेंगे, क्योंकि उसी दस्तावेज़ के लिए इसमें अधिक टोकन लगते हैं। प्रति पूर्ण कार्य लागत (cost per finished task) पर तुलना करें, और अपने वास्तविक प्रॉम्प्ट्स की गणना उस मॉडल के आधार पर करें जिसका उपयोग आप वास्तव में करने की योजना बना रहे हैं। यही समस्या विभिन्न प्रदाताओं के बीच भी है, जिनके tokenizer एक-दूसरे से भिन्न होते हैं, इसलिए Claude और ChatGPT दोनों पर वास्तविक कार्य की लागत निकालना आपको दोनों रेट कार्ड को अगल-बगल रखने से कहीं अधिक जानकारी देगा। वास्तविक टेक्स्ट में एक मिलियन Claude टोकन का क्या मूल्य है यह कवर करता है कि वह वॉल्यूम व्यवहार में कैसा दिखता है।

आउटपुट का खर्च आपके बिल में कब हावी होने लगता है?

जब आउटपुट की कीमत इनपुट से 5 गुना अधिक होती है, तो ब्रेक-ईवन पॉइंट को समझना आसान होता है। मान लीजिए आपके इनपुट टोकन I हैं और आउटपुट टोकन O हैं। इनपुट की लागत I है। आउटपुट की लागत 5 गुना O है। आउटपुट का खर्च कुल खर्च का आधा तब हो जाता है जब 5 गुना O का मान I से अधिक हो जाता है, जो कि 5 इनपुट टोकन के मुकाबले 1 आउटपुट टोकन का अनुपात है।

इसलिए, यदि आपका प्रॉम्प्ट आपके उत्तर से पांच गुना से अधिक लंबा है, तो इनपुट का खर्च मुख्य मद है। इससे कम होने पर, आउटपुट का खर्च मुख्य मद बन जाता है।

चार्टShare of spend by input to output token ratio, at 5x output pricing

label

input_share_pct

output_share_pct

100:1

95.2

4.8

75:1

93.75

6.25

20:1

10:1

66.7

33.3

5:1

1:1

16.7

83.3

1:6

3.2

96.8

इस चार्ट के पीछे का डेटा

[
  {
    "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 अनुपात 1 पर, आउटपुट कुल खर्च का 4.8% होता है, और ऐसी स्थिति में केवल प्रॉम्प्ट को छोटा करने का प्रयास ही सार्थक होता है। 5 अनुपात 1 पर दोनों पक्षों का खर्च बराबर होता है। 1 अनुपात 6 पर, आउटपुट 96.8% होता है और प्रॉम्प्ट का खर्च नगण्य हो जाता है। अधिकांश लोग अपने अनुपात का गलत अनुमान लगाते हैं, इसलिए किसी भी चीज़ को ऑप्टिमाइज़ करने से पहले अपने logs से सही डेटा निकालें।

एक एजेंट वर्कलोड: लंबा इनपुट, संक्षिप्त आउटपुट

रिट्रीवल एजेंट के एक चरण पर विचार करें: रिट्रीव किए गए दस्तावेज़ों और बातचीत के इतिहास के 60,000 इनपुट टोकन, और 800 टोकन का उत्तर। यह 75:1 का अनुपात है, जो किसी भी ऐसी प्रक्रिया के लिए सामान्य है जो लिखने से पहले पढ़ती है।

चार्टOne agent step, 60,000 input and 800 output tokens, US dollars per call

label

input_cost

output_cost

total_cost

Haiku 4.5

0.06

0.004

0.064

Sonnet 5

0.12

0.008

0.128

Opus 5

0.3

0.02

0.32

Fable 5

0.6

0.04

0.64

इस चार्ट के पीछे का डेटा

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

आउटपुट हर मॉडल पर उस कॉल का 6.25% होता है, क्योंकि यह अनुपात पूरी मूल्य सूची में स्थिर है। यह कॉल Opus 5 पर $0.32, Sonnet 5 पर $0.128, और Haiku 4.5 पर $0.064 की लागत रखती है। Opus 5 पर प्रतिदिन ऐसे दो सौ चरण चलाने का खर्च $64 प्रति दिन है।

एक बार जब आप इस विभाजन को देख लेते हैं, तो सुधार का तरीका स्पष्ट हो जाता है। उत्तर को 800 टोकन से घटाकर 400 करने पर कॉल की लागत में लगभग 3% की बचत होती है। प्रॉम्प्ट से 20,000 पुराने संदर्भ टोकन हटाने से लागत का लगभग एक तिहाई हिस्सा बच जाता है। रीड-हैवी एजेंट पर आउटपुट की लंबाई कम करने का प्रयास लगभग व्यर्थ है। कोडिंग एजेंट के टोकन वास्तव में कहाँ खर्च होते हैं इस बात का विश्लेषण करता है कि प्रॉम्प्ट में सबसे पहले क्या भरा जाता है।

जेनरेशन वर्कलोड: संक्षिप्त प्रॉम्प्ट, विस्तृत ड्राफ्ट

चार्टOne draft, 2,000 input and 12,000 output tokens, US dollars per draft

label

input_cost

output_cost

total_cost

batch_total_cost

Haiku 4.5

0.002

0.06

0.062

0.031

Sonnet 5

0.004

0.12

0.124

0.062

Opus 5

0.01

0.3

0.31

0.155

Fable 5

0.02

0.6

0.62

0.31

इस चार्ट के पीछे का डेटा

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

आउटपुट इस बिल का 96.8% है। Opus 5 की लागत प्रति ड्राफ्ट $0.31 है, जबकि Haiku 4.5 पर यह $0.062 है। यह पांच गुना अंतर लगभग पूरी तरह से आउटपुट पक्ष से आता है, और यही वह जगह है जहाँ एक सस्ता मॉडल आपको सबसे अधिक बचत कराता है।

अंतिम कॉलम Batch API के माध्यम से किए गए उसी कार्य को दर्शाता है, जो इनपुट और आउटपुट पर 50% की छूट देता है। Opus 5 की लागत घटकर प्रति ड्राफ्ट $0.155 हो जाती है। Batch प्रक्रिया तत्काल होने के बजाय एसिंक्रोनस (asynchronous) होती है। Anthropic का कहना है कि अधिकांश बैच एक घंटे से कम समय में पूरे हो जाते हैं, लेकिन यदि कोई बैच 24 घंटे बाद भी प्रोसेस हो रहा हो तो वह समाप्त (expire) हो जाता है। ऐसी स्थिति में, जिन अनुरोधों तक वह नहीं पहुँच पाया है, वे एक्सपायर्ड, बिना बिल के और बिना किसी संदेश के वापस आ जाते हैं। इसलिए, यह रात भर चलने वाली रिपोर्ट जनरेशन और बल्क क्लासिफिकेशन के लिए उपयुक्त है, बशर्ते एक्सपायर होने वाले कार्यों के लिए री-सबमिट करने का विकल्प हो। यह उन कार्यों के लिए उपयुक्त नहीं है जहाँ कोई व्यक्ति परिणाम की प्रतीक्षा कर रहा हो।

मॉडल रूटिंग यहाँ उस तरह से लाभ देती है जैसा एजेंट स्टेप पर कभी नहीं मिलता। यदि कार्य का विस्तृत हिस्सा यांत्रिक है, जैसे टेक्स्ट को रिफॉर्मेट करना या आपके द्वारा पहले से स्वीकृत आउटलाइन का विस्तार करना, तो सस्ता मॉडल उन टोकन्स को पांचवें हिस्से की कीमत पर तैयार कर देता है। Opus, Sonnet और Haiku के बीच चयन इस बात को कवर करता है कि गुणवत्ता की वास्तविक सीमा कहाँ स्थित है।

Caching केवल input पर छूट देता है

Prompt caching आपके prompt के एक prefix को सर्वर पर स्टोर करता है और इसे दोबारा पढ़ने के लिए input दर का एक छोटा हिस्सा चार्ज करता है। 27 October 2026 तक, इस पेज पर दी गई कीमतों वाले मॉडल्स के लिए multipliers इस प्रकार हैं: 5 मिनट के cache को लिखने के लिए base input दर का 1.25x, 1 घंटे के cache के लिए 2x, और cache hit को पढ़ने के लिए 0.1x। नए मॉडल्स में hit पढ़ने की दर कम है: Opus 5.5 और Sonnet 5.5 पर 0.05x, और Fable 5.1 पर 0.025x।

Output इस सौदे का हिस्सा नहीं है। कोई cached output नहीं होता। मॉडल द्वारा लिखा गया प्रत्येक token हर बार पूरी output दर पर बिल किया जाता है, भले ही prompt का कितना भी हिस्सा cache hit के रूप में वापस आया हो।

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

input_cost

output_cost

total_cost

No cache

0.3

0.02

0.32

55k prefix cache read

0.0525

0.02

0.0725

इस चार्ट के पीछे का डेटा

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

कॉल की लागत $0.32 से घटकर $0.0725 हो जाती है। Output की लागत में कोई बदलाव नहीं होता: पहले $0.02, बाद में $0.02। Caching बिल को कम करती है और उसके स्वरूप को बदल देती है। उस कॉल में output का हिस्सा 6.25% था। अब यह एक चौथाई से अधिक हो गया है, जिससे यह तय होता है कि आगे किस पहलू पर ध्यान देना फायदेमंद है।

पहली कॉल write का खर्च उठाती है। 5 मिनट के cache write की लागत base input का 1.25x है, इसलिए यह एक ही hit के बाद अपना खर्च निकाल लेता है। 1 घंटे के write की लागत 2x है, इसलिए इसके लिए दो hits की आवश्यकता होती है। write और read multipliers, और जहाँ caching का लाभ मिलना बंद हो जाता है उस गणित को विस्तार से समझाता है।

नियंत्रण के चार लीवर

max_tokens को मॉडल की अधिकतम सीमा पर नहीं, बल्कि अपने p95 आउटपुट लेंथ पर सेट करें।
विस्तृत चरणों (verbose steps) को सस्ते मॉडल पर रूट करें।
जिस काम के लिए कोई प्रतीक्षा नहीं कर रहा है, उसे बैच (batch) करें।
उन निर्देशों को हटा दें जो उत्तरों को अनावश्यक रूप से लंबा करते हैं।

max_tokens एक हार्ड सीलिंग है। इसे उच्च सेट करने से स्वयं कोई लागत नहीं बढ़ती, क्योंकि आपसे उत्पादित टोकन के लिए शुल्क लिया जाता है, न कि सीलिंग के लिए। एक उदार कैप का लाभ यह है कि यह गलत होने वाले उत्तरों पर लगी सीमा को हटा देता है। अपने लॉग से output_tokens वितरण निकालें, कैप को 95वें परसेंटाइल से थोड़ा ऊपर सेट करें, और stop_reason: "max_tokens" को कोड में रिस्पॉन्स जारी रखकर या पुनः प्रयास (retry) करके संभालें। आपके द्वारा पहचानी गई ट्रंकेशन (truncation) की लागत, उस 4,000 टोकन के लंबे उत्तर से कम होती है जिसके लिए आप भुगतान करते हैं और जिसे बाद में फेंक देते हैं। थिंकिंग भी output_tokens में आती है और max_tokens के विरुद्ध गिनी जाती है, इसलिए कैप का आकार उसी साक्ष्य के आधार पर तय करें। एडेप्टिव थिंकिंग वाले मॉडल पर, यदि थिंकिंग उत्तर की जगह ले रही है, तो प्रयास का स्तर कम करें।

रूटिंग तब काम करती है जब किसी चरण का महंगा हिस्सा निर्णय के बजाय वॉल्यूम (मात्रा) हो। निर्णय के लिए मजबूत मॉडल का उपयोग करें और टाइपिंग का काम किसी सस्ते मॉडल को सौंप दें। रूट किए गए संस्करण को पहले अपने स्वयं के मूल्यांकन सेट पर मापें, क्योंकि जो संख्या मायने रखती है वह प्रति पूर्ण कार्य की लागत है। ऊपर दिए गए एजेंट चरण पर, दो Haiku 4.5 प्रयासों की लागत $0.128 है, जबकि एक Opus 5 प्रयास की लागत $0.32 है, इसलिए मूल्य का अंतर एक या दो बार पुनः प्रयास करने की अनुमति देता है। यह गलत उत्तर को स्वीकार नहीं करता है जिसे कोई नहीं पकड़ पाता।

बैचिंग एकमात्र ऐसा लीवर है जो आउटपुट पर छूट देता है। दोनों तरफ 50% की छूट मिलती है, अधिकांश बैच एक घंटे के भीतर पूरे हो जाते हैं, और शेड्यूल पर होने वाला कोई भी कार्य इसके लिए योग्य है, बशर्ते जॉब 24 घंटे की सीमा पर समाप्त होने वाली किसी भी चीज़ को पुनः सबमिट कर दे।

अंतिम लीवर वह है जिसे लोग छोड़ देते हैं। "विस्तृत रहें" और "अपने तर्क समझाएं" जैसे वाक्यांश आपके द्वारा किए जाने वाले हर कॉल पर आउटपुट की लंबाई निर्धारित करते हैं। उन्हें उस आकार से बदलें जो आप चाहते हैं: "अधिकतम तीन वाक्यों में उत्तर दें", या "केवल JSON ऑब्जेक्ट लौटाएं, बिना किसी प्रस्तावना के"। एक सिस्टम प्रॉम्प्ट जो हर उत्तर में 300 टोकन जोड़ता है, उसकी लागत प्रॉम्प्ट में उन्हीं 300 टोकन की लागत से पांच गुना अधिक होती है। एजेंट की लागत को नियंत्रण में रखना मॉनिटरिंग पक्ष को कवर करता है, और आपके पैटर्न के लिए API या फ्लैट सब्सक्रिप्शन में से क्या सस्ता है यह तय करना महत्वपूर्ण है, इससे पहले कि आप प्रति-टोकन खर्च को ट्यून करने में एक सप्ताह बिताएं जिसे एक सब्सक्रिप्शन ने कवर कर लिया होता। एक डेवलपर के लिए यह मुख्य रूप से इस बात पर निर्भर करता है कि क्या Claude Pro का $20 प्रति माह और उसके साथ आने वाली उपयोग सीमाएं उस काम को कवर करती हैं जिसे आप अन्यथा मीटर कर रहे होते। यदि आप पहले से ही सत्र के बीच में उन सीमाओं तक पहुँच रहे हैं, तो यह पता लगाना कि आप किस विंडो पर प्रतीक्षा कर रहे हैं पहले आता है, क्योंकि इसका समाधान एक छोटा मॉडल, हल्का संदर्भ, अतिरिक्त उपयोग क्रेडिट, या उस काम को मीटर किए गए API पर ले जाना है। यदि मीटर किया गया API उस काम के लिए सस्ता विकल्प साबित होता है, तो छोटे प्लान पर जाना या इसे रद्द करना आपके द्वारा पहले से भुगतान किए गए महीने को सुरक्षित रखता है, इसलिए स्विच करने से आपको बाहर निकलने पर कोई अतिरिक्त लागत नहीं आती है। यदि आप Pro की तुलना ChatGPT के सब्सक्रिप्शन से कर रहे हैं, तो दोनों सब्सक्रिप्शन की कीमतों की तुलना दिखाती है कि कोडिंग कार्य के लिए कौन सा सस्ता है। यदि यह प्रश्न एक डेवलपर के बजाय किसी टीम के लिए पूछा जा रहा है, तो ध्यान दें कि Claude Enterprise प्रति सीट शुल्क को इन्हीं API दरों पर मीटर किए गए टोकन के साथ जोड़ता है। इसलिए, इस पृष्ठ पर दिया गया हर लीवर उस बिल के मीटर किए गए आधे हिस्से पर लागू होता है।

FAQ

Output tokens की कीमत input tokens से अधिक क्यों होती है?

उन्हें generate करने में प्रति token कहीं अधिक accelerator time लगता है। एक prompt को पूरे तौर पर एक ही forward pass में process किया जाता है, इसलिए model weights को एक बार पढ़ने से ही हजारों tokens process हो जाते हैं और hardware आमतौर पर multiply throughput द्वारा सीमित होता है। सामान्य decoding में उत्तर एक-एक token करके तैयार किया जाता है, और प्रत्येक token के लिए एक अलग forward pass की आवश्यकता होती है जो model weights और बढ़ते हुए KV cache को फिर से पढ़ता है, इसलिए hardware आमतौर पर memory bandwidth द्वारा सीमित हो जाता है। Speculative decoding जैसी तकनीकें इस अंतर को कम तो करती हैं, लेकिन पूरी तरह खत्म नहीं करतीं। Anthropic अपने पूरे वर्तमान catalogue में output की कीमत input से पांच गुना रखता है, Haiku 5.5 से लेकर Fable 5.1 तक।

क्या prompt caching से output tokens सस्ते हो जाते हैं?

नहीं। Prompt caching केवल input पर लागू होता है। 27 October 2026 तक, अधिकांश models पर cache read की कीमत base input दर का 0.1x है (Opus 5.5 और Sonnet 5.5 पर 0.05x, Fable 5.1 पर 0.025x), और cache write की कीमत 5 मिनट की अवधि के लिए 1.25x या 1 घंटे की अवधि के लिए 2x है। Output का बिल हर call पर पूरी दर से ही आता है, चाहे cache ने कुछ भी किया हो। यही कारण है कि caching आपके बिल के आकार के साथ-साथ उसके स्वरूप को भी बदल देता है: एक बार जब input का खर्च कम हो जाता है, तो output ही वह हिस्सा बन जाता है जिस पर ध्यान देना आवश्यक होता है।

क्या उच्च `max_tokens` होने पर मुझे पैसे देने पड़ते हैं यदि उत्तर छोटा आता है?

नहीं। आपसे केवल उन tokens के लिए शुल्क लिया जाता है जो model वास्तव में produce करता है, इसलिए max_tokens एक अधिकतम सीमा (ceiling) है, न कि कोई reservation। यह फिर भी महत्वपूर्ण है, क्योंकि यह किसी runaway reply पर एकमात्र कठोर सीमा है। इसे अपने देखे गए output_tokens के 95th percentile से थोड़ा ऊपर सेट करें, और फिर चुपचाप कटे हुए (truncated) उत्तर भेजने के बजाय code में stop_reason: "max_tokens" को handle करें।

मैं अपना input-to-output token ratio कैसे पता करूँ?

प्रत्येक response के usage object से input_tokens, output_tokens, cache_read_input_tokens और cache_creation_input_tokens को log करें, फिर एक सप्ताह के कुल योग को विभाजित करें। यदि ratio 5 input से 1 output से अधिक है, तो आपका पैसा prompt में खर्च हो रहा है, इसलिए स्थिर हिस्से को cache करें और बाकी को trim करें। यदि यह उससे कम है, तो आपका पैसा उत्तर में खर्च हो रहा है, इसलिए इसकी लंबाई को सीमित करें और उन steps को, जो सबसे अधिक output generate करते हैं, किसी सस्ते model या Batch API पर ले जाएँ।

क्या यह लेख उपयोगी था?

#claude #pricing #tokens #api #cost-control

आउटपुट टोकन की लागत इनपुट टोकन से अधिक क्यों होती है

Prefill एक बार चलता है, decoding प्रति token एक बार चलती है

इनपुट और आउटपुट गैप को स्वयं मापें

अक्टूबर 2026 तक प्रति मिलियन टोकन Claude का शुल्क

आउटपुट का खर्च आपके बिल में कब हावी होने लगता है?

एक एजेंट वर्कलोड: लंबा इनपुट, संक्षिप्त आउटपुट

जेनरेशन वर्कलोड: संक्षिप्त प्रॉम्प्ट, विस्तृत ड्राफ्ट

Caching केवल input पर छूट देता है

नियंत्रण के चार लीवर

FAQ

Output tokens की कीमत input tokens से अधिक क्यों होती है?

क्या prompt caching से output tokens सस्ते हो जाते हैं?

क्या उच्च max_tokens होने पर मुझे पैसे देने पड़ते हैं यदि उत्तर छोटा आता है?

मैं अपना input-to-output token ratio कैसे पता करूँ?

क्या यह लेख उपयोगी था?

क्या उच्च `max_tokens` होने पर मुझे पैसे देने पड़ते हैं यदि उत्तर छोटा आता है?