Token ni nini kwenye Claude na gharama zake

Token ni nini katika Claude?

Token ni kitengo cha maandishi ambacho Claude husoma na kuandika: sehemu ya neno, takriban herufi 3.5 za Kiingereza. Takwimu hiyo inatoka kwenye glossary ya Anthropic, na inazalisha zaidi ya token moja kwa kila neno pindi nafasi na alama za uandishi zinapohesabiwa, hivyo maneno elfu moja ya nathari ni zaidi ya token 1,300. Code ina uzito mkubwa zaidi kwa kila mstari: mabano, alama za uendeshaji, alama za chini (underscores), na indentation hugawanya herufi katika token nyingi zaidi kuliko Kiingereza, na faili ya chanzo yenye mistari mamia kadhaa kwa kawaida huwa na token maelfu kadhaa. Faili ya mistari 2,000 ambayo agent anaamua kusoma ni gharama ya token za tarakimu tano kabla ya mtu kuandika mstari mmoja wa code mpya.

Mambo mawili kuhusu tokenizer humchanganya mtu. Kwanza, yanategemea modeli husika. Kuanzia Julai 2026, Opus 4.7 na baadaye, Sonnet 5, na Fable 5 hutumia tokenizer mpya inayozalisha takriban token 30% zaidi kwa maandishi yale yale kuliko modeli za awali za Claude (ongezeko kamili hutofautiana kulingana na maudhui), jambo ambalo hubadilisha bajeti yoyote ya token ingawa bei kwa kila token haikuongezeka. Pili, tiktoken, maktaba inayotumiwa na kila chapisho la blogu, ni tokenizer ya OpenAI na huhesabu chini zaidi kuliko Claude kwa takriban 15–20% kwenye maandishi ya kawaida, na zaidi kwenye code. Hesabu pekee ya kuaminika ni endpoint ya count_tokens, inayofafanuliwa hapa chini.

Kwa nini kikao chako cha uandishi wa kodi kinagharimu kiasi hicho

Kila bili ya Claude, iwe ni ankara ya API au kikomo cha usajili, inategemea kipimo kimoja: tokeni zinazoingia na tokeni zinazotoka. Ukurasa wa bei unaonyesha mambo kwa urahisi: dola fulani kwa kila milioni ya tokeni za kuingiza, na dola fulani kwa kila milioni ya tokeni za kutokea. Hata hivyo, haikuelezi kuwa katika kikao cha uandishi wa kodi cha agentic, upande wa tokeni zinazoingia hufanya kazi zaidi kuliko unavyofikiria, kwa sababu mazungumzo yote hutumwa tena kila wakati. Nimeuza miundombinu ya kipimo kwa miaka kumi na tano, na tokeni ni kipimo cha kwanza nilichokiona ambapo wateja wengi hawawezi kueleza kinachoongeza matumizi. Huu ni somo la kusoma kipimo: nini huhesabiwa kama tokeni za kuingiza na kutokea katika kikao cha agentic, kwa nini mzunguko wa kutuma tena ni ghali sana, kwa nini prompt caching inabadilisha hesabu, na ni mbinu gani zinazobadilisha namba hiyo.

Kila kitu ni input: kile kinachopimwa na mita

Watu hudhani kuwa wanalipia kodi ambayo Claude huandika. Katika kikao cha agentic, hiyo ni sehemu ndogo ya gharama. Tokeni za input — ambazo zina bei nafuu lakini zina kiasi kikubwa zaidi — ni pamoja na:

• System prompt. Maelekezo ya mfumo ya Claude Code, pamoja na CLAUDE.md na faili za kumbukumbu (memory files), ambazo hupakiwa mwanzoni mwa kikao na kuwepo kwenye kila ombi linalofuata.
• Tool definitions. Schema ya kila tool ambayo agent anaweza kuita. Kila MCP server unayounganisha huongeza gharama hii ya msingi — ingawa Claude Code sasa huahirisha maelezo kamili ya tool za MCP kwa kimawazo (default), hivyo majina ya tool pekee ndiyo yanayokuwa kwenye context hadi tool itakapotumika kwa mara ya kwanza, jambo ambalo hupunguza lakini haliondoi gharama.
• Kila faili agent anayosoma. Read ya faili ya chanzo (source file) huweka faili nzima kwenye context, na inabaki hapo.
• Kila matokeo ya tool. Matokeo ya majaribio (test runs), output ya grep, maandishi ya terminal, logs za ujenzi (build logs) — yote yanarudi kama tokeni za input. Test suite inayofeli na kuchapisha mistari 8,000 imekutoza gharama sawa na kitabu kidogo.
• Mazungumzo yote hadi sasa, yanayotumwa tena kila hatua. Sehemu hii inastahili sehemu yake binafsi.

Sababu ya kuongezeka kwa gharama

Claude API haina hali ya kudumu (stateless). Haikumbuki kikao chako kati ya maombi — hakuna kinachokumbuka. Kwa hivyo, kwenye zamu ya 2, mteja hutuma zamu ya 1 pamoja na jibu lake na ujumbe wako mpya. Kwenye zamu ya 50, hutuma tena zamu ya 1 hadi 49 — kila faili lililosomwa, kila matokeo ya zana, kila tofauti (diff) — pamoja na zamu ya 50. Modeli husoma tena nakala nzima kila wakati, na kila token inayorewa hutoza ada ya ingizo (input).

Matokeo yake: gharama kwa kila zamu huongezeka kulingana na urefu wa kikao, na gharama ya jumla ya kikao huongezeka kwa kasi kubwa zaidi (quadratically). Ujumbe uliogharimu nusu senti kwenye zamu ya 3 unaweza kugharimu mara 20 zaidi kwenye zamu ya 60 kwa swali lile lile la mstari mmoja, kwa sababu unabeba mizigo ya zamu 60. Hii ndiyo sababu inayoelezea tiketi nyingi za "kwa nini bili yangu ni kubwa," na si tatizo la Claude pekee — kila bidhaa ya LLM inayohisi ina hali ya kudumu (stateful) ni API isiyo na hali ya kudumu (stateless) yenye mzunguko wa kutuma tena (resend loop) chini yake.

Output: kile unachokiona, pamoja na fikra usizoziona

Tokeni za output ndizo zenye gharama kubwa — mara tano zaidi ya kiwango cha input katika bidhaa zote za sasa ($5/$25 kwenye Opus 4.8, $3/$15 kwenye Sonnet 5, $1/$5 kwenye Haiku 4.5, kuanzia Julai 2026). Output inajumuisha maandishi na kodi ambazo Claude hutengeneza, pamoja na tokeni za fikra: uwezo wa ndani wa modeli kufanya utafiti kabla ya kujibu. Mambo mawili ni muhimu hapa. Fikra hutozwa kwa viwango vya output na inahesabiwa ndani ya max_tokens — API response inayofika kikomo cha stop_reason: "max_tokens" na jibu lililokatwa mara nyingi humaanisha kuwa fikra imetumia bajeti kabla ya jibu kukamilika. Pia, kwenye modeli za sasa, muhtasari wa fikra unaweza usionyeshwe kabisa — Opus 4.8, Sonnet 5, na Fable 5 huziondoa kwa kiamuzi — lakini fikra bado imefanyika na bado itatozwa. Kitu kisichof visible hakiko bure.

Claude Code inaruhusu fikra pana kwa kiamuzi kwa sababu inaboresha kazi za hatua nyingi, na bajeti ya kiamuzi inaweza kufika maelfu ya tokeni kwa kila ombi. Kwenye kazi rahisi unaweza kuipunguza: punguza kiwango cha juhudi kwa kutumia /effort au ndani ya /model, au rekebisha mipangilio ya fikra ndani ya /config. Hii ni njia halisi ya kudhibiti gharama, si imani tu.

Prompt caching inabadilisha hesabu

Prompt caching ndiyo sababu mzunguko wa kutuma tena haufatishi kila mtu ufilisi. API inaweza kuhifadhi sehemu ya mwanzo ya prompt yako isiyobadilika — system prompt, tool definitions, historia ya mazungumzo — na kwenye ombi linalofuata kutoa data hiyo kwa gharama ndogo sana. Kuanzia Julai 2026, viashiria vya gharama ni: cache write ina gharama ya 1.25× ya kiwango cha msingi cha input (2× kwa toleo la saa 1), na cache read ina gharama ya 0.1×. Writes ni ghali; reads zina punguzo la 90%. Read moja tu inarudisha zaidi thamani ya premium ya write ya dakika 5.

Claude Code inakusimamia caching, na katika kikao chenye afya, karibu mzunguko wote wa kutuma tena unatumia data kutoka kwenye cache. Lakini cache ya kawaida hudumu kwa dakika tano tangu matumizi ya mwisho. Ukiondoka kwa muda mrefu, ukirudi na kutuma ujumbe — cache itakuwa imepita muda wake, na prefix nzima itatakiwa kuandikwa upya kwa 1.25× badala ya kusomwa kwa 0.1×. Katika kikao cha token 150K, mzunguko huo mmoja wa baridi (cold turn) una gharama kubwa kuliko mzunguko kadhaa ya warm. Huu ni matokeo usio wa kawaida unaopaswa kuuelewa: mtindo wa kutulia kisha kuendelea unaweza kuwa na gharama kubwa kuliko kazi endelevu, kwa sababu kila pengo la kutulia baada ya TTL hubadilisha mzunguko wako ujao kutoka read ya bei nafuu kuwa re-write ya ghali. Fanya kazi kwa vipindi; usitume ujumbe mmoja kila baada ya dakika kumi kwenye kikao kikubwa.

Ikiwa unaita API kutoka programu yako kwenye VPS, hupati huduma hii bure — na kosa la kawaida ni kuweka timestamp au request ID ndani ya system prompt, jambo ambalo hubadilisha bytes za prefix kila ombi na kuzima caching kimya kimya. Dalili ni usage.cache_read_input_tokens kubaki kwenye sifuri katika maombi yanayofanana.

Kanuni, pamoja na mfano uliopigiwa hesabu

Usisikilize mtu yeyote anayetoa kauli kwamba "sesheni ina gharama ya $X." Sesheni hutofautiana kwa kiwango kikubwa sana. Kinachofanya kazi ni kanuni hii:

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

Mfano uliopigiwa hesabu kwenye Claude Opus 4.8, ambayo kufikia Julai 2026 ni $5 kwa milioni moja ya input tokens na $25 kwa milioni moja ya output. Mzunguko wa katikati ya sesheni wenye 80,000 tokens za muktadha uliokusanywa: 75,000 zimesomwa kutoka kwenye cache, 3,000 zimeandikwa upya, 2,000 ni input mpya ambayo haipo kwenye cache, na 1,500 ni output tokens ikiwa ni pamoja na 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

Takriban $0.10 kwa mzunguko; mzunguko hivi hivi hamsini ni takriban $5. Sasa mzunguko ule ule baada ya cache kuisha muda wake: tokens zote 80,000 zikiandikwa upya kwa $6.25/M ni $0.50 kabla ya output — takriban mara tano ya mzunguko wote uliokuwa na cache — kwa kazi inayofanana. Pengo hilo ndilo simulizi nzima ya caching katika namba moja.

Kwa ajili ya kalibresheni badala ya utabiri: Takwimu zilizochapishwa na Anthropic kwa matumizi ya Claude Code ya biashara, kufikia Julai 2026, wastani ni takriban $13 kwa kila mteja kwa siku ya kazi — $150–250 kwa mwezi — huku 90% ya watumiaji wakibaki chini ya $30 kwa siku. Gharama yako inategemea uchaguzi wa model, usafi wa sesheni, na ukubwa wa codebase, ndiyo maana viunganishi vilivyo chini ni muhimu.

Kuona matumizi yako

Katika Claude Code, amri ni /usage (/cost bado inafanya kazi — ni alias). Sehemu ya Session juu inaonyesha takwimu za token na makadirio ya gharama yaliyopigiwa mahesabu ndani ya mashine kwa ajili ya session ya sasa; kwenye mpango wa usajili, skrini hiyo hiyo inaonyesha viashiria vya kikomo cha mpango wako na mchanganuo unaopanga matumizi ya hivi karibuni kwa ujuzi, subagents, plugins, na MCP servers binafsi. Kwa malipo rasmi kwenye akaunti za API, ukurasa wa matumizi kwenye Claude Console ndio chanzo cha ukweli — takwimu ya CLI ni makadirio tu. /context huchora gridi ya rangi ya vitu vinavyotumia nafasi ya context window — system prompt, tools, MCP definitions, mafaili, historia — na ndiyo njia ya haraka zaidi kutambua CLAUDE.md iliyojaa sana au MCP server inayozungumza sana; tumia all ili kupata mchanganuo kamili wa kila kitu.

Kutoka kwenye API, kila jibu linakuambia kwa usahihi kilichotokea:

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}")

Zingatia kuwa input_tokens ni sehemu iliyobaki ambayo haijahifadhiwa kwenye cache pekee — ukubwa halisi wa prompt ni jumla ya sehemu zote tatu za ingizo. Agent iliyofanya kazi kwa saa moja ikionyesha input_tokens: 4000 si ya bei rahisi; token 200,000 nyingine zilichukuliwa kutoka kwenye cache. Ili kukadiria kabla ya kutuma, tumia endpoint ya kuhesabu token — ni bure kuita, ina kikomo chake cha kiwango cha maombi (rate limit), na inahesabu kwa kutumia tokenizer ya model yoyote utakayotaja (chukulia matokeo kama makadirio ya karibu; malipo yanajumuisha ombi halisi):

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

Usitumie kamwe tiktoken, kwa sababu hiyo hapo juu.

Mipango ya usajili dhidi ya kulipia unapotumia

Mbinu katika mwongozo huu ni sawa kila mahali; tofauti ni mfumo wa malipo tu. Kwa kutumia API key, Anthropic hutoza malipo ya kulipia unapotumia, kwa kila token, kulingana na viwango vilivyochapishwa — kila namba hapo juu ni pesa halisi. Katika usajili wa Claude (Pro, Max, Team, Enterprise), matumizi ya Claude Code yanatumia kiasi kilichojumuishwa kwenye mpango wako: kuanzia Julai 2026, ni dirisha la kikao cha saa tano kinachojirudia pamoja na dirisha la kila wiki, ambavyo vinashirikishwa kati ya mifano na chat ya claude.ai, na kiasi cha dola cha /usage ni kwa ajili ya taarifa tu na si bili. Ukimaliza dirisha, utaona "You've hit your session limit" au "You've hit your weekly limit" pamoja na muda wa kuanza upya — na kubadilisha mifano kwa /model hakutaurejeshea ufikiaji, kwa sababu madirisha yanashirikishwa kati ya mifano. Mipango inaweza kuwezesha matumizi ya mikopo (usage credits) kupitia /usage-credits, ili kununua matumizi baada ya kikomo. Sitataja kiasi cha mpango (plan quotas): ni namba zinazobadilika sana katika mada hii nzima, hivyo angalia claude.com/pricing na /usage zako badala yake. Mbinu za token bado ni muhimu kwenye usajili — kikao chenye matumizi mengi kinatumia dirisha lako kwa namna ile ile inayotumia pesa. Kwa upande wa usajili, angalia mpango gani wa Claude unaofaa matumizi yako.

Njia zinazofanya kazi vizuri

• Weka mipaka ya kile agent anachosoma. "Fix the validation bug in auth.py" husoma faili moja; "improve this codebase" husoma faili arobaini. Weka CLAUDE.md ikiwa nyepesi — inapakia kwenye kila session, hivyo tumia maelekezo muhimu pekee — na uhamishe maelekezo ya kazi maalum kwenye skills zinazopakia zinapohitajika.
• Weka maelezo kuwa mafupi na ya wazi. /clear kati ya kazi zisizoendana — muktadha wa zamani unatumwa tena, na unalipiwa tena, kwenye kila ujumbe unaofuata. Ndani ya kazi moja ndefu, /compact Focus on the failing tests and the diff hufupisha historia ili kuzuia gharama kuongezeka kwa kasi.
• Tumia model inayofaa. Sonnet inafaa kwa kodi nyingi kwa bei ya $2/$10 kwa milioni 1,000 za tokens kulingana na bei ya kuanzia Julai 2026 ($3/$15, dhidi ya Opus ya $5/$25), na Haiku kwa $1/$5 ni zana sahihi kwa kazi ndogo za subagent kama uchambuzi wa log. /model hubadilisha model katikati ya session.
• Chuja matokeo mengi kabla ya kuyatuma. Kutumia hook inayotumia grep kupunguza matokeo ya test run hadi kwenye makosa pekee kabla Claude hayaoni, hubadilisha tokens 20,000 za matokeo ya tool kuwa 300, na hufanya hivyo kwenye kila utumaji wa baadaye wa turn hiyo.
• Tumia batch kwa kazi zisizo za moja kwa moja. Kwa pipelines zako za API — classification, bulk review, kazi za usiku — Batches API hutumia model zilezile kwa punguzo la 50% kwa kubadilisha kwa utumaji wa asynchronous.
• Zingatia muda wa cache. Fanya kazi kwa vipindi endelevu. Claude Code session kwenye tmux kwenye VPS haigharimu chochote ikiwa imetulia — tokens hutumika tu wakati turn inapoendeshwa — lakini cache iliyopata joto (warm cache) ndiyo inayopotea wakati wa kutulia, na turn inayofuata italipia kuandikwa upya.

FAQ

Je, session ya uandishi wa kodi kwenye Claude Code hutumia token ngapi?

Hakuna idadi maalum — mzunguko mmoja wa katikati ya session mara nyingi hubeba maelfu ya prompt tokens pindi mafaili na historia zinapoongezeka. Session inayofanya kazi inaweza kufika mamilioni, ambapo nyingi hutolewa kutoka kwenye cache kwa gharama ya kumi ya kiwango cha msingi. Kwa ajili ya ulinganifu, takwimu za biashara za Anthropic zilizochapishwa hadi Julai 2026 zina wastani wa takriban $13 kwa kila mteja kwa siku moja ya kazi, huku 90% ya watumiaji wakiwa chini ya $30. Run /usage kwenye session yako mwenyewe; dakika tano za kuifuatilia ni bora kuliko wastani wowote uliochapishwa.

Je, thinking tokens zina gharama hata kama siwezi kuziona?

Ndiyo. Thinking tokens zinatozwa kama output tokens — kiwango cha juu cha gharama — na zinahesabiwa dhidi ya max_tokens. Pia, mifano ya sasa inatoza hata kama interface haionyeshi muhtasari wa reasoning. Ikiwa jibu linakatika na stop_reason: "max_tokens" kabla ya jibu linaloonekana kuisha, kuna uwezekano kuwa thinking imetumia bajeti. Katika Claude Code, punguza kiwango cha juhudi kwa kutumia /effort kwa kazi zisizohitaji reasoning ya kina.

Kwa nini session ndefu ya Claude Code inakuwa ghali zaidi kwa kila ujumbe?

Kwa sababu API haina hali ya kudumu (stateless): kila mzunguko unatuma tena mazungumzo yote — kila faili lililosomwa, matokeo ya tool, na mazungumzo ya awali — kama input inayotozwa. Hivyo, mzunguko wa 50 hubeba mzunguko wa 1 hadi 49 kama mizigo. Prompt caching hutumika kwa prefix inayojirudia kwa takriban kumi ya bei ya msingi ya input, lakini prefix yenyewe inaendelea kukua. Pia, mapengo yoyote ya muda baada ya cache TTL yanabadilisha mzunguko unaofuata kuwa uandishi mpya kwa bei kamili. /compact hupunguza historia; /clear huifuta upya.

Je, nawezaje kuangalia matumizi ya token za Claude na gharama zake?

Katika Claude Code, /usage huonyesha takwimu za token za session, makadirio ya gharama ya ndani, na viashiria vya mipaka ya mpango kwenye usajili (/cost ni alias); /context huonyesha kile kinachojaza dirisha. Kwa ajili ya malipo rasmi ya API, tumia ukurasa wa matumizi (usage page) kwenye Claude Console. Katika kodi yako mwenyewe, soma response.usage — kujumlisha input_tokens, cache_creation_input_tokens, na cache_read_input_tokens kunatoa ukubwa halisi wa prompt — na ukadirie mapema kwa kutumia endpoint ya count_tokens, usitumie kamwe tiktoken.