Ano ang Claude tokens? Math ng Claude Code

Ano ang mga token sa Claude?

Ang token ay yunit ng text na binabasa at sinusulat ni Claude: isang bahagi ng salita. Sa sariling glossary ng Anthropic, tinatayang 3.5 English character ito sa mga model bago ang Claude Opus 4.7. Sa kasalukuyang tokenizer, mas malapit ito sa 2.5, dahil tinutukoy ng Anthropic ang 1M token bilang humigit-kumulang 2.5M character doon. Sa alinmang batayan, lumalampas ito sa isang token bawat salita kapag isinama ang mga space at punctuation, kaya ang 1,000 salita ng prose ay madaling lalampas sa 1,300 token. Mas mabigat ang code bawat linya: hinahati ng mga brace, operator, underscore, at indentation ang code sa mas maraming token bawat character kaysa sa English, at ang source file na may ilang daang linya ay karaniwang nagkakahalaga ng ilang libong token. Ang file na may 2,000 linya na napagpasyahan ng agent na basahin ay maaaring kumonsumo ng limang-digit na bilang ng token bago pa makapagsulat ng isang linya ng bagong code.

Dalawang bagay tungkol sa tokenizer ang madalas na nakalilito. Una, partikular ang mga ito sa bawat model. Noong October 2026, ginagamit ng Claude Opus 4.7 at ng lahat ng mas bagong model, kabilang ang kasalukuyang Fable 5.1, Opus 5.5, Sonnet 5.5, at Haiku 5.5, ang mas bagong tokenizer na lumilikha ng humigit-kumulang 30% mas maraming token para sa parehong text kumpara sa mga naunang Claude model gaya ng Haiku 4.5; nag-iiba ang eksaktong dagdag depende sa content. Binabago nito ang anumang budget na itinakda sa token kahit hindi tumaas ang presyo bawat token. Ikalawa, ang tiktoken, ang library na ginagamit sa halos lahat ng blog post, ay tokenizer ng OpenAI, hindi ng Claude, kaya hindi tugma ang mga bilang nito sa sinisingil ng Anthropic. Ang tanging mapagkakatiwalaang bilang ay mula sa count_tokens endpoint, na tatalakayin sa ibaba.

Bakit ganito ang gastos ng coding session mo

Ang bawat Claude bill, API invoice man o subscription limit, ay pangunahing nakabatay sa isang meter: tokens na ipinapasok at tokens na inilalabas. May ilang API tool na may sarili ring singil. Halimbawa, nagkakahalaga ang web search ng $10 bawat 1,000 search noong October 2026, bukod pa sa tokens na idinadagdag ng mga resulta nito. Pero sa coding session, ang token meter ang pangunahing gumagalaw. Simple itong tingnan sa pricing page: ganitong halaga bawat million input token at ganito naman bawat million output token. Hindi ipinapakita roon na sa isang agentic coding session, mas mabilis umakyat ang input meter kaysa sa inaasahan dahil muling ipinapadala ang buong conversation sa bawat turn. Labinlimang taon akong nagbebenta ng metered infrastructure, at ang tokens ang unang meter na nakita kong talagang hindi matukoy ng karamihan ng customer kung ano ang nagpapabilis dito. Ito ang aralin sa pagbasa ng meter: ano ang itinuturing na input at output sa isang agentic session, bakit napakamahal ng resend loop, paano binabago ng prompt caching ang kalkulasyon, at aling mga lever ang tunay na nakapagpapabago sa halaga.

Lahat ay input: kung ano talaga ang binibilang ng meter

Ipinapalagay ng mga tao na binabayaran nila ang code na sinusulat ni Claude. Sa isang agentic session, maliit na bahagi lang iyon ng gastos. Kasama sa input tokens, na mas mura ang rate pero mas malaki ang volume, ang mga sumusunod:

• Ang system prompt. Kasama rito ang sariling harness instructions ng Claude Code, pati ang iyong CLAUDE.md at mga memory file, na nilo-load sa simula ng session at kasama sa bawat request pagkatapos nito.
• Mga tool definition. Kasama rito ang schema ng bawat tool na maaaring tawagin ng agent. Bawat MCP server na ikinokonekta mo ay nagdaragdag sa fixed overhead na ito. Gayunman, dine-defer na ngayon ng Claude Code bilang default ang kumpletong MCP tool definition. Mga pangalan lang ng tool ang nasa context hanggang sa unang paggamit sa isang tool. Binabawasan nito ang gastos, pero hindi ito inaalis.
• Bawat file na binabasa ng agent. Kapag nagbasa ng source file ang agent gamit ang Read, buong file ang napupunta sa context at nananatili roon.
• Bawat resulta ng tool. Kasama sa input tokens ang test run, grep output, terminal output, build log, at lahat ng iba pang output na ibinabalik ng tool. Ang failing test suite na nagpi-print ng 8,000 linya ay katumbas ng isang maikling libro. Noong October 2026, humigit-kumulang 30,000 character ng command output ang ipinapasa ng Claude Code inline bilang default. Ang mas mahaba rito ay ipinapadala bilang saved file na may preview na hanggang 2,000 character. Gayunman, buong-buo pa ring sinisingil ang bawat output na mas maikli sa limitasyong ito at bawat susunod na pagbasa sa saved file.
• Ang buong conversation hanggang sa puntong iyon, na muling ipinapadala sa bawat turn. Nangangailangan ito ng sarili nitong section.

Hindi libre ang muling pagpapadala

Stateless ang Claude API. Hindi nito naaalala ang session mo sa pagitan ng mga request; walang component na gumagawa nito. Kaya sa turn 2, ipinapadala ng client ang turn 1, ang response nito, at ang bago mong message. Sa turn 50, ipinapadala nitong muli ang lahat ng nasa context mula turn 1 hanggang turn 49, kasama ang bawat nabasang file, tool result, at diff na hindi pa naaalis sa pamamagitan ng compaction, pati ang turn 50. Sa compaction, pinapalitan ang lumang history ng summary. Samantala, nananatili sa sariling context ng subagent ang mga file na binasa nito, at ang resulta lamang nito ang ibinabalik. Muling binabasa ng model ang buong natitirang transcript sa bawat request, at sinisingil bilang input ang bawat token na muling binasa.

Ang resulta: halos linear ang paglaki ng cost bawat turn habang humahaba ang session, at halos quadratic ang kabuuang cost ng session. Ang message na nagkakahalaga ng kalahating sentimo sa turn 3 ay maaaring maging 20 beses na mas mahal sa turn 60, kahit pareho ang one-line question, dahil dala nito ang 60 turn ng data. Ito ang pangunahing katotohanang nagpapaliwanag sa karamihan ng mga ticket na “bakit napakataas ng bill ko.” Hindi ito partikular na problema ng Claude; ang bawat LLM product na mukhang stateful ay gumagamit sa ilalim ng stateless API na may resend loop.

Output: ang nakikita mo, kasama ang thinking na hindi mo nakikita

Ang mga output token ang pinakamahal, limang beses ang presyo kumpara sa input rate sa kasalukuyang lineup ($10/$50 sa Fable 5.1, $4/$20 sa Opus 5.5, $2/$10 sa Sonnet 5.5, $0.10/$0.50 sa Haiku 5.5 para sa mga prompt na hanggang 100,000 tokens, simula noong Oktubre 2026). Kasama sa output ang text at code na ginagawa ni Claude, at ang thinking tokens: ang panloob na pag-iisip na ginagawa ng model bago sumagot. Dalawang katotohanan ang mahalaga rito. Ang thinking ay binabayaran sa output rates at ibinabawas sa max_tokens, ang API response na namamatay sa stop_reason: "max_tokens" at ang putol na sagot ay madalas nangangahulugang naubos ng thinking ang budget bago pa man makasagot. At sa mga kasalukuyang model, maaaring hindi ipakita ang reasoning summary; default na tinatanggal ito ng API sa Fable 5.1, Opus 5.5, Sonnet 5.5, Haiku 5.5, at sa mga naunang model hanggang Opus 4.7, pero nangyari pa rin ang thinking at binabayaran pa rin ito. Ang hindi nakikita ay hindi libre.

Default na naka-enable ang extended thinking sa Claude Code dahil nasusukat na nakakatulong ito sa mga multi-step na gawain, at ang default budget ay maaaring umabot sa sampu-sampung libong tokens bawat request. Sa mga simpleng gawain, maaari mo itong babaan: bawasan ang effort level gamit ang /effort o sa /model, o patayin ang thinking sa /config sa mga model na pumapayag nito. Simula noong Oktubre 2026, hindi kayang patayin ng Claude Code ang thinking sa Opus 5.5, Sonnet 5.5, Haiku 5.5, o sa mga Fable model, kaya ang effort ang kontrol dito. Nagbibigay ang API ng mas maluwag na limitasyon sa dalawa sa mga ito. Ang Haiku 5.5 ay tumatanggap ng thinking: {"type": "disabled"} sa high effort o pababa, gaya ng mas lumang Opus 5, habang ang mas lumang Sonnet 5 ay tumatanggap nito sa lahat ng effort level, kasama ang xhigh at max. Tinatanggihan ng Sonnet 5.5 ang "disabled" at tinatanggap ang thinking: {"type": "between_tools"} sa halip, na nagtatanggal ng up-front thinking sa low, medium, o high effort, kaya ang request na walang tools ay nakakakuha ng sagot nang walang naunang thinking. Tanging ang Opus 5.5 at ang mga Fable model lang ang nagpapanatili ng thinking sa kahit anong ipadala mo. Ito ay isang tunay na paraan para makatipid, hindi ito haka-haka.

Binabago ng prompt caching ang math

Ang prompt caching ang dahilan kung bakit hindi nalulugi ang lahat dahil sa resend loop. Maaaring i-cache ng API ang stable prefix ng prompt mo, system prompt, tool definitions, at conversation history, at sa susunod na request ay ihatid ito sa maliit na bahagi ng presyo. Noong October 2026, ganito ang mga multiplier: ang write sa cache ay nagkakahalaga ng 1.25× ng base input rate (2× para sa 1-hour variant), at ang read mula sa cache ay nagkakahalaga ng 0.1× sa karamihan ng mga model, 0.05× sa Claude Opus 5.5 at Claude Sonnet 5.5, at 0.025× sa Claude Fable 5.1. Premium ang writes; 90% discount ang reads sa karamihan ng mga model, 95% sa Opus 5.5 at Sonnet 5.5, at 97.5% sa Fable 5.1. (Ibinaba ang read rate ng Sonnet 5.5 mula 0.1× tungo sa 0.05× noong October 7, 2026.) Sapat na ang isang read para mabawi nang higit pa ang premium ng 5-minute write.

Si Claude Code ang nagma-manage ng caching para sa iyo, at sa isang maayos na session, halos lahat ng malaking resend na iyon ay inihahatid mula sa cache. Ngunit nag-e-expire ang cache kapag matagal na walang activity. Noong October 2026, binibigyan ng Claude Code ang pangunahing conversation mo ng one-hour cache kapag subscription ang gamit at pasok ito sa included usage ng plan mo, at five minutes mula sa huling paggamit kapag API key o cloud provider ang gamit, o kapag gumagamit ka na ng usage credits (maaaring i-request ng promptCacheTtl ang one-hour cache sa ganitong setup, sa 2× write rate). Sa five-minute cache, kung lumampas sa inaasahan ang coffee break mo, bumalik ka, at nagpadala ng message, nag-expire na ang cache. Isusulat muli ang buong naipong prefix sa 1.25× sa halip na basahin sa cache rate. Sa 150K-token na session, isinusulat ng isang cold turn ang lahat ng 150K token sa 1.25×, samantalang babasahin sana ng warm turn ang mga ito sa 0.1×. 12.5-fold ang diperensya sa prefix (25-fold sa Opus 5.5 at Sonnet 5.5, at 50-fold sa Fable 5.1). Ito ang kontra-intuwitibong resultang dapat tandaan: maaaring mas mahal ang rhythm na idle-then-resume kaysa tuloy-tuloy na trabaho, dahil bawat idle gap na lumampas sa TTL ay nagpapalit sa susunod mong turn mula sa murang read tungo sa mahal na re-write. Magtrabaho sa mga stint. Sa five-minute cache, huwag magpadala ng tig-isang message sa malaking session kada sampung minuto.

Kung tinatawag mo ang API mula sa sarili mong application sa isang VPS, walang awtomatikong mangyayari sa mga ito: kailangan mong mag-opt in gamit ang cache_control. Ang karaniwang problemang sariling gawa ay ang timestamp o request ID na ini-interpolate sa system prompt. Binabago nito ang prefix bytes sa bawat request at tahimik na dini-disable ang caching. Ang palatandaan ay nananatiling zero ang usage.cache_read_input_tokens sa magkakamukhang tawag.

Ang formula, na may kumpletong halimbawa

Huwag maniwala sa sinumang nagsasabing pare-pareho ang gastos ng isang “session” na $X. Nagkakaiba ang gastos ng mga session nang hanggang dalawang order of magnitude. Ang nananatiling tama ay ang formula:

turn cost = (uncached input        x base input price)
          + (cache writes          x 1.25 x base input price)
          + (cache reads           x read multiplier x base input price)
          + (output incl. thinking x output price)

read multiplier = 0.10 on most models, 0.05 on Opus 5.5 and Sonnet 5.5, 0.025 on Fable 5.1
session cost = sum over all turns

Halimbawa gamit ang Claude Opus 4.8, na isa nang legacy model pero available pa rin at, noong October 2026, nagkakahalaga pa rin ng $5 bawat million input tokens at $25 bawat million output tokens. Isang mid-session turn na may 80,000 accumulated context tokens: 75,000 ang binasa mula sa cache, 3,000 ang bagong isinulat, 2,000 ang bagong uncached input, at 1,500 ang output tokens kasama ang thinking.

• Cache reads: 75,000 × $0.50/M = $0.0375
• Cache writes: 3,000 × $6.25/M = $0.019
• Uncached input: 2,000 × $5/M = $0.010
• Output: 1,500 × $25/M = $0.0375

Humigit-kumulang $0.10 para sa turn; kung limampung turn na ganito, nasa $5. Ngayon, tingnan ang parehong turn matapos mag-expire ang cache: ang 78,000 cacheable tokens ay muling isinulat sa halagang $6.25/M, at ang parehong 2,000 uncached tokens ay nagkakahalaga ng $5/M. Aabot ito sa humigit-kumulang $0.50 bago isama ang output, o halos limang beses ng buong warm turn, kahit pareho ang ginawa. Iyon ang buong kuwento ng caching sa isang numero. Sa kasalukuyang Claude Opus 5.5 ($4/$20, na may cache reads na 0.05×), ang parehong warm turn ay nagkakahalaga ng humigit-kumulang $0.07 (reads $0.015, writes $0.015, uncached input $0.008, output $0.030), habang ang cold version ay $0.40 bago isama ang output, o halos anim na beses ng warm turn. Ang apat na linyang iyon din ang tanging patas na paraan para ihambing ang mga vendor, dahil hindi isinasaalang-alang ng listahang presyo ang cache reads at thinking, at kapag pinatakbo ang mga ito sa tatlong totoong job, makikita kung mas mataas o mas mababa ang Claude bill kumpara sa OpenAI.

Kung gusto mong maunawaan ang mismong billing unit, sa halip na isang turn lamang, ipinapakita ng kung ilang pages, file, at dolyar ang katumbas ng isang million tokens ang parehong kalkulasyon sa mas mataas na antas. Para sa calibration at hindi prediction: ayon sa mga inilathalang bilang ng Anthropic para sa enterprise Claude Code deployments, noong October 2026, ang average ay humigit-kumulang $13 bawat developer bawat active day at $150 hanggang $250 bawat buwan, at 90% ng users ay nananatili sa ibaba ng $30 bawat araw. Nakadepende ang aktuwal mong gastos sa model na pinili, session hygiene, at laki ng codebase. Iyan mismo ang dahilan kung bakit mahalaga ang mga lever sa ibaba.

Pagtingin sa sarili mong usage

Sa Claude Code, ang command ay /usage (gumagana pa rin ang /cost, isa itong alias). Ipinapakita ng Session block sa itaas ang token statistics at ang locally computed na pagtatantya ng gastos para sa kasalukuyang session; sa mga subscription plan, ipinapakita ng parehong screen ang iyong plan-limit bars at ang breakdown na nag-uugnay ng kamakailang usage sa mga skill, subagent, plugin, at indibidwal na MCP server. Sa mga bagong bersyon, mayroon ding Prompt cache (main) line ang Session block na nagpapakita ng bahagi ng input na kinuha mula sa cache, ang mga miss, at kung mainit (warm) ba ang cache sa kasalukuyan. Para sa opisyal na billing sa mga API account, ang usage page sa Claude Console ang basehan ng katotohanan, ang figure sa CLI ay pagtatantya lamang. Ang /context ay gumuguhit ng colored grid ng kung ano ang sumasakop sa context window, system prompt, tools, MCP definitions, files, history, at ito ang pinakamabilis na paraan para makita ang bloated na CLAUDE.md o ang madaldal na MCP server; sa fullscreen mode, kino-collapse nito ang per-item breakdown, at ang pagpasa ng all ang nag-e-expand dito.

Mula sa API, sinasabi ng bawat response kung ano eksakto ang nangyari:

response = client.messages.create(model="claude-sonnet-5-5", max_tokens=2048,
                                  messages=messages)
u = response.usage
total_prompt = u.input_tokens + u.cache_creation_input_tokens + u.cache_read_input_tokens
print(f"uncached={u.input_tokens} written={u.cache_creation_input_tokens} "
      f"read={u.cache_read_input_tokens} output={u.output_tokens}")

Tandaan na ang input_tokens ay ang uncached remainder lamang, ang tunay na laki ng prompt ay ang kabuuan ng lahat ng tatlong input field. Ang agent na tumakbo ng isang oras na nagpapakita ng input_tokens: 4000 ay hindi mura; ang natitirang 200,000 tokens ay kinuha mula sa cache. Para mag-estimate bago magpadala, gamitin ang token-counting endpoint, libre itong tawagin, may sarili itong rate limit, at nagbibilang gamit ang tokenizer ng model na papangalanan mo (ituring ang resulta bilang malapit na pagtatantya; ang billing ay sumasalamin sa totoong request):

count = client.messages.count_tokens(model="claude-sonnet-5-5",
                                     messages=[{"role": "user", "content": big_file}])
print(count.input_tokens)

Huwag na huwag tiktoken, dahil sa dahilan sa itaas.

Mga subscription plan kumpara sa pay-as-you-go

Pareho ang mechanics ng gabay na ito sa lahat ng setup; ang nagkakaiba lamang ay ang billing. Kapag may API key, pay-as-you-go ang billing ng Anthropic ayon sa bawat token at sa mga nakapublikong rate. Ibig sabihin, totoong gastos ang bawat numerong nabanggit sa itaas. Mas maaga itong nagsisimulang maningil kaysa sa inaasahan ng karamihan, dahil walang free tier na mapagkukunan. May maliit lamang na credit kapag nag-sign up at ilang endpoint na walang singil. Ito ang aktuwal na nakukuha ng bagong API account bago maglagay ng card sa file. Ang eksepsiyon, mula October 7, 2026, ay ang Max o Team subscription. Kasama na ngayon sa mga planong ito ang monthly API credits para sa sarili mong app at agent sa Claude Platform: $100 bawat buwan sa Max 5x, $200 sa Max 20x, at sa Team, $20 bawat Standard seat at $100 bawat Premium seat. Pinagsasama-sama ang credits at nililimitahan sa $500. Maa-claim ang mga ito sa pamamagitan ng pag-link ng Console organization. Nag-e-expire ang hindi nagamit na credits sa pagtatapos ng bawat billing cycle. Hindi saklaw ng mga ito ang interactive Claude Code.

Sa Claude subscription—Pro, Max, Team, at mga dating seat-based Enterprise plan—ang paggamit ng Claude Code ay ibinabawas sa allowance na kasama sa plan mo. Noong October 2026, binubuo ito ng rolling five-hour session window at isang weekly window. Magkasama itong ginagamit ng mga model at ng claude.ai chat. Ang halagang nasa dolyar na /usage ay impormasyon lamang at hindi billable amount. Dalawa ang eksepsiyon noong October 2026. Walang kasamang usage ang kasalukuyang usage-based Enterprise seat, kaya sinisingil ang bawat token sa standard API rates. Hindi rin kasama ang Fable models sa allowance ng Pro, standard Team seat, o standard legacy Enterprise seat. Sa mga ito, pay-as-you-go usage credits ang ginagamit ng Fable models.

Kapag naubos ang isang window, makikita mo ang "You've hit your session limit" o "You've hit your weekly limit", kasama ang oras ng reset. Hindi maibabalik ng pagpapalit ng model gamit ang /model ang access, dahil shared ang mga window sa lahat ng model. Nakabatay ang mga window sa account, hindi sa client na ginagamit mo. Mahalaga ito kung sinusuri mo pa kung ano ang native na tumatakbo sa Linux at kung aling plan ang sumasaklaw sa bawat surface. Kung alin sa dalawang window ang naubos ang tutukoy kung gaano katagal ang paghihintay at kung ano ang makabuluhang gawin habang naghihintay. Kaya mahalagang malaman ang mga opsiyon kapag umabot ka sa limit habang may task. Maaaring paganahin ng mga plan ang usage credits. Pinamamahalaan ang mga ito gamit ang /usage-credits upang makabili ng usage lampas sa ceiling.

Hindi ko ililista ang plan quotas. Ito ang pinakamabilis magbago sa buong paksang ito. Sa halip, tingnan ang claude.com/pricing at ang sarili mong /usage bars. Mahalaga pa rin ang token mechanics sa isang subscription. Sinusunog ng wasteful session ang window mo sa parehong paraan na gagamit ito ng dollars. Para sa bahagi tungkol sa subscription, tingnan kung aling Claude plan ang angkop sa paggamit mo.

Mga lever na talagang gumagana

• Limitahan ang binabasa ng agent. Ang “Ayusin ang validation bug sa auth.py” ay nagbabasa ng isang file; ang “pagandahin ang codebase na ito” ay nagbabasa ng apatnapu. Panatilihing lean ang CLAUDE.md dahil nilo-load ito sa bawat session, kaya ilagay lamang dito ang mahahalagang instruction at ilipat ang mga instruction na partikular sa workflow sa skills na nilo-load kapag kailangan.
• Malinaw at compact. I-/clear ang magkakaibang task; muling ipinapadala at muling sinisingil ang stale context sa bawat kasunod na message. Sa loob ng isang mahabang task, ang /compact Focus on the failing tests and the diff ay nagbubuod ng history upang hindi ka mapasama sa quadratic curve.
• Itugma ang laki ng model sa gawain. Kayang pangasiwaan ng Sonnet ang karamihan ng coding sa halagang $2/$10 bawat milyong token noong October 2026, at standard price na ito sa halip na introductory price: $2/$10 ang Sonnet 5.5, at nanatiling $2/$10 ang Sonnet 5 matapos kanselahin ang nakaplanong pagtaas nito noong September 1 sa $3/$15. Kumpara ito sa $4/$20 ng Opus 5.5. Samantala, ang Haiku 5.5 na nagkakahalaga ng $0.10/$0.50 (para sa prompts na hanggang 100,000 token, at $0.50/$2.50 para sa lampas dito) ang angkop na tool para sa mechanical na subagent work gaya ng log triage. Sa kabilang dulo, nasa $10/$50 ang Fable 5.1, kapareho ng rate ng Fable 5 at dalawa at kalahating beses ng Opus 5.5 sa parehong panig ng meter. Kaya mahalagang alamin kung aling mga gawain ang talagang nakapagbibigay-katwiran sa rate na iyon bago mo itong iwanang naka-select para sa routine work. Ang /model ay nagpapalit sa kalagitnaan ng session.
• I-pre-filter ang verbose output. Kapag nag-grep ang isang hook sa test run at iniiwan lamang ang failures bago ito makita ni Claude, nababawasan ang 20,000 token na tool result at nagiging 300 token. Ginagawa ito sa bawat susunod na muling pagpapadala ng turn na iyon.
• I-batch ang mga gawaing hindi interactive. Para sa sarili mong API pipeline, classification, bulk review, at nightly job, pinapatakbo ng Batches API ang parehong mga model nang may 50% discount kapalit ng asynchronous delivery.
• Isaalang-alang ang cache clock. Magtrabaho sa tuloy-tuloy na mga stint. Walang bayad habang idle ang isang detached Claude Code session sa tmux sa isang VPS, at gumagastos lamang ng token kapag tumatakbo ang isang turn. Ngunit kapag lumampas ang idle time sa cache TTL, mawawala ang warm cache at sisingilin muli ang mga token para sa re-write sa susunod na turn.

FAQ

Ilang token ang ginagamit ng coding session sa Claude Code?

Walang nakapirming bilang. Sa isang karaniwang mid-session turn, maaaring umabot sa sampu-sampung libong prompt token ang laman kapag nadagdagan na ang mga file at history. Ang isang working session ay maaaring umabot sa milyon-milyong token. Karamihan sa mga ito ay siniserbisyuhan mula sa cache sa ikasampu ng base rate o mas mababa, depende sa model. Bilang reference, ipinapakita ng mga inilathalang enterprise figure ng Anthropic noong October 2026 na nasa humigit-kumulang $13 bawat developer bawat active day ang average, at mas mababa sa $30 ang 90% ng mga user. Patakbuhin ang /usage sa sarili mong session. Mas kapaki-pakinabang ang limang minutong pagmamanman dito kaysa sa anumang inilathalang average.

May bayad ba ang thinking token kahit hindi ko ito nakikita?

Oo. Sinisingil ang thinking token bilang output token, gamit ang mas mahal na rate. Ibinibilang din ito sa max_tokens. Sinisingil ito ng mga kasalukuyang model kahit hindi ipinapakita ng interface ang reasoning summary. Kung nag-truncate ang isang response gamit ang stop_reason: "max_tokens" bago matapos ang nakikitang sagot, malamang na naubos ng thinking ang budget. Sa Claude Code, babaan ang effort level gamit ang /effort para sa mga task na hindi nangangailangan ng malalim na reasoning.

Bakit mas nagiging mahal ang bawat message sa mahabang Claude Code session?

Dahil stateless ang API. Sa bawat turn, muling ipinapadala nito ang conversation na nasa context pa rin, kasama ang bawat nabasang file, tool result, at naunang exchange na hindi pa naaalis sa pamamagitan ng compaction. Sinisingil ang mga ito bilang input, kaya sa turn 50, kasama pa rin ang turns 1 hanggang 49. Sa karamihan ng model, inihahatid ng prompt caching ang paulit-ulit na prefix sa ikasampu ng base input price. 5% ito sa Opus 5.5 at Sonnet 5.5, at 2.5% sa Fable 5.1. Gayunman, patuloy na lumalaki ang prefix. Kapag lumampas sa cache TTL ang idle gap, magiging full-price rewrite ang susunod na turn. Pinapaliit ng /compact ang history. Nire-reset ito ng /clear.

Paano ko susuriin ang token usage at cost ng Claude ko?

Sa Claude Code, ipinapakita ng /usage ang session token statistics, lokal na cost estimate, at plan-limit bars sa mga subscription. Alias ang /cost nito. Ipinapakita ng /context kung ano ang pumupuno sa window. Para sa authoritative API billing, gamitin ang usage page sa Claude Console. Sa sarili mong code, basahin ang response.usage. Ang pagsasama ng input_tokens, cache_creation_input_tokens, at cache_read_input_tokens ang nagbibigay ng aktuwal na prompt size. Para sa maagang estimate, gamitin ang count_tokens endpoint, hindi ang tiktoken.