Claude मध्ये आउटपुट टोकन्स महाग का असतात?
Claude मॉडेल्समध्ये आउटपुट टोकन्सची किंमत इनपुटच्या पाचपट का आहे ते जाणून घ्या. Prefill आणि Decoding प्रक्रियेतील तांत्रिक फरक आणि तुमच्या मासिक बिलावर होणारा परिणाम येथे स्पष्ट केला
इनपुट टोकनपेक्षा आउटपुट टोकनचा खर्च अधिक का असतो
सध्याच्या कॅटलॉगमधील प्रत्येक Claude मॉडेलमध्ये आउटपुट टोकनचा खर्च इनपुट टोकनच्या खर्चाच्या पाचपट आहे. याचे कारण संगणनाची रचना आहे. Prompt वाचताना मॉडेलवर एकदाच प्रक्रिया होते. उत्तर लिहिताना प्रत्येक टोकनसाठी स्वतंत्र प्रक्रिया करावी लागते आणि प्रत्येक प्रक्रिया त्यापूर्वीच्या प्रक्रियेची प्रतीक्षा करते.
किंमत यादीतील प्रत्येक ओळीत हेच प्रमाण आहे. त्यामुळे तुम्ही निवडलेल्या मॉडेलमुळे तुमच्या बिलातील आउटपुटचा वाटा बदलत नाही. तो तुमच्या workload च्या रचनेवर ठरतो. 60,000 टोकन वाचून 800 टोकनमध्ये उत्तर देणाऱ्या agent step मध्ये आउटपुटचा खर्च जवळजवळ नसतो. 2,000 टोकन वाचून 12,000 टोकन लिहिणाऱ्या drafting job मध्ये इनपुटचा खर्च जवळजवळ नसतो. दोन्ही प्रकरणांचे Anthropic ने प्रकाशित केलेल्या दरांनुसार खाली विश्लेषण केले आहे. हे दर 27 October 2026 रोजी तपासले आहेत.
Prefill एकदाच चालते, decoding प्रत्येक token साठी एकदा चालते
Inference server विनंती दोन टप्प्यांत हाताळतो. या दोन्ही टप्प्यांचा खर्च खूप वेगळा असतो. Prefill prompt वाचते. Decoding उत्तर लिहिते.
Prefill संपूर्ण prompt एकाच वेळी घेते. प्रत्येक prompt token त्याच forward pass मध्ये network मध्ये प्रवेश करतो. त्यामुळे attention आणि feed-forward काम हजारो token एकावेळी हाताळणाऱ्या काही मोठ्या matrix multiplication मध्ये रूपांतरित होते. Model weights memory मधून एकदा वाचले की संपूर्ण prompt हाताळता येतो. Accelerator मधील matrix units सतत कार्यरत राहतात. त्यामुळे prefill सामान्यतः compute-bound असते. मर्यादा chip किती वेगाने multiplication करू शकते यावर ठरते. NVIDIA च्या serving documentation नुसार काही अपवाद आहेत: अतिशय छोटे prefills आणि लांब prefix आधीच cache hit असलेले prefills memory-bound होतात.
सामान्य decoding अशा प्रकारे काम करू शकत नाही, कारण token 2 हा token 1 वर अवलंबून असतो. Model ने नुकताच तयार केलेला token पुढील step च्या input चा भाग बनतो. त्यामुळे हे steps एकामागोमाग एक चालतात. प्रत्येक 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 किती वेगाने हलवता येतात यावर ठरते, multiplication किती वेगाने करता येते यावर नाही. Long context असताना NVIDIA KV cache reads ला bottleneck म्हणून विशेष नमूद करते. Prefill दरम्यान संपूर्ण prompt हाताळण्यासाठी झालेला तोच weight traffic decoding दरम्यान केवळ एक token तयार करतो.
Speculative decoding हा नियम मोडत नाही, पण त्यात बदल घडवते. एक छोटे draft model पुढील अनेक token चा अंदाज लावते. मोठे model हे सर्व token एका pass मध्ये parallel तपासते. NVIDIA च्या मते त्यामुळे decode compute-bound होण्याकडे झुकू शकतो. मोठे model हे अंदाज क्रमाने स्वीकारते आणि पहिला चुकीचा token आढळताच थांबते. त्यामुळे लांब उत्तरासाठी अजूनही अनेक passes लागतात.
Serving systems batching वापरून ही अडचण कमी करतात. अनेक requests एकत्र decode केल्या जातात. त्यामुळे weights एकदा वाचून batch मधील प्रत्येक request साठी एक token तयार करता येतो. Decoding परवडण्याजोगे होण्याचे हेच कारण आहे. मात्र मर्यादा पुन्हा memory चीच असते. प्रक्रियेत असलेल्या प्रत्येक request साठी स्वतंत्र KV cache असते. तयार होणाऱ्या प्रत्येक token सोबत हे cache वाढते. Accelerator ची memory भरली की batch यापुढे मोठा करता येत नाही.
यापैकी कोणत्याही बाबीतून अचूक संख्या मिळत नाही. 5x हा hardware ratio म्हणून मोजलेला आकडा आहे असे समजू नका. Anthropic ने ठरवलेली ही किंमत आहे आणि तिच्यामागे या असममिततेचा विचार आहे. तुम्ही स्वतः तपासू शकता ती या फरकाची दिशा. त्यासाठी साधारण एक मिनिट पुरेसे आहे.
स्वतः input आणि output gap मोजा
कोणत्याही Ubuntu मशीनवर साधने install करा:
sudo apt update && sudo apt install -y curl jq moreutilsआता लहान prompt stream करा, जो दीर्घ उत्तर मागतो, आणि प्रत्येक ओळ आल्याची वेळ नोंदवा.
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 प्रत्येक ओळीच्या सुरुवातीला command सुरू झाल्यापासून गेलेले सेकंद जोडते. त्या output मधून दोन गोष्टी वाचणे उपयुक्त आहे. पहिल्या content_block_delta ओळीपर्यंतचा वेळ म्हणजे तुमचा first token पर्यंतचा वेळ आहे आणि संपूर्ण prefill त्यातच पूर्ण झालेले असते. त्यानंतरची प्रत्येक ओळ decoding ची एक छोटी पायरी असते आणि message_stop येईपर्यंत वेळेचे stamps वाढत जातात.
आता ही रचना उलटी करा. prompt मध्ये मोठा document द्या आणि उत्तराची मर्यादा काही 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'पहिला delta लहान prompt पेक्षा जास्त वेळ घेतो, कारण prefill साठी अधिक मजकूर वाचावा लागतो. तो आल्यावर response जवळजवळ लगेच संपतो, कारण decode करण्यासाठी फक्त काही tokens उरलेले असतात. Tens of thousands of tokens आत गेले, पण clock फारसा पुढे गेला नाही. काही hundred tokens बाहेर आले, तरी clock संपूर्ण वेळ चालू राहिला.
प्रत्येक non-streaming response शेवटी billing साठी वापरले जाणारे 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 प्रमाणे billing करते. Request पाठवण्यापूर्वी prompt ची किंमत ठरवण्यासाठी POST /v1/messages/count_tokens बहुतेक requests साठी तोच request body वापरते, model न चालवता {"input_tokens": N} estimate परत करते आणि तिच्या स्वतःच्या rate limit मध्ये free असते. Messages API स्वीकारत असलेल्या काही bodies ती नाकारते: web search, MCP connector यांसारखी बहुतेक server tools तसेच url किंवा file source असलेले image किंवा document blocks. त्यामुळे त्यांची गणना करताना images आणि PDFs base64 म्हणून पाठवा. API चा विनामूल्य भाग एवढाच नाही; पहिल्या project चे budget ठरवण्यापूर्वी Claude API च्या कोणत्या भागांसाठी तुमच्याकडून कधीही billing होत नाही हे तपासणे उपयुक्त ठरेल.
ऑक्टोबर 2026 पर्यंत दशलक्ष tokens मागे Claude चे शुल्क
या तक्त्यामागील डेटा
[
{
"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
}
]शेवटच्या स्तंभातील मूल्य output ला input ने भागल्यावर मिळते आणि प्रत्येक ओळीत ते 5 असे दिसते. Haiku 4.5 साठी input चे शुल्क $1 आणि output चे शुल्क $5 आहे. Opus 5 साठी हे शुल्क अनुक्रमे $5 आणि $25 आहे. सर्वाधिक महाग असलेल्या Fable 5 साठी शुल्क $10 आणि $50 आहे. त्यामुळे तो सर्वोच्च दर लगेच नाकारण्यापूर्वी Fable 5 चे हे दर तुम्हाला काय देतात हे वाचणे उपयुक्त ठरेल. या श्रेणीत वर जाताना input आणि output दोन्ही बाजू एकाच गुणकाने वाढतात. त्यामुळे एकूण खर्च बदलतो, पण input आणि output मधील वाटा जसा होता तसाच राहतो.
Sonnet 5 साठी input चे शुल्क $2 आणि output चे शुल्क $10 आहे. Anthropic ने हा दर 31 August 2026 पर्यंत introductory pricing म्हणून लागू केला होता. 1 September पासून तो $3 आणि $15 करण्याचे नियोजित होते. त्याऐवजी $2 आणि $10 हा standard price करण्यात आला. त्यामुळे वाढ लागू झालीच नाही. खालील प्रत्येक उदाहरणात वापरलेला दर हाच तुम्ही आज भरत असलेला दर आहे.
हे page प्रथम प्रकाशित झाल्यानंतर Anthropic ने नवीन models देखील release केले आहेत. आता claude.com/pricing वर वरील चार models उपलब्ध असलेले legacy models म्हणून दाखवले आहेत. नवीन models मध्येही तोच 5x ratio आहे. Opus 5.5 साठी शुल्क $4 आणि $20, Sonnet 5.5 साठी $2 आणि $10, तसेच Fable 5.1 साठी $10 आणि $50 आहे. 100,000 tokens पर्यंतच्या prompts साठी Haiku 5.5 चे शुल्क $0.10 आणि $0.50 आहे. त्यापेक्षा जास्त tokens साठी ते $0.50 आणि $2.50 होते. पुढे मोजलेला 60,000 token agent step या मर्यादेखाली येतो. मात्र agent चा history वाढत राहिल्यास तो अखेरीस ही मर्यादा ओलांडेल. प्रत्यक्ष jobs मध्ये Haiku 5.5 चे दोन price tiers कसे लागू होतात हे त्या बदलाचा bill वर होणारा परिणाम दाखवते. Opus 5.5 चे base input आणि output rates, Opus 5 पेक्षा 20% कमी आहेत. त्यामुळे खालील प्रत्येक uncached 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% कमी आहे.
Rates बदलतात. त्यामुळे ते तपासण्यासाठी हे page वापरू नका. claude.com/pricing हा अधिकृत आणि अंतिम स्रोत आहे. किंमत बदलल्यानंतरही पद्धत कायम राहते.
एक महत्त्वाची सूचना Anthropic च्या price table मधील rates च्या खालील notes मध्ये आहे. Anthropic च्या pricing page नुसार Claude 4.7 आणि त्यानंतरचे models नवीन tokenizer वापरतात. Sonnet 4.6 आणि त्यापूर्वीच्या models मधील tokenizer च्या तुलनेत तोच text process करताना हा tokenizer अंदाजे 30% अधिक tokens तयार करतो. प्रति दशलक्ष tokens या किंमतीवरच दोन models ची तुलना केल्यास नवीन model अधिक स्वस्त वाटेल. कारण त्यावर तोच document अधिक tokens मध्ये मोजला जातो. प्रत्यक्ष पूर्ण झालेल्या task मागील खर्चावर तुलना करा. तसेच तुम्ही प्रत्यक्ष वापरणार असलेल्या model विरुद्ध तुमचे खरे prompts मोजा. Providers मधील तुलना करतानाही हाच धोका असतो, कारण त्यांच्या tokenizers मध्येही परस्पर फरक असतो. त्यामुळे Claude आणि ChatGPT वर प्रत्यक्ष job चा खर्च मोजणे दोन rate cards शेजारी ठेवण्यापेक्षा अधिक उपयुक्त आहे. प्रत्यक्ष text मध्ये दशलक्ष Claude tokens किती असतात यामध्ये त्या प्रमाणाचे व्यवहारातील स्वरूप स्पष्ट केले आहे.
आउटपुटचा खर्च बिलावर कधी प्रभावी ठरू लागतो?
आउटपुटची किंमत इनपुटच्या 5 पट असल्याने, ब्रेक-इव्हन पॉईंट लक्षात ठेवणे सोपे आहे. तुमच्या इनपुट टोकन्सना I आणि आउटपुट टोकन्सना O म्हणा. इनपुटचा खर्च I आहे. आउटपुटचा खर्च 5 गुणिले O आहे. जेव्हा 5 गुणिले O हे I पेक्षा जास्त असते, तेव्हा आउटपुटचा खर्च एकूण खर्चाच्या निम्म्याहून अधिक होतो; हे गुणोत्तर 5 इनपुट टोकन्समागे 1 आउटपुट टोकन असे आहे.
त्यामुळे, जर तुमचा प्रॉम्प्ट तुमच्या उत्तरापेक्षा पाच पटीने मोठा असेल, तर इनपुटचा खर्च हा बिलातील मोठा घटक ठरतो. त्यापेक्षा कमी गुणोत्तर असल्यास, आउटपुटचा खर्च मोठा ठरतो.
या तक्त्यामागील डेटा
[
{
"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% असतो आणि प्रॉम्प्टचा खर्च नगण्य असतो. बहुतेक लोक त्यांच्या स्वतःच्या गुणोत्तराचा अंदाज चुकीचा लावतात, त्यामुळे कोणत्याही गोष्टीचे ऑप्टिमायझेशन करण्यापूर्वी तुमच्या लॉग्समधून अचूक माहिती मिळवा.
एजंट workload: मोठा context आत, लहान उत्तर बाहेर
एक retrieval agent step घ्या: retrieved documents आणि conversation history मधून 60,000 input tokens, आणि 800 token चे उत्तर. हे 75 ते 1 असे प्रमाण आहे. जे काही वाचल्यानंतर लिहिते, त्यासाठी हे सामान्य आहे.
या तक्त्यामागील डेटा
[
{
"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
}
]प्रत्येक model वर त्या call च्या Output चे प्रमाण 6.25% आहे, कारण संपूर्ण price list मध्ये हे ratio निश्चित आहे. Opus 5 वर त्या call ची किंमत $0.32, Sonnet 5 वर $0.128, आणि Haiku 4.5 वर $0.064 आहे. Opus 5 वर दररोज असे 200 steps घेतल्यास दररोज $64 खर्च येतो.
हा विभागणीचा परिणाम पाहिल्यावर कोणता बदल महत्त्वाचा आहे हे स्पष्ट होते. उत्तर 800 tokens वरून 400 tokens केल्यास call च्या खर्चात सुमारे 3% बचत होते. Prompt मधून stale context चे 20,000 tokens काढल्यास सुमारे एक-तृतीयांश खर्च वाचतो. Read-heavy agent मध्ये output length कमी करण्याचा प्रयत्न जवळजवळ निष्फळ ठरतो. coding agent चे tokens प्रत्यक्षात कुठे खर्च होतात या prompt मध्ये नेमके काय भरते, हे स्पष्ट करते.
जनरेशन workload: लहान prompt, मोठा draft
आता रचना उलटी पाहू. 2,000 token चे brief आणि 12,000 token चा draft, म्हणजे 1 ते 6 असे प्रमाण.
या तक्त्यामागील डेटा
[
{
"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% इतका वाटा output चा आहे. प्रत्येक draft साठी Opus 5 ची किंमत $0.31 आहे, तर Haiku 4.5 वर ती $0.062 आहे. पाच पट हा फरक जवळजवळ पूर्णपणे output मुळे आहे. त्यामुळे स्वस्त model वापरल्यास सर्वाधिक बचत याच भागात होते.
शेवटचा column हेच काम Batch API द्वारे दाखवतो. त्यात input आणि output या दोन्हींवर 50% सवलत मिळते. Opus 5 ची किंमत प्रत्येक draft साठी $0.155 इतकी होते. Batch प्रक्रिया त्वरित न होता asynchronous असते. Anthropic च्या मते बहुतेक batches एका तासाच्या आत पूर्ण होतात. मात्र 24 तासांनी प्रक्रिया सुरू असलेला batch expire होतो. त्या वेळेपर्यंत ज्या requests पर्यंत प्रक्रिया पोहोचलेली नसते, त्या expired म्हणून परत येतात; त्यासाठी billing होत नाही आणि message मिळत नाही. त्यामुळे overnight report generation आणि bulk classification साठी Batch योग्य आहे. Expire झालेल्या requests पुन्हा submit करण्याची पायरी ठेवावी लागते. एखादी व्यक्ती बसून निकालाची वाट पाहत असेल, अशा कामासाठी ते योग्य नाही.
इथे model routing उपयुक्त ठरते; agent step मध्ये ते कधीच तसे उपयुक्त ठरत नाही. कामाचा verbose भाग यांत्रिक असेल, जसे मजकूर reformat करणे किंवा आधीच मंजूर केलेला outline विस्तारणे, तर स्वस्त model हे tokens पाचव्या भागाच्या किमतीत तयार करते. Opus, Sonnet आणि Haiku यांपैकी निवड quality ची वास्तविक मर्यादा कुठे आहे हे स्पष्ट करते.
कॅशमुळे input स्वस्त होते; output नाही
Prompt caching तुमच्या prompt चा एक prefix सर्व्हरवर साठवते. तो prefix पुन्हा वाचण्यासाठी input rate च्या काही भागाइतके शुल्क आकारले जाते. 27 October 2026 रोजी, या पृष्ठावर किंमत दिलेल्या models साठी 5 minute cache लिहिण्यासाठी base input rate च्या 1.25x, 1 hour cache लिहिण्यासाठी 2x आणि cache hit वाचण्यासाठी 0.1x असे multipliers आहेत. नवीन models मध्ये cache hit वाचण्याचे शुल्क आणखी कमी आहे: Opus 5.5 आणि Sonnet 5.5 वर 0.05x, तसेच Fable 5.1 वर 0.025x.
Output या सवलतीत समाविष्ट नाही. Cached output अशी संकल्पना नाही. Model ने लिहिलेला प्रत्येक token प्रत्येक वेळी full output rate ने बिल केला जातो. Prompt पैकी किती भाग cache hit म्हणून परत आला, याने हे बदलत नाही.
Opus 5 वर तोच agent step घ्या. त्यातील 60,000 input tokens पैकी 55,000 tokens warm cache मधून मिळतात.
या तक्त्यामागील डेटा
[
{
"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 ची किंमत बदलत नाही: आधी $0.02, आणि नंतर $0.02. Caching मुळे बिल कमी होते आणि त्याची रचना बदलते. त्या call मध्ये output चा वाटा 6.25% होता. आता तो एक चतुर्थांशपेक्षा अधिक आहे. त्यामुळे पुढे कोणता खर्च घटक कमी करणे उपयुक्त ठरेल, हे बदलते.
पहिल्या call मध्ये cache लिहिण्याचा खर्च येतो. 5 minute cache write साठी base input च्या 1.25x इतका खर्च येतो. त्यामुळे एकाच hit नंतर तो खर्च भरून निघतो. 1 hour write साठी 2x खर्च येतो. त्यामुळे त्यासाठी दोन hits आवश्यक असतात. write आणि read multipliers, तसेच caching कधी फायदेशीर राहत नाही या गणनेचे स्पष्टीकरण देते.
तुमच्या नियंत्रणातील चार उपाय
- तुमच्या p95 output length वर
max_tokensसेट करा, model maximum वर नाही. - जास्त विस्ताराच्या टप्प्यांसाठी स्वस्त model वापरा.
- ज्याची कोणी वाट पाहत नाही ते सर्व batch मध्ये चालवा.
- प्रत्युत्तरांची लांबी अनावश्यकपणे वाढवणाऱ्या instructions काढून टाका.
max_tokens ही कठोर कमाल मर्यादा आहे. ती जास्त ठेवली म्हणून स्वतःहून कोणताही खर्च होत नाही, कारण शुल्क तयार झालेल्या tokens साठी आकारले जाते; या मर्यादेसाठी कधीही शुल्क आकारले जात नाही. मोठी cap केल्याने चुकलेल्या प्रत्युत्तरावर असलेली मर्यादा दूर होते. तुमच्या logs मधून output_tokens distribution काढा, cap 95th percentile पेक्षा थोडी जास्त ठेवा आणि stop_reason: "max_tokens" चे code मध्ये व्यवस्थापन करा: response पुढे चालू ठेवा किंवा पुन्हा प्रयत्न करा. तुम्ही ओळखू शकता अशी truncation, तुम्ही शुल्क भरून टाकून देत असलेल्या 4,000 token च्या अनावश्यक लांबलचक उत्तरापेक्षा स्वस्त पडते. Thinking देखील output_tokens मध्ये येते आणि max_tokens विरुद्ध मोजले जाते. त्यामुळे त्याच पुराव्यावरून cap चे आकारमान ठरवा. Adaptive thinking असलेल्या models मध्ये thinking सतत उत्तराची जागा घेत असेल, तर effort level कमी करा.
एखाद्या टप्प्याचा खर्चिक भाग judgement ऐवजी volume असेल, तेव्हा routing उपयुक्त ठरते. निर्णयासाठी सक्षम model ठेवा आणि मजकूर तयार करण्याचे काम स्वस्त model कडे द्या. Routed version आधी तुमच्या स्वतःच्या evaluation set वर मोजा, कारण महत्त्वाचा आकडा म्हणजे पूर्ण झालेल्या प्रत्येक task मागील खर्च. वरील agent step मध्ये, दोन Haiku 4.5 attempts साठी $0.128 खर्च येतो, तर एका Opus 5 attempt साठी $0.32 खर्च येतो. त्यामुळे या किंमतीतील फरक एक-दोन retries चा खर्च पेलतो. मात्र कोणाच्याही लक्षात न येणारे चुकीचे उत्तर हा फरक पेलू शकत नाही.
Output वर सवलत देणारा एकमेव उपाय batching आहे. दोन्ही बाजूंवर 50% सवलत मिळते, बहुतेक batches एका तासाच्या आत पूर्ण होतात आणि ठराविक schedule वरील कोणतेही काम पात्र ठरते, परंतु job ने 24 hour ची मर्यादा संपल्यावर जे काही expire होते ते पुन्हा submit करणे आवश्यक आहे.
शेवटचा उपाय लोक अनेकदा टाळतात. "be thorough" आणि "explain your reasoning" यांसारखी वाक्ये तुम्ही पुढे करणार असलेल्या प्रत्येक call ची output length वाढवतात. त्याऐवजी तुम्हाला हवी असलेली रचना स्पष्टपणे सांगा: "Answer in at most three sentences" किंवा "Return only the JSON object, with no preamble". प्रत्येक reply मध्ये 300 tokens वाढवणाऱ्या system prompt साठी, त्याच 300 tokens च्या prompt मधील खर्चाच्या पाचपट खर्च येतो. सतत चालणाऱ्या agent चा खर्च नियंत्रणात ठेवणे या विषयात monitoring भाग समाविष्ट आहे. तसेच तुमच्या वापराच्या पद्धतीसाठी API स्वस्त आहे की flat subscription हे ठरवणे महत्त्वाचे आहे, कारण subscription ने सहज पेलला असता असा per-token खर्च कमी करण्यासाठी पूर्ण आठवडा tuning करण्यात अर्थ नाही. एका developer साठी याचा मुख्य प्रश्न असा असतो की Claude Pro ची दरमहा $20 किंमत आणि त्यासोबत येणाऱ्या usage limits तुम्ही अन्यथा मोजून वापरले असते ते काम पूर्ण करण्यासाठी पुरेशा आहेत का. Session च्या मध्यातच त्या limits गाठत असाल, तर तुम्ही कोणत्या window ची वाट पाहत आहात हे ठरवणे आधी करा. त्यानंतरचा उपाय smaller model, lighter context, extra usage credits किंवा ते काम metered API वर हलवणे असा असू शकतो. Metered API हे त्या कामासाठी स्वस्त पर्याय ठरल्यास, smaller plan वर जाणे किंवा तो cancel करणे केल्यावर आधीच भरलेल्या महिन्याचा वापर कायम राहतो; त्यामुळे बदल करताना अतिरिक्त खर्च होत नाही. तुम्ही metered API ऐवजी ChatGPT च्या plan शी Pro ची तुलना करत असाल, तर शेजारी मांडलेल्या दोन subscription ladders coding work साठी कोणता स्वस्त ठरतो हे दाखवतात. हा प्रश्न एका developer ऐवजी team साठी विचारला जात असेल, तर लक्षात ठेवा की Claude Enterprise मध्ये per seat fee सोबत याच API rates वर मोजले जाणारे tokens असतात. त्यामुळे या पानावरील प्रत्येक उपाय त्या bill च्या metered भागाला अजूनही लागू होतो.
FAQ
Output tokens ची किंमत input tokens पेक्षा जास्त का असते?
ते निर्माण करण्यासाठी प्रत्येक token मागे accelerator चा बराच अधिक वेळ लागतो. Prompt वर संपूर्ण मजकुरासाठी एकाच forward pass मध्ये प्रक्रिया केली जाते. त्यामुळे model weights चे एकदाच वाचन हजारो tokens साठी पुरते आणि hardware प्रामुख्याने multiply throughput मुळे मर्यादित असते. सामान्य decoding मध्ये उत्तर एका वेळी एक token अशा प्रकारे तयार होते. प्रत्येक token साठी स्वतंत्र forward pass आवश्यक असतो. त्यात model weights आणि वाढत जाणारा KV cache पुन्हा वाचला जातो. त्यामुळे hardware प्रामुख्याने memory bandwidth मुळे मर्यादित असते. Speculative decoding सारख्या तंत्रांमुळे हा फरक कमी होतो, पण तो पूर्णपणे नाहीसा होत नाही. Anthropic च्या सध्याच्या संपूर्ण catalogue मध्ये Haiku 5.5 पासून Fable 5.1 पर्यंत 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 साठी पूर्ण दर आकारला जातो. त्यामुळे caching मुळे तुमच्या bill चा आकारच नव्हे तर त्याची रचना देखील बदलते. Input चा खर्च मोठ्या प्रमाणात कमी झाल्यावर output हा कमी करण्यासारखा मुख्य खर्च ठरतो.
Reply लहान असल्यास उच्च max_tokens साठी मला पैसे द्यावे लागतात का?
नाही. Model प्रत्यक्षात निर्माण करते त्या tokens साठीच शुल्क आकारले जाते. त्यामुळे max_tokens ही कमाल मर्यादा आहे, आगाऊ राखीव मात्रा नाही. तरीही ती महत्त्वाची आहे, कारण अनियंत्रितपणे वाढणाऱ्या reply वर ती एकमेव कठोर मर्यादा आहे. तुमच्या निरीक्षणातील output_tokens च्या 95th percentile पेक्षा max_tokens थोडे अधिक ठेवा. त्यानंतर stop_reason: "max_tokens" चे code मध्ये व्यवस्थापन करा; उत्तर नकळत truncated होऊन production मध्ये जाऊ देऊ नका.
माझे input-to-output token ratio कसे शोधू?
प्रत्येक response मधील usage object मधून input_tokens, output_tokens, cache_read_input_tokens आणि cache_creation_input_tokens log करा. त्यानंतर एका आठवड्यातील एकूण संख्यांचा भागाकार करा. Input-to-output ratio 5 ते 1 पेक्षा जास्त असल्यास तुमचा खर्च prompt मध्ये आहे. त्यामुळे स्थिर भाग cache करा आणि उर्वरित भाग कमी करा. हा ratio त्यापेक्षा कमी असल्यास तुमचा खर्च reply मध्ये आहे. त्यामुळे त्याची लांबी मर्यादित करा आणि सर्वाधिक output निर्माण करणाऱ्या steps ना स्वस्त model किंवा Batch API कडे हलवा.