Ano ang Claude tokens at bakit mahal ang Code session?

Ano ang mga token sa Claude?

Ang token ay yunit ng text na binabasa at sinusulat ni Claude: isang bahagi ng salita, na humigit-kumulang 3.5 English characters. Galing ang bilang na ito sa sariling glossary ng Anthropic. Kapag isinama ang mga space at punctuation mark, lumalabas itong higit sa isang token bawat salita. Dahil dito, ang isang libong salita ng prose ay karaniwang lampas sa 1,300 token. Mas mabigat ang code sa bawat linya: hinahati ng braces, operator, underscore, at indentation ang code sa mas maraming token kada character kaysa sa English. Karaniwang umaabot sa ilang libong token ang source file na may ilang daang linya. Ang 2,000-line file na pinagpasyahang basahin ng agent ay maaaring mangailangan ng limang-digit na bilang ng token bago pa man magsulat ng isang linya ng bagong code.

May dalawang bagay tungkol sa tokenizer na madalas nakalilito. Una, partikular ito sa bawat model. Noong July 2026, gumagamit ang Opus 4.7 at mga sumunod na bersyon nito, Sonnet 5, at Fable 5 ng mas bagong tokenizer. Gumagawa ito ng humigit-kumulang 30% mas maraming token para sa parehong text kaysa sa mga naunang Claude model. Nag-iiba ang eksaktong dagdag depende sa content. Dahil dito, nagbabago ang anumang token budget kahit hindi tumaas ang presyo kada token. Ikalawa, ang tiktoken, ang library na karaniwang ginagamit ng mga blog post, ay tokenizer ng OpenAI. Karaniwan nitong binibilang nang mas mababa nang humigit-kumulang 15–20% ang token ng Claude sa ordinaryong text, at mas malaki pa ang diperensiya sa code. Ang tanging mapagkakatiwalaang bilang ay mula sa count_tokens endpoint, na tatalakayin sa ibaba.

Magkano ang aktuwal na gastos ng coding session mo

Ang bawat Claude bill, API invoice man o subscription limit, ay nakabatay sa iisang meter: tokens in at tokens out. Mukhang simple ito sa pricing page: ganitong halaga bawat milyong input token, at ganito naman bawat milyong output token. Pero hindi ipinapakita roon na sa isang agentic coding session, mas mabilis umakyat ang input side ng meter kaysa sa inaasahan, dahil ipinapadala muli ang buong conversation sa bawat turn. Labinlimang taon na akong nagbebenta ng metered infrastructure, at ang tokens ang unang meter na nakita kong hindi talaga maipaliwanag ng karamihan sa mga customer kung ano ang nagpapataas ng usage nito. Ito ang aralin sa pagbasa ng meter: kung ano ang binibilang na input at output sa isang agentic session, kung bakit napakamahal ng resend loop, kung paano binabago ng prompt caching ang kalkulasyon, at kung aling mga lever ang tunay na nakaaapekto sa numero.

Lahat ay input: kung ano talaga ang binibilang ng meter

Ipinapalagay ng mga tao na binabayaran nila ang code na isinusulat ni Claude. Sa isang agentic session, maliit na bahagi lamang iyon. Kasama sa input tokens, na mas mura ang rate ngunit mas mataas nang 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 pagsisimula ng session at nananatili sa bawat kasunod na request.
• Mga tool definition. Kasama rito ang schema ng bawat tool na maaaring tawagin ng agent. Ang bawat MCP server na ikinokonekta mo ay nagdaragdag sa fixed overhead na ito. Gayunman, dine-defer na ngayon ng Claude Code bilang default ang buong MCP tool definitions. Kaya mga pangalan lamang ng tool ang nasa context hanggang sa unang gamitin ang isang tool. Binabawasan nito ang gastos, ngunit hindi ito inaalis.
• Bawat file na binabasa ng agent. Kapag naglagay ang isang Read ng source file sa context, napupunta roon ang buong file at nananatili ito roon.
• Bawat tool result. Kabilang dito ang mga test run, grep output, terminal output, build log, at lahat ng ibinabalik bilang input tokens. Kung ang isang failing test suite ay nag-print ng 8,000 linya, siningil ka nito na parang isang maikling aklat.
• Ang buong conversation hanggang sa puntong iyon, na muling ipinapadala sa bawat turn. Karapat-dapat itong magkaroon ng sarili nitong section.

Ang muling pagpapadala ang hindi mo agad nakikitang nagiging gastos

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 turns 1 hanggang 49, bawat file na binasa, bawat resulta ng tool, bawat diff, pati ang turn 50. Muling binabasa ng model ang buong transcript sa bawat request, at sinisingil bilang input ang bawat token na muling binasa.

Ang resulta: halos linearly na tumataas ang cost sa bawat turn habang humahaba ang session, at humigit-kumulang quadratically na tumataas ang kabuuang cost ng session. Ang isang message na nagkakahalaga ng kalahating sentimo sa turn 3 ay maaaring magkahalaga nang 20 beses sa turn 60, kahit pareho ang one-line question, dahil dala nito ang 60 turn ng history. Ito ang pangunahing paliwanag sa karamihan ng mga ticket na nagtatanong kung bakit napakataas ng bill. Hindi ito partikular na katangian ng Claude; ang bawat LLM product na mukhang stateful ay gumagamit sa ilalim ng isang stateless API na may loop ng muling pagpapadala.

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

Mahal ang output tokens; limang beses ang rate ng input sa kasalukuyang lineup ($5/$25 sa Opus 4.8, $3/$15 sa Sonnet 5, $1/$5 sa Haiku 4.5, noong July 2026). Kasama sa output ang text at code na ginagawa ni Claude, pati ang thinking tokens: ang internal reasoning ng model bago ito sumagot. Dalawang bagay ang mahalaga rito. Sinisingil ang thinking sa output rates at ibinabawas ito sa max_tokens. Kapag nagwawakas ang API response na may stop_reason: "max_tokens" at madalas na truncated ang sagot, maaaring naubos ng thinking ang budget bago pa mabuo ang sagot. Sa mga kasalukuyang model, maaari ring hindi ipinapakita ang reasoning summary. Hindi ito ipinapakita bilang default ng Opus 4.8, Sonnet 5, at Fable 5, pero naganap pa rin ang thinking at siningil pa rin ito. Hindi nangangahulugang libre ang isang bagay dahil hindi ito nakikita.

Bilang default, naka-enable ang extended thinking sa Claude Code dahil napatunayang nakatutulong ito sa mga gawaing may maraming hakbang. Maaaring umabot sa sampu-sampung libong token bawat request ang default budget. Para sa mas simpleng task, maaari mo itong bawasan: ibaba ang effort level gamit ang /effort o sa /model, o baguhin ang thinking settings sa /config. Totoong paraan ito para kontrolin ang gastos, hindi 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 iyong prompt, system prompt, tool definitions, at conversation history. Sa susunod na request, maihahatid nito ang mga ito sa maliit na bahagi ng presyo. Noong July 2026, ganito ang multipliers: ang write ng cache ay nagkakahalaga ng 1.25× ng base input rate (2× para sa 1-hour variant), at ang read ng cache ay nagkakahalaga ng 0.1×. Premium ang mga write; 90% discount naman ang mga read. Isang read lang ay higit nang sapat para mabawi ang premium ng 5-minute write.

Si Claude Code ang namamahala sa caching para sa iyo. Sa isang maayos na session, halos lahat ng malaking resend na iyon ay hinahain mula sa cache. Pero ang default cache ay nananatili lamang nang five minutes mula sa huling paggamit. Kung matagal kang mawawala para magkape, babalik, at magpapadala ng message, mag-e-expire ang cache. Isusulat muli ang buong naipong prefix sa 1.25× sa halip na basahin sa 0.1×. Sa isang 150K-token session, ang isang cold turn na iyon ay mas mahal kaysa sa mahigit isang dosenang warm turn. Ito ang mahalagang counterintuitive na resulta: maaaring mas mahal ang rhythm na idle-then-resume kaysa sa tuloy-tuloy na trabaho, dahil bawat idle gap na lumampas sa TTL ay ginagawang mahal na re-write ang susunod mong turn sa halip na murang read. Magtrabaho nang pa-stint; huwag magpadala ng isang message bawat sampung minuto sa isang napakalaking session.

Kung tinatawag mo ang API mula sa sarili mong application sa isang VPS, wala kang awtomatikong libreng access sa caching na ito. 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. Makikita ito kapag nananatiling zero ang usage.cache_read_input_tokens sa magkakamukhang call.

Ang formula, na may aktuwal na halimbawa

Huwag maniwala sa sinumang nagsasabing may nakapirming “$X ang halaga ng isang session.” Nagkakaiba ang halaga 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 0.10 x base input price)
          + (output incl. thinking x output price)

session cost = sum over all turns

Aktuwal na halimbawa sa Claude Opus 4.8, na noong July 2026 ay nagkakahalaga ng $5 bawat milyong input token at $25 bawat milyong output token. Isang mid-session turn na may 80,000 token na naipong context: 75,000 ang binasa mula sa cache, 3,000 ang bagong isinulat, 2,000 ang bagong input na hindi naka-cache, at 1,500 ang output token kasama ang thinking.

• Mga pagbasa mula sa cache: 75,000 × $0.50/M = $0.0375
• Mga pagsulat sa cache: 3,000 × $6.25/M = $0.019
• Input na hindi naka-cache: 2,000 × $5/M = $0.010
• Output: 1,500 × $25/M = $0.0375

Humigit-kumulang $0.10 para sa turn; ang limampung turn na katulad nito ay nasa $5. Ngayon, tingnan ang parehong turn matapos mag-expire ang cache: ang buong 80,000 token ay muling isinulat sa halagang $6.25/M, kaya $0.50 ito bago pa isama ang output—humigit-kumulang limang beses ng buong warm turn, kahit pareho ang ginawa. Ipinapakita ng agwat na ito ang buong epekto ng caching sa iisang numero. Ang apat na linyang iyon lamang ang tapat na paraan upang ikumpara ang mga vendor, dahil hindi isinasaalang-alang ng mga nakapaskil na rate ang mga pagbasa mula sa cache at ang thinking, at kapag pinatakbo ang mga ito sa tatlong aktuwal na trabaho, makikita kung saan mas mataas o mas mababa ang singil ng Claude kaysa sa OpenAI.

Kung gusto mong maunawaan ang mismong billing unit sa halip na isang turn lamang, ipinapakita ng katumbas ng isang milyong token sa mga page, file, at dolyar ang parehong kalkulasyon sa mas mataas na antas. Para sa calibration, hindi prediction: ayon sa inilathalang datos ng Anthropic para sa mga enterprise deployment ng Claude Code, noong July 2026, ang average ay humigit-kumulang $13 bawat developer bawat aktibong araw at $150–250 bawat buwan, habang 90% ng mga user ay nananatiling mas mababa sa $30 bawat araw. Nakadepende ang aktuwal mong gastos sa piniling model, session hygiene, at laki ng codebase. Iyan mismo ang dahilan kung bakit mahalaga ang mga lever sa ibaba.

Sariling paggamit

Sa Claude Code, ang command ay /usage (gumagana pa rin ang /cost dahil alias ito). Ipinapakita ng Session block sa itaas ang statistics ng token at lokal na kinuwentang pagtatantiya ng gastos para sa kasalukuyang session. Sa subscription plan, ipinapakita rin ng parehong screen ang mga bar para sa limitasyon ng plan at breakdown na nag-uugnay sa kamakailang paggamit sa skills, subagents, plugins, at indibidwal na MCP servers. Para sa awtoritatibong billing sa mga API account, ang usage page sa Claude Console ang opisyal na batayan; pagtatantiya lamang ang figure sa CLI. Ipinapakita ng /context ang isang may-kulay na grid ng mga gumagamit ng context window, system prompt, tools, MCP definitions, files, history, at iba pa. Ito ang pinakamabilis na paraan upang makita ang lumobong CLAUDE.md o MCP server na masyadong maraming mensahe. Ipasa ang all upang makita ang buong breakdown ng bawat item.

Mula sa API, eksaktong ipinapakita ng bawat response ang nangyari:

response = client.messages.create(model="claude-sonnet-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 natitirang bahagi lamang na hindi naka-cache. Ang tunay na laki ng prompt ay kabuuan ng tatlong input field. Hindi mura ang agent na tumakbo nang isang oras at nagpakita ng input_tokens: 4000; naihatid mula sa cache ang iba pang 200,000 token. Para magtantiya bago magpadala, gamitin ang token-counting endpoint. Libre itong tawagan, may sarili itong rate limit, at gumagamit ng tokenizer ng model na pinangalanan mo. Ituring itong malapit na pagtatantiya lamang; ang billing ay batay sa aktuwal na request:

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

Huwag kailanman tiktoken dahil sa dahilan sa itaas.

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

Pareho ang mechanics sa gabay na ito saanman; ang settlement lang ang nagkakaiba. Kapag API key ang gamit, pay-as-you-go ang billing ng Anthropic, batay sa bawat token at sa published rates. Totoong pera ang bawat numerong nabanggit sa itaas. Mas maaga kaysa inaasahan ng karamihan ang pagsisimula ng meter na ito dahil walang free tier na masasandalan. May maliit na credit lang sa pag-sign up at ilang endpoint na walang bayad. Ito ang aktuwal na nakukuha ng bagong API account bago ka maglagay ng card sa account. Sa Claude subscription (Pro, Max, Team, Enterprise), sa halip na hiwalay na bayaran, ginagamit ng Claude Code ang allowance na kasama sa iyong plan. As of July 2026, binubuo ito ng rolling five-hour session window at weekly window na parehong ginagamit ng iba't ibang model at ng chat sa claude.ai. Impormasyonal lang ang /usage dollar figure at hindi ito bill. Kapag naubos ang isang window, makikita mo ang "Naabot mo na ang session limit" o "Naabot mo na ang weekly limit", kasama ang oras ng reset. Hindi maibabalik ng paglipat ng model gamit ang /model ang access dahil shared ang mga window sa lahat ng model. Nakasunod ang mga window sa account, hindi sa client na ginagamit mo, kaya mahalagang malaman ito habang inaalam 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 aktuwal mong naubos, iyon ang magpapasya kung gaano katagal ang paghihintay at kung ano ang sulit gawin habang naghihintay. Kaya makatutulong na malaman ang mga opsyon kapag naabot mo ang limit habang may task. Maaaring mag-enable ang mga plan ng usage credits na pinamamahalaan gamit ang /usage-credits upang makabili ng usage lampas sa ceiling. Hindi ko sadyang ililista ang plan quotas. Ito ang pinakamabilis magbago sa lahat ng numerong tinatalakay dito. Sa halip, tingnan ang claude.com/pricing at ang sarili mong /usage bars. Mahalaga pa rin ang token mechanics sa subscription. Ang maaksayang session ay kumokonsumo ng iyong window sa parehong paraan na makakakonsumo ito ng dollars. Para sa subscription side, tingnan ang kung aling Claude plan ang angkop sa iyong usage.

Mga lever na talagang gumagana

• Limitahan ang saklaw ng 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 apatnapung file. Panatilihing maigsi ang CLAUDE.md dahil nilo-load ito sa bawat session. Ilagay lamang dito ang mahahalagang instruction, at ilipat ang mga instruction na partikular sa workflow sa mga skill na nilo-load kapag kinakailangan.
• Malinaw at compact. /clear sa pagitan ng magkakaibang task; muling ipinapadala at muling sinisingil ang lumang context sa bawat kasunod na mensahe. Sa loob ng isang mahabang task, ibinubuod ng /compact Focus on the failing tests and the diff ang history habang lumalaki ito at iniiwas ka sa quadratic curve.
• Itugma ang laki ng model. Sonnet ang sapat para sa karamihan ng coding sa halagang $2/$10 bawat isang milyong token sa introductory pricing noong July 2026 ($3/$15 ang regular na presyo, kumpara sa $5/$25 ng Opus), at ang Haiku na $1/$5 ang tamang tool para sa mechanical na gawain ng subagent gaya ng log triage. Nasa kabilang dulo naman ang Fable 5 sa $10/$50, dalawang beses ang presyo ng Opus sa parehong bahagi ng meter. Kaya mahalagang alamin kung aling mga task ang talagang nangangailangan ng ganoong rate bago mo itong iwanang naka-select para sa mga routine na gawain. Nagpapalit ng model ang /model sa kalagitnaan ng session.
• I-pre-filter ang verbose na output. Kapag ginamit ang isang hook para i-grep ang test run at iwan lamang ang mga failure bago ito makita ni Claude, nababawasan ang 20,000 token na tool result sa 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 sa 50% mas mababang presyo kapalit ng asynchronous delivery.
• Isaalang-alang ang cache clock. Magtrabaho sa tuloy-tuloy na mga session. Walang gastos habang idle ang isang detached Claude Code session sa tmux sa isang VPS; gumagastos lamang ng token kapag tumatakbo ang isang turn. Ngunit ang warm cache ang nawawala habang idle, kaya kailangang muling isulat ang context sa susunod na turn.

FAQ

Ilang token ang ginagamit ng coding session sa Claude Code?

Walang nakapirming bilang. Karaniwang umaabot sa sampu-sampung libong prompt token ang isang turn sa kalagitnaan ng session kapag dumami na ang mga file at history. Umaabot naman sa milyon-milyon ang isang working session, at karamihan dito ay hinahain mula sa cache sa halagang ikasampu ng base rate. Bilang batayan, ang inilathalang enterprise figures ng Anthropic noong July 2026 ay nagpapakitang nasa humigit-kumulang $13 bawat developer bawat aktibong araw ang average, at wala pang $30 para sa 90% ng mga user. Patakbuhin ang /usage sa sarili mong session. Mas kapaki-pakinabang ang limang minutong pagmamanman nito kaysa sa anumang inilathalang average.

May bayad ba ang thinking tokens kahit hindi ko nakikita ang mga ito?

Oo. Sinisingil ang thinking tokens bilang output tokens sa mas mataas na rate. Kasama rin ang mga ito sa max_tokens. Sinisingil ng mga kasalukuyang modelo ang mga ito kahit hindi ipinapakita ng interface ang reasoning summary. Kung napuputol ang isang response sa stop_reason: "max_tokens" bago matapos ang nakikitang sagot, malamang na naubos ng thinking ang budget. Sa Claude Code, ibaba 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, ipinapadalang muli ang buong conversation, bawat file read, bawat tool result, at bawat naunang exchange bilang billed input. Dahil dito, dala ng turn 50 ang turns 1 hanggang 49 bilang input. Hinahain ng prompt caching ang paulit-ulit na prefix sa humigit-kumulang ikasampu ng base input price. Gayunman, patuloy na humahaba ang prefix. Kapag lumampas sa cache TTL ang idle gap, magiging full-price rewrite ang susunod na turn. Pinaiikli ng /compact ang history. Nire-reset ito ng /clear.

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

Sa Claude Code, ipinapakita ng /usage ang session token statistics, local cost estimate, at mga bar para sa plan limit sa mga subscription. Alias ang /cost nito. Ipinapakita naman ng /context kung ano ang kumokonsumo 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 pagtatantiya, gamitin ang count_tokens endpoint, at huwag ang tiktoken.