Claude Code ఖర్చు ట్రాకర్ల పోలిక: ఏది ఏం చూపిస్తుంది

Claude Code ఖర్చు ట్రాకర్ వాస్తవంగా ఏమి చదువుతుంది

ప్రతి Claude Code ఖర్చు ట్రాకర్ మూడు డేటా మూలాల్లో ఒకదాన్ని చదువుతుంది. అది ఏ ప్రశ్నకు సమాధానం ఇవ్వగలదో ఆ మూలం నిర్ణయిస్తుంది. Log parser మీ స్వంత డిస్క్‌లోని session transcript files ను చదువుతుంది. Dashboard మీ account లేదా మీ organisation కోసం Anthropic నిర్వహించే usage records ను చదువుతుంది. Metrics backend మీరు దాన్ని ప్రారంభించినప్పుడు Claude Code పంపే OpenTelemetry (OTel) stream ను చదువుతుంది. ఈ మూడింటి ఫలితాలు ఒకేసారి సరైనవిగా ఉండవచ్చు. అయినప్పటికీ అవి వేర్వేరు అంశాలను లెక్కించడం వల్ల పరస్పరం సరిపోకపోవచ్చు.

ఈ guide tokens ను మళ్లీ వివరించదు. Claude Code token usage ను ఎలా లెక్కిస్తుంది అనే వివరణలో input, output, cache writes మరియు cache reads గురించి ఉంది. ఆ భాగం స్పష్టంగా తెలియకపోతే ఏ dashboard కూడా పెద్దగా ఉపయోగపడదు. ఇక్కడి ప్రశ్న మరింత నిర్దిష్టమైనది: ప్రతి రకమైన tool ఏమి చూడగలదు, ఏమి ఎప్పటికీ చూడలేదు?

ఒకే రోజున మూడు Claude Code ఖర్చు ట్రాకర్లు ఎందుకు కనిపించాయి

ఒకే రోజున Claude Code కోసం మూడు వేర్వేరు ఖర్చు ట్రాకర్లు విడుదలయ్యాయి. అవి ఒకే సాధనం యొక్క మూడు వెర్షన్లు కావు. ఇదే ముఖ్యమైన విషయం. ఒకటి స్థానిక session files ను parse చేసింది. మరొకటి account usage screens ను wrapper ద్వారా అందించింది. ఇంకొకటి మీరు స్వయంగా అమలు చేసుకునే hosted tracing backend.

Agent session ఖర్చు స్పష్టంగా అర్థం కాకపోవడం ప్రారంభమైనందువల్ల అవి ఒకేసారి వచ్చాయి. మీరు తెరపై చూడగలిగే పరిమితిలో chat ఖర్చు సుమారుగా అర్థమవుతుంది. Agent ఇరవై files చదివి, test suite నడిపి, ప్రతి turn లో మొత్తం conversation ను మళ్లీ పంపుతుంది. అందువల్ల మీరు స్వయంగా టైప్ చేయని context ఆధారంగా bill పెరుగుతుంది. Subscription లో dollar figure అసలు ఉండదు. కొన్ని రోజుల్లో ఇతర రోజులకన్నా వేగంగా ఖాళీ అయ్యే usage bar మాత్రమే కనిపిస్తుంది. ఈ మూడు సాధనాల్లో ప్రతి ఒక్కటి ఈ లోటులో వేర్వేరు భాగాన్ని పూరిస్తుంది.

ఆకారం 1: స్థానిక log parser ఈ రోజు వినియోగానికి ఎంత ఖర్చయ్యేదో చూపుతుంది

Claude Code ప్రతి conversation ను JSON Lines (JSONL) రూపంలో ~/.claude/projects/<project>/<session-id>.jsonl వద్ద నిల్వ చేస్తుంది. ఇందులో <project> అనేది non-alphanumeric అక్షరాలను - తో భర్తీ చేసిన మీ working directory path. ఆ file లోని ప్రతి assistant turn దాని request కు సంబంధించిన token counts ను కలిగి ఉంటుంది. Log parser వాటిని కలిపి, వాటి ధరను లెక్కిస్తుంది.

ccusage ను ఎక్కువ మంది ఎంచుకుంటారు. దీన్ని install చేయాల్సిన అవసరం లేదు:

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

daily తేదీ ఆధారంగా totals చూపుతుంది. --breakdown ప్రతి row ను model ఆధారంగా విభజిస్తుంది. దీనివల్ల ఒక Opus afternoon మొత్తం వారంలో ఎక్కువ భాగం వినియోగించినట్లు గుర్తించవచ్చు. blocks subscription reset అయ్యే five-hour window ఆధారంగా groups చేస్తుంది. session ప్రతి conversation కు total చూపుతుంది. --instances project ఆధారంగా groups చేస్తుంది. దీనివల్ల ఏ repository ఎక్కువ ఖర్చుతో ఉందో చూడవచ్చు. పరిధిని పరిమితం చేయడానికి --since మరియు --until జోడించండి. మీ version ఆశించే date format కోసం npx ccusage@latest daily --help అమలు చేయండి. August 2026 నాటికి ఇది Codex, OpenCode సహా ఇతర agent CLIs ను కూడా చదువుతుంది. వాటిని పోల్చేటప్పుడు ఇది ఉపయోగకరం.

ధర model price table నుంచి వస్తుంది. ఈ tool కు మూడు cost modes ఉన్నాయి. --mode auto ఉపయోగించినప్పుడు file లో Claude Code రాసిన costUSD value ఉంటే దానిని ఉపయోగిస్తుంది. అది లేకపోతే token counts ఆధారంగా లెక్కిస్తుంది. --mode calculate ఎల్లప్పుడూ tokens ఆధారంగా లెక్కిస్తుంది. Recorded cost ను విస్మరిస్తుంది. --mode display recorded costs ను మాత్రమే చూపిస్తుంది. Recorded cost లేని rows కోసం $0.00 ను ముద్రిస్తుంది. ఏదైనా total తప్పుగా కనిపిస్తే, అదే report ను ముందుగా calculate తో, తరువాత display తో అమలు చేయండి. వాటి మధ్య పెద్ద తేడా ఉంటే, ఎక్కువ entries లో recorded cost లేదని అర్థం. అందువల్ల మీరు చూస్తున్న మొత్తం estimate మాత్రమే.

ఇదే data ను మీ prompt కు కూడా అందించవచ్చు. Claude Code status bar కోసం సంక్షిప్త line ను ccusage statusline ముద్రిస్తుంది. ఇతర status line commands లాగే దీన్ని ~/.claude/settings.json లో configure చేయవచ్చు. Settings block మరియు అది స్వీకరించే fields కోసం Claude Code statusline నిర్మాణం చూడండి.

ఈ machine లో జరగని విషయాలను log parser చూడలేదు. రెండో laptop, claude.ai లోని session, teammate చేసిన పని: ఆ transcripts ఆయా disks లో ఉంటాయి. పాత data కూడా ఉండకపోవచ్చు. cleanupPeriodDays setting కింద transcripts default గా 30 days తర్వాత cleanup అవుతాయి. కాబట్టి మీరు archive చేయకపోతే గత quarter data ఉండదు.

ఇంకో ప్రమాదం ఉంది. అది నిర్మాణానికి సంబంధించినది. Entry format Claude Code కు internal అయినందున versions మధ్య మారుతుందని Anthropic documentation చెబుతుంది. అందువల్ల ఈ files ను నేరుగా parse చేసే scripts ఏ release లోనైనా break కావచ్చు. ఈ రకమైన ప్రతి tool కు ఇదే వర్తిస్తుంది. JSONL పై చేతితో రాసిన jq one-liner కనిపించేదానికంటే ఎందుకు అధ్వాన్నమైన ఆలోచనో ఇదే కారణం. Maintained parsers format changes ను మీ కోసం అనుసరిస్తాయి. Field పేరు మార్చిన రోజున మీ one-liner మాత్రం నమ్మకంగా కనిపించే తప్పు సంఖ్యను చూపిస్తుంది.

చివరగా subscription సందర్భంలో dollar figure కు ఒక caveat అవసరం. Pro లేదా Max లో మీరు token కు చెల్లించరు. కాబట్టి ఈ సంఖ్య list API rates ప్రకారం మీ tokens కు అయ్యే ఖర్చును చూపిస్తుంది. ఇది మీ usage ఎంత ఎక్కువగా ఉందో కొలుస్తుంది. ఇది మీ bill కాదు. ఏ plan ఎంచుకోవాలో తెలుసుకోవడమే నిజమైన ప్రశ్న అయితే, ఆ comparison వేరుగా చేయాలి: Claude subscription తో API billing పోలిక చూడండి.

విధానం 2: అంతర్నిర్మిత usage screens ఏ model బడ్జెట్‌ను ఖర్చు చేసిందో చూపిస్తాయి

Claude Code తన స్వంత reporting ను అందిస్తుంది. అయితే చాలామంది దాన్ని ఎప్పుడూ తెరవరు. ఒక session లో `/usage ను అమలు చేయండి. పైభాగంలోని Session block ప్రస్తుత session కోసం model వారీగా tokens మరియు dollar మొత్తాన్ని చూపిస్తుంది. ఇది standard list rates ఆధారంగా token counts ను locally లెక్కిస్తుంది. ఆ మొత్తం discount లేదా promotional pricing ను పరిగణనలోకి తీసుకోదు. అందువల్ల అది మీ invoice తో భిన్నంగా ఉండవచ్చు. /clear` కొత్త conversation ను ప్రారంభించినప్పుడు totals మళ్లీ reset అవుతాయి.

Pro, Max, Team లేదా Enterprise plan లో ఇదే screen మీ plan limit లో ఎంత భాగం ఉపయోగించారో చూపిస్తుంది. ఇటీవలి usage లో skills, subagents, plugins మరియు వ్యక్తిగత MCP servers వాటాలనూ మొత్తం usage లో శాతంగా చూపిస్తుంది. ఇటీవలి usage లో 10% లేదా అంతకంటే ఎక్కువ వాటా కలిగిన ప్రవర్తనలను కూడా ఇది గుర్తిస్తుంది. ఉదాహరణకు long context లేదా cache misses. గత 24 గంటలు మరియు గత 7 రోజుల మధ్య మారడానికి `d లేదా w` నొక్కండి. ఈ గణాంకాలు సుమారుగా ఉంటాయి. ఇవి ఈ machine లోని local session history ఆధారంగా లెక్కించబడతాయి. అందువల్ల రెండో device పరిగణనలోకి రాదు. ఆ bar కేవలం తక్కువగా కాకుండా పూర్తిగా ఖాళీగా ఉన్నప్పుడు, window మూసుకుందని screen చెబుతుంది. అయితే పని కొనసాగించడానికి ఏమి చేయాలో చెప్పదు. Limit చేరుకున్న తర్వాత ఏం చేయాలి అనేది model, context మరియు plan కు సంబంధించిన వేరు నిర్ణయం.

ఒక developer కంటే ఎక్కువ మంది ఉన్నప్పుడు ఈ సంఖ్యలు account స్థాయికి మారుతాయి. API organisation కు Console usage page, ప్రతి member కోసం spend మరియు accepted lines చూపించే Claude Code dashboard, అలాగే admin key తో అదే daily per-user metrics ను అందించే Claude Code Analytics API లభిస్తాయి. Teams మరియు Enterprise plans లో admin console లో spend report లభిస్తుంది. దాన్ని CSV గా export చేయవచ్చు. ఈ report ప్రతిరోజూ update అవుతుంది. Enterprise లో అదనంగా analytics API ఉంటుంది. మీరు వీటిలో ఏవి చూస్తారో ప్రతి developer ఎలా sign in చేశారనే దానిపై ఆధారపడి ఉంటుంది. అందువల్ల mixed organisation రెండు reports ను చూసి, వాటి మొత్తాలను చేతితో కలపాలి.

బడ్జెట్ పరిమాణాన్ని నిర్ణయించడానికి, August 2026 నాటికి Anthropic cost documentation లో ప్రచురించిన గణాంకం ప్రకారం, active day కు developer ఒక్కొక్కరికి సగటు వ్యయం సుమారు $13. నెలకు developer ఒక్కొక్కరికి $150 నుంచి $250 వరకు ఉంటుంది. 90% users active day కు $30 కంటే తక్కువ ఖర్చు చేస్తారు. దీన్ని మీ team కోసం prediction గా కాకుండా enterprise deployments నుంచి వచ్చిన published benchmark గా పరిగణించండి. మీరు అంచనా వేయడానికి ముందు pilot group ను అమలు చేసి కొలవండి.

Dashboards day మరియు person స్థాయికి దిగువన ఉన్న వివరాలను చూడలేవు. మంగళవారం ఎక్కువ భాగం Opus ఉపయోగించబడిందని అవి చెబుతాయి. కానీ ఏ prompt, ఏ repository లేదా ఏ CI job కారణమో చెప్పవు. Organisation reports ప్రతిరోజూ update అవుతాయి. అందువల్ల వీటిలో ఆలస్యం ఉంటుంది. ఇవి review tool గా ఉపయోగపడతాయి, కానీ ఈ మధ్యాహ్నం runaway agent ను గుర్తించడానికి ఉపయోగపడవు. Runaway agent ను ఆపడానికి reports కాకుండా limits అవసరం. దీనినే VPSలో agent ఖర్చులను పరిమితిలో ఉంచడం వివరిస్తుంది.

విధానం 3: మీ స్వంత OpenTelemetry stack ఏ prompt తిరోగమించిందో చూపిస్తుంది

ఒక environment variable సెట్ చేసిన తర్వాత Claude Code OpenTelemetry metrics మరియు events ను పంపుతుంది. మీ నియంత్రణలో ఉన్న system కు ప్రతి user కు సంబంధించిన token మరియు cost data ను దాదాపు real time లో stream చేసే ఏకైక ఎంపిక ఇదే. Metrics లో claude_code.cost.usage USDలో, claude_code.token.usage tokensలో, claude_code.session.count మరియు claude_code.active_time.total ఉంటాయి.

Token metric ముఖ్యమైనది. దానికి సంబంధించిన attributes కారణంగా ఇది ఉపయోగకరంగా ఉంటుంది. ప్రతి data point లో type ఉంటుంది. అది input, output, cacheRead లేదా cacheCreation కావచ్చు. అదనంగా model మరియు query_source ఉంటాయి. అవి main, subagent లేదా auxiliary కావచ్చు. ఇందులో agent.name, skill.name, mcp_server.name మరియు mcp_tool.name కూడా ఉంటాయి. దీంతో ఏ dashboard సమాధానం ఇవ్వలేని ప్రశ్నలకు సమాధానం ఇవ్వవచ్చు: మొత్తం bill లో మీ స్వంత turns కు బదులుగా subagents కోసం ఎంత ఖర్చవుతోంది, ఒక MCP server మీ input tokens ను రెట్టింపు చేసిందా, ఎవరైనా CLAUDE.md ను మార్చిన తర్వాత cache reads తగ్గిపోయాయా. సాధారణంగా cache behaviour లోనే అనుకోని విషయం బయటపడుతుంది. prompt caching ఎప్పుడు తన ఖర్చును తిరిగి చెల్లిస్తుందో వివరించే చోట మీరు చూస్తున్నది ఏమిటో తెలుస్తుంది.

ఇది ప్రతి చర్చలో ప్రస్తావనకు వచ్చే అంశం కాబట్టి ఒక సవరణ అవసరం. Langfuse మంచి self-hosted tracing backend. VPSపై దీన్ని నడపడం గురించి agent tracing కోసం Langfuse ను self-hosting చేయడం లో వివరించబడింది. దీని OTLP endpoint traces ను మాత్రమే స్వీకరిస్తుంది. Claude Code metrics మరియు log events ను export చేస్తుంది, spans ను కాదు. అందువల్ల OTEL_EXPORTER_OTLP_ENDPOINT ను Langfuse కు చూపిస్తే project ఖాళీగానే ఉంటుంది, చదవదగిన error కూడా కనిపించదు. APIపై మీరు స్వయంగా నిర్మించే agents కు Langfuse సరైన tool. అలాంటి సందర్భంలో మీ code ప్రతి span ను దాని prompt, model మరియు cost తో సృష్టిస్తుంది. Claude Code CLI కోసం metrics store సరైన ఎంపిక.

మీ స్వంత VPSలో Claude Code ఖర్చు ట్రాకింగ్ ఏర్పాటు చేయండి

రెండు సేవలు సరిపోతాయి: metrics స్వీకరించే collector, వాటిని నిల్వ చేసే Prometheus. రెండింటినీ public internet నుంచి దూరంగా ఉంచండి. ఎందుకంటే open OTLP port ను కనుగొన్న ఎవరైనా అందులో writes చేయగలరు. /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:

10.8.0.1 అనేది WireGuard tunnel లోని server address. అందువల్ల collector మీ machines నుంచి మాత్రమే చేరుకోగలిగేలా ఉంటుంది. ఇతర ఎక్కడి నుంచీ చేరుకోలేరు. ఇక్కడ port ముందు ఉన్న address ముఖ్యమైన పని చేస్తుంది. ఎందుకంటే published Docker ports ను ufw filter చేయదు: Docker published ports ufw ను ఎందుకు దాటవేస్తాయి చూడండి. Tunnel ను ఏర్పాటు చేసే విధానం మీ స్వంత VPSలో WireGuard VPN లో ఉంది.

/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. Port 8889 hostకు ఎప్పుడూ publish చేయబడదు. Prometheus Compose network ద్వారా service name ఉపయోగించి collector ను చేరుకుంటుంది:

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

Collector log Everything is ready. Begin running and processing data. తో ముగియాలి. Config error వద్ద log ఆగిపోతే YAML parse కాలేదని అర్థం. అప్పుడు container నిరంతరం restart అవుతుంది.

ఇప్పుడు Claude Code ను దీనికి అనుసంధానించండి. Claude Code నడిచే ప్రతి machineలో ~/.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"
  }
}

ఒక session ప్రారంభించి, ఒక prompt పంపండి. Export interval పూర్తయ్యే వరకు వేచి ఉండండి. ఇక్కడ అది 10 seconds, defaultగా 60 seconds. తరువాత Prometheus ఏమి స్వీకరించిందో అడగండి:

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

claude_code_ తో ప్రారంభమయ్యే అనేక names రావాలి. Exporter dots ను underscores గా మార్చి unit ను జతచేస్తుంది. అందువల్ల ఖచ్చితమైన strings మీ collector version పై ఆధారపడి ఉంటాయి. ఫలితం ఖాళీగా ఉంటే ఏదీ చేరలేదని అర్థం. Protocol మరియు port సరిపోతున్నాయో తనిఖీ చేయండి. http/protobuf 4318 కు, grpc 4317 కు వెళ్తాయి. Mismatch అయితే నిశ్శబ్దంగా విఫలమవుతుంది. claude --debug నడపండి. Debug log OTel export errors ను చూపిస్తుంది.

ఒక machine మాత్రమే ఉండి server అవసరం లేకపోతే, పై విధానాలన్నింటినీ దాటవేయండి. OTEL_METRICS_EXPORTER=prometheus సెట్ చేస్తే Claude Code స్వయంగా http://localhost:9464/metrics వద్ద scrape endpoint ను అందిస్తుంది. prometheus మాత్రమే exporterగా జాబితా చేయబడినప్పుడు, scrape చెల్లుబాటు అయ్యే Prometheus text format గా ఉండేందుకు Claude Code metric names నుంచి USD, tokens మరియు s units ను తొలగిస్తుంది.

ఈ నిర్మాణంతో ఒక privacy నిర్ణయం తీసుకోవాలి. Defaultగా counts మాత్రమే machine నుంచి బయటకు వెళ్తాయి. Prompt text లేదా tool output బయటకు వెళ్లవు. OTEL_LOG_USER_PROMPTS=1 మరియు OTEL_LOG_TOOL_CONTENT=1 ఈ ప్రవర్తనను మార్చుతాయి. అప్పుడు మీ metrics boxలో source code మరియు contextలో ఉన్న ఇతర సమాచారం కూడా నిల్వ అవుతుంది. వాటిని ఉద్దేశపూర్వకంగా మాత్రమే enable చేయండి. ముందుగా agent contextలో secrets లేకుండా ఉంచడం చదవండి.

Scripted మరియు CI runs కోసం ఖర్చును ట్రాక్ చేయడం

Non-interactive runs ఆశ్చర్యానికి గురిచేస్తాయి, ఎందుకంటే screen ను ఎవరూ పర్యవేక్షించరు. claude -p ను --output-format json తో ఉపయోగిస్తే, ఆ run ఖర్చు దాని result payload లో అందుతుంది:

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

ఈ payload లో total_cost_usd తో పాటు ప్రతి model కు సంబంధించిన breakdown ఉంటుంది. అందువల్ల dashboard అవసరం లేకుండానే CI job తన ఖర్చును నమోదు చేయగలదు. ఆ విలువను ఒక file కు append చేయండి లేదా పైన పేర్కొన్న collector కు metric గా పంపండి. ఉపయోగకరమైన ఖర్చు tracking లో ఇది తక్కువ వ్యయమైన పద్ధతి. ప్రతి run కు ఒక్క jq call మాత్రమే అవసరం.

విఫలత పరిస్థితులు మరియు మీరు చూడబోయేది

నివేదిక ఖాళీగా ఉంది. npx ccusage@latest daily ఎలాంటి వరుసలను ముద్రించకపోతే, అది Claude Code వ్రాసే స్థానాన్ని చదవడం లేదని అర్థం. CLAUDE_CONFIG_DIR ఆ స్థానాన్ని మార్చుతుంది. Parser కు కూడా కొత్త స్థానం తెలియజేయాలి. వరుసలు కనిపిస్తున్నా అవి సుమారు ఒక నెల క్రితంతో ఆగిపోతే, అది cleanupPeriodDays రూపొందించిన విధంగానే పనిచేస్తోందని అర్థం: transcripts డిఫాల్ట్‌గా 30 రోజుల తర్వాత తొలగించబడతాయి.

రెండు యంత్రాలు వేర్వేరు మొత్తాలను నివేదిస్తున్నాయి. ఇది ఆశించిన ప్రవర్తనే. Bug కాదు. /usage మరియు ఏదైనా log parser కూడా స్థానిక session history ను మాత్రమే చదువుతాయి. అందువల్ల మరొక device లేదా claude.ai నుంచి జరిగిన వినియోగం రెండింటిలోనూ కనిపించదు.

స్థానిక మొత్తం invoice తో సరిపోలడం లేదు. స్థానిక గణాంకాలు standard list rates ఆధారంగా token counts నుంచి లెక్కించబడతాయి. Promotional pricing లేదా ఒప్పంద discount గురించి వాటికి సమాచారం ఉండదు. Subscription లో మీ tokens ను విడిగా bill చేయరు. API billing కోసం Console usage page అధికారిక ఆధారం.

మీరు అదే పని చేసినప్పటికీ ఖర్చు పెరిగింది. ముందుగా cache columns ను తనిఖీ చేయండి. Long session ప్రతి turn లో తన మొత్తం history ను మళ్లీ పంపుతుంది. Cache active గా ఉన్నప్పుడు cached rate వర్తిస్తుంది. Cache cold అయిన తర్వాత full input rate వర్తిస్తుంది. అందువల్ల ఒక దీర్ఘ విరామం తర్వాత మొత్తం conversation మళ్లీ process అవుతుంది. ఇది చిన్న output number పక్కన పెద్ద input number గా కనిపిస్తుంది. input మరియు output token pricing మధ్య తేడా ఈ రెండూ స్వతంత్రంగా ఎందుకు మారుతాయో వివరిస్తుంది.

Subagents ఉన్న రోజు అసాధ్యంగా కనిపిస్తోంది. ప్రతి subagent తన స్వంత context window లో నడుస్తుంది. అందువల్ల token వినియోగం ఎన్ని subagents నడిచాయి, ప్రతి ఒక్కటి ఎంతసేపు నడిచింది అనే దానిపై ఆధారపడి పెరుగుతుంది. query_source attribute ద్వారా claude_code.token.usage లోని OTel data మాత్రమే వాటిని వేరు చేస్తుంది. Log parser మొత్తం మాత్రమే చూపిస్తుంది; మిగతాది మీరు ఊహించాల్సి ఉంటుంది.

FAQ

ccusage Max ప్లాన్‌లో నాకు వాస్తవంగా బిల్ చేసిన మొత్తాన్ని చూపుతుందా?

లేదు. Subscriptionలో ప్రతి tokenకు విడిగా బిల్ చేయరు. అందువల్ల log parser మీ tokensకు standard list API rates ఆధారంగా ధర లెక్కించి, అదే పనిని API ద్వారా చేస్తే అయ్యే ఖర్చును చూపుతుంది. ఒక రోజు పని ఎంత భారంగా ఉందో సాపేక్షంగా అంచనా వేయడానికి ఇది ఉపయోగకరం. Projects లేదా models మధ్య పోల్చడానికి కూడా ఇది సహాయపడుతుంది. మీరు చెల్లించాల్సిన వాస్తవ మొత్తానికి API billing కోసం Console usage pageను, subscription కోసం plan billing pageను చూడాలి.

ఈ tools చదివే session filesను Claude Code ఎక్కడ నిల్వ చేస్తుంది?

~/.claude/projects/<project>/<session-id>.jsonl లో నిల్వ చేస్తుంది. ఇక్కడ <project> అనేది non-alphanumeric characters స్థానంలో - ఉంచిన working directory path. ప్రతి line ఒక message, tool use లేదా metadata entryకు సంబంధించిన JSON object. CLAUDE_CONFIG_DIR ద్వారా మొత్తం directoryని తరలించవచ్చు. cleanupPeriodDays లోని settings.json 30-day retentionను నియంత్రిస్తుంది. Anthropic entry formatను internalగా, versions మధ్య మారవచ్చునని documentationలో పేర్కొంటుంది. అందువల్ల మీ స్వంత scriptకు బదులుగా నిర్వహణలో ఉన్న toolతో దీనిని parse చేయండి.

Claude Code telemetryని Langfuseకు పంపవచ్చా?

నేరుగా పంపలేరు. Langfuse OTLP endpoint tracesను స్వీకరిస్తుంది. అయితే Claude Code spansకు బదులుగా metrics మరియు log eventsను export చేస్తుంది. అందువల్ల ఆ dataను నిల్వ చేయడానికి అనుకూలమైన స్థానం ఉండదు. Claude Code metricsను OpenTelemetry collectorకు పంపి, వాటిని Prometheusలో నిల్వ చేయండి. APIపై మీరు స్వయంగా నిర్మించే agents కోసం Langfuseను ఉపయోగించండి. ఆ సందర్భంలో prompt, model మరియు costను కలిగి ఉన్న spansను మీ code స్వయంగా emit చేస్తుంది.

నా local numbers Console usage pageతో ఎందుకు సరిపోలడం లేదు?

అవి వేర్వేరు విధానాల్లో లెక్కించబడతాయి. /usage మరియు log parsers మీరు ఉపయోగిస్తున్న machineలోని session files నుంచి token countsను కలిపి, standard list rates ఆధారంగా ధరను లెక్కిస్తాయి. Console మీ organisationకు వాస్తవంగా బిల్ చేసిన మొత్తాన్ని report చేస్తుంది. ఇందులో ప్రతి machine, ప్రతి key మరియు వర్తించిన discounts అన్నీ పరిగణనలోకి వస్తాయి. కాబట్టి mismatch సాధారణమే. చాలా పెద్ద తేడా ఉంటే, సాధారణంగా రెండో device, CI runner లేదా అదే accountకు billing చేస్తున్న మరో team member కారణంగా ఉంటుంది.

CIలో claude -p run ఖర్చును ఎలా track చేయాలి?

దాన్ని --output-format jsonతో run చేసి, result నుంచి total_cost_usdను చదవండి. ఉదాహరణకు claude -p "..." --output-format json | jq '.total_cost_usd'ను ఉపయోగించవచ్చు. అదే payloadలో ప్రతి modelకు సంబంధించిన breakdown మరియు session ID కూడా ఉంటాయి. ప్రతి jobకు ఆ valueను record చేస్తే, agent, dashboard లేదా అదనపు service లేకుండానే ప్రతి pipeline ఖర్చును తెలుసుకోవచ్చు.