Claudeలో 1M tokens ధర ఎంత? Input, output ఖర్చు

Claudeలో 1M tokens ధర ఎంత?

1M tokens అంటే ఒక మిలియన్ tokens. ప్రతి Claude API (application programming interface) ధరను ఇదే unitలో పేర్కొంటారు. దీనికి ఒకే ధర ఉండదు. Input మరియు outputకు వేర్వేరు రేట్లు ఉంటాయి. ప్రతి modelకు తనదైన రెండు రేట్లు ఉంటాయి. August 2026 నాటికి, Claude Haiku 4.5లో ఒక మిలియన్ input tokens ధర $1, Claude Sonnet 5లో $2, Claude Opus 5లో $5.

Output ఖరీదైన భాగం. ప్రస్తుతం ఉన్న ప్రతి modelలో output rate, input rateకు ఐదు రెట్లు ఉంటుంది. అందువల్ల headline figure కంటే input మరియు output మధ్య విభజనే మీ billపై ఎక్కువ ప్రభావం చూపుతుంది. పొడవైన documents పంపి, చిన్న సమాధానాలు తిరిగి ఇచ్చే app, చిన్న prompt నుంచి పొడవైన సమాధానాలు రాసే app కంటే పూర్తిగా భిన్నంగా ఖర్చవుతుంది.

ఈ page unit economics గురించి వివరిస్తుంది: ఒక tokenకు ఎంత ఖర్చవుతుంది, build చేయడానికి ముందు billను ఎలా అంచనా వేయాలి. మీరు పని చేస్తున్నప్పుడు tokens వాస్తవంగా ఎక్కడ ఉపయోగించబడతాయో తెలుసుకోవడానికి Claude Code sessionలో tokens ఎక్కడ ఉపయోగించబడతాయో చదవండి.

1M tokens ఎలా కనిపిస్తుంది

token అనేది model చదివే లేదా రాసే text యొక్క ఒక భాగం. Anthropic ఇచ్చే సుమారు అంచనా ప్రకారం, ప్రతి 4 characters కు ఒక token ఉంటుంది. English లో ఇది సుమారు 0.75 words కు సమానం. అందువల్ల ఒక million tokens అంటే సుమారు 750,000 words, లేదా plain text లో దాదాపు 4 MB.

సాధారణ inputs కోసం ప్రచురించిన అంచనాలు ఈ పరిమాణాన్ని మరింత స్పష్టంగా చూపిస్తాయి.

[
  {
    "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 ను సుమారు 400 సగటు web pages ను ఒక్కసారి చదవడానికి, లేదా ఆ పరిమాణంలోని 8 research papers కు సమానంగా చూడవచ్చు. ఇది మధ్యస్థ పరిమాణంలోని codebase ను ఒకసారి పూర్తిగా పరిశీలించడానికి, లేదా ఒక వ్యక్తి ఒక నెలపాటు తక్కువ స్థాయిలో chat ఉపయోగించడానికి సరిపోతుంది.

ఇవన్నీ అంచనాలుగానే పరిగణించాలి. Code, JSON మరియు English కాకుండా ఇతర భాషల text లో ఒక token లో ఉండే words సంఖ్య తక్కువగా ఉంటుంది. అందువల్ల 0.75 నిష్పత్తి ఆశావహమైన గరిష్ఠ అంచనా. Token count ను మరో విషయం కూడా ప్రభావితం చేస్తుంది: Opus 5 మరియు Sonnet 5 ను కలిగి ఉన్న Claude Opus 4.7 మరియు తరువాతి versions, Sonnet 4.6 మరియు అంతకుముందు versions కంటే అదే text కు సుమారు 30 percent ఎక్కువ tokens ఉత్పత్తి చేసే కొత్త tokenizer ను ఉపయోగిస్తాయి. Claude Haiku 4.5 పాత tokenizer ను ఉపయోగిస్తుంది. కాబట్టి Haiku 4.5 పై కొలిచిన count, అదే input కోసం Sonnet 5 పై ఉండే count కంటే తక్కువగా ఉంటుంది. దీనివల్ల ఆ సరిహద్దు దాటే models మధ్య నేరుగా price-per-million పోలిక న్యాయసమ్మతం కాదు. నిర్ణయం తీసుకునే ముందు అదే prompt ను రెండు models కు ఇచ్చి count చేయండి.

మిలియన్ tokens కు Claude వసూలు చేసే రుసుము

[
  {
    "label": "Haiku 4.5",
    "input_usd": 1,
    "output_usd": 5
  },
  {
    "label": "Sonnet 5 (to 31 Aug 2026)",
    "input_usd": 2,
    "output_usd": 10
  },
  {
    "label": "Sonnet 5 (from 1 Sep 2026)",
    "input_usd": 3,
    "output_usd": 15
  },
  {
    "label": "Opus 5",
    "input_usd": 5,
    "output_usd": 25
  }
]

Claude Sonnet 5 కు 31 August 2026 వరకు ప్రారంభ ధరలు వర్తిస్తాయి: input కు $2, output కు $10. 1 September 2026 నుంచి సాధారణ రుసుము వర్తిస్తుంది: input కు $3, output కు $15. Claude Opus 5 ధర input కు $5, output కు $25. ఈ ధరల పట్టికకు మించి ఉన్న ఒక model ఉంది: Claude Fable 5 ధర input కు $10, output కు $50. అందువల్ల ఆ రుసుములు చెల్లించడం విలువైనదా అనేది మీరు దానికి అప్పగించే పనులపై ఆధారపడి ఉంటుంది.

రుసుములు మారవచ్చు. ఈ పేజీలోని ప్రతి సంఖ్యను August 2026 నాటి worked example గా పరిగణించండి. బడ్జెట్‌ను ఖరారు చేసే ముందు ప్రస్తుత సంఖ్యలను అధికారిక pricing pageలో నిర్ధారించండి.

ఈ రుసుములు Claude ధరను తెలియజేస్తాయి. కానీ మీ workload కు ఇది చౌకైన ఎంపికో కాదో తెలియజేయవు. Claude మరియు ChatGPT రెండింటిలో ఖర్చు లెక్కించిన మూడు పనులు ప్రతి API లో ఏది తక్కువ ఖర్చుతో వస్తుందో చూపిస్తుంది.

Context length రుసుమును మార్చదు. Claude 4.6 మరియు తరువాతి versions లో పూర్తి 1M token context window కు standard pricing వర్తిస్తుంది. అందువల్ల 900,000 token request కు, 9,000 token request కు ఉన్నట్లే ప్రతి token పై అదే రుసుము ఉంటుంది. Long prompt కు ఎక్కువ tokens ఉన్నందువల్ల ఎక్కువ ఖర్చవుతుంది. ప్రత్యేక long-context rate వర్తించదు.

ధర మారినప్పటికీ పనిచేసే లెక్క

ప్రతి బిల్లు రెండు గుణకారాలు మరియు ఒక కూడికతో రూపొందుతుంది.

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, August 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 అవుతాయి. Messages API stateless గా ఉండటం, calls మధ్య model ఏదీ గుర్తుంచుకోకపోవడం వల్ల అవి ప్రతి request తో పంపబడతాయి. User question కు సుమారు 300 tokens జత అవుతాయి. Answer సుమారు 400 tokens ఉంటుంది. అంటే ప్రతి request కు 4,300 input tokens మరియు 400 output tokens ఉంటాయి.

ఒక మిలియన్ 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 ఖర్చవుతుంది. ఈ పరిమాణంలో మీరు rate గురించి జరిపే ఏ negotiation కంటే మీ model ఎంపిక మరియు caching నిర్ణయం ఒక్కొక్కటి ఎక్కువ ప్రభావం చూపుతాయి. ఏ model ను run చేయాలి అనేది వేరు ప్రశ్న. మీ evaluations లో ఉత్తీర్ణమయ్యే అతి తక్కువ ఖర్చు model ను ఎంచుకోవాలి: Opus, Sonnet మరియు Haiku మధ్య ఎంపిక లో దీన్ని సరైన విధంగా ఎలా test చేయాలో వివరించబడింది.

Prompt caching పునరావృత భాగం ఖర్చును తగ్గిస్తుంది

ప్రతి అభ్యర్థనలో ఆ 4,000 token prefix ఒకేలా ఉంటుంది. అయినా ప్రతి సారి దానికి పూర్తి input ధర చెల్లిస్తారు. Prompt caching ప్రాసెస్ చేసిన prefix ను నిల్వ చేసి, దాన్ని మళ్లీ ఉపయోగించినప్పుడు తగ్గించిన రేటును వసూలు చేస్తుంది.

Cache read ఖర్చు base input rate లో 0.1 రెట్లు ఉంటుంది. 5 నిమిషాల lifetime కోసం cache రాయడానికి base rate లో 1.25 రెట్లు, 1 గంట lifetime కోసం 2 రెట్లు ఖర్చవుతుంది. కాబట్టి 5 నిమిషాల cache ఒక read తర్వాతే తన ఖర్చును భర్తీ చేస్తుంది. Cache రాయడానికి అదనంగా 0.25 ఖర్చవుతుంది, ప్రతి read 0.9 ఆదా చేస్తుంది. 1 గంట cache సమతుల్యానికి చేరుకోవడానికి రెండు 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
  }
}

ఆ మూడు input counters కు మూడు వేర్వేరు రేట్లతో billing జరుగుతుంది. అవి కలిపి మీ వాస్తవ input volume ను చూపిస్తాయి: total_input_tokens = cache_read_input_tokens + cache_creation_input_tokens + input_tokens. Caching ప్రారంభమైన తర్వాత input_tokens ను మాత్రమే చదివే cost estimate చాలా తప్పుగా ఉంటుంది.

Cache ఖర్చును భర్తీ చేయకుండా ఆపే రెండు కారణాలు ఉన్నాయి. రెండూ ఎటువంటి error లేకుండానే విఫలమవుతాయి.

Prefix byte-identical గా ఉండాలి. Cache lookup prefix match పై ఆధారపడి ఉంటుంది. అందువల్ల system prompt ప్రారంభంలో timestamp లేదా user's name ఉంచితే ప్రతి అభ్యర్థనలో prefix మారుతుంది. అప్పుడు ప్రతి సారి base input ధరలో 1.25 రెట్లు చెల్లిస్తారు. ఒక్కసారి కూడా read జరగదు. దీని లక్షణం cache_creation_input_tokens విలువ ఎక్కువగా ఉండి, cache_read_input_tokens విలువ 0గా ఉండటం. అభ్యర్థనల మధ్య content ఒకేలా ఉండే చివరి block పై cache_control ను ఉంచండి. మారే ప్రతిదాన్ని దాని తరువాత ఉంచండి. మీ tools definitions మార్చితే వాటి కింద ఉన్న మొత్తం cache invalid అవుతుంది, ఎందుకంటే invalidation క్రమం tools, తరువాత system, తరువాత messages గా కిందికి అమలవుతుంది.

Prefix తగినంత పొడవుగా ఉండాలి. Cache చేయగల కనీస పొడవు Opus 5లో 512 tokens, Sonnet 5లో 1,024 tokens, Haiku 4.5లో 4,096 tokens. Prompt దీనికంటే చిన్నగా ఉంటే cache చేయబడదు. ఎటువంటి error కూడా తిరిగి ఇవ్వబడదు. పై ఉదాహరణలోని 4,000 token prefix Sonnet 5లో cache అవుతుంది. Haiku 4.5లో cache కాదు, ఎందుకంటే 4,000 ఆ model యొక్క కనీస పరిమితికంటే తక్కువ. రెండు counters విలువలు 0గా ఉంటే ఏదీ cache కాలేదు.

బ్యాచ్ ప్రాసెసింగ్ రేటును సగానికి తగ్గిస్తుంది

Batch API అభ్యర్థనలను asynchronous గా ప్రాసెస్ చేస్తుంది. Input మరియు output రెండింటిపై 50 percent తగ్గింపు వర్తిస్తుంది. పై ఉదాహరణలో 1,000 అభ్యర్థనలకు $12.60 అయ్యే ఖర్చు $6.30 అవుతుంది. ఈ తగ్గింపు prompt caching తో కలుస్తుంది. అందువల్ల bulk పనులను అమలు చేయడానికి cached batch job అత్యంత తక్కువ ఖర్చు మార్గం.

దీనికి ప్రతిగా latency పెరుగుతుంది. అందువల్ల ఒక వ్యక్తి కూర్చొని ఫలితం కోసం వేచి ఉండే పనులకు batch సరిపోదు. రాత్రివేళ classification మరియు document backfill పనులకు ఇది అనుకూలంగా ఉంటుంది.

ఒకే conversation లో chat ఖర్చులు ఎందుకు పెరుగుతాయి

API ఎలాంటి state ను నిల్వ చేయదు. అందువల్ల ప్రతి turn సమయంలో client మొత్తం conversation ను మళ్లీ పంపుతుంది. కాబట్టి ఒక chat లో token వినియోగం దాని పొడవుతో సరళరేఖలా కాకుండా, దాని వర్గంతో పెరుగుతుంది.

సగటున 500 tokens ఉండే turnలను తీసుకుందాం. 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 మాత్రమే ఉంటుంది.

అందుకే chat feature ఖర్చు transcript సూచించేదానికంటే ఎక్కువగా ఉంటుంది. అందుకే స్థిరంగా ఉండే prefix ను cache చేయడం లేదా పాత turnలను సంక్షిప్తం చేయడం పొడవైన threadsలో ప్రయోజనకరంగా ఉంటుంది. Tool calls పై loop చేసే agent కూడా ఇదే విధానాన్ని కలిగి ఉంటుంది. అంతేకాదు, ప్రతి tool result historyలోనే ఉండి, తరువాతి ప్రతి turnలో మళ్లీ పంపబడుతుంది. మీరు స్వయంగా నడిపే agentకు కఠినమైన spending limit ఏర్పాటు చేయడం ఇక్కడ అత్యంత ముఖ్యమైనది. ఎందుకంటే ఈ పెరుగుదల స్వయంచాలకంగా జరుగుతుంది, దాన్ని ఎవరూ పర్యవేక్షించరు.

మీరు ఊహించేముందు token లను లెక్కించండి

word count ఆధారంగా token count ను అంచనా వేయడం ఆపండి. 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"
    }]
  }'

Response లో ఒక field ఉంటుంది:

{ "input_tokens": 14 }

మీ నిజమైన system prompt మరియు tool definitions ను representative user message తో కలిపి దీనికి పంపండి. తరువాత వచ్చిన సంఖ్యను పై cost function లో ఉపయోగించండి. ఈ endpoint message request కు ఉపయోగించే అదే body ను స్వీకరిస్తుంది. అందువల్ల images మరియు PDFs కూడా సరిగ్గా లెక్కించబడతాయి. రెండు విషయాలు గుర్తుంచుకోవాలి. ఈ count ఒక estimate మాత్రమే. ఇది billed figure తో స్వల్పంగా భిన్నంగా ఉండవచ్చు. అలాగే ఈ లెక్కింపు మీరు పంపే model యొక్క tokenizer తో జరుగుతుంది. కాబట్టి వాస్తవంగా run చేయబోయే 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వా అన్నదానిపై ఆధారపడి ఉంటుంది. August 2026 నాటికి ఒక million input tokens ధర Claude Haiku 4.5లో $1, introductory pricing కింద Claude Sonnet 5లో $2, Claude Opus 5లో $5. ఈ modelsలో ప్రతి దానికీ output ధర input rate కంటే ఐదు రెట్లు ఎక్కువ. 1 September 2026న Sonnet 5 ధర inputకు $3, outputకు $15 అవుతుంది. Rates మారవచ్చు. కాబట్టి budgetలో ఒక మొత్తాన్ని చేర్చే ముందు official pricing pageలో వాటిని నిర్ధారించండి.

1M tokens అంటే 1M wordsతో సమానమా?

కాదు. ఒక tokenలో Englishకు సుమారు 4 characters ఉంటాయి. ఇది దాదాపు 0.75 wordsకు సమానం. అందువల్ల one million tokens సుమారు 750,000 words అవుతుంది. ఈ ratio ఒక అంచనా మాత్రమే. Code, JSON, అలాగే English కాకుండా ఇతర languagesలో ప్రతి wordకు ఎక్కువ tokens అవసరం కావచ్చు. Claude Opus 4.7 మరియు తరువాతి versionsలో కొత్త tokenizer ఉపయోగిస్తారు. అదే textకు Claude Sonnet 4.6 మరియు అంతకుముందు versionsతో పోలిస్తే ఇది సుమారు 30 percent ఎక్కువ tokens ఉత్పత్తి చేస్తుంది. అందువల్ల వేర్వేరు model generations మధ్య countsను నేరుగా పోల్చలేరు. మీరు run చేయాలనుకుంటున్న modelను పంపించి, ఉచిత /v1/messages/count_tokens endpointతో కొలవండి.

Prompt caching ఎల్లప్పుడూ ఖర్చును తగ్గిస్తుందా?

కాదు. 5 minute cache writeకు base input rateకు 1.25 రెట్లు ఖర్చవుతుంది. అందువల్ల write చేసి మళ్లీ ఎప్పుడూ read చేయని prefixను సాధారణంగా పంపడం కంటే 25 percent ఎక్కువ ఖర్చవుతుంది. మొదటి read నుంచే అది తన ఖర్చును తిరిగి పొందుతుంది. ఇది రెండు విధాలుగా విఫలమవుతుంది. రెండూ ఎటువంటి error లేకుండానే జరుగుతాయి. Requests మధ్య cached prefix మారితే lookup ఎప్పుడూ match కాదు, ఎందుకంటే ఇది exact prefix match. Prefix model యొక్క minimum cacheable length కంటే చిన్నదైతే కూడా cache చేయబడదు. ఆ పరిమితి Sonnet 5లో 1,024 tokens, Haiku 4.5లో 4,096 tokens. ఎటువంటి error కూడా తిరిగి ఇవ్వబడదు. cache_creation_input_tokens మరియు cache_read_input_tokens రెండూ 0 చూపిస్తే cache ఏ పనీ చేయడం లేదు.

నా message count కంటే bill వేగంగా ఎందుకు పెరిగింది?

ప్రతి turnలో మొత్తం conversation మళ్లీ పంపబడుతుంది. Messages API ఎటువంటి stateను నిల్వ చేయదు. అందువల్ల chatలోని turn 20కు inputగా ముందున్న 19 turns అన్నీ మళ్లీ పంపబడతాయి. ప్రతి turn సగటున 500 tokens ఉంటే, 20-turn conversationలో transcript పొడవు 10,000 tokens మాత్రమే ఉన్నప్పటికీ సుమారు 105,000 input tokens పంపబడతాయి. Agent loops కూడా ఇదే విధంగా పనిచేస్తాయి, ఎందుకంటే ప్రతి tool result historyలోనే ఉంటుంది. స్థిరంగా ఉండే prefixను cache చేయండి. లేదా పాత turnsను summarise చేసి వాటిని request నుంచి తొలగించండి.