Claude Code ఖర్చు ట్రాకర్ల పోలిక: ఏది ఏం చూపిస్తుంది
Claude Code ఖర్చు ట్రాకర్లు వేర్వేరు ప్రశ్నలకు సమాధానం ఇస్తాయి. స్థానిక log parsers, built-in usage screens, మీ OpenTelemetry stack మధ్య తేడాలను స్పష్టంగా పోల్చండి.
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 ఖర్చు ట్రాకర్లు మూడు వేర్వేరుగా ప్రచురించబడ్డాయి. అవి ఒకే tool యొక్క మూడు versions కావు; ఉపయోగకరమైన అంశం ఇదే. ఒకటి స్థానిక session files ను parse చేసింది. మరొకటి account usage screens ను wrapper ద్వారా అందించింది. ఇంకొకటి మీరు స్వయంగా run చేసే hosted tracing backend.
Agent session ఖర్చు స్పష్టంగా కనిపించకుండా పోవడంతో అవి ఒకేసారి వచ్చాయి. మీరు screen పై చూడగలిగే మొత్తానికి chat ఖర్చు సాధారణంగా దగ్గరగా ఉంటుంది. కానీ agent ఇరవై files చదివి, test suite ను run చేసి, ప్రతి turn లో మొత్తం conversation ను మళ్లీ పంపుతుంది. అందువల్ల మీరు స్వయంగా type చేయని context ఆధారంగా bill నిర్ణయించబడుతుంది. Subscription లో Claude Code చూపించే session dollar figure ఒక estimate మాత్రమే; అది billing కు సంబంధించదని Anthropic చెబుతోంది. ముఖ్యమైనది usage bar. కొన్ని రోజుల్లో అది ఇతర రోజుల కంటే వేగంగా నిండుతుంది. ఈ మూడు tools లో ప్రతి ఒక్కటి ఆ అంతరంలోని వేర్వేరు భాగాన్ని చూపిస్తుంది.
రూపం 1: స్థానిక log parser ద్వారా ఈరోజు వినియోగానికి ఎంత ఖర్చయ్యేదో తెలుసుకోవడం
Claude Code ప్రతి conversation ను JSON Lines (JSONL) రూపంలో ~/.claude/projects/<project>/<session-id>.jsonl వద్ద నిల్వ చేస్తుంది. ఇక్కడ <project> అనేది మీ working directory path; ఇందులోని alphanumeric కాని అక్షరాలను - తో భర్తీ చేస్తారు. ఆ 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 --jsondaily తేదీ ప్రకారం మొత్తం లెక్కలను చూపుతుంది. --breakdown ప్రతి row ను model ప్రకారం విభజిస్తుంది. దీని ద్వారా ఒక Opus afternoon మొత్తం వారపు వినియోగంలో ఎంత భాగమో తెలుసుకోవచ్చు. blocks subscription reset అయ్యే five-hour window ప్రకారం సమూహీకరిస్తుంది. session ప్రతి conversation కు మొత్తం చూపుతుంది. daily --instances project ప్రకారం సమూహీకరిస్తుంది. దీని ద్వారా ఏ repository ఎక్కువ ఖర్చుతో ఉందో చూడవచ్చు. పరిధిని నిర్దేశించడానికి --since మరియు --until జోడించండి. మీ version ఆశించే date format కోసం npx ccusage@latest daily --help అమలు చేయండి. October 2026 నాటికి ఇది Codex, OpenCode సహా ఇతర agent CLIలను కూడా చదువుతుంది. మీరు వాటిని పోల్చుతున్నప్పుడు ఇది ఉపయోగకరం. Default reports గుర్తించిన అన్ని sources ను కలుపుతాయి. Claude Code పై మాత్రమే దృష్టి పెట్టడానికి daily లేదా session కు ముందు claude జోడించండి.
ధర model price table నుంచి తీసుకోబడుతుంది. ఈ tool కు మూడు cost modes ఉన్నాయి. File లో Claude Code రాసిన costUSD value అందుబాటులో ఉంటే --mode auto దాన్ని ఉపయోగిస్తుంది. అది లేకపోతే token counts ఆధారంగా లెక్కిస్తుంది. --mode calculate ఎల్లప్పుడూ tokens ఆధారంగా లెక్కిస్తుంది. Recorded cost ను పట్టించుకోదు. --mode display recorded costs ను మాత్రమే చూపిస్తుంది. Cost లేని rows కు $0.00 ను ముద్రిస్తుంది. Total తప్పుగా కనిపిస్తే, అదే report ను ముందుగా calculate తో, తరువాత display తో అమలు చేయండి. రెండింటి మధ్య పెద్ద తేడా ఉంటే, ఎక్కువ entries కు recorded cost లేదని అర్థం. అందువల్ల మీరు చూస్తున్న మొత్తం estimate మాత్రమే. మీరు contracted rates చెల్లిస్తే, ccusage.json config file లోని defaults కింద ఉన్న pricingOverrides individual models ధరను భర్తీ చేస్తుంది.
ఇదే data ను మీ prompt కు కూడా ఉపయోగించవచ్చు. ccusage statusline Claude Code status bar కోసం compact line ను ముద్రిస్తుంది. దీన్ని ఇతర status line command లాగే ~/.claude/settings.json లో configure చేయవచ్చు. Settings block మరియు అది స్వీకరించే fields కోసం Claude Code statusline నిర్మాణం చూడండి.
ఈ machine పై జరగని విషయాలను log parser చూడలేదు. రెండో laptop, claude.ai లోని session, teammate పని: ఆ transcripts ఆయా disks లోనే ఉంటాయి. cleanupPeriodDays కింద, 30 రోజుల inactivity తర్వాత పాత terminal sessions default గా తొలగించబడతాయి. అయితే retention ను configure చేయవచ్చు. సంవత్సరాల history ఉంచడానికి 3650 వంటి పెద్ద value ఉపయోగించండి. Desktop లేదా Cowork లో ప్రారంభించిన, లేదా ఇటీవల కొనసాగించిన sessions యొక్క transcripts సాధారణంగా ఆ వ్యవధి దాటిన తర్వాత కూడా ఉంచబడతాయి. HIPAA configurations వంటి కొన్ని మినహాయింపులు ఉన్నాయి.
ఇంకో ప్రమాదం ఉంది. అది నిర్మాణానికి సంబంధించినది. Entry format Claude Code కు internal అని, versions మధ్య అది మారుతుందని Anthropic documentation పేర్కొంటుంది. అందువల్ల ఈ files ను నేరుగా parse చేసే scripts ఏ release లోనైనా పనిచేయడం మానేయవచ్చు. ఈ రకమైన ప్రతి tool కు ఇదే వర్తిస్తుంది. JSONL పై చేతితో రాసిన jq one-liner కనిపించేదానికంటే ఎందుకు అధ్వాన్నమైన ఆలోచనో ఇదే కారణం. Maintained parsers format మార్పులను మీ కోసం అనుసరిస్తాయి. Field పేరు మారిన రోజున మీ one-liner మాత్రం నమ్మకంగా తప్పు సంఖ్యను చూపిస్తుంది.
చివరగా, subscription సందర్భంలో dollar figure కు ఒక మినహాయింపు గుర్తుంచుకోవాలి. మీ Pro లేదా Max plan limit లోపు usage కు token ఆధారంగా billing ఉండదు. అందువల్ల ఈ సంఖ్య list API rates ప్రకారం మీ tokens కు అయ్యే ఖర్చును చూపిస్తుంది. ఇది మీ usage ఎంత ఎక్కువగా ఉందో కొలుస్తుంది. ఇది మీ bill కాదు. Usage credits దీనికి మినహాయింపు. వాటిని enable చేస్తే plan limit దాటిన usage కు standard API rates ప్రకారం separate charge విధించబడుతుంది. claude.ai లో ఆ నెల spend ను Settings > Usage కింద చూపిస్తుంది. మీరు ఏ plan ఎంచుకోవాలో తెలుసుకోవడమే అసలు ప్రశ్న అయితే, ఆ comparison వేరే అంశం. Claude subscription తో API billing పోలిక చూడండి.
విధానం 2: అంతర్నిర్మిత వినియోగ తెరలు బడ్జెట్ను ఏ మోడల్ ఖర్చు చేసిందో తెలియజేస్తాయి
Claude Code దాని స్వంత reporting సౌకర్యాన్ని అందిస్తుంది, కానీ చాలామంది దాన్ని ఎప్పుడూ తెరవరు. ఒక session లో /usage ను అమలు చేయండి. పైభాగంలోని Session block ప్రస్తుత session కోసం model వారీగా tokens మరియు dollar మొత్తాన్ని చూపుతుంది. Administrator managed settings లో modelPricing table ను సెట్ చేయకపోతే, token counts ను standard list rates వద్ద స్థానికంగా లెక్కించి ఈ మొత్తాన్ని నిర్ణయిస్తుంది. Administrator ఆ table ను సెట్ చేసి ఉంటే, Total cost line లో at your organization's configured rates అని చూపుతుంది. ఏ సందర్భంలోనైనా ఇది అంచనా మాత్రమే. మీ invoice లోని మొత్తంతో ఇది భిన్నంగా ఉండవచ్చు. Pro లేదా Max ప్లాన్లో Anthropic ప్రకారం billing కోసం ఈ మొత్తం సంబంధితం కాదు, ఎందుకంటే ఆ usage ప్లాన్లోనే చేర్చబడి ఉంటుంది. /clear కొత్త conversation ప్రారంభించినప్పుడు totals reset అవుతాయి.
Pro, Max, Team లేదా seat-based Enterprise plan లో, మీ plan limit లో ఎంత భాగం ఉపయోగించారో అదే తెర చూపుతుంది. Usage-based Enterprise లో చేర్చిన allowance ఉండదు. అందువల్ల అయిపోయే included allowance ఉండదు; ప్రతి token కు API rates ప్రకారం billing జరుగుతుంది. ఈ plans లో ఇటీవలి usage ను total లో శాతంగా skills, subagents, plugins మరియు వ్యక్తిగత MCP servers కు కూడా ఈ తెర కేటాయిస్తుంది. ఇటీవలి usage లో 10% లేదా అంతకంటే ఎక్కువ భాగం ఉన్న ప్రవర్తనలను కూడా ఇది గుర్తిస్తుంది. ఉదాహరణకు long context లేదా cache misses. గత 24 గంటలు మరియు గత 7 రోజుల మధ్య మారడానికి d లేదా w నొక్కండి. ఈ figures సుమారు అంచనాలు మాత్రమే. ఇవి ఈ machine లోని local session history ఆధారంగా లెక్కించబడతాయి. అందువల్ల రెండో device లోని usage ఇందులో లెక్కించబడదు. Allowance పూర్తిగా ఉపయోగించబడితే, Claude Code ఆ limit పేరు మరియు reset time చూపుతుంది. Consumption bar ఖాళీగా ఉండటం allowance పూర్తయిందని అర్థం కాదు. Reset తర్వాత session వేచి ఉండి కొనసాగవచ్చు. Limit చేరుకున్న తర్వాత ఏం చేయాలో నిర్ణయించడం model, context మరియు plan గురించి వేరే విషయం.
ఒక developer కంటే ఎక్కువ మంది ఉన్నప్పుడు, ఈ సంఖ్యలు account స్థాయికి మారుతాయి. API organisation కు Console Cost page, ప్రతి member కు spend మరియు accepted lines చూపించే Claude Code dashboard, అలాగే admin key తో అదే రోజువారీ per-user metrics ను తిరిగి ఇచ్చే Claude Code Analytics API లభిస్తాయి. Teams మరియు Enterprise plans లో admin console లో spend report లభిస్తుంది. దాన్ని CSV గా export చేయవచ్చు మరియు అది ప్రతిరోజూ update అవుతుంది. Seat-based plans లో usage-credit spend మరియు usage-based Enterprise లో పూర్తి usage ఇందులో ఉంటాయి. Enterprise లో analytics API కూడా ఉంటుంది. ప్రతి developer ఎలా sign in అయ్యారనే దానిపై మీరు చూసే సమాచారం ఆధారపడి ఉంటుంది. అందువల్ల mixed organisation రెండు reports ను చూసి, వాటి మొత్తాన్ని manual గా కలపాలి.
Budget పరిమాణాన్ని నిర్ణయించడానికి, October 2026 నాటికి Anthropic cost documentation లో ప్రచురించిన figure ప్రకారం active day కు developer కు సగటున సుమారు $13, నెలకు developer కు $150 నుంచి $250 వరకు ఖర్చవుతుంది. Users లో 90% మంది active day కు $30 కంటే తక్కువ ఖర్చు చేస్తారు. దీన్ని మీ team కోసం prediction గా కాకుండా enterprise deployments నుంచి వచ్చిన published benchmark గా పరిగణించండి. ముందుగా pilot group ను అమలు చేసి measure చేయండి. తరువాత మాత్రమే ఆ ఫలితాలను విస్తరించి అంచనా వేయండి.
Dashboards day మరియు person కంటే తక్కువ స్థాయి వివరాలను చూడలేవు. మంగళవారం ఎక్కువ usage Opusదేనని అవి చెబుతాయి. కానీ ఏ prompt, ఏ repository లేదా ఏ CI job కారణమో చెప్పవు. Organisation reports ప్రతిరోజూ update అవుతున్నందున అవి ఆలస్యంగా కూడా ఉంటాయి. అందువల్ల ఇవి review tool మాత్రమే; ఈ మధ్యాహ్నం అదుపు తప్పిన agent ను గుర్తించే సాధనం కాదు. అదుపు తప్పిన agent ను గుర్తించడానికి reports కాదు, limits అవసరం. దీని గురించి VPSలో agent ఖర్చులను పరిమితం చేయడం లో వివరించబడింది.
ఆకారం 3: ఏ prompt తిరోగమించిందో మీ స్వంత OpenTelemetry stack తెలియజేస్తుంది
Telemetry ను enable చేసి exporters ను configure చేసిన తర్వాత Claude Code OpenTelemetry metrics మరియు events ను పంపుతుంది. మీరు నియంత్రించే సిస్టమ్లో ప్రతి వినియోగదారుకు సంబంధించిన 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 కూడా ఉంటాయి. మీరు స్వయంగా configure చేసిన MCP servers మరియు మీ స్వంత custom subagents పేర్లు custom గా వస్తాయి. OTEL_LOG_TOOL_DETAILS=1 set చేస్తే tool events కు Bash commands మరియు tool input కూడా జత అవుతాయి. ఏ dashboard సమాధానం ఇవ్వలేని ప్రశ్నలకు ఇది సరిపోతుంది: మొత్తం ఖర్చులో మీ స్వంత turns కు బదులుగా subagents వాటా ఎంత, ఒక MCP server మీ input tokens ను రెండింతలు చేసిందా, ఎవరో CLAUDE.md ను మార్చిన తర్వాత cache reads తగ్గిపోయాయా. సాధారణంగా cache ప్రవర్తనలోనే అనూహ్య ఫలితం కనిపిస్తుంది. prompt caching తన ఖర్చును ఎప్పుడు తిరిగి చెల్లిస్తుందో అనే వివరణలో మీరు చూస్తున్నది ఏమిటో వివరించారు.
ఇక్కడ ఒక సవరణ అవసరం. ఈ విషయం గురించి జరిగే ప్రతి చర్చలో ఇది ప్రస్తావనకు వస్తుంది. Langfuse మంచి self-hosted tracing backend. VPS పై దాన్ని నడిపే విధానం agent tracing కోసం Langfuse ను self-host చేయడం లో ఉంది. దాని OTLP endpoint traces ను మాత్రమే స్వీకరిస్తుంది. Default గా Claude Code metrics మరియు log events ను export చేస్తుంది, spans ను కాదు. అందువల్ల OTEL_EXPORTER_OTLP_ENDPOINT ను Langfuse కు point చేస్తే project ఖాళీగా ఉంటుంది. చదవదగిన error కూడా మీకు లభించదు. Span export అందుబాటులో ఉంది. అయితే అది beta లో ఉంటుంది. CLAUDE_CODE_ENHANCED_TELEMETRY_BETA=1 మరియు OTEL_TRACES_EXPORTER set చేసిన తర్వాత మాత్రమే అది enable అవుతుంది. Langfuse యొక్క స్వంత Claude Code integration వేరే విధానాన్ని ఉపయోగిస్తుంది. Stop hook లేదా దాన్ని install చేసే plugin, ప్రతి response తర్వాత session transcripts ను చదివి traces గా మారుస్తుంది. అందువల్ల log parser కు ఉండే local-only పరిమితులు దీనికీ ఉంటాయి. API పై మీరు స్వయంగా నిర్మించే agents కు Langfuse సరైన సాధనం. అక్కడ ప్రతి span ను మీ code 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 నుంచి మాత్రమే చేరుకోగలిగేలా ఉంటుంది. ఆ address ను port ముందు ఉంచడం ఇక్కడ ముఖ్యమైనది. కారణం, published Docker ports ను ufw filter చేయదు: Docker published ports ufw ను ఎందుకు bypass చేస్తాయి చూడండి. 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 collectorCollector 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_ తో ప్రారంభమయ్యే అనేక పేర్లు కనిపించాలి. Exporter dots ను underscores గా మార్చి unit ను జోడిస్తుంది. అందువల్ల ఖచ్చితమైన strings మీ collector version పై ఆధారపడి ఉంటాయి. ఫలితం ఖాళీగా ఉంటే ఏదీ చేరలేదని అర్థం. Protocol మరియు port సరిపోతున్నాయో తనిఖీ చేయండి. http/protobuf 4318 కు, grpc 4317 కు వెళ్తాయి. అవి సరిపోకపోతే ఎటువంటి స్పష్టమైన error లేకుండానే export విఫలమవుతుంది. claude --debug-file /tmp/claude-debug.log అమలు చేసి, ఆ fileలో [3P telemetry] lines కోసం చూడండి. Claude Code OTel export errors ను అక్కడ నమోదు చేస్తుంది.
ఒక machine మాత్రమే ఉండి server అవసరం లేకపోతే పై విధానాలన్నింటినీ వదిలేయండి. CLAUDE_CODE_ENABLE_TELEMETRY=1 మరియు OTEL_METRICS_EXPORTER=prometheus సెట్ చేయండి. అప్పుడు Claude Code స్వయంగా http://localhost:9464/metrics వద్ద scrape endpoint ను అందిస్తుంది. prometheus మాత్రమే exporter గా జాబితా చేయబడినప్పుడు, scrape చెల్లుబాటు అయ్యే Prometheus text format లో ఉండేందుకు Claude Code exported metrics నుంచి USD, tokens మరియు s units ను తొలగిస్తుంది. Metric names మారవు. otlp,prometheus వంటి exporters ను కలిపే setting ఉపయోగిస్తే units అలాగే ఉంటాయి.
ఈ విధానంలో ఒక privacy నిర్ణయం తీసుకోవాలి. Default గా counts మరియు metadata మాత్రమే machine నుంచి బయటకు వెళ్తాయి. Prompt text లేదా tool output వెళ్లవు. OTEL_LOG_USER_PROMPTS=1 exported events కు prompt text ను జోడిస్తుంది. OTEL_LOG_ASSISTANT_RESPONSES=0 దాన్ని override చేయకపోతే assistant response text ను కూడా enable చేస్తుంది. OTEL_LOG_TOOL_CONTENT=1 trace spans కు ఎంచుకున్న tool output ను జోడిస్తుంది. Content limit వద్ద exclusions మరియు truncation అమలవుతాయి. Default limit 60 KB. ఈ flags ఎంచుకున్న contentలో source code మరియు secrets ను బయటపెట్టవచ్చు. అయితే context లో ఉన్న ప్రతిదాన్ని అవి స్వయంచాలకంగా export చేయవు. పూర్తి conversation bodies కోసం ప్రత్యేకమైన OTEL_LOG_RAW_API_BODIES setting అవసరం. వాటిని ఉద్దేశపూర్వకంగా మాత్రమే enable చేయండి. ముందుగా agent context లో secrets లేకుండా ఉంచడం చదవండి.
స్క్రిప్ట్లు మరియు 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 కు సంబంధించిన విభజన కూడా ఉంటుంది. అందువల్ల CI job ఎలాంటి dashboard అవసరం లేకుండా తన ఖర్చును నమోదు చేయగలదు. ప్రతి local figure మాదిరిగానే ఇది client-side estimate మాత్రమే. --continue లేదా --resume తో conversation ను కొనసాగించే run అయితే, ముందుగా జరిగిన runs తో సహా మొత్తం conversation ఖర్చును report చేస్తుంది. ఆ విలువను file కు append చేయండి లేదా పై collector కు metric గా పంపండి. ఉపయోగకరమైన spend tracking కోసం ఇది తక్కువ ఖర్చుతో కూడిన మార్గం. ప్రతి run కు ఒక jq call మాత్రమే అవసరం.
విఫలత పరిస్థితులు మరియు కనిపించే ఫలితాలు
రిపోర్ట్ ఖాళీగా ఉంది. npx ccusage@latest daily ఎలాంటి వరుసలను ముద్రించకపోతే, అది Claude Code వ్రాసే స్థానాన్ని చదవడం లేదని అర్థం. CLAUDE_CONFIG_DIR ఆ స్థానాన్ని మారుస్తుంది. ccusage కూడా అదే variable ను చదువుతుంది. కాబట్టి రెండింటికీ ఒకే విలువను ఉపయోగించండి. పాత sessions కనిపించకపోతే cleanupPeriodDays ను పరిశీలించండి: terminal sessions లో inactivity 30 days పూర్తయిన తర్వాత default గా తొలగించబడతాయి. Desktop మరియు Cowork transcripts సాధారణంగా ఆ వ్యవధి దాటిన తర్వాత కూడా ఉంచబడతాయి.
రెండు machines వేర్వేరు totals ను చూపిస్తున్నాయి. ఇది ఆశించదగినదే. ఇది bug కాదు. /usage breakdown మరియు ఏదైనా log parser కూడా local session history ను మాత్రమే చదువుతాయి. అందువల్ల మరో device లేదా claude.ai నుంచి వచ్చిన usage రెండింటిలోనూ కనిపించదు.
Local total invoice తో సరిపోలడం లేదు. మీరు contracted rates ను configure చేయకపోతే, local figures standard list rates ఆధారంగా token counts నుంచి లెక్కించబడతాయి: managed settings లో modelPricing కోసం ఒక /usage table, లేదా ccusage కోసం pricingOverrides. Subscription లో plan limit లోని usage కు token ఆధారంగా billing ఉండదు. usage credits కు మాత్రమే billing ఉంటుంది. API billing కోసం Console Cost page అధికారిక ఆధారం.
అదే పని చేస్తున్నప్పటికీ cost పెరిగింది. ముందుగా cache columns ను పరిశీలించండి. ఒక long session ప్రతి turn లో తన పూర్తి history ని మళ్లీ పంపుతుంది. Cache warm గా ఉన్నప్పుడు cached rate వర్తిస్తుంది. Cache cold అయిన తర్వాత పూర్తి input rate వర్తిస్తుంది. అందువల్ల ఒక long break మొత్తం conversation ను మళ్లీ process చేస్తుంది. ఇది పెద్ద input number మరియు చిన్న output number రూపంలో కనిపిస్తుంది. input మరియు output token pricing ఈ రెండు ఎందుకు స్వతంత్రంగా మారుతాయో వివరిస్తుంది.
Subagents ఉన్న రోజు అసాధ్యంగా కనిపిస్తోంది. ప్రతి subagent తన స్వంత context window లో నడుస్తుంది. అందువల్ల token use, నడిచిన subagents సంఖ్య మరియు ప్రతి subagent నడిచిన వ్యవధి ఆధారంగా పెరుగుతుంది. Plan లో /usage attribution ఈ machine కు సంబంధించిన subagent share ను percentage గా చూపిస్తుంది. ప్రతి request వివరాల కోసం, OTel data లో claude_code.token.usage పై ఉన్న query_source attribute ద్వారా subagents ను వేరు చేయవచ్చు. Log parser మొత్తం మాత్రమే చూపిస్తుంది; కారణాన్ని మీరు ఊహించాల్సి వస్తుంది.
FAQ
ccusage Max planలో నాకు వాస్తవంగా బిల్ అయ్యే మొత్తాన్ని చూపుతుందా?
లేదు. Subscription plan పరిమితిలోని usageకు token ఆధారంగా విడిగా బిల్లింగ్ జరగదు. అందువల్ల log parser మీ tokensకు సాధారణ list API rates ప్రకారం ధరను లెక్కిస్తుంది. అదే పనిని API ద్వారా చేస్తే ఎంత ఖర్చయ్యేదో అది చూపిస్తుంది. ఒక రోజు usage ఎంత ఎక్కువగా ఉందో సాపేక్షంగా అంచనా వేయడానికి ఇది ఉపయోగకరం. Projects లేదా models మధ్య పోల్చడానికి కూడా ఇది సహాయపడుతుంది. మీరు చెల్లించాల్సిన మొత్తానికి API billing కోసం Console Cost pageను, subscription కోసం plan billing pageను చూడండి. Usage credits ఆన్ చేసి ఉంటే, పరిమితిని మించిన usageకు standard API rates ప్రకారం బిల్లింగ్ జరుగుతుంది. ఆ ఖర్చును claude.aiలో Settings > Usage కింద చూడవచ్చు.
ఈ 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. మొత్తం directoryని CLAUDE_CONFIG_DIR మార్చుతుంది. settings.jsonలోని cleanupPeriodDays retentionను నియంత్రిస్తుంది. Terminal sessionsకు inactivity తర్వాత default retention 30 days. Desktop మరియు Cowork transcripts సాధారణంగా ఆ వ్యవధి దాటిన తర్వాత కూడా ఉంచబడతాయి. Anthropic entry formatను internalగా, versions మధ్య మార్పులకు లోబడి ఉండేదిగా document చేస్తుంది. అందువల్ల మీ స్వంత scriptకన్నా నిర్వహించబడుతున్న toolతో దాన్ని parse చేయండి.
Claude Code telemetryని Langfuseకు పంపవచ్చా?
Default telemetryతో పంపలేరు. Langfuse OTLP endpoint tracesను స్వీకరిస్తుంది. అయితే defaultగా Claude Code spansకు బదులుగా metrics మరియు log eventsను export చేస్తుంది. కాబట్టి ఆ dataను స్వీకరించడానికి Langfuseలో destination ఉండదు. Span export beta feature. దాన్ని మీరు స్వయంగా ఆన్ చేయాలి. Langfuse యొక్క స్వంత Claude Code integration బదులుగా Stop hookను ఉపయోగిస్తుంది. అది session transcriptsను tracesగా మారుస్తుంది. Spend totals కోసం 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ను కలుపుతాయి. Contracted rates configure చేయకపోతే, అవి standard list rates ప్రకారం ధరను లెక్కిస్తాయి. Managed settingsలో /usage కోసం modelPricing ద్వారా లేదా ccusage కోసం pricingOverrides ద్వారా ఈ rates వర్తిస్తాయి. Console మీ organisationకు చెందిన machines మరియు keysన్నింటి usageను చూపిస్తుంది. Actual API costs కోసం దాని Cost pageను ఉపయోగించండి. Claude Code analytics dashboardలోని spend figures estimates మాత్రమే. కాబట్టి తేడా ఉండటం సాధారణం. చాలా పెద్ద తేడా సాధారణంగా రెండో device, CI runner లేదా అదే accountకు billing చేస్తున్న మరో team member వల్ల ఏర్పడుతుంది.
CIలో claude -p run ఖర్చును ఎలా track చేయాలి?
దాన్ని --output-format jsonతో run చేసి, ఫలితంలోని total_cost_usdను చదవండి. ఉదాహరణకు claude -p "..." --output-format json | jq '.total_cost_usd'ను ఉపయోగించవచ్చు. అదే payloadలో ప్రతి modelకు సంబంధించిన breakdown మరియు session ID కూడా ఉంటాయి. ప్రతి jobకు ఆ valueను record చేస్తే agent, dashboard లేదా అదనపు service లేకుండానే ప్రతి pipeline spendను పొందవచ్చు.