Claude Code spend tracker के प्रकार और तुलना

Claude Code spend tracker वास्तव में क्या पढ़ता है

प्रत्येक Claude Code spend tracker तीन डेटा स्रोतों में से एक को पढ़ता है, और स्रोत यह तय करता है कि वह किस प्रश्न का उत्तर दे सकता है। एक log parser आपकी अपनी डिस्क पर मौजूद session transcript फाइलों को पढ़ता है। एक dashboard उन usage records को पढ़ता है जिन्हें Anthropic आपके खाते या आपके संगठन के लिए रखता है। एक metrics backend उस OpenTelemetry (OTel) stream को पढ़ता है जिसे Claude Code चालू करने पर उत्सर्जित (emit) करता है। तीनों एक ही समय में सही हो सकते हैं और फिर भी उनमें असहमति हो सकती है, क्योंकि वे अलग-अलग चीजों की गणना कर रहे होते हैं।

यह गाइड tokens की दोबारा व्याख्या नहीं करती है। Claude Code token usage की गणना कैसे करता है में input, output, cache writes और cache reads शामिल हैं, और जब तक वह हिस्सा स्पष्ट न हो, किसी भी dashboard का अधिक अर्थ नहीं है। यहाँ प्रश्न अधिक सीमित है: प्रत्येक टूल के स्वरूप के लिए, वह क्या देख सकता है, और वह क्या कभी नहीं देख सकता है।

एक ही दिन में तीन Claude Code spend trackers क्यों दिखाई दिए

एक ही दिन में तीन अलग-अलग Claude Code spend trackers पोस्ट किए गए। ये एक ही टूल के तीन वर्शन नहीं थे, और यही इसका उपयोगी पहलू है। एक ने लोकल session files को पार्स किया। दूसरे ने account usage स्क्रीन को रैप किया। तीसरा एक hosted tracing backend था जिसे आप स्वयं रन करते हैं।

वे एक साथ इसलिए आए क्योंकि agent session की लागत अब स्पष्ट नहीं रह गई है। एक चैट की लागत लगभग उतनी ही होती है जितनी आप स्क्रीन पर देख सकते हैं। एक agent बीस फाइलें पढ़ता है, टेस्ट सूट रन करता है, और हर टर्न पर पूरी बातचीत को फिर से भेजता है, इसलिए बिल उस कॉन्टेक्स्ट से बढ़ता है जिसे आपने कभी टाइप ही नहीं किया। सब्सक्रिप्शन पर कोई डॉलर का आंकड़ा नहीं होता, केवल एक usage बार होता है जो कुछ दिनों में दूसरों की तुलना में तेजी से खाली हो जाता है। इन तीनों में से प्रत्येक तरीका उस अंतर के एक अलग हिस्से को पूरा करता है।

आकृति 1: एक स्थानीय लॉग पार्सर आपको बताता है कि आज का खर्च क्या है

Claude Code प्रत्येक बातचीत को ~/.claude/projects/<project>/<session-id>.jsonl पर JSON Lines (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 तक यह अन्य एजेंट CLIs को भी पढ़ता है, जिसमें Codex और OpenCode शामिल हैं, जो तब महत्वपूर्ण होता है जब आप उनकी तुलना कर रहे हों।

मूल्य निर्धारण एक मॉडल मूल्य तालिका से आता है, और टूल में तीन कॉस्ट मोड हैं। --mode auto उस costUSD मान का उपयोग करता है जिसे Claude Code ने फ़ाइल में लिखा है जब वह मौजूद होता है, और जब वह नहीं होता है तो टोकन काउंट से गणना करता है। --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 पर एजेंट की लागत को सीमित रखने का विषय है।

Shape 3: अपना खुद का OpenTelemetry stack आपको बताता है कि कौन सा prompt regressed हुआ है

एक environment variable सेट करते ही Claude Code, OpenTelemetry metrics और events उत्सर्जित (emit) करना शुरू कर देता है। यह एकमात्र विकल्प है जो प्रति-उपयोगकर्ता (per-user) token और cost डेटा को आपके नियंत्रण वाले सिस्टम में लगभग वास्तविक समय (near real time) में स्ट्रीम करता है। इन metrics में USD में claude_code.cost.usage, tokens में claude_code.token.usage, claude_code.session.count और claude_code.active_time.total शामिल हैं।

Token metric सबसे महत्वपूर्ण है, क्योंकि इसके attributes काफी उपयोगी हैं। प्रत्येक डेटा पॉइंट में type होता है, जो input, output, cacheRead या cacheCreation हो सकता है, साथ ही model और query_source भी होते हैं, जो main, subagent या auxiliary हो सकते हैं। इसमें agent.name, skill.name, mcp_server.name और mcp_tool.name भी शामिल होते हैं। यह उन सवालों के जवाब देने के लिए पर्याप्त है जिन तक कोई भी 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 स्वीकार करता है। Claude Code metrics और log events निर्यात करता है, spans नहीं, इसलिए OTEL_EXPORTER_OTLP_ENDPOINT को Langfuse की ओर इंगित करने से प्रोजेक्ट खाली रहता है और आपको कोई उपयोगी error भी नहीं मिलता। Langfuse उन agents के लिए सही टूल है जिन्हें आप स्वयं API पर बनाते हैं, जहाँ आपका अपना कोड प्रत्येक span को उसके prompt, model और cost के साथ बनाता है। Claude Code CLI के लिए, एक metrics store ही सही विकल्प है।

अपने VPS पर Claude Code spend tracking सेट अप करें

दो services पर्याप्त हैं: metrics प्राप्त करने के लिए एक collector, और उन्हें स्टोर करने के लिए Prometheus। दोनों को public internet से दूर रखें, क्योंकि एक खुला 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 के अंदर सर्वर का पता है, इसलिए collector केवल आपकी मशीनों से ही reachable है और कहीं से नहीं। 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 service name के माध्यम से Compose network पर 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. पर समाप्त होना चाहिए। यदि log किसी config error पर रुकता है, तो इसका मतलब है कि YAML parse नहीं हुआ है, और container loop में restart होता रहेगा।

अब Claude Code को इसकी ओर point करें। 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"
  }
}

एक 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 पर जाता है, और बेमेल होने पर यह चुपचाप fail हो जाता है। claude --debug चलाएँ और debug log OTel export errors की रिपोर्ट करेगा।

एक मशीन और बिना सर्वर के लिए, उपरोक्त सभी को छोड़ दें। OTEL_METRICS_EXPORTER=prometheus सेट करें और Claude Code स्वयं http://localhost:9464/metrics पर एक scrape endpoint expose करता है। जब prometheus एकमात्र सूचीबद्ध exporter होता है, तो Claude Code metric names से USD, tokens और s units को हटा देता है ताकि scrape मान्य Prometheus text format में रहे।

इस संरचना के साथ एक privacy निर्णय जुड़ा है। default रूप से केवल counts मशीन से बाहर जाते हैं, कोई prompt text और कोई tool output नहीं। OTEL_LOG_USER_PROMPTS=1 और OTEL_LOG_TOOL_CONTENT=1 इसे बदल देते हैं, और फिर आपके metrics box में source code और context में मौजूद अन्य चीजें आ जाती हैं। उन्हें सोच-समझकर चालू करें, और पहले secrets को agent context से बाहर रखना पढ़ें।

स्क्रिप्टेड और CI रन के लिए खर्च को ट्रैक करना

Non-interactive रन लोगों को आश्चर्यचकित करते हैं, क्योंकि कोई भी स्क्रीन नहीं देख रहा होता है। claude -p, --output-format json के साथ अपने result payload में उस रन की लागत की रिपोर्ट करता है:

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

Payload में total_cost_usd और प्रति-मॉडल ब्रेकडाउन शामिल होता है, इसलिए एक CI जॉब बिना किसी डैशबोर्ड के अपने खर्च को रिकॉर्ड कर सकती है। मान को किसी फाइल में जोड़ें, या इसे ऊपर बताए गए कलेक्टर के लिए एक मेट्रिक के रूप में पुश करें। यह उपलब्ध सबसे सस्ता उपयोगी खर्च ट्रैकिंग तरीका है, और इसमें प्रति रन एक jq कॉल का खर्च आता है।

विफलता के प्रकार और आप क्या देखेंगे

रिपोर्ट खाली है। npx ccusage@latest daily यदि कोई पंक्ति प्रिंट नहीं हो रही है, तो इसका मतलब है कि यह उस स्थान से नहीं पढ़ रहा है जहाँ Claude Code लिखता है। CLAUDE_CONFIG_DIR उस स्थान को बदल देता है, और पार्सर को इसके बारे में सूचित करना आवश्यक है। यदि पंक्तियाँ मौजूद हैं लेकिन लगभग एक महीने पहले रुक गई हैं, तो यह cleanupPeriodDays है जो अपनी डिज़ाइन के अनुसार काम कर रहा है: डिफ़ॉल्ट रूप से 30 दिनों के बाद ट्रांसक्रिप्ट हटा दी जाती हैं।

दो मशीनें अलग-अलग कुल योग दिखा रही हैं। यह अपेक्षित है और कोई बग नहीं है। /usage और कोई भी लॉग पार्सर दोनों केवल स्थानीय सत्र इतिहास (local session history) को पढ़ते हैं, इसलिए किसी अन्य डिवाइस या claude.ai से किया गया उपयोग दोनों में अनुपस्थित रहता है।

स्थानीय कुल योग इनवॉइस से मेल नहीं खाता है। स्थानीय आंकड़े मानक सूची दरों पर टोकन गणना से निकाले जाते हैं। उन्हें प्रचार संबंधी मूल्य निर्धारण या अनुबंधित छूट के बारे में कोई जानकारी नहीं होती है, और सब्सक्रिप्शन पर आपके टोकन व्यक्तिगत रूप से बिल नहीं किए जाते हैं। API बिलिंग के लिए Console उपयोग पृष्ठ ही आधिकारिक है।

आपके द्वारा समान कार्य करने के बावजूद लागत बढ़ गई। किसी भी अन्य चीज़ से पहले कैश कॉलम की जाँच करें। एक लंबा सत्र हर टर्न पर अपना पूरा इतिहास फिर से भेजता है, जिसकी कीमत कैश गर्म होने पर कैश दर पर और ठंडा होने पर पूर्ण इनपुट दर पर होती है, इसलिए एक लंबा ब्रेक पूरी बातचीत को फिर से प्रोसेस करता है। यह एक छोटे आउटपुट नंबर के बगल में एक बड़े इनपुट नंबर के रूप में दिखाई देता है, और इनपुट बनाम आउटपुट टोकन मूल्य निर्धारण बताता है कि ये दोनों स्वतंत्र रूप से क्यों बदलते हैं।

सब-एजेंट्स वाला एक दिन असंभव लगता है। प्रत्येक सब-एजेंट अपनी स्वयं की कॉन्टेक्स्ट विंडो चलाता है, इसलिए टोकन का उपयोग इस आधार पर बढ़ता है कि कितने एजेंट चले और प्रत्येक कितने समय तक चला। केवल OTel डेटा ही उन्हें अलग करता है, जो claude_code.token.usage पर query_source एट्रिब्यूट के माध्यम से होता है। एक लॉग पार्सर आपको केवल कुल योग दिखाएगा और आपको अनुमान लगाने के लिए छोड़ देगा।

FAQ

क्या ccusage यह दिखाता है कि Max plan पर मुझसे वास्तव में कितना शुल्क लिया जा रहा है?

नहीं। सब्सक्रिप्शन पर आपसे प्रति टोकन शुल्क नहीं लिया जाता है, इसलिए एक लॉग पार्सर आपके टोकन को मानक API दरों पर आंकता है और यह दिखाता है कि वही काम API के माध्यम से करने पर कितना खर्च होता। यह इस बात का एक अच्छा सापेक्ष माप है कि किसी दिन कितना काम हुआ, और यह प्रोजेक्ट्स या मॉडल्स की आपस में तुलना करने के लिए उपयोगी है। आपको कितना भुगतान करना है, इसके लिए Console का usage पेज API बिलिंग को कवर करता है और प्लान बिलिंग पेज सब्सक्रिप्शन को कवर करता है।

Claude Code उन सेशन फाइलों को कहाँ स्टोर करता है जिन्हें ये टूल्स पढ़ते हैं?

~/.claude/projects/<project>/<session-id>.jsonl में, जहाँ <project> वर्किंग डायरेक्टरी पाथ है जिसमें नॉन-अल्फान्यूमेरिक कैरेक्टर्स को - से बदल दिया गया है। प्रत्येक लाइन एक मैसेज, टूल उपयोग या मेटाडेटा एंट्री के लिए एक JSON ऑब्जेक्ट है। CLAUDE_CONFIG_DIR पूरी डायरेक्टरी को मूव करता है, और settings.json में cleanupPeriodDays 30-दिन के रिटेंशन को नियंत्रित करता है। Anthropic एंट्री फॉर्मेट को आंतरिक मानता है और यह वर्जन्स के बीच बदल सकता है, इसलिए इसे अपनी स्क्रिप्ट के बजाय किसी मेंटेन किए जाने वाले टूल से पार्स करें।

क्या मैं Claude Code टेलीमेट्री को Langfuse पर भेज सकता हूँ?

सीधे नहीं। Langfuse OTLP एंडपॉइंट ट्रेसेस को स्वीकार करता है, और Claude Code स्पैन के बजाय मेट्रिक्स और लॉग इवेंट्स को एक्सपोर्ट करता है, इसलिए डेटा के लिए कोई गंतव्य नहीं है। Claude Code मेट्रिक्स को एक OpenTelemetry कलेक्टर पर भेजें और उन्हें Prometheus में स्टोर करें। Langfuse का उपयोग उन एजेंट्स के लिए करें जिन्हें आप स्वयं API पर बनाते हैं, जहाँ आपका अपना कोड ऐसे स्पैन उत्सर्जित करता है जो प्रॉम्प्ट, मॉडल और लागत को कैरी करते हैं।

मेरे स्थानीय नंबर Console के usage पेज से मेल क्यों नहीं खाते?

क्योंकि उनकी गणना अलग तरह से की जाती है। /usage और लॉग पार्सर उस मशीन पर सेशन फाइलों से टोकन काउंट को जोड़ते हैं जिस पर आप काम कर रहे हैं, फिर उन्हें मानक लिस्ट दरों पर आंकते हैं। Console यह रिपोर्ट करता है कि किसी भी छूट के बाद, हर मशीन और हर की (key) पर आपके संगठन से वास्तव में कितना शुल्क लिया गया। अंतर होना सामान्य है। बहुत बड़ा अंतर आमतौर पर यह दर्शाता है कि कोई दूसरा डिवाइस, CI रनर, या टीम का कोई अन्य सदस्य उसी अकाउंट पर बिलिंग कर रहा है।

मैं CI में claude -p रन की लागत को कैसे ट्रैक करूँ?

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