लेखक: Claude के इनपुट और आउटपुट टोकन की लागत में अंतर क्यों है
Claude में आउटपुट टोकन की कीमत इनपुट से 5 गुना अधिक क्यों होती है? जानिए Prefill और Decoding की प्रक्रिया में अंतर और कैसे यह आपके मासिक AI बिल को सीधे प्रभावित करता है।
आउटपुट टोकन की लागत इनपुट टोकन से अधिक क्यों होती है
वर्तमान कैटलॉग के प्रत्येक Claude मॉडल पर आउटपुट टोकन की लागत इनपुट टोकन की तुलना में पांच गुना अधिक है। इसका कारण गणना (computation) का स्वरूप है। प्रॉम्प्ट को पढ़ना मॉडल पर एक बार की प्रक्रिया है। उत्तर लिखना प्रति टोकन एक बार की प्रक्रिया है, और प्रत्येक प्रक्रिया को अपने से पहले वाली प्रक्रिया के पूरा होने का इंतजार करना पड़ता है।
यह अनुपात मूल्य सूची की प्रत्येक पंक्ति पर समान है, इसलिए आपके द्वारा चुना गया मॉडल यह नहीं बदलता कि आपके बिल का कितना हिस्सा आउटपुट का है। यह आपके वर्कलोड का स्वरूप तय करता है। एक एजेंट स्टेप जो 60,000 टोकन पढ़ता है और 800 में उत्तर देता है, वह आउटपुट पर लगभग कुछ भी खर्च नहीं करता है। एक ड्राफ्टिंग कार्य जो 2,000 टोकन पढ़ता है और 12,000 लिखता है, वह इनपुट पर लगभग कुछ भी खर्च नहीं करता है। दोनों मामलों का विश्लेषण नीचे Anthropic की अगस्त 2026 की प्रकाशित दरों के आधार पर किया गया है।
Prefill एक बार चलता है, decoding हर token के लिए एक बार चलती है
एक inference server अनुरोध को दो चरणों में संभालता है, जिनकी लागत बहुत अलग होती है। 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 कितनी तेजी से गुणा कर सकती है।
Decoding इस तरह काम नहीं कर सकती, क्योंकि token 2, token 1 पर निर्भर करता है। model द्वारा अभी-अभी बनाया गया token अगले चरण के input का हिस्सा बन जाता है, इसलिए ये चरण एक साथ नहीं चल सकते। प्रत्येक output token का अपना forward pass होता है, और इनमें से प्रत्येक pass एक single token बनाने के लिए high-bandwidth memory से model weights के पूरे set को पढ़ता है। यह decoding को memory-bound बनाता है: सीमा यह है कि weights कितनी तेजी से move किए जा सकते हैं, न कि कितनी तेजी से उन्हें गुणा किया जा सकता है। वही weight traffic जो prefill के दौरान पूरे prompt को consume करता था, decoding के दौरान आपको केवल एक token देता है।
Serving systems batching के जरिए इसका मुकाबला करते हैं। कई अनुरोध एक साथ decode होते हैं, इसलिए weights को एक बार पढ़ने से batch में मौजूद हर अनुरोध के लिए एक token प्राप्त होता है। यही कारण है कि decoding किफायती है। इसकी सीमा फिर से memory है। चल रहा हर अनुरोध एक KV cache (key/value cache, अब तक के हर token के लिए stored attention state) रखता है, वह cache हर generate होने वाले 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'पहला डेल्टा (delta) छोटे प्रॉम्प्ट की तुलना में अधिक समय लेता है, क्योंकि प्रीफिल को पढ़ने के लिए बहुत अधिक टेक्स्ट होता है। इसके आने के बाद प्रतिक्रिया लगभग तुरंत समाप्त हो जाती है, क्योंकि डिकोड करने के लिए केवल कुछ ही टोकन बचे होते हैं। हज़ारों टोकन अंदर गए और घड़ी मुश्किल से हिली। कुछ सौ टोकन बाहर आए और घड़ी पूरे समय चलती रही।
हर नॉन-स्ट्रीमिंग प्रतिक्रिया उन नंबरों के साथ समाप्त होती है जिनके लिए आपसे शुल्क लिया जाता है।
{
"usage": {
"input_tokens": 41283,
"output_tokens": 6,
"cache_creation_input_tokens": 0,
"cache_read_input_tokens": 0
}
}प्रति अनुरोध चारों फ़ील्ड्स को लॉग करें। output_tokens में विस्तृत थिंकिंग (thinking) शामिल है, इसलिए जो मॉडल उत्तर देने से पहले सोचता है, वह उस थिंकिंग के लिए आउटपुट दर पर शुल्क लेता है। भेजने से पहले किसी प्रॉम्प्ट की कीमत जानने के लिए, POST /v1/messages/count_tokens उसी रिक्वेस्ट बॉडी को स्वीकार करता है, मॉडल को चलाए बिना {"input_tokens": N} लौटाता है, और यह निःशुल्क है। यह API का एकमात्र हिस्सा नहीं है जिस पर कोई खर्च नहीं आता, और Claude API के किन हिस्सों के लिए आपसे कभी शुल्क नहीं लिया जाता को अपने पहले प्रोजेक्ट का बजट बनाने से पहले देख लेना चाहिए।
अगस्त 2026 तक प्रति मिलियन टोकन Claude का शुल्क
The data behind this chart
[
{
"label": "Haiku 4.5",
"input_usd": 1,
"output_usd": 5,
"output_multiple": 5
},
{
"label": "Sonnet 5 (to 31 Aug)",
"input_usd": 2,
"output_usd": 10,
"output_multiple": 5
},
{
"label": "Sonnet 5 (from 1 Sep)",
"input_usd": 3,
"output_usd": 15,
"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 दो बार दिखाई देता है क्योंकि इसकी प्रारंभिक दर समाप्त हो रही है। 31 अगस्त 2026 तक इसका शुल्क $2 इनपुट और $10 आउटपुट है। 1 सितंबर 2026 से $3 इनपुट और $15 आउटपुट की मानक दर लागू होगी, जो दोनों तरफ 50% अधिक है। नीचे दिए गए प्रत्येक कार्य उदाहरण में अगस्त की दर का उपयोग किया गया है।
दरें बदलती रहती हैं, और यह पृष्ठ वह स्थान नहीं है जहाँ आपको उन्हें जाँचना चाहिए। claude.com/pricing ही सत्य का स्रोत है। मूल्य परिवर्तन के बाद भी जो चीज बनी रहती है, वह है गणना की विधि।
एक चेतावनी जो मूल्य सूची में नहीं दिखाई गई है। Anthropic का documentation बताता है कि Claude 4.7 और बाद के models एक नए tokenizer का उपयोग करते हैं, जो Sonnet 4.6 और उससे पहले के tokenizer की तुलना में समान टेक्स्ट के लिए लगभग 30% अधिक टोकन उत्पन्न करता है। केवल प्रति मिलियन टोकन मूल्य पर तुलना करने पर नए model बेहतर दिखेंगे, क्योंकि वही document उन पर अधिक टोकन लेता है। पूर्ण किए गए कार्य की लागत पर तुलना करें, और जिस model का आप वास्तव में उपयोग करने की योजना बना रहे हैं, उसके विरुद्ध अपने वास्तविक prompts की गणना करें। यही समस्या विभिन्न providers के बीच भी है, जिनके tokenizers एक-दूसरे से इससे भी अधिक भिन्न होते हैं, इसलिए Claude और ChatGPT दोनों पर वास्तविक कार्य की लागत निकालना आपको दोनों rate cards की तुलना करने से कहीं अधिक जानकारी देगा। वास्तविक टेक्स्ट में एक मिलियन Claude टोकन का मूल्य क्या है यह बताता है कि व्यवहार में वह मात्रा कैसी दिखती है।
आउटपुट कब आपके बिल का मुख्य हिस्सा बन जाता है?
आउटपुट की कीमत इनपुट से 5 गुना होने के कारण, ब्रेक-ईवन पॉइंट को याद रखना आसान है। मान लीजिए आपके इनपुट टोकन I हैं और आउटपुट टोकन O हैं। इनपुट की लागत I है। आउटपुट की लागत 5 गुना O है। आउटपुट आपके खर्च का आधा हिस्सा तब पार करता है जब 5 गुना O, I से अधिक हो जाता है, जो कि 5 इनपुट टोकन के मुकाबले 1 आउटपुट टोकन का अनुपात है।
इसलिए, यदि आपका प्रॉम्प्ट आपके उत्तर से पांच गुना से अधिक लंबा है, तो इनपुट बड़ा खर्च है। इससे कम होने पर, आउटपुट बड़ा खर्च बन जाता है।
The data behind this chart
[
{
"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% होता है और प्रॉम्प्ट एक नगण्य त्रुटि (rounding error) जैसा हो जाता है। अधिकांश लोग अपने अनुपात का गलत अनुमान लगाते हैं, इसलिए किसी भी चीज़ को ऑप्टिमाइज़ करने से पहले अपने लॉग्स से सही डेटा निकालें।
एक एजेंट वर्कलोड: लंबा इनपुट, संक्षिप्त आउटपुट
रिट्रीवल एजेंट के एक चरण पर विचार करें: रिट्रीव किए गए दस्तावेजों और बातचीत के इतिहास के 60,000 इनपुट टोकन, और 800 टोकन का उत्तर। यह 75 अनुपात 1 है, जो किसी भी ऐसी प्रक्रिया के लिए सामान्य है जो लिखने से पहले पढ़ती है।
The data behind this chart
[
{
"label": "Haiku 4.5",
"input_cost": 0.06,
"output_cost": 0.004,
"total_cost": 0.064
},
{
"label": "Sonnet 5 (Aug)",
"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 पुराने संदर्भ टोकन हटाने से लागत का लगभग एक तिहाई हिस्सा बच जाता है। रीड-हेवी एजेंट पर आउटपुट की लंबाई कम करना लगभग व्यर्थ प्रयास है। कोडिंग एजेंट के टोकन वास्तव में कहाँ जाते हैं इस बात का विवरण देता है कि प्रॉम्प्ट में सबसे पहले क्या भरा जाता है।
कार्यभार का सृजन: संक्षिप्त प्रॉम्प्ट, विस्तृत ड्राफ्ट
अब इसके विपरीत स्थिति पर विचार करें। 2,000 टोकन का संक्षिप्त विवरण, 12,000 टोकन का ड्राफ्ट, यानी 1 से 6 का अनुपात।
The data behind this chart
[
{
"label": "Haiku 4.5",
"input_cost": 0.002,
"output_cost": 0.06,
"total_cost": 0.062,
"batch_total_cost": 0.031
},
{
"label": "Sonnet 5 (Aug)",
"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 परिणाम तुरंत देने के बजाय 24 घंटे के भीतर देता है, इसलिए यह रातों-रात रिपोर्ट तैयार करने और बल्क क्लासिफिकेशन के लिए उपयुक्त है। यह उन कार्यों के लिए उपयुक्त नहीं है जहाँ कोई व्यक्ति परिणाम की प्रतीक्षा कर रहा हो।
मॉडल रूटिंग यहाँ उस तरह से लाभ पहुँचाती है जैसा कि एजेंट स्टेप पर कभी नहीं होता। यदि कार्य का विस्तृत हिस्सा यांत्रिक है, जैसे टेक्स्ट को रिफॉर्मेट करना या आपके द्वारा स्वीकृत आउटलाइन का विस्तार करना, तो सस्ता मॉडल उन टोकन को पांचवें हिस्से की कीमत पर तैयार कर देता है। Opus, Sonnet और Haiku के बीच चयन इस बात को कवर करता है कि गुणवत्ता की वास्तविक सीमा कहाँ स्थित है।
Caching केवल इनपुट पर छूट देता है
Prompt caching आपके prompt के एक हिस्से को सर्वर पर स्टोर करता है और इसे दोबारा पढ़ने के लिए इनपुट दर का एक छोटा हिस्सा चार्ज करता है। अगस्त 2026 तक, 5 मिनट के cache को लिखने के लिए मल्टीप्लायर बेस इनपुट दर का 1.25 गुना, 1 घंटे के cache के लिए 2 गुना, और cache hit को पढ़ने के लिए 0.1 गुना है।
आउटपुट इस सौदे में शामिल नहीं है। कोई भी आउटपुट cache नहीं किया जाता है। मॉडल द्वारा लिखा गया प्रत्येक टोकन पूरी आउटपुट दर पर बिल किया जाता है, चाहे prompt का कितना भी हिस्सा cache hit के रूप में वापस आया हो।
Opus 5 पर वही एजेंट स्टेप लें, जिसमें 60,000 इनपुट टोकन में से 55,000 टोकन warm cache से लिए गए हैं।
The data behind this chart
[
{
"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 हो जाती है। आउटपुट लाइन में कोई बदलाव नहीं होता: पहले $0.02, बाद में $0.02। Caching बिल को कम करती है और इसके स्वरूप को बदल देती है। उस कॉल में आउटपुट 6.25% था। अब यह इसका एक चौथाई से अधिक है, जो यह बदल देता है कि आगे किस विकल्प पर ध्यान देना फायदेमंद है।
पहली कॉल लिखने (write) का खर्च उठाती है। 5 मिनट के cache write की लागत बेस इनपुट का 1.25 गुना है, इसलिए यह एक ही hit के बाद अपनी लागत वसूल कर लेता है। 1 घंटे के write की लागत 2 गुना है, इसलिए इसे दो hit की आवश्यकता होती है। write और read मल्टीप्लायर, और जहाँ caching का लाभ मिलना बंद हो जाता है उस गणित को विस्तार से समझाता है।
चार लीवर जिन्हें आप नियंत्रित करते हैं
max_tokensको मॉडल की अधिकतम सीमा पर नहीं, बल्कि अपने p95 आउटपुट लेंथ पर सेट करें।- विस्तृत चरणों (verbose steps) को सस्ते मॉडल पर रूट करें।
- ऐसी किसी भी चीज़ को बैच (batch) करें जिसका कोई इंतज़ार नहीं कर रहा है।
- उन निर्देशों को हटा दें जो उत्तरों को अनावश्यक रूप से लंबा बनाते हैं।
max_tokens एक कठोर सीमा (hard ceiling) है, और इसे उच्च सेट करने से अपने आप में कोई लागत नहीं आती है, क्योंकि आपसे केवल उत्पन्न टोकन के लिए शुल्क लिया जाता है, न कि सीमा के लिए। एक उदार कैप का लाभ यह है कि यह गलत होने वाले उत्तर पर लगी सीमा को हटा देता है। अपने लॉग से output_tokens वितरण निकालें, कैप को 95वें पर्सेंटाइल से थोड़ा ऊपर सेट करें, और stop_reason: "max_tokens" को कोड में रिस्पॉन्स जारी रखकर या पुनः प्रयास करके संभालें। आपके द्वारा पहचानी गई ट्रंकेशन (truncation) की लागत उस 4,000 टोकन के अनावश्यक विस्तार से कम होती है जिसके लिए आप भुगतान करते हैं और फिर उसे फेंक देते हैं। विस्तारित सोच (extended thinking) भी output_tokens में ही आती है, इसलिए उस बजट को भी उसी साक्ष्य के आधार पर सेट करें।
रूटिंग तब काम करती है जब किसी चरण का महंगा हिस्सा निर्णय लेने के बजाय वॉल्यूम (मात्रा) होता है। निर्णय लेने के लिए मजबूत मॉडल का उपयोग करें, और टाइपिंग का काम किसी सस्ते मॉडल को सौंप दें। रूट किए गए संस्करण को पहले अपने स्वयं के मूल्यांकन सेट पर मापें, क्योंकि एक सस्ता मॉडल जिसे दो प्रयासों की आवश्यकता होती है, वह एक महंगे प्रयास से अधिक महंगा पड़ता है।
बैचिंग एकमात्र ऐसा लीवर है जो आउटपुट पर छूट देता है। दोनों तरफ 50% की छूट, 24 घंटे के भीतर परिणाम, और शेड्यूल पर चलने वाली कोई भी चीज़ इसके लिए पात्र है।
अंतिम लीवर वह है जिसे लोग छोड़ देते हैं। "विस्तृत रहें" (be thorough) और "अपने तर्क समझाएं" (explain your reasoning) जैसे वाक्यांश आपके द्वारा किए जाने वाले हर कॉल पर आउटपुट की लंबाई निर्धारित करते हैं। उन्हें उस प्रारूप से बदलें जो आप चाहते हैं: "अधिकतम तीन वाक्यों में उत्तर दें", या "बिना किसी प्रस्तावना के केवल JSON ऑब्जेक्ट लौटाएं"। एक सिस्टम प्रॉम्प्ट जो हर उत्तर में 300 टोकन जोड़ता है, उसकी लागत प्रॉम्प्ट में उन्हीं 300 टोकन की लागत से पांच गुना अधिक होती है। एजेंट की लागत को नियंत्रित रखना मॉनिटरिंग पक्ष को कवर करता है, और क्या आपके पैटर्न के लिए API या फ्लैट सब्सक्रिप्शन सस्ता है यह तय करना महत्वपूर्ण है, इससे पहले कि आप प्रति-टोकन खर्च को ट्यून करने में एक सप्ताह बिताएं जिसे एक सब्सक्रिप्शन ने कवर कर लिया होता। एक डेवलपर के लिए यह मुख्य रूप से इस बात पर निर्भर करता है कि क्या Claude Pro का $20 प्रति माह और उसके साथ आने वाली उपयोग सीमाएं उस काम को कवर करती हैं जिसे आप अन्यथा मीटर कर रहे होते। यदि आप पहले से ही सत्र के बीच में उन सीमाओं तक पहुँच रहे हैं, तो यह पता लगाना कि आप किस विंडो पर प्रतीक्षा कर रहे हैं पहले आता है, क्योंकि इसका समाधान एक छोटा मॉडल, हल्का संदर्भ, अतिरिक्त उपयोग क्रेडिट, या उस काम को मीटर किए गए API पर ले जाना है। यदि मीटर किया गया API उस काम के लिए सस्ता विकल्प साबित होता है, तो छोटे प्लान पर जाना या उसे रद्द करना उस महीने को सुरक्षित रखता है जिसके लिए आप पहले ही भुगतान कर चुके हैं, इसलिए स्विच करने में आपको कोई अतिरिक्त लागत नहीं आती है। यदि आप जिस प्लान की तुलना Pro से कर रहे हैं वह मीटर किए गए API के बजाय ChatGPT का है, तो दोनों सब्सक्रिप्शन की कीमतों की तुलना यह दिखाती है कि कोडिंग कार्य के लिए कौन सा सस्ता है। यदि यह प्रश्न एक डेवलपर के बजाय किसी टीम के लिए पूछा जा रहा है, तो ध्यान दें कि Claude Enterprise प्रति सीट शुल्क के साथ इन समान API दरों पर मीटर किए गए टोकन को जोड़ता है। इसलिए, इस पृष्ठ पर दिए गए सभी लीवर उस बिल के मीटर किए गए हिस्से पर लागू होते हैं।
FAQ
आउटपुट टोकन इनपुट टोकन से महंगे क्यों होते हैं?
उन्हें जनरेट करने में प्रति टोकन कहीं अधिक एक्सेलेरेटर समय लगता है। प्रॉम्प्ट को पूरे टेक्स्ट पर एक ही फॉरवर्ड पास में प्रोसेस किया जाता है, इसलिए मॉडल वेट्स को एक बार पढ़ने से हजारों टोकन कवर हो जाते हैं और हार्डवेयर की सीमा मल्टीप्लाई थ्रूपुट (multiply throughput) द्वारा तय होती है। उत्तर एक बार में एक टोकन करके तैयार किया जाता है, और प्रत्येक टोकन के लिए एक अलग फॉरवर्ड पास की आवश्यकता होती है जो पूरे मॉडल वेट्स को फिर से पढ़ता है, इसलिए हार्डवेयर की सीमा मेमोरी बैंडविड्थ द्वारा तय होती है। Anthropic ने अपने पूरे वर्तमान कैटलॉग में आउटपुट की कीमत इनपुट से पांच गुना रखी है, Haiku 4.5 से लेकर Fable 5 तक।
क्या प्रॉम्प्ट कैशिंग आउटपुट टोकन को सस्ता बनाती है?
नहीं। प्रॉम्प्ट कैशिंग केवल इनपुट पर लागू होती है। अगस्त 2026 तक, कैश रीड की लागत बेस इनपुट दर का 0.1 गुना है, और कैश राइट की लागत 5 मिनट की अवधि के लिए 1.25 गुना या 1 घंटे की अवधि के लिए 2 गुना है। आउटपुट के लिए हर कॉल पर पूरी दर से बिल लिया जाता है, चाहे कैश ने कुछ भी किया हो। यही कारण है कि कैशिंग आपके बिल के आकार के साथ-साथ उसके स्वरूप को भी बदल देती है: एक बार जब इनपुट पक्ष कम हो जाता है, तो आउटपुट वह हिस्सा बन जाता है जिसे ऑप्टिमाइज़ करना महत्वपूर्ण होता है।
क्या उच्च max_tokens मुझे पैसे खर्च करवाता है यदि उत्तर छोटा आता है?
नहीं। आपसे उन टोकन के लिए बिल लिया जाता है जो मॉडल वास्तव में प्रोड्यूस करता है, इसलिए max_tokens एक अधिकतम सीमा है, न कि कोई रिज़र्वेशन। यह अभी भी महत्वपूर्ण है, क्योंकि यह एक ऐसे उत्तर पर एकमात्र कठोर सीमा है जो बहुत लंबा हो सकता है। इसे अपने देखे गए output_tokens के 95वें परसेंटाइल से थोड़ा ऊपर सेट करें, फिर चुपचाप कटे हुए उत्तर भेजने के बजाय कोड में stop_reason: "max_tokens" को हैंडल करें।
मैं अपना इनपुट से आउटपुट टोकन अनुपात कैसे पता करूँ?
प्रत्येक रिस्पॉन्स के usage ऑब्जेक्ट से input_tokens, output_tokens, cache_read_input_tokens और cache_creation_input_tokens को लॉग करें, फिर एक सप्ताह के कुल योग को विभाजित करें। 5 इनपुट से 1 आउटपुट के अनुपात से ऊपर, आपका पैसा प्रॉम्प्ट में खर्च हो रहा है, इसलिए स्थिर हिस्से को कैश करें और बाकी को ट्रिम करें। उससे नीचे, आपका पैसा उत्तर में खर्च हो रहा है, इसलिए इसकी लंबाई को सीमित करें और उन स्टेप्स को, जो सबसे अधिक आउटपुट जनरेट करते हैं, किसी सस्ते मॉडल या Batch API पर ले जाएं।