Claude API इतना महंगा क्यों है? टोकन गणित समझें

Claude महंगा क्यों है? संक्षिप्त उत्तर

Claude के महंगे होने के चार कारण हैं जो एक-दूसरे के साथ जुड़ जाते हैं। Output tokens की कीमत input tokens की तुलना में पांच गुना अधिक है। API आपकी बातचीत को याद नहीं रखता है, इसलिए हर बार पूरी history को फिर से भेजा जाता है और हर बार उसका शुल्क लिया जाता है। एक agent एक सवाल को दर्जनों API calls में बदल देता है, और प्रत्येक call में वह बढ़ती हुई history शामिल होती है। इन सबके ऊपर, frontier model की कीमत उसके द्वारा किए जाने वाले कार्य की कठिनाई के आधार पर तय की जाती है, न कि छोटे model को चलाने की लागत के आधार पर।

एक token टेक्स्ट का एक हिस्सा होता है। एक मोटे अनुमान के अनुसार, एक token लगभग चार characters या अंग्रेजी के लगभग 0.75 शब्दों के बराबर होता है। दरें प्रति मिलियन tokens के हिसाब से दी जाती हैं, जिसे MTok (million tokens) लिखा जाता है। नीचे दी गई प्रत्येक दर अगस्त 2026 तक प्रकाशित Claude API दर है।

ज्यादातर हैरान करने वाले बिल उस सूची के दूसरे और तीसरे कारणों से आते हैं। लोग आमतौर पर यह मानकर आते हैं कि Claude द्वारा लिखे गए उत्तरों के लिए पैसे देने पड़ते हैं। एक agent session में, लिखने की लागत अक्सर बिल के दसवें हिस्से से भी कम होती है।

प्रकाशित दरें, ताकि हम संख्याओं पर सहमत हो सकें

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

निरपेक्ष संख्याओं के बजाय उनके अनुपात पर ध्यान दें। प्रत्येक मॉडल इनपुट की तुलना में आउटपुट के लिए ठीक पांच गुना अधिक शुल्क लेता है। Opus 5 की लागत प्रति मिलियन इनपुट टोकन 5 डॉलर और प्रति मिलियन आउटपुट टोकन 25 डॉलर है। Haiku 4.5 की लागत 1 और 5 है। इसलिए सबसे सस्ते मॉडल से सबसे महंगे मॉडल तक का अंतर पांच गुना है, और पढ़ने (इनपुट) से लिखने (आउटपुट) तक का अंतर भी पांच गुना है।

Sonnet 5 की प्रारंभिक कीमत 31 अगस्त, 2026 तक प्रति मिलियन 2 और 10 डॉलर है। 1 सितंबर, 2026 से यह बढ़कर 3 और 15 हो जाएगी। दरें मॉडल releases के साथ बदलती हैं, इसलिए उन पर बजट बनाने से पहले वर्तमान दरों की जाँच कर लें। इस तालिका के नीचे कोई मुफ्त टियर (free tier) उपलब्ध नहीं है, हालांकि नए accounts को थोड़ा credit मिलता है और API के कुछ हिस्से पूरी तरह से निःशुल्क हैं।

अंतिम कॉलम cache read दर है। यह अधिकांश बिलों को निर्धारित करता है। गणना के बाद इस पर वापस आएं।

Output tokens की लागत input tokens से पांच गुना अधिक क्यों है?

पढ़ना और लिखना समान कार्य नहीं हैं। Input tokens को एक ही बार में process किया जाता है। Model पूरे prompt को एक साथ पढ़ता है और उस पर काम समानांतर (parallel) रूप से चलता है, यही कारण है कि 60,000 tokens वाले prompt को पढ़ने में 1,000 tokens वाले prompt की तुलना में 60,000 गुना अधिक समय नहीं लगता है।

Output tokens एक-एक करके उत्पन्न होते हैं। प्रत्येक नए token को model के माध्यम से अपने स्वयं के pass की आवश्यकता होती है, और इसे संदर्भ (context) के रूप में अपने से पहले के प्रत्येक token की आवश्यकता होती है। 1,000 tokens लिखने का अर्थ है 1,000 passes, एक के बाद एक। यह क्रमिक (serial) कार्य उस तरह से नहीं फैलाया जा सकता जैसे पढ़ने का कार्य किया जा सकता है, इसलिए प्रत्येक output token हार्डवेयर को अधिक समय तक व्यस्त रखता है।

यही कारण है कि "उत्तर को छोटा करें" लोगों की अपेक्षा से कम प्रभावी उपाय है। यह एक agent के बिल के छोटे हिस्से पर ही काम करता है।

हर टर्न पर मेरी पूरी बातचीत के लिए बिल क्यों बनता है?

Claude API स्टेटलेस (stateless) है। Anthropic की तरफ कोई ऐसी बातचीत जमा नहीं रहती जिसमें आप केवल एक नया संदेश जोड़ रहे हों। प्रत्येक रिक्वेस्ट में पूरा मैसेज हिस्ट्री शामिल होती है, और कुछ भी लिखने से पहले मॉडल उस पूरे इतिहास को पढ़ता है। इसलिए 30वें टर्न पर 1 से 29 तक के टर्न के लिए भी बिल बनता है।

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

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

ऊपर दिया गया सेशन 20,000 टोकन्स से शुरू होता है, जिसमें सिस्टम प्रॉम्प्ट, टूल डेफिनिशन और एजेंट द्वारा खोली गई पहली फाइलें शामिल हैं। टर्न 40 तक कॉन्टेक्स्ट में 100,000 टोकन्स होते हैं। यदि आप सभी चालीस टर्न का औसत निकालें, तो प्रति रिक्वेस्ट लगभग 60,000 टोकन्स पढ़े जाते हैं।

एक agent, chat की तुलना में इतना महंगा क्यों है?

एक chat में प्रति प्रश्न एक request होती है। एक agent में प्रति चरण (step) एक request होती है। किसी file को पढ़ना एक चरण है। कोई test चलाना एक चरण है। test के output को पढ़ना एक चरण है। file को edit करना एक चरण है। एक coding agent के लिए किसी कार्य को पूरा करने में चालीस चरण लगना सामान्य बात है।

tool के उपयोग के साथ दो अतिरिक्त लागतें जुड़ी होती हैं। tool की परिभाषाएँ हर request पर input tokens के रूप में जाती हैं, क्योंकि model को हर बार यह बताना पड़ता है कि कौन-से tools उपलब्ध हैं। Anthropic ने इस overhead को प्रकाशित किया है: जब tool_choice को auto पर set किया जाता है, तो tool use system prompt 286 tokens का होता है, जिसमें आपके स्वयं के tool schemas के tokens भी जुड़ जाते हैं। कुछ server-side tools पर अलग से शुल्क भी लगता है। Web search के लिए, परिणाम द्वारा consume किए गए tokens के अलावा, प्रति 1,000 searches $10 का शुल्क लिया जाता है।

हर tool का परिणाम भी स्थायी context बन जाता है। यदि कोई command 3,000 lines print करती है, तो वे 3,000 lines session के शेष भाग के लिए हर request में शामिल हो जाती हैं। Claude Code द्वारा रिपोर्ट किया जाने वाला प्रति-session token usage इसे स्पष्ट करता है: किसी लंबी output वाली command के तुरंत बाद input संख्या को बढ़ते हुए देखें।

एक वास्तविक सत्र का हिसाब

यहाँ Opus 5 पर एजेंटिक कोडिंग का एक यथार्थवादी घंटा दिया गया है। इसमें 40 API requests शामिल हैं। context 20,000 से बढ़कर 100,000 tokens तक पहुँच जाता है, इसलिए प्रति request औसत लगभग 60,000 tokens रहता है। मॉडल प्रति request लगभग 700 tokens लिखता है, जिसमें छोटे tool calls और कोड के कुछ लंबे blocks का मिश्रण होता है।

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

विभाजन पर ध्यान दें। Reading की लागत 12.00 डॉलर है और writing की लागत 0.70 डॉलर है, इसलिए जो output आप वास्तव में पढ़ते हैं, वह बिल का लगभग पांच प्रतिशत है। मॉडल ने 28,000 tokens लिखे और उसे 2,400,000 tokens पढ़ने के लिए बिल किया गया। किसी ने भी 2.4 मिलियन tokens टाइप नहीं किए। वही 100,000 tokens बार-बार पढ़े गए।

लेवल 1: प्रॉम्प्ट कैशिंग, जो सबसे बड़ा कारक है

प्रॉम्प्ट कैशिंग आपके प्रॉम्प्ट के स्थिर उपसर्ग (stable prefix) के प्रोसेस किए गए रूप को स्टोर करती है। अगली रिक्वेस्ट पर, उस उपसर्ग को दोबारा प्रोसेस करने के बजाय कैश से पढ़ा जाता है। कैश में लिखने की लागत 5 मिनट वाले कैश के लिए इनपुट दर का 1.25 गुना, या 1 घंटे वाले कैश के लिए 2 गुना होती है। इसे पढ़ने की लागत इनपुट दर का 0.1 गुना है। Opus 5 पर, यह 0.50 डॉलर प्रति मिलियन है, न कि 5 डॉलर।

इसे ऊपर दिए गए सत्र पर लागू करें। जैसे-जैसे बातचीत बढ़ती है, 100,000 टोकन में से प्रत्येक को एक बार कैश में लिखा जाता है। बाकी 2,300,000 इनपुट टोकन कैश रीड बन जाते हैं।

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_control फ़ील्ड के साथ चिह्नित करते हैं। ब्रेकपॉइंट को उस सामग्री के बाद रखें जो टर्न के बीच नहीं बदलती है: जैसे सिस्टम प्रॉम्प्ट और टूल परिभाषाएँ। एक लंबा दस्तावेज़ जिसका आप बार-बार संदर्भ देते हैं, उसे भी उसी स्थिर ब्लॉक में होना चाहिए।

{
  "model": "claude-opus-5",
  "system": [
    {
      "type": "text",
      "text": "<long, stable instructions>",
      "cache_control": {"type": "ephemeral"}
    }
  ],
  "messages": [{"role": "user", "content": "..."}]
}

अब आपके प्रॉम्प्ट का क्रम यह तय करता है कि पैसे कितने खर्च होंगे। कैश हिट के लिए प्रॉम्प्ट की शुरुआत से ही सटीक मिलान की आवश्यकता होती है, इसलिए जो कुछ भी हर रिक्वेस्ट पर बदलता है, उसे उन चीजों के बाद होना चाहिए जो नहीं बदलती हैं। यदि आप अपने सिस्टम प्रॉम्प्ट के शीर्ष पर टाइमस्टैम्प रखते हैं, तो आप हर टर्न पर कैश को तोड़ देंगे: पूरा उपसर्ग मिस (miss) हो जाएगा, और आपको इसे दोबारा लिखने के लिए इनपुट दर का 1.25 गुना भुगतान करना होगा।

रिस्पॉन्स आपको बताता है कि क्या यह काम कर गया। एक रिक्वेस्ट भेजें और 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"}]
  }'

हर रिस्पॉन्स में इस तरह का एक usage ऑब्जेक्ट होता है:

{
  "usage": {
    "input_tokens": 105,
    "cache_creation_input_tokens": 7345,
    "cache_read_input_tokens": 7123,
    "output_tokens": 239
  }
}

एक रिपीट रिक्वेस्ट जिसमें cache_read_input_tokens में अभी भी 0 दिखाई देता है, इसका मतलब है कि कैश हिट नहीं हो रहा है। इसका सामान्य कारण यह है कि आपके ब्रेकपॉइंट से पहले कुछ बदल गया है। 5 मिनट वाला कैश एक्सपायर भी हो जाता है, इसलिए 6 मिनट बाद भेजी गई रिक्वेस्ट एक मिस होगी जिसके बाद एक नया राइट (write) होगा।

लेवल 2: आसान टर्न को छोटे मॉडल पर भेजें

एजेंट सत्र में अधिकांश टर्न कठिन नहीं होते हैं। किसी फाइल को खोलना, फॉर्मैटर चलाना, या डिफ (diff) पढ़ना। इनके लिए फ्रंटियर मॉडल की आवश्यकता नहीं होती है। इन्हें Haiku 4.5 पर रूट करने से इनपुट दर 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"
  }
]

वही सत्र Opus 5 पर बिना कैशिंग के 12.70 डॉलर, कैशिंग के साथ 2.48 डॉलर, Sonnet 5 पर कैशिंग के साथ 0.99 डॉलर, और Haiku 4.5 पर कैशिंग के साथ 0.50 डॉलर का पड़ता है। केवल कैशिंग बिल का लगभग अस्सी प्रतिशत हिस्सा कम कर देती है। मॉडल का चुनाव बाकी बचे खर्च का अधिकांश हिस्सा हटा देता है।

यहाँ एक स्पष्ट चेतावनी है। एक सस्ता मॉडल जो गलत उत्तर देता है, वह आपको पूरे सत्र का खर्च दोबारा भुगतने पर मजबूर करता है, साथ ही आपका समय भी बर्बाद होता है। कार्य की कठिनाई के आधार पर रूट करें, न कि कीमत के आधार पर। यह नियम ऊपर की ओर भी लागू होता है: Claude Fable 5 की कीमत Opus 5 से ऊपर $10 और $50 प्रति मिलियन है, इसलिए ये दरें आपको क्या प्रदान करती हैं इसे पढ़ने के बाद ही वहां कोई टर्न भेजें। Opus, Sonnet और Haiku के बीच चुनाव यह बताता है कि प्रत्येक मॉडल कहाँ बेहतर प्रदर्शन करता है।

स्तर 3: कॉन्टेक्स्ट हाइजीन

कॉन्टेक्स्ट में छोड़ा गया प्रत्येक टोकन हर शेष टर्न पर बिल किया जाता है, इसलिए किसी टोकन को जल्दी हटाना उसे देर से हटाने की तुलना में कहीं अधिक फायदेमंद है। 40 टर्न वाले सेशन के 5वें टर्न पर डाला गया 5,000 टोकन का फाइल 35 बार और पढ़ा जाता है। यह 175,000 अतिरिक्त इनपुट टोकन हैं, जो एक लापरवाह पेस्ट के लिए Opus 5 पर लगभग एक डॉलर के बराबर है।

चार आदतें जो इस संख्या को बदलती हैं:

• कल के सेशन को जारी रखने के बजाय नए कार्य के लिए एक नया सेशन शुरू करें।
• आउटपुट के मॉडल तक पहुँचने से पहले ही शोर मचाने वाले कमांड्स को head -50 जैसे किसी टूल से फिल्टर करें, न कि बाद में।
• केवल उस एक फंक्शन के बारे में पूछें जिसकी आपको आवश्यकता है, पूरी फाइल के बारे में नहीं।
• जब एक लंबा सेशन प्रगति करना बंद कर दे, तो एक सारांश (summary) मांगें और उससे फिर से शुरुआत करें। सारांश कुछ सौ टोकन का होता है। ट्रांसक्रिप्ट एक लाख टोकन की होती है।

लेवल 4: जो इंटरैक्टिव नहीं है उसे बैच करें

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

क्या मुझसे ज्यादा पैसे लिए जा रहे हैं?

"Claude महंगा क्यों है" के पीछे यही असली सवाल है, इसलिए यहाँ एक सीधा जवाब दिया गया है। दरें प्रकाशित की गई हैं, मानक टियर पर सभी के लिए समान हैं, और शुल्क प्रति टोकन लिया जाता है। अपवाद केवल बातचीत द्वारा तय किया गया अनुबंध है, और वहाँ भी Claude Enterprise pricing में टोकन के बजाय प्रति सीट शुल्क जोड़ा जाता है, न कि उन्हें बदला जाता है। यदि आप किसी अन्य प्लान के बजाय किसी अन्य वेंडर से तुलना कर रहे हैं, तो the same jobs priced on the Claude and ChatGPT APIs यह दिखाता है कि कौन सा विकल्प कहाँ सस्ता पड़ता है। बिल में कुछ भी विवेकाधीन नहीं है। रेट कार्ड आपको यह नहीं बता सकता कि आपको मूल्य मिल रहा है या नहीं, क्योंकि यह टोकन की कीमत तय करता है और आपको परिणामों की परवाह है।

इसलिए परिणामों की कीमत तय करें। ऊपर दिए गए सेशन की लागत बिना कैशिंग के 12.70 डॉलर थी। यदि इसने कोई ऐसा फीचर तैयार किया जिसमें आपको एक घंटा लगता, तो यह सस्ता है। यदि इसने चालीस बार गोल-गोल घूमने में समय बर्बाद किया, तो वही 12.70 डॉलर किसी काम के नहीं थे, और दर कभी समस्या नहीं थी।

यह वह हिस्सा है जिसे याद रखना जरूरी है। आपका बिल टोकन के साथ बढ़ता है, मूल्य के साथ नहीं। एक उत्पादक सेशन और एक बर्बाद सेशन, यदि समान लंबाई के हों, तो उनकी लागत समान होती है। यही कारण है कि चार लीवर रेट कार्ड से अधिक मायने रखते हैं: आप प्रति टोकन कीमत पर बातचीत नहीं कर सकते, लेकिन आप यह तय करते हैं कि काम में कितने टोकन लगेंगे।

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

क्या आपके बिल को कम नहीं करता है

कुछ लोकप्रिय सलाह का बहुत कम प्रभाव पड़ता है। मॉडल को "संक्षिप्त रहने" (be concise) के लिए कहना आउटपुट को छोटा करता है, जबकि आउटपुट कुल बिल का केवल पांच प्रतिशत होता है। अपने प्रश्न को छोटा करने से 60,000 टोकन के कॉन्टेक्स्ट में कुछ सौ टोकन ही बचते हैं। विस्तारित थिंकिंग (extended thinking) को बंद करना केवल तभी मदद करता है जब थिंकिंग टोकन आपके आउटपुट का एक बड़ा हिस्सा हों, और यूसेज ब्लॉक आपको इसका सटीक विवरण देता है, जिससे आपको अनुमान लगाने की आवश्यकता नहीं रहती।

एक बड़ा कॉन्टेक्स्ट विंडो अपने आप में कोई लागत नहीं है। Claude 4.6 और उसके बाद के वर्ज़न पर, पूरी एक मिलियन टोकन की विंडो मानक प्रति-टोकन दर पर बिल की जाती है, इसलिए 900,000 टोकन के अनुरोध की लागत प्रति टोकन 9,000 टोकन वाले अनुरोध के समान ही होती है। विंडो का आकार कीमत तय नहीं करता है। आप विंडो में क्या डालते हैं, यह कीमत तय करता है।

दो और चीजें एक ही सत्र के बजाय योजना (planning) का हिस्सा होनी चाहिए। यदि आपका उपयोग दैनिक और इंटरैक्टिव है, तो प्रति-टोकन भुगतान की तुलना एक फ्लैट प्लान से करें: API और सब्सक्रिप्शन लागत की तुलना इस गणना को पूरा करती है। यदि फ्लैट प्लान बेहतर है और आप उसी समय किसी अन्य वेंडर के प्लान पर विचार कर रहे हैं, तो Claude और ChatGPT प्लान की कीमतों की तुलना दोनों के बीच समान तुलना करती है। और यदि कोई एजेंट सर्वर पर बिना निगरानी के चलता है, तो कुछ भी और ट्यून करने से पहले एक सख्त खर्च सीमा (hard spend cap) निर्धारित करें, जो कि VPS पर AI एजेंट के लिए लागत नियंत्रण में बताया गया है। पैमाने की स्पष्ट समझ के लिए, एक मिलियन Claude टोकन वास्तव में क्या खरीदते हैं रेट कार्ड को टेक्स्ट के पन्नों में बदल देता है।

FAQ

जब मैंने एजेंट का उपयोग शुरू किया तो मेरा Claude बिल क्यों बढ़ गया?

क्योंकि एक एजेंट हर प्रश्न के लिए कई अनुरोध (requests) भेजता है, और प्रत्येक अनुरोध में अब तक की पूरी बातचीत शामिल होती है। एक सामान्य चैट हर प्रश्न के लिए केवल एक अनुरोध भेजती है। एक कोडिंग एजेंट हर चरण के लिए एक अनुरोध भेजता है, और एक कार्य के लिए चालीस चरण होना सामान्य है। उन सभी अनुरोधों में से प्रत्येक के लिए पूरे कॉन्टेक्स्ट (context) का बिल लिया जाता है, इसलिए 100,000 टोकन पर समाप्त होने वाले सत्र के लिए कुल मिलाकर दो मिलियन से अधिक इनपुट टोकन का बिल लिया जा सकता है। इसे सीधे देखने के लिए API रिस्पॉन्स में input_tokens और cache_read_input_tokens पढ़ें।

क्या प्रॉम्प्ट कैशिंग वास्तव में बिल को इतना कम कर देती है?

दिए गए उदाहरण में, इसने सत्र की लागत को 12.70 डॉलर से घटाकर 2.48 डॉलर कर दिया, क्योंकि कैश रीड (cache read) की लागत इनपुट दर का दसवां हिस्सा होती है। बचत पूरी तरह से आपके हिट रेट पर निर्भर करती है। पांच मिनट वाले कैश के साथ, यह एक बार के रीड के बाद ही अपनी लागत वसूल कर लेता है, क्योंकि राइट (write) की लागत इनपुट का 1.25 गुना और रीड की लागत 0.1 गुना होती है। यदि आपका प्रॉम्प्ट हर अनुरोध पर शुरुआत के पास बदल जाता है, तो आपको कोई हिट नहीं मिलेगा और आप बिना किसी लाभ के राइट प्रीमियम का भुगतान करेंगे। यह सुनिश्चित करने से पहले कि यह काम कर रहा है, cache_read_input_tokens के साथ पुष्टि करें।

क्या मुझे हर काम के लिए बस Haiku का उपयोग करना चाहिए?

नहीं। Haiku 4.5 की लागत प्रति मिलियन इनपुट टोकन 1 डॉलर है, जबकि Opus 5 के लिए यह 5 डॉलर है, इसलिए वर्गीकरण (classification) और रूटिंग जैसे सरल और अधिक मात्रा वाले कार्यों पर बचत वास्तविक है। कठिन कार्यों पर गलत उत्तर, मॉडल द्वारा बचाई गई राशि से अधिक महंगा पड़ता है, क्योंकि आपको दोबारा प्रयास (retry) के लिए भुगतान करना पड़ता है और साथ ही अपना समय भी खर्च करना पड़ता है। जो पैटर्न कारगर रहता है वह मिश्रित है: यांत्रिक कार्यों के लिए छोटा मॉडल, और निर्णय लेने वाले कार्यों के लिए फ्रंटियर मॉडल का उपयोग करें।

क्या API, Claude सब्सक्रिप्शन से सस्ता है?

यह इस पर निर्भर करता है कि आपका उपयोग कितना स्थिर है। सब्सक्रिप्शन एक निश्चित मासिक मूल्य है जिसके साथ उपयोग की सीमाएं जुड़ी होती हैं। API प्रति टोकन भुगतान का मॉडल है जिसकी कोई ऊपरी सीमा नहीं है, जो तब सस्ता होता है जब आपका उपयोग कम हो या रुक-रुक कर हो, और तब महंगा होता है जब आप हर कार्य दिवस पर इसका भारी उपयोग करते हैं। उपयोग ब्लॉक से अपने प्रति दिन के औसत टोकन लें, उन्हें अपने मॉडल की दर पर आंकें, फिर उस आंकड़े की तुलना प्लान की कीमत से करें, जो एंट्री टियर के लिए Claude Pro की लागत और इसकी उपयोग सीमाएं कहां समाप्त होती हैं में निर्धारित है। यदि योग API के पक्ष में आता है, तो प्लान को छोड़ना या निचले टियर पर जाना आपके द्वारा पहले से भुगतान किए गए महीने को बर्बाद नहीं करता है, क्योंकि आपकी एक्सेस वर्तमान बिलिंग अवधि के अंत तक बनी रहती है।