Claude Code खर्च ट्रॅकर्सची तुलना कशी करावी?

Claude Code spend tracker नक्की काय वाचतो

प्रत्येक Claude Code spend tracker तीनपैकी एका डेटा स्रोतावरून माहिती वाचतो आणि कोणता प्रश्न सोडवायचा हे त्या स्रोतावर अवलंबून असते. लॉग पार्सर (log parser) तुमच्या डिस्कवरील सेशन ट्रान्सक्रिप्ट फाइल्स वाचतो. डॅशबोर्ड तुमच्या खात्यासाठी किंवा संस्थेसाठी Anthropic कडे असलेल्या वापराच्या नोंदी वाचतो. मेट्रिक्स बॅकएंड (metrics backend) OpenTelemetry (OTel) स्ट्रीम वाचतो, जो तुम्ही Claude Code सुरू करता तेव्हा तो उत्सर्जित करतो. हे तिन्ही स्रोत एकाच वेळी बरोबर असू शकतात आणि तरीही त्यांच्या आकडेवारीत तफावत असू शकते, कारण ते वेगवेगळ्या गोष्टी मोजत असतात.

हे मार्गदर्शक टोकन्सची पुन्हा व्याख्या करत नाही. Claude Code टोकन वापर कसा मोजतो यामध्ये इनपुट, आउटपुट, कॅशे राइट्स आणि कॅशे रीड्सची माहिती दिली आहे आणि जोपर्यंत तो भाग स्पष्ट होत नाही, तोपर्यंत कोणत्याही डॅशबोर्डचा फारसा उपयोग नसतो. येथे प्रश्न अधिक मर्यादित आहे: प्रत्येक प्रकारच्या टूलसाठी, ते काय पाहू शकते आणि ते काय कधीही पाहू शकत नाही.

एकाच दिवशी तीन Claude Code खर्च ट्रॅकर्स का दिसले

एकाच दिवशी तीन स्वतंत्र Claude Code खर्च ट्रॅकर्स प्रसिद्ध झाले. ही एकाच साधनाची तीन वेगवेगळी आवृत्ती नव्हती आणि हाच त्याचा महत्त्वाचा भाग आहे. एकाने स्थानिक session फाइल्स पार्स केल्या. दुसऱ्याने अकाउंट वापराच्या स्क्रीनला रॅप (wrap) केले. तिसरा एक होस्ट केलेला ट्रेसिंग बॅकएंड होता जो तुम्ही स्वतः चालवू शकता.

ते एकत्र आले कारण एजंट सेशनचा खर्च आता स्पष्ट राहिलेला नाही. चॅटचा खर्च साधारणपणे स्क्रीनवर दिसतो तितकाच असतो. एक एजंट वीस फाइल्स वाचतो, टेस्ट सूट चालवतो आणि प्रत्येक टर्नवर संपूर्ण संभाषण पुन्हा पाठवतो, त्यामुळे बिल अशा संदर्भावरून (context) वाढते जे तुम्ही कधीही टाइप केलेले नसते. सबस्क्रिप्शनवर कोणतीही डॉलरची रक्कम नसते, फक्त एक वापराची पट्टी (usage bar) असते जी काही दिवशी इतरांपेक्षा वेगाने रिकामी होते. या तीनही पद्धती त्यातील वेगवेगळ्या गरजा पूर्ण करतात.

आकार 1: स्थानिक लॉग पार्सर तुम्हाला आजचा खर्च सांगतो

Claude Code प्रत्येक संभाषण JSON Lines (JSONL) स्वरूपात ~/.claude/projects/<project>/<session-id>.jsonl वर साठवते, जिथे <project> हा तुमच्या वर्किंग डिरेक्टरीचा मार्ग आहे आणि त्यातील नॉन-अल्फान्युमेरिक अक्षरे - ने बदललेली असतात. त्या फाईलमधील प्रत्येक असिस्टंट टर्नमध्ये त्याच्या विनंतीसाठी लागलेल्या टोकन्सची संख्या असते. एक लॉग पार्सर त्यांची बेरीज करतो आणि किंमत काढतो.

ccusage हे असे साधन आहे जे बहुतेक लोक वापरतात. यासाठी कोणत्याही इन्स्टॉलेशनची गरज नाही:

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

daily तारखेनुसार एकूण खर्च दर्शवते. --breakdown प्रत्येक ओळ मॉडेलनुसार विभागते, ज्यावरून तुम्हाला समजते की Opus वापरून घालवलेली एक दुपार संपूर्ण आठवड्याच्या खर्चाच्या बरोबरीची आहे. blocks सबस्क्रिप्शन रिसेट होणाऱ्या पाच तासांच्या विंडोनुसार गट करते. session प्रत्येक संभाषणाचा एकूण खर्च काढते आणि --instances प्रोजेक्टनुसार गट करते, जेणेकरून कोणते रिपॉझिटरी महाग पडत आहे हे तुम्ही पाहू शकता. रेंज मर्यादित करण्यासाठी --since आणि --until जोडा आणि तुमच्या व्हर्जनला अपेक्षित असलेल्या फॉरमॅटसाठी npx ccusage@latest daily --help चालवा. ऑगस्ट 2026 पर्यंत, हे साधन Codex आणि OpenCode सह इतर एजंट CLIs देखील वाचते, जे तुम्ही त्यांची तुलना करत असाल तर महत्त्वाचे ठरते.

किंमत मॉडेल प्राईस टेबलवरून घेतली जाते आणि या टूलमध्ये तीन कॉस्ट मोड्स आहेत. --mode auto जेव्हा उपलब्ध असेल तेव्हा Claude Code ने फाईलमध्ये लिहिलेले costUSD मूल्य वापरते आणि ते नसल्यास टोकन काउंटवरून गणना करते. --mode calculate नेहमी टोकन्सवरून गणना करते आणि नोंदवलेली किंमत दुर्लक्षित करते. --mode display फक्त नोंदवलेली किंमत दर्शवते आणि ज्या ओळींना किंमत नाही तिथे $0.00 प्रिंट करते. जर एकूण बेरीज चुकीची वाटत असेल, तर तोच रिपोर्ट आधी calculate अंतर्गत आणि नंतर display अंतर्गत चालवा. त्यांच्यामध्ये मोठी तफावत असल्यास याचा अर्थ असा की बहुतेक नोंदींमध्ये कोणतीही किंमत नोंदवलेली नाही, त्यामुळे तुम्ही जे वाचत आहात ते सर्व एक अंदाज आहे.

हाच डेटा तुमच्या प्रॉम्प्टला फीड केला जाऊ शकतो. ccusage statusline Claude Code स्टेटस बारसाठी एक संक्षिप्त ओळ प्रिंट करते, जी इतर कोणत्याही स्टेटस लाईन कमांडप्रमाणे ~/.claude/settings.json मध्ये जोडलेली असते. सेटिंग्ज ब्लॉक आणि त्याला मिळणाऱ्या फील्ड्ससाठी Claude Code स्टेटसलाईन तयार करणे पहा.

लॉग पार्सरला जे दिसत नाही ते म्हणजे या मशीनवर न घडलेली कोणतीही गोष्ट. दुसरे लॅपटॉप, claude.ai वरील सेशन, सहकाऱ्याचे काम: हे ट्रान्सक्रिप्ट्स त्या त्या डिस्कवर राहतात. जुना डेटा देखील उपलब्ध नसतो, कारण cleanupPeriodDays सेटिंगनुसार ट्रान्सक्रिप्ट्स डीफॉल्टनुसार 30 दिवसांनंतर काढून टाकले जातात, त्यामुळे तुम्ही आर्काइव्ह केले नसेल तर मागील तिमाहीचा डेटा निघून गेला असतो.

यामध्ये आणखी एक जोखीम आहे, आणि ती स्ट्रक्चरल आहे. Anthropic च्या डॉक्युमेंटेशननुसार, एंट्री फॉरमॅट हा Claude Code चा अंतर्गत भाग आहे आणि तो व्हर्जननुसार बदलतो, त्यामुळे या फाईल्स थेट पार्स करणाऱ्या स्क्रिप्ट्स कोणत्याही रिलीजवर बंद पडू शकतात. हे या आकाराच्या प्रत्येक टूलला लागू होते. म्हणूनच JSONL वर हाताने लिहिलेली jq वन-लायनर वापरणे ही दिसते त्यापेक्षा वाईट कल्पना आहे: मेंटेन केलेले पार्सर्स तुमच्यासाठी फॉरमॅटमधील बदल ट्रॅक करतात, तर तुमची वन-लायनर एखादे फील्ड रिनेम झाल्याच्या दिवशी आत्मविश्वासाने चुकीचा आकडा देईल.

शेवटी, सबस्क्रिप्शनवर डॉलरच्या आकड्याबाबत एक स्पष्टीकरण आवश्यक आहे. Pro किंवा Max वर तुम्हाला प्रति टोकन बिल आकारले जात नाही, त्यामुळे हा आकडा म्हणजे तुमच्या टोकन्सची लिस्ट API दरांप्रमाणे झालेली किंमत आहे. हे तुमच्या वापराची तीव्रता मोजते. हे तुमचे बिल नाही. जर खरा प्रश्न कोणत्या प्लॅनवर असावे हा असेल, तर ती तुलना एक स्वतंत्र प्रक्रिया आहे: API बिलिंग विरुद्ध Claude सबस्क्रिप्शन पहा.

आकार 2: इन-बिल्ट युसेज स्क्रीन तुम्हाला सांगते की कोणत्या मॉडेलने बजेट खर्च केले

Claude Code स्वतःचे रिपोर्टिंग देते आणि बहुतेक लोक ते कधीही उघडत नाहीत. सेशनमध्ये /usage रन करा. वरच्या बाजूला असलेला Session ब्लॉक सध्याच्या सेशनसाठी मॉडेलनुसार टोकन्स आणि डॉलरमधील रक्कम दाखवतो, जी स्थानिक पातळीवर मानक दरांवरून मोजली जाते. ही रक्कम सवलत किंवा प्रमोशनल किमती दर्शवत नाही, त्यामुळे ती तुमच्या इनव्हॉइसपेक्षा वेगळी असू शकते. जेव्हा /clear नवीन संभाषण सुरू करते, तेव्हा हे एकूण आकडे रिसेट होतात.

Pro, Max, Team किंवा Enterprise प्लॅनवर, तीच स्क्रीन तुम्ही तुमच्या प्लॅनची किती मर्यादा वापरली आहे हे दाखवते आणि अलीकडील वापर स्किल्स, सब-एजंट्स, प्लगइन्स आणि वैयक्तिक MCP सर्व्हर्सना एकूण टक्केवारीनुसार विभागून दाखवते. हे अशा वर्तनांना हायलाइट करते जे अलीकडील वापराच्या 10% किंवा त्याहून अधिक आहेत, जसे की लांब कॉन्टेक्स्ट किंवा कॅशे मिसेस. गेल्या 24 तासांमधील आणि गेल्या 7 दिवसांमधील माहितीमध्ये स्विच करण्यासाठी d किंवा w दाबा. हे आकडे अंदाजे आहेत आणि या मशीनवरील स्थानिक सेशन हिस्ट्रीवरून मोजले जातात, त्यामुळे दुसऱ्या डिव्हाइसचा वापर यात मोजला जात नाही. जेव्हा तो बार रिकामा असतो, तेव्हा स्क्रीन तुम्हाला सांगते की विंडो बंद झाली आहे, परंतु काम कसे सुरू ठेवावे हे सांगत नाही, आणि मर्यादा गाठल्यानंतर काय करावे हा मॉडेल, कॉन्टेक्स्ट आणि प्लॅनबद्दलचा एक स्वतंत्र निर्णय आहे.

एकापेक्षा जास्त डेव्हलपर्स असल्यास, आकडेवारी अकाउंट स्तरावर जाते. API ऑर्गनायझेशनला Console युसेज पेज मिळते, जे Claude Code डॅशबोर्ड आहे. यात प्रत्येक सदस्याचा खर्च आणि स्वीकारलेल्या ओळींची माहिती असते. तसेच, एक Claude Code Analytics API मिळते जे ॲडमिन की वापरून दररोज प्रति-वापरकर्ता मेट्रिक्स देते. Teams आणि Enterprise प्लॅनमध्ये ॲडमिन कन्सोलमध्ये CSV एक्सपोर्टसह खर्चाचा रिपोर्ट मिळतो, जो दररोज अपडेट होतो. Enterprise प्लॅनमध्ये एक ॲनॅलिटिक्स API देखील जोडले जाते. तुम्हाला यापैकी काय दिसते हे प्रत्येक डेव्हलपर कसा साइन-इन झाला यावर अवलंबून असते, त्यामुळे मिश्र ऑर्गनायझेशनला दोन रिपोर्ट वाचून त्यांची बेरीज हाताने करावी लागते.

बजेट ठरवण्यासाठी, ऑगस्ट 2026 पर्यंतच्या Anthropic च्या कॉस्ट डॉक्युमेंटेशनमधील प्रकाशित आकडेवारीनुसार, प्रति डेव्हलपर प्रति सक्रिय दिवस सरासरी $13 आणि प्रति डेव्हलपर प्रति महिना $150 ते $250 खर्च येतो, तर 90% वापरकर्त्यांचा खर्च प्रति सक्रिय दिवस $30 च्या खाली असतो. याला एंटरप्राइझ डिप्लॉयमेंटमधील एक बेंचमार्क समजा, तुमच्या टीमसाठीचा अंदाज नाही. कोणताही निष्कर्ष काढण्यापूर्वी एक पायलट ग्रुप चालवून मोजमाप करा.

डॅशबोर्डला दिवस आणि व्यक्तीच्या खालील गोष्टी दिसत नाहीत. ते तुम्हाला सांगतील की मंगळवारी Opus चा वापर सर्वाधिक होता. ते तुम्हाला हे सांगणार नाहीत की कोणत्या प्रॉम्प्टने, कोणत्या रिपॉझिटरीने किंवा कोणत्या CI जॉबने हे केले. हे रिपोर्ट मागे असतात कारण ऑर्गनायझेशन रिपोर्ट दररोज अपडेट होतात, त्यामुळे हे साधन पुनरावलोकनासाठी आहे, आज दुपारी अनियंत्रित एजंटला पकडण्यासाठी नाही. अनियंत्रित एजंटला पकडण्यासाठी रिपोर्टची नाही तर मर्यादेची गरज असते, जो VPS वर एजंटचा खर्च मर्यादित ठेवणे या विषयाचा भाग आहे.

आकार 3: तुमची स्वतःची OpenTelemetry स्टॅक तुम्हाला सांगते की कोणता प्रॉम्प्ट रिग्रेस झाला आहे

एक environment variable सेट केल्यावर Claude Code OpenTelemetry मेट्रिक्स आणि इव्हेंट्स उत्सर्जित (emit) करते. प्रति-वापरकर्ता टोकन आणि खर्चाचा डेटा तुमच्या नियंत्रणाखालील सिस्टिममध्ये रिअल-टाइममध्ये स्ट्रीम करण्याचा हा एकमेव पर्याय आहे. मेट्रिक्समध्ये USD मधील claude_code.cost.usage, टोकन्स मधील claude_code.token.usage, claude_code.session.count आणि claude_code.active_time.total यांचा समावेश होतो.

टोकन मेट्रिक हे त्याच्या ॲट्रिब्यूट्समुळे महत्त्वाचे आहे. प्रत्येक डेटा पॉईंटमध्ये type असते, जे input, output, cacheRead किंवा cacheCreation असते, तसेच model आणि query_source असते, जे main, subagent किंवा auxiliary असते. यात agent.name, skill.name, mcp_server.name आणि mcp_tool.name देखील समाविष्ट असतात. हे कोणत्याही डॅशबोर्डला न समजणाऱ्या प्रश्नांची उत्तरे देण्यासाठी पुरेसे आहे: बिलापैकी किती हिस्सा हा तुमच्या स्वतःच्या टर्न्सऐवजी सब-एजंट्सचा आहे, एखाद्या MCP सर्व्हरने तुमचे इनपुट टोकन्स दुप्पट केले आहेत का, किंवा CLAUDE.md मध्ये बदल केल्यानंतर कॅशे रीड्स कमी झाले आहेत का. कॅशेचे वर्तन हे सहसा जिथे आश्चर्य दडलेले असते ते ठिकाण असते आणि प्रॉम्प्ट कॅशिंग कधी फायदेशीर ठरते हे तुम्ही काय पाहत आहात हे स्पष्ट करते.

एक दुरुस्ती करणे आवश्यक आहे, कारण प्रत्येक चर्चेत हा मुद्दा येतो. Langfuse हे एक चांगले self-hosted ट्रेसिंग बॅकएंड आहे आणि ते VPS वर चालवणे एजंट ट्रेसिंगसाठी Langfuse self-hosting मध्ये समाविष्ट केले आहे. त्याचे OTLP एंडपॉईंट फक्त ट्रेसेस स्वीकारते. Claude Code मेट्रिक्स आणि लॉग इव्हेंट्स एक्सपोर्ट करते, स्पॅन्स (spans) नाही, त्यामुळे OTEL_EXPORTER_OTLP_ENDPOINT ला Langfuse कडे निर्देशित केल्यास प्रोजेक्ट रिकामा राहतो आणि वाचण्यासारखी कोणतीही त्रुटी (error) मिळत नाही. तुम्ही स्वतः API वर तयार केलेल्या एजंट्ससाठी Langfuse हे योग्य साधन आहे, जिथे तुमचा स्वतःचा कोड प्रत्येक स्पॅन त्याच्या प्रॉम्प्ट, मॉडेल आणि खर्चासह तयार करतो. Claude Code CLI साठी, मेट्रिक्स स्टोअर हा योग्य पर्याय आहे.

तुमच्या स्वतःच्या VPS वर Claude Code खर्च ट्रॅकिंग सेट करा

दोन सेवा पुरेशा आहेत: मेट्रिक्स प्राप्त करण्यासाठी एक collector आणि ते साठवण्यासाठी Prometheus. दोन्ही सेवा सार्वजनिक इंटरनेटपासून दूर ठेवा, कारण उघडा OTLP पोर्ट शोधणाऱ्या कोणाकडूनही 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 टनेल मधील सर्व्हरचा पत्ता आहे, त्यामुळे collector फक्त तुमच्या मशीनवरूनच पोहोचण्यायोग्य आहे आणि इतर कोठूनही नाही. पोर्टच्या आधीचा पत्ता येथे प्रत्यक्ष काम करतो, कारण प्रकाशित केलेले Docker पोर्ट ufw द्वारे फिल्टर केले जात नाहीत: Docker प्रकाशित पोर्ट ufw ला का बायपास करतात पहा. टनेल सेट करणे म्हणजे तुमच्या स्वतःच्या 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. पोर्ट 8889 कधीही होस्टवर प्रकाशित केला जात नाही, कारण Prometheus सेवा नावाद्वारे Compose नेटवर्कवर 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 लॉग Everything is ready. Begin running and processing data. वर संपला पाहिजे. जर लॉग कॉन्फिगरेशन त्रुटीवर थांबत असेल, तर याचा अर्थ YAML पार्स झाले नाही आणि कंटेनर लूपमध्ये रीस्टार्ट होईल.

आता Claude Code ला त्याकडे निर्देशित करा. Claude Code चालवणाऱ्या प्रत्येक मशीनवर, ~/.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"
  }
}

एक सत्र सुरू करा, एक प्रॉम्प्ट पाठवा, एक्सपोर्ट इंटरव्हलची (येथे 10 सेकंद, डीफॉल्टनुसार 60 सेकंद) प्रतीक्षा करा, आणि नंतर Prometheus ला त्याने काय शिकले आहे ते विचारा:

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

तुम्हाला claude_code_ ने सुरू होणारी अनेक नावे मिळायला हवीत. एक्सपोर्टर डॉट्सचे अंडरस्कोअरमध्ये रूपांतर करतो आणि युनिट जोडतो, त्यामुळे नेमकी स्ट्रिंग्स तुमच्या collector आवृत्तीवर अवलंबून असतात. रिकाम्या निकालाचा अर्थ असा की काहीही पोहोचलेले नाही. प्रोटोकॉल आणि पोर्ट जुळतात का ते तपासा, कारण http/protobuf हे 4318 वर जाते आणि grpc हे 4317 वर जाते, आणि विसंगती असल्यास ते शांतपणे अपयशी ठरते. claude --debug चालवा आणि डीबग लॉग OTel एक्सपोर्ट त्रुटींची माहिती देईल.

एका मशीनसाठी आणि सर्व्हर नसल्यास, वरील सर्व वगळा. OTEL_METRICS_EXPORTER=prometheus सेट करा आणि Claude Code स्वतः http://localhost:9464/metrics वर एक scrape एंडपॉईंट उघड करेल. जेव्हा prometheus हा एकमेव एक्सपोर्टर सूचीबद्ध असतो, तेव्हा Claude Code मेट्रिक नावांतून USD, tokens आणि s युनिट्स वगळतो जेणेकरून scrape वैध Prometheus मजकूर स्वरूपात राहील.

या रचनेसोबत एक गोपनीयतेचा निर्णय येतो. डीफॉल्टनुसार फक्त counts मशीनबाहेर जातात, कोणताही प्रॉम्प्ट मजकूर किंवा टूल आउटपुट नाही. OTEL_LOG_USER_PROMPTS=1 आणि OTEL_LOG_TOOL_CONTENT=1 ते बदलतात, आणि त्यानंतर तुमच्या मेट्रिक्स बॉक्समध्ये सोर्स कोड आणि कॉन्टेक्स्टमध्ये असलेली इतर कोणतीही माहिती साठवली जाते. ते जाणीवपूर्वक चालू करा आणि प्रथम एजंट कॉन्टेक्स्टच्या बाहेर सिक्रेट्स ठेवणे वाचा.

स्क्रिप्टेड आणि CI रनसाठी खर्चाचा मागोवा घेणे

नॉन-इंटरअॅक्टिव्ह रनमुळे अनेकदा गोंधळ होतो, कारण स्क्रीनवर कोणीही लक्ष ठेवून नसते. claude -p आणि --output-format json वापरून, रनचा खर्च त्याच्या रिझल्ट पेलोडमध्ये मिळतो:

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

या पेलोडमध्ये total_cost_usd आणि प्रत्येक मॉडेलचा स्वतंत्र तपशील असतो, त्यामुळे CI जॉब डॅशबोर्डशिवाय स्वतःचा खर्च नोंदवू शकतो. हे मूल्य एखाद्या फाईलमध्ये जोडा किंवा वर नमूद केलेल्या कलेक्टरकडे मेट्रिक म्हणून पाठवा. खर्चाचा मागोवा घेण्याचा हा सर्वात स्वस्त आणि उपयुक्त मार्ग आहे, ज्यासाठी प्रति रन फक्त एक jq कॉल लागतो.

अपयशाचे प्रकार आणि तुम्हाला काय दिसेल

रिपोर्ट रिकामा आहे. npx ccusage@latest daily ने कोणतीही ओळ प्रिंट न होणे याचा अर्थ असा की, Claude Code जिथे डेटा लिहितो, तिथून तो वाचला जात नाहीये. CLAUDE_CONFIG_DIR ते लोकेशन बदलतो, त्यामुळे पार्सरला त्याबद्दल माहिती देणे आवश्यक असते. जर ओळी अस्तित्वात असतील पण त्या एका महिन्यापूर्वी थांबल्या असतील, तर ते cleanupPeriodDays अपेक्षेप्रमाणे काम करत असल्याचे लक्षण आहे: ट्रान्सक्रिप्ट्स डीफॉल्टनुसार 30 दिवसांनंतर काढून टाकल्या जातात.

दोन मशिन्सवर वेगवेगळी एकूण संख्या दिसते. हे अपेक्षित आहे आणि हा बग नाही. /usage आणि कोणताही लॉग पार्सर फक्त स्थानिक सेशन हिस्ट्री वाचतात, त्यामुळे दुसऱ्या डिव्हाइसवरून किंवा claude.ai वरून झालेला वापर दोन्ही ठिकाणी दिसत नाही.

स्थानिक एकूण संख्या इनव्हॉइसशी जुळत नाही. स्थानिक आकडेवारी मानक दरांवर आधारित टोकन काउंटवरून काढली जाते. त्यांना प्रमोशनल किंमती किंवा करारातील सवलतीबद्दल माहिती नसते आणि सबस्क्रिप्शनवर तुमचे टोकन्स स्वतंत्रपणे बिल केले जात नाहीत. API बिलिंगसाठी Console वरील वापराचे पेज अधिकृत मानले जाते.

तुम्ही तेच काम करत असताना खर्च वाढला. इतर काहीही तपासण्यापूर्वी कॅशे (cache) कॉलम्स तपासा. एक लांब सेशन प्रत्येक टर्नवर त्याचा संपूर्ण इतिहास पुन्हा पाठवते. कॅशे वॉर्म असताना ते कॅशे दराने आणि ते कोल्ड झाल्यावर पूर्ण इनपुट दराने आकारले जाते, त्यामुळे एक मोठा ब्रेक संपूर्ण संभाषण पुन्हा प्रोसेस करतो. हे लहान आउटपुट नंबरच्या शेजारी एक मोठा इनपुट नंबर म्हणून दिसते आणि input against output token pricing हे दोन्ही स्वतंत्रपणे का बदलतात याचे स्पष्टीकरण देते.

सब-एजंट्स असलेला दिवस अशक्य वाटतो. प्रत्येक सब-एजंट स्वतःची कॉन्टेक्स्ट विंडो चालवतो, त्यामुळे टोकनचा वापर किती एजंट्स चालले आणि प्रत्येक किती वेळ टिकला यावर अवलंबून असतो. फक्त OTel डेटा त्यांना वेगळे करतो, जो claude_code.token.usage वरील query_source ॲट्रिब्युटद्वारे मिळतो. लॉग पार्सर तुम्हाला फक्त एकूण संख्या दाखवेल आणि तुम्हाला अंदाज लावत बसावे लागेल.

FAQ

ccusage वरून मला Max प्लॅनसाठी किती बिल येईल हे समजते का?

नाही. सबस्क्रिप्शनमध्ये तुम्हाला प्रति टोकन बिल आकारले जात नाही, त्यामुळे लॉग पार्सर तुमच्या टोकन्सची किंमत मानक API दरांवरून मोजतो आणि तेवढेच काम API द्वारे केले असते तर किती खर्च आला असता हे दाखवतो. दिवसाचा कामाचा ताण मोजण्यासाठी हे एक चांगले सापेक्ष परिमाण आहे आणि विविध प्रोजेक्ट्स किंवा मॉडेल्सची तुलना करण्यासाठी ते उपयुक्त ठरते. तुम्हाला किती रक्कम द्यायची आहे, हे पाहण्यासाठी Console मधील usage पेजवर API बिलिंग आणि प्लॅन बिलिंग पेजवर सबस्क्रिप्शनची माहिती तपासा.

Claude Code या टूल्सद्वारे वाचल्या जाणाऱ्या सेशन फाइल्स कोठे साठवते?

~/.claude/projects/<project>/<session-id>.jsonl मध्ये, जिथे <project> हा वर्किंग डिरेक्टरीचा पाथ आहे आणि त्यातील नॉन-अल्फान्यूमेरिक अक्षरे - ने बदललेली असतात. प्रत्येक ओळ ही एका मेसेज, टूलचा वापर किंवा मेटाडेटा एन्ट्रीसाठी एक JSON ऑब्जेक्ट असते. CLAUDE_CONFIG_DIR संपूर्ण डिरेक्टरी हलवते आणि cleanupPeriodDays मधील settings.json 30 दिवसांच्या रिटेन्शनवर नियंत्रण ठेवते. Anthropic या एन्ट्री फॉरमॅटला अंतर्गत मानते आणि तो व्हर्जननुसार बदलू शकतो, त्यामुळे स्वतःची स्क्रिप्ट लिहिण्याऐवजी मेंटेन केलेल्या टूलचा वापर करून तो पार्स करा.

मी Claude Code ची टेलिमेट्री Langfuse कडे पाठवू शकतो का?

थेट नाही. Langfuse चा OTLP एंडपॉइंट ट्रेसेस स्वीकारतो, तर Claude Code हे स्पॅन्सऐवजी मेट्रिक्स आणि लॉग इव्हेंट्स एक्सपोर्ट करते, त्यामुळे हा डेटा तिथे साठवता येत नाही. Claude Code चे मेट्रिक्स OpenTelemetry कलेक्टरकडे पाठवा आणि ते Prometheus मध्ये साठवा. तुम्ही स्वतः API वर बनवलेल्या एजंट्ससाठी Langfuse वापरा, जिथे तुमचा स्वतःचा कोड प्रॉम्प्ट, मॉडेल आणि खर्च दर्शवणारे स्पॅन्स उत्सर्जित करतो.

माझे स्थानिक आकडे Console usage पेजवरील आकड्यांशी जुळत का नाहीत?

कारण त्यांची गणना वेगळ्या पद्धतीने केली जाते. /usage आणि लॉग पार्सर्स तुम्ही वापरत असलेल्या मशीनवरील सेशन फाइल्समधील टोकन काउंटची बेरीज करतात आणि त्यानंतर मानक दरांवर त्यांची किंमत ठरवतात. Console तुमच्या संस्थेला सर्व मशीन्स आणि सर्व कीजवर मिळून, सवलतीनंतर प्रत्यक्षात किती शुल्क आकारले गेले आहे, याची माहिती देते. आकड्यांमध्ये तफावत असणे सामान्य आहे. जर ही तफावत खूप मोठी असेल, तर याचा अर्थ दुसरे एखादे डिव्हाइस, CI रनर किंवा टीममधील दुसरा सदस्य त्याच अकाउंटवर बिलिंग करत असावा.

CI मधील claude -p रनचा खर्च कसा ट्रॅक करू?

ते --output-format json सह रन करा आणि निकालातून total_cost_usd वाचा, उदाहरणार्थ claude -p "..." --output-format json | jq '.total_cost_usd' वापरून. त्याच पेलोडमध्ये प्रति-मॉडेल ब्रेकडाउन आणि सेशन ID समाविष्ट असतो. प्रत्येक जॉबसाठी ती व्हॅल्यू रेकॉर्ड करा, म्हणजे तुम्हाला कोणत्याही एजंट, डॅशबोर्ड किंवा अतिरिक्त सेवेशिवाय प्रति-पाइपलाइन खर्च समजेल.