SSD Nodes Learn Hosting plans →
Mga Gabay Matt ConnorNi Matt Connor

Paghahambing ng Claude Code Spend Tracker

Ihambing ang local log parsers, built-in usage screens, at OpenTelemetry stack. Alamin kung alin ang sumusukat sa session logs, account usage, o OTel stream.

Ano talaga ang binabasa ng Claude Code spend tracker

Ang bawat Claude Code spend tracker ay nagbabasa mula sa isa sa tatlong data source, at ang source ang nagtatakda kung aling tanong ang masasagot nito. Binabasa ng log parser ang session transcript files na nasa sarili mong disk. Binabasa ng dashboard ang usage records na iniingatan ng Anthropic para sa account o organization mo. Binabasa ng metrics backend ang OpenTelemetry (OTel) stream na inilalabas ng Claude Code kapag pinagana mo ito. Maaaring tama ang tatlo nang sabay-sabay ngunit magkakaiba pa rin ang resulta, dahil magkaibang bagay ang binibilang ng mga ito.

Hindi na muling ipinapaliwanag ng guide na ito ang tokens. Sinasaklaw ng kung paano binibilang ng Claude Code ang token usage ang input, output, cache writes, at cache reads, at kaunti ang magiging saysay ng anumang dashboard hangga't hindi malinaw ang bahaging iyon. Mas tiyak ang tanong dito: para sa bawat uri ng tool, ano ang nakikita nito, at ano ang hindi nito kailanman makikita.

Bakit lumitaw sa isang araw ang tatlong spend tracker para sa Claude Code

Tatlong magkahiwalay na spend tracker para sa Claude Code ang na-post sa parehong araw. Hindi sila tatlong bersyon ng iisang tool, at iyon ang mahalagang bahagi. Ang isa ay nag-parse ng mga lokal na session file. Ang isa ay nag-wrap sa mga screen ng account usage. Ang isa naman ay isang hosted tracing backend na ikaw mismo ang nagpapatakbo.

Sabay-sabay silang lumitaw dahil hindi na madaling matukoy ang gastos ng isang agent session. Sa chat, humigit-kumulang katumbas ng nakikita sa screen ang gastos. Pero nagbabasa ang isang agent ng dalawampung file, nagpapatakbo ng test suite, at muling ipinapadala ang buong conversation sa bawat turn. Dahil dito, ang bill ay nakabatay sa context na hindi mo mismo tina-type. Sa subscription, ang dollar figure ng session na ipinapakita ng Claude Code ay estimate lamang at ayon sa Anthropic ay hindi nauugnay sa billing. Ang mahalagang sukatan ay ang usage bar, na mas mabilis mapuno sa ilang araw kaysa sa iba. Ang bawat isa sa tatlong tool ay tumutugon sa magkakaibang bahagi ng puwang na iyon.

Hugis 1: sinasabi ng local log parser kung magkano ang nagastos ngayon

Iniimbak ng Claude Code ang bawat conversation bilang JSON Lines (JSONL) sa ~/.claude/projects/<project>/<session-id>.jsonl, kung saan ang <project> ay path ng working directory mo na pinalitan ng - ang mga non-alphanumeric na character. Taglay ng bawat assistant turn sa file na iyon ang bilang ng token para sa request nito. Pinagsasama-sama ng log parser ang mga ito at kinakalkula ang presyo.

ccusage ang karaniwang ginagamit ng karamihan. Wala itong kailangang i-install:

npx ccusage@latest daily
npx ccusage@latest daily --breakdown
npx ccusage@latest blocks
npx ccusage@latest session --json

daily ang nagta-total ayon sa petsa. Hinahati ng --breakdown ang bawat row ayon sa model, kaya makikita mo kung isang hapon ng paggamit ng Opus ang kumain sa malaking bahagi ng gastos sa buong linggo. Pinapangkat ng blocks ang mga ito ayon sa limang-oras na window kung kailan nagre-reset ang subscription. Nagtatotal ang session bawat conversation, at pinapangkat ng daily --instances ayon sa project para makita mo kung aling repository ang magastos. Idagdag ang --since at --until para limitahan ang saklaw, at patakbuhin ang npx ccusage@latest daily --help para makita ang format ng petsang inaasahan ng iyong version. Simula October 2026, binabasa rin nito ang iba pang agent CLI, kabilang ang Codex at OpenCode, na mahalaga kung ikinukumpara mo ang mga ito. Pinagsasama ng default reports ang lahat ng natukoy na source; idagdag ang claude bago ang daily o session para Claude Code lamang ang isama.

Gumagamit ang pricing ng model price table, at may tatlong cost mode ang tool. Ginagamit ng --mode auto ang value ng costUSD na isinulat ng Claude Code sa file kung mayroon nito, at kinakalkula ang halaga mula sa token counts kung wala ito. Palaging kinakalkula ng --mode calculate ang halaga mula sa mga token at binabalewala ang anumang recorded cost. Ipinapakita lamang ng --mode display ang recorded costs at nagpi-print ng $0.00 para sa mga row na walang recorded cost. Kung mukhang mali ang total, patakbuhin ang parehong report gamit ang calculate at pagkatapos ay gamit ang display. Kung malaki ang agwat ng mga ito, nangangahulugan iyon na karamihan sa mga entry ay walang recorded cost, kaya estimate ang lahat ng binabasa mo. Kung contracted rates ang binabayaran mo, pinapalitan ng pricingOverrides sa ilalim ng defaults sa isang ccusage.json config file ang presyo para sa bawat model.

Maaari ring gamitin ang parehong data sa iyong prompt. Nagpi-print ang ccusage statusline ng compact line para sa Claude Code status bar, na ikinokonekta sa ~/.claude/settings.json gaya ng iba pang status line command. Tingnan ang pagbuo ng Claude Code statusline para sa settings block at mga field na ipinapasa rito.

Hindi nakikita ng log parser ang anumang hindi nangyari sa machine na ito. Ang pangalawang laptop, session sa claude.ai, o gawain ng teammate ay nasa mga disk ng mga iyon. Bilang default, nililinis ang mga mas lumang terminal session pagkalipas ng 30 araw na walang aktibidad sa ilalim ng cleanupPeriodDays, ngunit maaaring i-configure ang retention: gumamit ng malaking value gaya ng 3650 para magpanatili ng mga history sa loob ng maraming taon. Bilang default, pinananatili nang lampas sa panahong iyon ang mga transcript ng session na sinimulan o huling ipinagpatuloy sa Desktop o Cowork, maliban sa ilang exception gaya ng HIPAA configurations.

May isa pang panganib, at nasa estruktura ito. Sinasabi ng dokumentasyon ng Anthropic na internal sa Claude Code ang entry format at nagbabago ito sa pagitan ng mga version, kaya maaaring masira sa anumang release ang mga script na direktang nagpa-parse sa mga file na ito. Nalalapat ito sa lahat ng tool na ganito ang disenyo. Ito rin ang dahilan kung bakit mas masamang ideya kaysa sa inaakala ang isang sariling-gawang jq one-liner sa JSONL: sinusubaybayan ng mga maintained parser ang mga pagbabago sa format para sa iyo, samantalang mag-uulat ang iyong one-liner ng kumpiyansang maling numero sa araw na palitan ang pangalan ng isang field.

Sa huli, kailangan ng dollar figure ng paglilinaw kapag subscription ang gamit. Ang paggamit sa loob ng limit ng iyong Pro o Max plan ay hindi sinisingil ayon sa token, kaya ipinapakita ng numero kung magkano sana ang halaga ng iyong mga token batay sa list API rates. Sinusukat nito kung gaano kabigat ang iyong paggamit. Hindi ito ang iyong bill. Ang exception ay usage credits: kapag pinagana mo ang mga ito, sisingilin nang hiwalay sa standard API rates ang paggamit na lampas sa plan limit, at ipinapakita ng claude.ai ang gastos para sa buwang iyon sa Settings > Usage. Kung ang tunay na tanong ay kung aling plan ang dapat gamitin, hiwalay na pagsusuri iyon: tingnan ang API billing kumpara sa Claude subscription.

Paraan 2: ipinapakita ng built-in usage screen kung aling model ang gumastos ng budget

May sarili nang reporting ang Claude Code, pero bihira itong buksan ng mga user. Patakbuhin ang /usage sa loob ng isang session. Ipinapakita ng Session block sa itaas ang mga token ayon sa model at ang halagang dolyar para sa kasalukuyang session. Lokal itong kinakalkula mula sa bilang ng mga token gamit ang standard list rates, maliban kung nagtakda ang administrator ng modelPricing table sa managed settings. Sa ganitong kaso, nakasaad sa Total cost line ang at your organization's configured rates. Sa alinmang sitwasyon, pagtatantiya lamang ang halagang ito at maaaring hindi tumugma sa invoice mo. Sa Pro o Max, sinasabi ng Anthropic na hindi ito nauugnay sa billing dahil kasama ang usage na iyon sa plan. Nire-reset ang mga total kapag nagsimula ang /clear ng bagong conversation.

Sa Pro, Max, Team, o seat-based Enterprise plan, ipinapakita rin ng screen kung gaano karami sa plan limit mo ang nagamit mo na. Walang included allowance na mauubos ang usage-based Enterprise dahil bawat token ay sinisingil sa API rates. Sa mga plan na ito, iniuugnay rin ng screen ang kamakailang usage sa skills, subagents, plugins, at indibidwal na MCP servers bilang porsyento ng kabuuan. Tina-tag nito ang mga behavior na bumubuo ng 10% o higit pa ng kamakailang usage, gaya ng mahabang context o cache misses. Pindutin ang d o w upang magpalipat-lipat sa huling 24 oras at huling 7 araw. Tinatantiya ang mga figure na ito at kinakalkula mula sa lokal na session history sa machine na ito, kaya hindi kasama ang usage mula sa ikalawang device. Kapag naubos ang allowance, tinutukoy ng Claude Code ang limit at ipinapakita ang oras ng reset nito; hindi ibig sabihin na ubos na ang allowance kapag walang laman ang consumption bar. Maaaring maghintay ang session at magpatuloy pagkatapos ng reset. Ang gagawin kapag naabot na ang limit ay hiwalay na desisyon tungkol sa model, context, at plan.

Kapag higit sa isang developer ang gumagamit, napupunta ang mga numero sa account. Nakakakuha ang isang API organisation ng Console Cost page, Claude Code dashboard na may spend at accepted lines bawat member, at Claude Code Analytics API na nagbabalik ng parehong daily per-user metrics gamit ang admin key. Nakakakuha ang Teams at Enterprise plans ng spend report sa admin console na may CSV export at ina-update araw-araw. Saklaw nito ang usage-credit spend sa seat-based plans at buong usage sa usage-based Enterprise. May analytics API rin ang Enterprise. Depende sa paraan ng pag-sign in ng bawat developer kung alin sa mga ito ang makikita mo. Kaya kailangang basahin ng isang mixed organisation ang dalawang report at pagsamahin ang mga ito nang mano-mano.

Para sa pagtantya ng budget, ang published figure sa cost documentation ng Anthropic noong October 2026 ay average na humigit-kumulang $13 bawat developer bawat active day at $150 hanggang $250 bawat developer bawat buwan, at mas mababa sa $30 bawat active day ang gastos ng 90% ng mga user. Ituring ito bilang published benchmark mula sa enterprise deployments, hindi bilang prediksyon para sa team mo. Magpatakbo muna ng pilot group at magsukat bago mag-extrapolate.

Hindi nakikita ng dashboards ang anumang mas detalyado kaysa sa araw at tao. Sasabihin ng mga ito na Opus ang gumamit ng pinakamarami noong Martes. Hindi nila sasabihin kung aling prompt, repository, o CI job ang gumamit nito. Nahuhuli rin ang mga ito dahil araw-araw ina-update ang organisation reports. Kaya tool ang mga ito para sa pagsusuri, hindi para mahuli ngayong hapon ang agent na hindi makontrol ang gastos. Kailangan ng limits, hindi reports, upang mahuli ito. Iyan ang paksa ng pagpapanatiling kontrolado ng gastos ng agent sa isang VPS.

Hugis 3: ipinapakita ng sarili mong OpenTelemetry stack kung aling prompt ang nagdulot ng regression

Naglalabas ang Claude Code ng OpenTelemetry metrics at event kapag pinagana mo ang telemetry at na-configure ang exporters. Ito ang tanging opsyon na nag-stream ng token at cost data ng bawat user papunta sa sistemang kontrolado mo, halos real time. Kasama sa metrics ang claude_code.cost.usage sa USD, claude_code.token.usage sa tokens, claude_code.session.count at claude_code.active_time.total.

Ang token metric ang pinakamahalaga dahil sa mga attribute nito. May dalang type ang bawat data point, na input, output, cacheRead o cacheCreation, pati model at query_source, na main, subagent o auxiliary. May dala rin itong agent.name, skill.name, mcp_server.name at mcp_tool.name. Dumarating bilang custom ang mga pangalan ng MCP server na ikaw mismo ang nag-configure at ng sarili mong custom subagent, maliban kung itakda mo ang OTEL_LOG_TOOL_DETAILS=1, na nagdaragdag din ng Bash command at tool input sa tool event. Sapat na ito upang sagutin ang mga tanong na hindi kayang sagutin ng anumang dashboard: gaano kalaking bahagi ng bill ang mula sa mga subagent sa halip na sa sarili mong turn, kung dinoble ng isang MCP server ang input token mo, at kung bumagsak ang cache read matapos may mag-edit ng CLAUDE.md. Karaniwang nasa cache behavior ang mga hindi inaasahang resulta, at ipinapaliwanag ng kung kailan sulit ang prompt caching kung ano ang dapat mong tingnan.

May isang pagwawastong mahalagang banggitin dahil lumilitaw ito sa bawat thread tungkol dito. Magandang self-hosted tracing backend ang Langfuse, at saklaw ng pag-self-host ng Langfuse para sa agent tracing ang pagpapatakbo nito sa isang VPS. Traces lamang ang tinatanggap ng OTLP endpoint nito. Bilang default, metrics at log event ang ini-export ng Claude Code, hindi spans. Kaya kung ituturo mo ang OTEL_EXPORTER_OTLP_ENDPOINT sa Langfuse, mananatiling walang laman ang project at wala kang makikitang kapaki-pakinabang na error. May span export, pero beta ito at nananatiling naka-off hanggang itakda mo ang CLAUDE_CODE_ENHANCED_TELEMETRY_BETA=1 at OTEL_TRACES_EXPORTER. Iba ang paraan ng sariling Claude Code integration ng Langfuse: gumagamit ito ng Stop hook, o plugin na nag-i-install nito, na nagbabasa ng session transcript pagkatapos ng bawat response at kino-convert ang mga ito sa traces. Dahil dito, kapareho nito ang mga limitasyong local-only ng isang log parser. Ang Langfuse ang tamang tool para sa mga agent na ikaw mismo ang binuo gamit ang API, kung saan ang sarili mong code ang gumagawa ng bawat span kasama ang prompt, model at cost nito. Para sa kabuuang spend mula sa Claude Code CLI, mas angkop ang metrics store.

I-set up ang Claude Code spend tracking sa sarili mong VPS

Sapat na ang dalawang service: isang collector para tumanggap ng metrics, at Prometheus para mag-store ng mga ito. Panatilihing hindi naaabot mula sa public internet ang dalawa, dahil ang bukas na OTLP port ay tumatanggap ng writes mula sa sinumang makahanap nito. Isulat ang /opt/ccmetrics/compose.yaml:

services:
  collector:
    image: otel/opentelemetry-collector-contrib:latest
    command: ["--config=/etc/otel/config.yaml"]
    volumes:
      - ./collector.yaml:/etc/otel/config.yaml:ro
    ports:
      - "10.8.0.1:4318:4318"
    restart: unless-stopped
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prom-data:/prometheus
    ports:
      - "127.0.0.1:9090:9090"
    restart: unless-stopped

volumes:
  prom-data:

Ang 10.8.0.1 ay address ng server sa loob ng WireGuard tunnel, kaya naaabot ang collector mula sa mga machine mo at mula sa wala nang iba. Mahalaga rito ang address bago ang port, dahil hindi bina-block ng ufw ang mga published Docker port: tingnan ang kung bakit nalalampasan ng mga Docker published port ang ufw. Ang pag-set up mismo ng tunnel ay nasa WireGuard VPN sa sarili mong VPS.

/opt/ccmetrics/collector.yaml:

receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4318

processors:
  batch:

exporters:
  prometheus:
    endpoint: 0.0.0.0:8889

service:
  pipelines:
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [prometheus]

/opt/ccmetrics/prometheus.yml. Hindi kailanman ipinapublish sa host ang port 8889, dahil naaabot ng Prometheus ang collector sa pamamagitan ng Compose network gamit ang service name:

global:
  scrape_interval: 30s

scrape_configs:
  - job_name: claude-code
    static_configs:
      - targets: ["collector:8889"]
cd /opt/ccmetrics
docker compose up -d
docker compose logs collector

Dapat magtapos ang log ng collector sa Everything is ready. Begin running and processing data.. Kapag huminto ang log dahil sa config error, hindi na-parse ang YAML at paulit-ulit na magre-restart ang container.

Ituro naman ngayon ang Claude Code rito. Sa bawat machine na nagpapatakbo ng Claude Code, idagdag ito sa ~/.claude/settings.json:

{
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
    "OTEL_METRICS_EXPORTER": "otlp",
    "OTEL_LOGS_EXPORTER": "none",
    "OTEL_EXPORTER_OTLP_PROTOCOL": "http/protobuf",
    "OTEL_EXPORTER_OTLP_ENDPOINT": "http://10.8.0.1:4318",
    "OTEL_METRIC_EXPORT_INTERVAL": "10000"
  }
}

Magsimula ng session, magpadala ng isang prompt, maghintay sa export interval (10 segundo dito, 60 segundo bilang default), at pagkatapos ay tanungin ang Prometheus kung ano ang natutuhan nito:

curl -s http://localhost:9090/api/v1/label/__name__/values | grep -o 'claude_code[a-z_]*'

Dapat kang makakuha ng ilang pangalan na nagsisimula sa claude_code_. Pinapalitan ng exporter ang mga tuldok ng underscore at idinadagdag ang unit, kaya nakadepende ang eksaktong strings sa bersyon ng collector. Ibig sabihin ng walang result na walang dumating. Tiyaking nagtutugma ang protocol at port, dahil ang http/protobuf ay pumupunta sa 4318 at ang grpc ay pumupunta sa 4317, at tahimik na mabibigo ang mismatch. Patakbuhin ang claude --debug-file /tmp/claude-debug.log at tingnan sa file na iyon ang mga linyang [3P telemetry], dahil doon iniuulat ng Claude Code ang mga OTel export error.

Kung isang machine lang ang gagamitin at walang server, laktawan ang lahat ng nasa itaas. Itakda ang CLAUDE_CODE_ENABLE_TELEMETRY=1 at OTEL_METRICS_EXPORTER=prometheus, at maglalabas ang Claude Code ng scrape endpoint sa http://localhost:9464/metrics mismo. Kapag ang prometheus lang ang exporter na nakalista, inaalis ng Claude Code ang mga unit na USD, tokens at s sa exported metrics upang manatiling valid na Prometheus text format ang scrape. Hindi nagbabago ang mga pangalan ng metric, at pinananatili ng setting na pinagsasama ang mga exporter, gaya ng otlp,prometheus, ang mga unit.

May kasamang isang desisyon sa privacy ang ganitong setup. Bilang default, counts at metadata lamang ang lumalabas sa machine; walang prompt text at walang tool output. Idinadagdag ng OTEL_LOG_USER_PROMPTS=1 ang prompt text sa exported events at ina-enable din ang assistant response text, maliban kung ino-override ito ng OTEL_LOG_ASSISTANT_RESPONSES=0. Idinadagdag ng OTEL_LOG_TOOL_CONTENT=1 ang piniling tool output sa trace spans, na may exclusions at truncation kapag umabot sa content limit, na 60 KB bilang default. Maaaring mailantad ng mga flag na ito ang source code at mga secret sa content na pinipili nila; hindi nila awtomatikong ine-export ang lahat ng nasa context. Kailangan ang hiwalay na setting na OTEL_LOG_RAW_API_BODIES para sa buong conversation bodies. I-enable lamang ang mga ito kapag sinadya mo, at basahin muna ang pag-iwas na mapasama ang mga secret sa agent context.

Pagsubaybay sa gastos para sa scripted at CI runs

Ang mga non-interactive run ang karaniwang nakagugulat dahil walang nagbabantay sa screen. Ibinabalik ng claude -p kasama ng --output-format json ang gastos ng run na iyon sa result payload:

claude -p "summarise the failing tests" --output-format json | jq '.total_cost_usd'

Nilalaman ng payload ang total_cost_usd kasama ang breakdown ayon sa bawat model, kaya maaaring itala ng isang CI job ang sarili nitong gastos nang hindi gumagamit ng dashboard. Gaya ng lahat ng lokal na figure, client-side estimate lamang ito. Kapag ipinagpatuloy ng isang run ang conversation gamit ang --continue o --resume, iniuulat nito ang kabuuang gastos ng buong conversation, kasama ang mga naunang run. Idagdag ang value sa isang file, o i-push ito bilang metric sa collector sa itaas. Ito ang pinakasimpleng kapaki-pakinabang na paraan ng pagsubaybay sa gastos, at isang jq call bawat run ang kailangan nito.

Mga mode ng failure at kung ano ang makikita mo

Walang laman ang report. npx ccusage@latest daily kapag walang nailalabas na row, ibig sabihin ay hindi nito binabasa ang lokasyon kung saan nagsusulat ang Claude Code. CLAUDE_CONFIG_DIR inililipat ang lokasyong iyon, at binabasa rin ng ccusage ang variable na iyon, kaya gamitin ang parehong value sa dalawa. Kung may nawawalang older session, tingnan ang cleanupPeriodDays: awtomatikong nililinis ang mga terminal session pagkatapos ng 30 araw na walang aktibidad, habang karaniwang nananatili nang lampas sa panahong iyon ang mga transcript mula sa Desktop at Cowork.

Magkaiba ang iniulat na total ng dalawang machine. Inaasahan ito at hindi ito bug. Ang /usage breakdown at ang anumang log parser ay parehong nagbabasa lamang ng lokal na session history, kaya wala sa alinman ang usage mula sa ibang device o mula sa claude.ai.

Hindi tumutugma ang lokal na total sa invoice. Kinukuwenta ang mga lokal na figure mula sa token count gamit ang standard list rate maliban kung nag-configure ka ng contracted rate: isang modelPricing table sa managed settings para sa /usage, o pricingOverrides para sa ccusage. Sa subscription, hindi sinisingil per token ang usage na saklaw ng plan limit, at usage credits lamang ang sinisingil. Ang Console Cost page ang awtoritatibong source para sa API billing.

Tumaas ang cost kahit pareho ang ginawa mong trabaho. Suriin muna ang mga cache column. Sa mahabang session, muling ipinapadala ang buong history sa bawat turn. Sisingilin ito sa cached rate habang warm ang cache at sa full input rate kapag naging cold ito, kaya kapag matagal ang pagitan ng mga turn, muling pinoproseso ang buong conversation. Makikita ito bilang malaking input number na katabi ng maliit na output number, at ipinapaliwanag ng pagpepresyo ng input kumpara sa output token kung bakit magkahiwalay ang galaw ng dalawang ito.

Mukhang imposibleng mataas ang isang araw na may subagents. Gumagamit ang bawat subagent ng sarili nitong context window, kaya nakadepende ang token use sa dami ng nag-run at sa tagal ng bawat isa. Sa isang plan, ipinapakita ng /usage attribution ang bahagi ng subagent para sa machine na ito bilang percentage. Para sa detalye ng bawat request, pinaghihiwalay ng OTel data ang mga ito gamit ang query_source attribute sa claude_code.token.usage. Ipapakita sa iyo ng log parser ang total, pero ikaw ang kailangang tumukoy sa pinagmulan nito.

FAQ

Ipinapakita ba ng ccusage ang aktuwal na sinisingil sa akin sa Max plan?

Hindi. Ang paggamit na nasa loob ng limit ng subscription plan ay hindi sinisingil bawat token. Kaya pinapresyuhan ng log parser ang iyong mga token gamit ang karaniwang list API rates at ipinapakita kung magkano sana ang parehong gawain kung ginawa ito sa pamamagitan ng API. Magandang panukat ito ng relatibong bigat ng isang araw, at kapaki-pakinabang sa paghahambing ng mga project o model sa isa't isa. Para sa aktuwal mong babayaran, saklaw ng Console Cost page ang API billing, at saklaw ng plan billing page ang subscription. Kung naka-enable ang usage credits, ang paggamit na lampas sa limit ay sisingilin sa karaniwang API rates. Ipinapakita ng claude.ai ang gastusing iyon sa Settings > Usage.

Saan iniimbak ni Claude Code ang mga session file na binabasa ng mga tool na ito?

Sa ~/.claude/projects/<project>/<session-id>.jsonl, kung saan ang <project> ay ang path ng working directory na pinalitan ng - ang mga character na hindi alphanumeric. Ang bawat linya ay isang JSON object para sa isang message, tool use, o metadata entry. Inililipat ng CLAUDE_CONFIG_DIR ang buong directory. Kinokontrol naman ng cleanupPeriodDays sa settings.json ang retention. Bilang default, 30 araw ng inactivity ang retention para sa terminal session. Karaniwan namang pinananatili nang mas matagal ang mga transcript ng Desktop at Cowork. Itinuturing ng Anthropic na internal ang format ng entry at maaari itong magbago sa pagitan ng mga version. Kaya gumamit ng maintained tool sa pag-parse nito sa halip na sarili mong script.

Maaari ko bang ipadala ang telemetry ng Claude Code sa Langfuse?

Hindi gamit ang default telemetry. Tumatanggap ang Langfuse OTLP endpoint ng traces. Bilang default, metrics at log events ang ine-export ng Claude Code, hindi spans, kaya walang paglalagyan ang data. Beta feature ang span export at kailangan mo itong i-enable. Gumagamit naman ang sariling Claude Code integration ng Langfuse ng Stop hook na nagko-convert ng mga session transcript sa traces. Para sa kabuuang gastusin, ipadala ang Claude Code metrics sa isang OpenTelemetry collector at i-store ang mga ito sa Prometheus. Gamitin ang Langfuse para sa mga agent na ikaw mismo ang binuo sa API, kung saan nag-e-emit ang sarili mong code ng mga span na naglalaman ng prompt, model, at cost.

Bakit hindi nagtutugma ang mga lokal kong numero sa Console usage page?

Dahil magkaiba ang paraan ng pagkalkula sa mga ito. Pinagsasama-sama ng /usage at ng mga log parser ang token count mula sa mga session file sa machine na ginagamit mo. Pagkatapos, pinapresyuhan nila ang mga ito gamit ang karaniwang list rates, maliban kung may naka-configure na contracted rates, sa pamamagitan ng modelPricing sa managed settings para sa /usage o pricingOverrides para sa ccusage. Saklaw ng Console ang paggamit ng iyong organisation sa lahat ng machine at key. Gamitin ang Cost page nito para sa aktuwal na API costs, dahil mga estimate ang spend figures sa Claude Code analytics dashboard. Normal ang hindi pagtutugma. Kapag napakalaki nito, karaniwang may ikalawang device, CI runner, o ibang team member na naniningil sa parehong account.

Paano ko matatrack ang cost ng isang claude -p run sa CI?

Patakbuhin ito gamit ang --output-format json at basahin ang total_cost_usd mula sa resulta, halimbawa gamit ang claude -p "..." --output-format json | jq '.total_cost_usd'. Kasama rin sa parehong payload ang breakdown bawat model at ang session ID. I-record ang halagang iyon sa bawat job para makuha ang spend bawat pipeline nang walang agent, dashboard, o karagdagang service.

Nakatulong ba ang artikulong ito?