Claudeలో 1M tokens ధర ఎంత? Input, output ఖర్చు
Claude APIలో 1M tokensకు ఒకే ధర ఉండదు. Input, output రేట్లు వేర్వేరుగా ఉంటాయి, output సాధారణంగా input కంటే 5 రెట్లు ఖరీదు. మీ billను ఇలా అంచనా వేయండి.
Claudeలో 1M tokens ధర ఎంత?
1M tokens అంటే ఒక మిలియన్ tokens. Claude API (application programming interface) model ధరలను పేర్కొనే యూనిట్ ఇదే. దీనికి ఒకే ధర ఉండదు, ఎందుకంటే input మరియు outputలకు వేర్వేరు రేట్లతో బిల్లింగ్ జరుగుతుంది. ప్రతి modelకు తనదైన రెండు రేట్లు ఉంటాయి. Claude Haiku 5.5లో రెండు రేట్ల జతలు ఉన్నాయి: 100,000 tokens వరకు ఉన్న promptsకు ఒకటి, దానికంటే ఎక్కువ promptsకు ఎక్కువ రేటు మరొకటి. October 2026 నాటికి, ఒక మిలియన్ input tokens ధర Claude Haiku 4.5లో $1, Claude Sonnet 5లో $2, Claude Opus 5లో $5.
Output భాగం ఖరీదైనది. ప్రస్తుతం ఉన్న ప్రతి modelలో output rate, input rate కంటే ఐదు రెట్లు ఉంటుంది. అందువల్ల headline figure కంటే input మరియు outputల విభజనే మీ బిల్లును ఎక్కువగా నిర్ణయిస్తుంది. పొడవైన documents పంపి, చిన్న సమాధానాలు ఇచ్చే app, చిన్న prompt నుంచి పొడవైన సమాధానాలు రాసే app కంటే పూర్తిగా భిన్నంగా పనిచేస్తుంది.
ఈ పేజీ unit economics గురించి వివరిస్తుంది: ఒక tokenకు ఎంత ఖర్చవుతుంది, మీరు నిర్మాణం ప్రారంభించే ముందు బిల్లును ఎలా అంచనా వేయాలి. మీరు పనిచేస్తున్నప్పుడు tokens వాస్తవంగా ఎక్కడ వినియోగమవుతాయో తెలుసుకోవడానికి Claude Code sessionలో tokens ఎక్కడికి వెళ్తాయో చదవండి.
1M tokens ఎలా ఉంటాయి
Token అనేది మోడల్ చదివే లేదా రాసే టెక్స్ట్ భాగం. Claude 4.7 కంటే ముందు మోడళ్లలో ఒక token సుమారుగా 3.5 English అక్షరాలకు సమానమని Anthropic glossary చెబుతోంది. ఆ మోడళ్లలో 1M tokens సుమారుగా 750,000 పదాలను కలిగి ఉంటాయని Anthropic model overview చెబుతోంది. ఒక token కు 3.5 అక్షరాలు అనుకుంటే, ఇది సుమారుగా 3.5 million అక్షరాలు, అంటే plain English text లో సుమారుగా 3.5 MB. Claude Opus 4.7 తో ప్రవేశపెట్టిన కొత్త tokenizer లో అదే 1M tokens సుమారుగా 555,000 పదాలను లేదా దాదాపు 2.5 million అక్షరాలను కలిగి ఉంటుంది.
సాధారణ inputల కోసం ప్రచురించిన అంచనాలు ఈ పరిమాణాన్ని మరింత స్పష్టంగా చూపిస్తాయి.
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"label": "Average web page (10 kB)",
"tokens": "2,500"
},
{
"label": "Documentation page (100 kB)",
"tokens": "25,000"
},
{
"label": "Research paper PDF (500 kB)",
"tokens": "125,000"
}
]ఈ రేట్ల ప్రకారం, 1M tokens ను సగటు web pageలను 400 సార్లు ఒక్కసారి చదివిన పరిమాణంగా లేదా ఆ పరిమాణంలోని 8 research papers గా భావించవచ్చు. ఇది మధ్యస్థ పరిమాణంలోని codebase ను ఒక్కసారి పూర్తిగా చదవడానికి లేదా ఒక వ్యక్తి నెలరోజుల తేలికపాటి chat వినియోగానికి సమానం.
ఇవన్నీ అంచనాలుగా మాత్రమే పరిగణించండి. Code, JSON మరియు English కాకుండా ఇతర భాషల్లోని text ఒక token లో తక్కువ పదాలను కలిగి ఉంటుంది. అందువల్ల పై word counts ఆశావహమైన గరిష్ఠ అంచనాలు. మరో అంశం కూడా count ను మారుస్తుంది: Claude Opus 4.7 మరియు తరువాతి మోడళ్లు, ఇందులో Opus 5 మరియు Sonnet 5 ఉన్నాయి, Sonnet 4.6 మరియు అంతకుముందు మోడళ్లతో పోలిస్తే అదే text కు సుమారుగా 30 శాతం ఎక్కువ tokens ఉత్పత్తి చేసే కొత్త tokenizer ను ఉపయోగిస్తాయి. Claude Haiku 4.5 పాత tokenizer ను ఉపయోగిస్తుంది. అందువల్ల ఒకే input కు Haiku 4.5 పై మీరు కొలిచిన count, Sonnet 5 పై ఉన్న count కంటే తక్కువగా ఉంటుంది. ఈ సరిహద్దు దాటినప్పుడు millionకు నేరుగా price పోలిక చేయడం సముచితం కాదు. నిర్ణయం తీసుకునే ముందు అదే prompt ను రెండు మోడళ్లపై count చేయండి.
మిలియన్ టోకెన్లకు Claude వసూలు చేసే ధర
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"label": "Haiku 4.5",
"input_usd": 1,
"output_usd": 5
},
{
"label": "Sonnet 5",
"input_usd": 2,
"output_usd": 10
},
{
"label": "Sonnet 4.6",
"input_usd": 3,
"output_usd": 15
},
{
"label": "Opus 5",
"input_usd": 5,
"output_usd": 25
}
]Claude Sonnet 5 కోసం input కు $2, output కు $10 ఖర్చవుతుంది. Anthropic ఈ ధరను 31 August 2026 వరకు ప్రారంభ ధరగా అందించింది. తరువాత ఇదే ప్రామాణిక ధరగా కొనసాగించి, ధరను $3 మరియు $15 కు పెంచే ప్రణాళికను రద్దు చేసింది. Claude Opus 5 ధర input కు $5, output కు $25. Fable మోడళ్ల ధరలు దీనికంటే పూర్తిగా ఎక్కువ స్థాయిలో ఉన్నాయి. Claude Fable 5 మరియు తరువాత వచ్చిన Claude Fable 5.1 రెండింటికీ input ధర $10, output ధర $50. అందువల్ల ఆ ధరలు చెల్లించడం విలువైనదేనా అనేది మీరు వాటిని ఏ పనులకు ఉపయోగిస్తారనే దానిపై ఆధారపడి ఉంటుంది.
Anthropic ప్రస్తుత మోడల్ శ్రేణి ఈ పేజీలో ధరలు పేర్కొన్న మోడళ్లకంటే కొత్తది. Claude Opus 5.5 ధర input కు $4, output కు $20. Claude Sonnet 5.5 ధరలు వరుసగా $2 మరియు $10. Claude Haiku 5.5 ధరలు $0.10 మరియు $0.50 నుంచి ప్రారంభమవుతాయి. Opus 5, Sonnet 5, Haiku 4.5 మరియు Fable 5 ప్రస్తుతం legacy models గా చూపబడుతున్నాయి. ఇవి ఇంకా అందుబాటులో ఉన్నందున, కింద ఇచ్చిన ఉదాహరణలు మార్పులు లేకుండా పనిచేస్తాయి. Haiku 5.5 ధర మరియు దాని ఉపయోగ పరిధి కొత్త మోడళ్లలో చౌకైనదాని గురించి వివరిస్తుంది.
ధరలు మారవచ్చు. ఈ పేజీలోని ప్రతి మొత్తాన్ని October 2026 నాటి ఉదాహరణగా పరిగణించండి. బడ్జెట్ను ఆమోదించే ముందు ప్రస్తుత మొత్తాలను అధికారిక ధరల పేజీలో నిర్ధారించండి.
ఈ ధరలు Claude ఖర్చును మాత్రమే చూపిస్తాయి. మీ workload కు ఇది చౌకైన ఎంపికేనా అనే విషయాన్ని చూపించవు. Claude మరియు ChatGPT రెండింటిలో లెక్కించిన మూడు పనులు ఏ API లో ఏది మెరుగ్గా ఉంటుందో చూపిస్తుంది.
ఒక మినహాయింపు తప్ప context length ధరను మార్చదు. Claude 4.6 మరియు తరువాతి మోడళ్లలో, Claude Haiku 5.5 మినహా, పూర్తి 1M token context window కు ప్రామాణిక ధరలే వర్తిస్తాయి. అందువల్ల 900,000 tokenల request కు, 9,000 tokenల request కు ఉన్నట్లే ఒక్కో tokenకు అదే ధర ఉంటుంది. పొడవైన prompt కు ఎక్కువ tokens ఉన్నందున ఎక్కువ ఖర్చవుతుంది. దానికి ప్రత్యేకమైన long-context ధర ఉండదు. Claude Haiku 5.5 కు prompt length ఆధారంగా ధర నిర్ణయించబడుతుంది. Prompt 100,000 tokens ను మించిన request కు input ప్రతి మిలియన్ tokensకు $0.50, output ప్రతి మిలియన్ tokensకు $2.50 వసూలవుతుంది. సాధారణ ధరలు $0.10 మరియు $0.50. Cache reads మరియు cache writes కూడా ఈ పరిమితిలోకి లెక్కించబడతాయి.
ధర మారిన తర్వాత కూడా పనిచేసే గణన
ప్రతి బిల్లు రెండు గుణకారాలు మరియు ఒక కూడికతో రూపొందుతుంది.
cost = (input_tokens / 1,000,000) * input_rate
+ (output_tokens / 1,000,000) * output_rateదీన్ని మీరు అమలు చేయగల code రూపంలో ఇలా రాయవచ్చు:
INPUT_RATE = 2.00 # USD per million input tokens, Sonnet 5, October 2026
OUTPUT_RATE = 10.00 # USD per million output tokens
def cost(input_tokens, output_tokens):
return (input_tokens * INPUT_RATE + output_tokens * OUTPUT_RATE) / 1_000_000
print(f"{cost(4300, 400):.4f}")అది 0.0126 ను ముద్రిస్తుంది. 4,300 input tokens పంపి, 400 output tokens పొందే request కు Sonnet 5 లో సుమారు 1.3 cents ఖర్చవుతుంది. రెండు rates ను మీ code లో ఒకే చోట ఉంచండి. ధర మారినప్పుడు రెండు lines ను సవరించండి. అప్పుడు మీ system లోని ప్రతి estimate కూడా దానికి అనుగుణంగా మారుతుంది.
నిజమైన అప్లికేషన్కు ఒక ఉదాహరణ అంచనా
ఒక support assistant ను పరిగణించండి. దాని system prompt మరియు product documentation కలిపి 4,000 tokens ఉంటాయి. model ప్రతి request సమయంలో వాటిని చదువుతుంది. డిఫాల్ట్గా Messages API calls మధ్య state ను నిల్వ చేయదు. అందువల్ల మీ client ప్రతి సారి వాటిని పంపుతుంది. Message threads అనే optional beta ద్వారా system prompt మరియు tools ను ఒకసారి పంపి, తరువాత కొత్త messages ను మాత్రమే పంపవచ్చు. అయితే model ను పిలిచే ముందు API పూర్తి conversation ను మళ్లీ నిర్మిస్తుంది. Anthropic ప్రకారం threads pricing ను మార్చవు. కాబట్టి దిగువ ఖర్చు రెండు విధానాల్లోనూ ఒకే విధంగా ఉంటుంది. User question కు సుమారు 300 tokens చేరతాయి. Answer కు సుమారు 400 tokens పడతాయి. అందువల్ల ప్రతి request కు 4,300 input tokens మరియు 400 output tokens ఉంటాయి.
ఒక million input tokens తో ఈ విధమైన సుమారు 232 requests నిర్వహించవచ్చు. రోజుకు 1,000 requests ఉంటే, అప్లికేషన్ ప్రతిరోజూ 4.3 million input tokens వినియోగిస్తుంది. కాబట్టి "1M tokens" traffic ఆరు గంటలకంటే తక్కువకే సరిపోతుంది.
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"label": "Opus 5, list rates",
"cost_per_1k_usd": "31.50"
},
{
"label": "Sonnet 5, list rates",
"cost_per_1k_usd": "12.60"
},
{
"label": "Sonnet 5, Batch API",
"cost_per_1k_usd": "6.30"
},
{
"label": "Haiku 4.5, list rates",
"cost_per_1k_usd": "6.30"
},
{
"label": "Sonnet 5, warm prompt cache",
"cost_per_1k_usd": "5.40"
}
]Claude Opus 5 పై ఆ traffic కు ప్రతి 1,000 requests కు $31.50 ఖర్చవుతుంది. Sonnet 5 పై ఇది $12.60. Claude Haiku 4.5 కు మారితే ఖర్చు $6.30 కు తగ్గుతుంది. Sonnet 5 లో warm prompt cache ఉపయోగిస్తే ఖర్చు ఇంకా తగ్గి $5.40 అవుతుంది.
అటువంటి traffic ఉన్న ఒక నెలకు 30తో గుణించండి. list rates ప్రకారం Sonnet 5 కు నెలకు సుమారు $378 ఖర్చవుతుంది. అదే అప్లికేషన్లో warm cache ఉపయోగిస్తే ఖర్చు సుమారు $162. ఈ volume వద్ద మీరు చర్చించి పొందగలిగే ఏ rate కంటే మీ model ఎంపిక మరియు caching నిర్ణయం ఒక్కొక్కటి ఎక్కువ ప్రభావం చూపుతాయి. ఏ model ను అమలు చేయాలి అనేది వేరే ప్రశ్న. మీ evaluations లో ఉత్తీర్ణమయ్యే అతి తక్కువ ఖర్చున్న model ను ఎంచుకోవాలి: Opus, Sonnet మరియు Haiku మధ్య ఎంపిక దీన్ని సరిగ్గా ఎలా పరీక్షించాలో వివరిస్తుంది.
Prompt caching పునరావృత భాగం ఖర్చును తగ్గిస్తుంది
ఆ 4,000 token prefix ప్రతి requestలో ఒకేలా ఉంటుంది. దాని కోసం ప్రతి సారి పూర్తి input ధర చెల్లించాలి. Prompt caching, process చేసిన prefix ను నిల్వ చేసి, దాన్ని మళ్లీ ఉపయోగించినప్పుడు తక్కువ రేటును వసూలు చేస్తుంది.
ఈ page యొక్క price chart మరియు worked examplesలో ఉన్న మోడళ్లపై (Haiku 4.5, Sonnet 5, Sonnet 4.6 మరియు Opus 5), అలాగే Fable 5 పై, cache read ఖర్చు base input rateలో 0.1 రెట్లు ఉంటుంది. కొన్ని కొత్త మోడళ్లలో read ఖర్చు ఇంకా తక్కువగా ఉంటుంది: Opus 5.5 మరియు Sonnet 5.5 కోసం 0.05 రెట్లు, Fable 5.1 మరియు Mythos 5.1 కోసం 0.025 రెట్లు. Cacheను రాయడానికి 5 నిమిషాల lifetime కోసం base ధరకు 1.25 రెట్లు, 1 గంట lifetime కోసం base ధరకు 2 రెట్లు ఖర్చవుతుంది. అందువల్ల 0.1 రెట్లు వసూలు చేసే మోడళ్లలో 5 నిమిషాల cache ఒక read తర్వాత తన ఖర్చును తిరిగి పొందుతుంది. కారణం, writeకు అదనంగా 0.25 ఖర్చవుతుంది, ప్రతి read 0.9 ఆదా చేస్తుంది. 1 గంట cache break-even చేరడానికి 2 reads అవసరం.
దీన్ని ప్రారంభించే సరళమైన మార్గం ఒకే top-level field:
curl https://api.anthropic.com/v1/messages \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-d '{
"model": "claude-opus-5",
"max_tokens": 1024,
"cache_control": {"type": "ephemeral"},
"system": "You are a helpful assistant.",
"messages": [
{"role": "user", "content": "What are the key themes in Pride and Prejudice?"}
]
}'తర్వాత తిరిగి వచ్చే usage block ను చదవండి:
{
"usage": {
"cache_creation_input_tokens": 5120,
"cache_read_input_tokens": 1800,
"input_tokens": 50,
"output_tokens": 503
}
}ఆ 3 input counters కు 3 వేర్వేరు rates వర్తిస్తాయి. వాటి మొత్తం మీ వాస్తవ input volume: total_input_tokens = cache_read_input_tokens + cache_creation_input_tokens + input_tokens. Caching ప్రారంభించిన తర్వాత input_tokens ను మాత్రమే చూసే cost estimate చాలా తప్పుగా ఉంటుంది.
Cache ఖర్చును తిరిగి పొందకుండా ఆపే 2 కారణాలు ఉన్నాయి. రెండింటిలోనూ ఎటువంటి error లేకుండానే సమస్య వస్తుంది.
Prefix byte-identical గా ఉండాలి. Cache lookup prefix match పై ఆధారపడుతుంది. కాబట్టి system prompt ప్రారంభంలో timestamp లేదా user పేరు ఉంచితే ప్రతి requestలో prefix మారుతుంది. అప్పుడు ప్రతి సారి base input ధరకు 1.25 రెట్లు చెల్లిస్తారు, కానీ cache read ఒక్కసారి కూడా జరగదు. దీని లక్షణం cache_creation_input_tokens ఎక్కువగా ఉండి, cache_read_input_tokens 0గా ఉండటం. Requests మధ్య content ఒకేలా ఉండే చివరి blockపై cache_control ను ఉంచండి. మారే ప్రతిదాన్ని దాని తర్వాత ఉంచండి. మీ tools definitions మార్చితే వాటి కింద ఉన్న మొత్తం cache invalid అవుతుంది. ఎందుకంటే invalidation, tools, ఆ తర్వాత system, ఆ తర్వాత messages అనే క్రమంలో కిందికి కొనసాగుతుంది.
Prefix తగినంత పొడవుగా ఉండాలి. Cache చేయగల కనిష్ఠ పొడవు Opus 5లో 512 tokens, Sonnet 5లో 1,024, Haiku 4.5లో 4,096 tokens. Prompt దీనికంటే తక్కువగా ఉంటే cache చేయబడదు, ఎటువంటి error కూడా తిరిగి రాదు. పై ఉదాహరణలోని 4,000 token prefix Sonnet 5లో cache అవుతుంది. Haiku 4.5లో cache కాదు, ఎందుకంటే 4,000 ఆ మోడల్ కనిష్ఠ పరిమితి కంటే తక్కువ. రెండు counters కూడా 0గా ఉంటే ఏదీ cache కాలేదు.
బ్యాచ్ ప్రాసెసింగ్ రేటును సగానికి తగ్గిస్తుంది
Batch API అభ్యర్థనలను asynchronous పద్ధతిలో ప్రాసెస్ చేస్తుంది. Input మరియు output రెండింటిపై 50 percent తగ్గింపు వర్తిస్తుంది. పై ఉదాహరణలో, ప్రతి 1,000 అభ్యర్థనలకు అయ్యే $12.60 ఖర్చు $6.30 కు తగ్గుతుంది. ఈ తగ్గింపు prompt caching తో కలిపి వర్తిస్తుంది. అందువల్ల bulk పనులను అమలు చేయడానికి cached batch job అత్యంత తక్కువ ఖర్చుతో కూడిన మార్గం. Batch లో message threads పనిచేయవు. కాబట్టి ప్రతి batch అభ్యర్థనలో పూర్తి conversation ఉండాలి.
దీనికి బదులుగా తగ్గేది latency. అందువల్ల ఎవరైనా కూర్చొని ఫలితం కోసం వేచి ఉండాల్సిన పనులకు batch సరిపోదు. Overnight classification మరియు document backfill పనులకు ఇది అనుకూలంగా ఉంటుంది.
ఒకే సంభాషణలో chat ఖర్చులు ఎందుకు పెరుగుతాయి
డిఫాల్ట్గా API ఎలాంటి state ను ఉంచదు. అందువల్ల ప్రతి turn లో మీ client మొత్తం conversation ను మళ్లీ పంపుతుంది. ఐచ్ఛిక message threads beta కొంతకాలం conversation ను server పై ఉంచుతుంది. దీంతో తరువాతి turn లలో కొత్త messages మాత్రమే upload అవుతాయి. అయితే model ను call చేయడానికి ముందు API ఇప్పటికీ పూర్తి conversation ను మళ్లీ నిర్మిస్తుంది. Threads pricing ను మార్చవని Anthropic చెబుతోంది. రెండు సందర్భాల్లోనూ ఒకే chat లో token వినియోగం దాని పొడవు పెరిగే కొద్దీ నేరుగా కాకుండా దాని వర్గంతో పెరుగుతుంది.
ప్రతి turn సగటున 500 tokens కలిగి ఉందని అనుకుందాం. Turn 1 లో 500 input tokens పంపబడతాయి. Turn 2 లో 1,000 పంపబడతాయి. Turn 20 లో 10,000 పంపబడతాయి. దీనిని n(n+1)/2 తో కలిపితే, 20 turn conversation సుమారు 105,000 input tokens పంపింది. అయితే transcript మొత్తం పొడవు 10,000 tokens మాత్రమే.
అందుకే transcript సూచించే ఖర్చుకంటే chat feature ఖర్చు ఎక్కువగా ఉంటుంది. అందుకే స్థిరంగా ఉండే prefix ను cache చేయడం లేదా పాత turns ను సంక్షిప్తం చేయడం పొడవైన threads లో తన ఖర్చును తానే భర్తీ చేస్తుంది. Tool calls పై loop చేసే agent కూడా ఇదే విధానాన్ని అనుసరిస్తుంది, అయితే మరింత ఖర్చుతో. ప్రతి tool result history లోనే ఉండి, తరువాతి ప్రతి turn లో మళ్లీ పంపబడుతుంది. మీరు స్వయంగా నడిపే agent కు కఠినమైన ఖర్చు పరిమితిని విధించడం ఇక్కడ అత్యంత ముఖ్యమైనది. ఎందుకంటే ఈ పెరుగుదల స్వయంచాలకంగా జరుగుతుంది, దాన్ని ఎవరూ పర్యవేక్షించకపోవచ్చు.
అంచనా వేయడానికి ముందు token సంఖ్యను లెక్కించండి
పదాల సంఖ్య ఆధారంగా token సంఖ్యను అంచనా వేయడం ఆపండి. API మీ కోసం వాటిని ఎలాంటి అదనపు ఛార్జీ లేకుండా లెక్కిస్తుంది. ఈ లెక్కింపు message creation కు వేరుగా ఉన్న rate limit కింద జరుగుతుంది.
curl https://api.anthropic.com/v1/messages/count_tokens \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "content-type: application/json" \
-H "anthropic-version: 2023-06-01" \
-d '{
"model": "claude-opus-5",
"system": "You are a scientist",
"messages": [{
"role": "user",
"content": "Hello, Claude"
}]
}'ప్రతిస్పందనలో ఒక field ఉంటుంది:
{ "input_tokens": 14 }మీ నిజమైన system prompt మరియు tool definitions ను representative user message తో కలిపి దీనికి పంపండి. ఆ సంఖ్యను పై cost function లో ఉపయోగించండి. ఈ endpoint message request లో ఉన్న structured inputs నే స్వీకరిస్తుంది. ఇందులో system prompts, tools, images మరియు PDFs కూడా ఉంటాయి. అందువల్ల base64 గా పంపిన images మరియు PDFs కూడా సరిగ్గా లెక్కించబడతాయి. అయితే ఇది ప్రతి message request body ను స్వీకరించదు. web search మరియు web fetch వంటి server tools, MCP connector, URL లేదా file reference ద్వారా పంపిన images లేదా documents ను ఇది తిరస్కరిస్తుంది. thread ఉన్న ఏ request నైనా ఇది తిరస్కరిస్తుంది. Threaded conversation కోసం system prompt మరియు tools సహా మొత్తం conversation ను లెక్కించండి.
రెండు ముఖ్యమైన జాగ్రత్తలు ఉన్నాయి. ఈ count ఒక estimate మాత్రమే. అందువల్ల billed figure తో స్వల్పంగా తేడా ఉండవచ్చు. అలాగే, మీరు అందించే model యొక్క tokenizer తోనే ఇది కొలవబడుతుంది. కాబట్టి వాస్తవంగా నడపబోయే model ను అందించండి.
Output tokens ను ముందుగానే లెక్కించలేరు, ఎందుకంటే అవి ఇంకా ఉత్పత్తి కాలేదు. వాటికి max_tokens తో పరిమితి విధించండి. తరువాత live traffic లో usage.output_tokens నుంచి వాస్తవ distribution ను కొలవండి.
బిల్లులోకి ఇంకా ఏమేమి చేరతాయి
బిల్లులో ఎక్కువ భాగం tokens కు సంబంధించినదే. అయితే కొన్ని అంశాలు tokens కావు. అవి చాలామందిని ఆశ్చర్యపరుస్తాయి.
- ప్రతి request లో tool definitions input tokens గా మారతాయి. మీ స్వంత schemas ను లెక్కించకముందే, tool use system prompt ఒక్కటే Opus 5 లో 286 నుంచి 406 tokens జోడిస్తుంది. వివరణలు ఎక్కువగా ఉన్న పది tool descriptions చిన్న prompt పరిమాణాన్ని రెండింతలు చేయవచ్చు.
- Web search కు ప్రతి 1,000 searches కు $10 వసూలు చేస్తారు. ఫలితాలు context లోకి వచ్చినప్పుడు అవి వినియోగించే tokens కు ఇది అదనం.
- Web fetch కు ప్రత్యేక రుసుము ఉండదు. అయితే fetch చేసిన page input tokens గా మారుతుంది. 100 kB documentation page లో సుమారుగా 25,000 tokens ఉంటాయి.
- Claude 4.6 మరియు తదుపరి versions లో
inference_geoతో US-only inference కోరితే, cache reads మరియు writes సహా ప్రతి token category పై 1.1 multiplier వర్తిస్తుంది.
మొత్తం వినియోగ పరిమాణాన్ని బట్టి API కొనడం సరైనదా కాదా నిర్ణయించాలి. Plan లోని usage ceiling ను చేరుకున్నప్పుడు సాధారణంగా ఈ ప్రశ్న ఎదురవుతుంది. అప్పుడు limit దాటిన తర్వాతి మార్గాలు window ముగిసే వరకు వేచి ఉండటం నుంచి, ఆ పనిని metered API calls కు మార్చడం వరకు ఉంటాయి. వినియోగం ఒక నిర్దిష్ట స్థాయికంటే తక్కువగా ఉంటే flat monthly plan స్పష్టంగా ప్రయోజనకరంగా ఉంటుంది. Claude subscription తో పోల్చిన API ఆ పోలికను వాస్తవ సంఖ్యలతో చూపిస్తుంది.
FAQ
Claude లో 1M tokens ధర ఎంత?
ఇది model పై, అలాగే tokens input లేదా output అనేదానిపై ఆధారపడి ఉంటుంది. October 2026 నాటికి, ఒక million input tokens ధర Claude Haiku 4.5 లో $1, Claude Sonnet 5 లో $2, Claude Opus 5 లో $5. కొత్త Claude Haiku 5.5 లో 100,000 tokens వరకు prompts కు ఒక million input tokens ధర $0.10 నుంచి ప్రారంభమవుతుంది; అంతకంటే ఎక్కువకు $0.50 వసూలు చేస్తుంది. ఈ models అన్నింటిలో output ధర input rate కు ఐదు రెట్లు ఉంటుంది. Rates మారవచ్చు. కాబట్టి budget లో సంఖ్యను చేర్చే ముందు అధికారిక pricing page లో వాటిని నిర్ధారించండి.
1M tokens అంటే 1M words తో సమానమా?
కాదు. Claude Opus 4.7 కంటే ముందు models లో, ఒక token సుమారుగా 3.5 English characters కు సమానం అని Anthropic చెబుతుంది. ఒక million tokens లో సుమారుగా 750,000 words ఉంటాయి. Claude Opus 4.7 మరియు తరువాతి versions ఉపయోగించే కొత్త tokenizer లో, ఒక million tokens లో సుమారుగా 555,000 words ఉంటాయి. కారణం, అదే text కు Claude Sonnet 4.6 మరియు అంతకుముందు versions తో పోలిస్తే ఆ tokenizer సుమారుగా 30 percent ఎక్కువ tokens ఉత్పత్తి చేయడం. ఈ నిష్పత్తులు మార్గదర్శకం మాత్రమే. Code, JSON మరియు English కాకుండా ఇతర భాషలు ప్రతి word కు ఎక్కువ tokens ఉపయోగిస్తాయి. Model generations మధ్య counts ను నేరుగా పోల్చలేరు. మీరు అమలు చేయాలనుకుంటున్న model ను పంపుతూ, ఉచిత /v1/messages/count_tokens endpoint తో కొలవండి.
Prompt caching ఎల్లప్పుడూ డబ్బు ఆదా చేస్తుందా?
కాదు. 5 minute cache write కు base input rate కు 1.25 రెట్లు ఖర్చవుతుంది. అందువల్ల write చేసి ఎప్పుడూ read చేయని prefix ను సాధారణంగా పంపడం కంటే 25 percent ఎక్కువ ఖర్చవుతుంది. మొదటి read నుంచే దాని ఖర్చు తిరిగి వస్తుంది. ఇది రెండు విధాలుగా విఫలమవుతుంది. రెండూ ఎటువంటి సూచన లేకుండానే జరుగుతాయి. Requests మధ్య cached prefix మారితే lookup సరిపోలదు, ఎందుకంటే ఇది exact prefix match. Prefix model యొక్క కనీస cacheable length కంటే తక్కువగా ఉంటే ఏదీ cache కాదు, error కూడా తిరిగి రాదు. Sonnet 5 లో ఈ పరిమితి 1,024 tokens, Haiku 4.5 లో 4,096. cache_creation_input_tokens మరియు cache_read_input_tokens రెండూ 0 చూపిస్తే cache ఏ పని చేయడం లేదు.
నా message count కంటే bill వేగంగా ఎందుకు పెరిగింది?
ప్రతి turn లో model మొత్తం conversation ను మళ్లీ చదువుతుంది. Default గా Messages API ఎటువంటి state ను నిల్వ చేయదు. అందువల్ల chat లోని turn 20, ముందు ఉన్న 19 turns అన్నింటినీ మళ్లీ input గా పంపుతుంది. Optional message threads beta ద్వారా కొత్త messages మాత్రమే upload చేయవచ్చు. అయితే threads pricing ను మార్చవని Anthropic చెబుతుంది. ప్రతి turn సగటున 500 tokens ఉంటే, 20 turn conversation సుమారుగా 105,000 input tokens పంపుతుంది. Transcript పొడవు మాత్రం 10,000 tokens మాత్రమే. ప్రతి tool result history లోనే ఉండటం వల్ల agent loops కూడా ఇదే విధంగా పనిచేస్తాయి. స్థిరమైన prefix ను cache చేయండి. లేదా పాత turns ను summarise చేసి request నుంచి తొలగించండి.