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 दर है।

ज्यादातर हैरान कर देने वाले bills उस सूची के दूसरे और तीसरे कारणों से आते हैं। लोग आमतौर पर यह मानकर आते हैं कि 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 है। अतः सबसे सस्ते और सबसे महंगे मॉडल के बीच का अंतर पांच गुना है, और पढ़ने (input) से लिखने (output) के बीच का अंतर भी पांच गुना है।

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

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

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

पढ़ना और लिखना समान मात्रा में काम नहीं है। Input tokens को एक ही बार में process किया जाता है। Model पूरे prompt को एक साथ पढ़ता है और उस पर काम समानांतर (parallel) रूप से चलता है, यही कारण है कि 60,000 token के prompt को पढ़ने में 1,000 token के 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 तक का भी बिल लिया जाता है।

इसका मतलब है कि बातचीत की लागत उसकी लंबाई की तुलना में तेजी से बढ़ती है। टर्न 1 एक छोटे कॉन्टेक्स्ट का बिल बनाता है। टर्न 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 किया जाता है, तो Opus 5 पर tool use system prompt 286 tokens का होता है, जिसमें आपके स्वयं के tool schemas के tokens भी जुड़ जाते हैं। कुछ server-side tools पर अलग से शुल्क भी लगता है। Web search के लिए, परिणामों द्वारा उपयोग किए गए tokens के अलावा, प्रति 1,000 searches पर $10 का शुल्क लिया जाता है।

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

एक वास्तविक सत्र का गणित

यहाँ Opus 5 पर एजेंटिक कोडिंग का एक यथार्थवादी घंटा दिया गया है। इसमें चालीस API अनुरोध शामिल हैं। संदर्भ 20,000 से बढ़कर 100,000 टोकन तक पहुँच जाता है, इसलिए प्रति अनुरोध औसत लगभग 60,000 टोकन है। मॉडल प्रति अनुरोध लगभग 700 टोकन लिखता है, जिसमें छोटे टूल कॉल और कोड के कुछ लंबे ब्लॉक शामिल हैं।

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

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

लेवल 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 डॉलर का पड़ता है। केवल कैशिंग ही बिल का लगभग अस्सी प्रतिशत हिस्सा कम कर देती है। मॉडल का चुनाव बाकी बचे खर्च का अधिकांश हिस्सा हटा देता है।

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

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

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

चार आदतें जो इस संख्या को प्रभावित करती हैं:

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

Lever 4: जो interactive नहीं है, उसे batch करें

Batch API अनुरोधों को asynchronously process करता है और input तथा output दोनों पर 50 प्रतिशत की छूट देता है। यदि किसी job को अगले एक सेकंड में उत्तर की आवश्यकता नहीं है, तो उसे batch करें। इसमें classification, extraction, backlog का summarising और evaluation runs शामिल हैं। Batch discount, prompt caching के साथ जुड़ जाता है। यह interactive session पर लागू नहीं होता है, क्योंकि वहाँ प्रतीक्षा करने के लिए कुछ भी नहीं होता है।

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

"Claude महंगा क्यों है" के पीछे यही वास्तविक प्रश्न है, इसलिए यहाँ एक सीधा उत्तर दिया गया है। दरें प्रकाशित की जाती हैं, मानक टियर पर सभी के लिए समान हैं, और शुल्क प्रति token लिया जाता है। बिल में कुछ भी विवेकाधीन (discretionary) नहीं है। रेट कार्ड आपको यह नहीं बता सकता कि आपको मूल्य मिल रहा है या नहीं, क्योंकि यह tokens की कीमत तय करता है और आप परिणामों की परवाह करते हैं।

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

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

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

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

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

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

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

FAQ

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

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

क्या prompt caching वास्तव में बिल को इतना कम कर देता है?

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

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

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

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

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