Claude Code செலவு கண்காணிப்பு கருவிகள்: ஒப்பீடு

Claude Code செலவு கண்காணிப்பு கருவி உண்மையில் எதைப் படிக்கிறது

ஒவ்வொரு Claude Code செலவு கண்காணிப்பு கருவியும் மூன்று தரவு மூலங்களில் ஒன்றைப் படிக்கிறது. அந்த மூலமே, அந்தக் கருவியால் எந்தக் கேள்விக்கு பதிலளிக்க முடியும் என்பதைத் தீர்மானிக்கிறது. ஒரு log parser, உங்கள் வட்டில் உள்ள session transcript கோப்புகளைப் படிக்கிறது. ஒரு dashboard, உங்கள் கணக்கு அல்லது நிறுவனத்திற்காக Anthropic வைத்திருக்கும் பயன்பாட்டுப் பதிவுகளைப் படிக்கிறது. ஒரு metrics backend, Claude Code-ஐ நீங்கள் இயக்கும்போது அது வெளியிடும் OpenTelemetry (OTel) stream-ஐப் படிக்கிறது. இவை மூன்றிலும் சரியான தகவல்கள் இருந்தாலும், அவை வெவ்வேறு விஷயங்களைக் கணக்கிடுவதால், அவற்றுக்கிடையே முரண்பாடுகள் இருக்கலாம்.

இந்த வழிகாட்டி tokens பற்றிய விளக்கத்தை மீண்டும் வழங்கவில்லை. Claude Code எவ்வாறு token பயன்பாட்டைக் கணக்கிடுகிறது என்ற பகுதி, input, output, cache writes மற்றும் cache reads ஆகியவற்றைப் பற்றி விளக்குகிறது. அந்தப் பகுதி தெளிவாகத் தெரியாதவரை, எந்த dashboard-ம் பெரிய அளவில் பயன் தராது. இங்கே கேள்வி மிகவும் குறிப்பிட்டது: ஒவ்வொரு கருவியின் வடிவத்திற்கும், அது எதைப் பார்க்க முடியும், எதை ஒருபோதும் பார்க்க முடியாது?

ஒரே நாளில் ஏன் மூன்று Claude Code செலவு கண்காணிப்பான்கள் (spend trackers) தோன்றின

ஒரே நாளில் மூன்று தனித்தனி Claude Code செலவு கண்காணிப்பான்கள் வெளியிடப்பட்டன. இவை ஒரே கருவியின் மூன்று பதிப்புகள் அல்ல, இதுவே இதில் பயனுள்ள அம்சமாகும். ஒன்று உள்ளூர் session கோப்புகளைப் பகுப்பாய்வு செய்தது. மற்றொன்று கணக்கு பயன்பாட்டுத் திரைகளை (account usage screens) ஒருங்கிணைத்தது. மூன்றாவது, நீங்கள் சுயமாக இயக்கும் ஒரு hosted tracing backend ஆகும்.

ஏஜென்ட் session-ன் செலவு வெளிப்படையாகத் தெரியாமல் போனதால் இவை அனைத்தும் ஒரே நேரத்தில் வந்தன. ஒரு சாதாரண chat-ன் செலவு திரையில் தெரிவதைப் போலவே இருக்கும். ஆனால், ஒரு ஏஜென்ட் இருபது கோப்புகளைப் படித்து, test suite-ஐ இயக்கி, ஒவ்வொரு முறையும் முழு உரையாடலையும் மீண்டும் அனுப்புகிறது. எனவே, நீங்கள் தட்டச்சு செய்யாத context-களே கட்டணத்தை அதிகரிக்கின்றன. சந்தா முறையில் (subscription) டாலர் மதிப்பு தெரிவதில்லை, மாறாக சில நாட்களில் வேகமாகத் தீரும் ஒரு பயன்பாட்டுப் பட்டை (usage bar) மட்டுமே உள்ளது. இந்த மூன்று கண்காணிப்பான்களும் அந்த இடைவெளியின் வெவ்வேறு பகுதிகளை நிரப்புகின்றன.

வடிவம் 1: இன்றைய செலவை அறிய உதவும் local log parser

Claude Code ஒவ்வொரு உரையாடலையும் ~/.claude/projects/<project>/<session-id>.jsonl-ல் JSON Lines (JSONL) வடிவில் சேமிக்கிறது. இதில் <project> என்பது உங்கள் working directory பாதை, இதில் உள்ள non-alphanumeric எழுத்துக்கள் - மூலம் மாற்றப்பட்டிருக்கும். அந்த கோப்பில் உள்ள ஒவ்வொரு 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 தேதியின் அடிப்படையில் மொத்தத்தைக் காட்டுகிறது. --breakdown ஒவ்வொரு வரிசையையும் model வாரியாகப் பிரிக்கிறது; இதன் மூலம் ஒரு மதிய நேர Opus பயன்பாடுதான் வாரத்தின் பெரும்பகுதி செலவு என்பதை அறியலாம். blocks subscription reset ஆகும் ஐந்து மணிநேர இடைவெளியின் அடிப்படையில் தொகுக்கிறது. session ஒவ்வொரு உரையாடலுக்கும் மொத்தத்தைக் காட்டுகிறது, --instances project வாரியாகத் தொகுக்கிறது, இதன் மூலம் எந்த repository அதிக செலவை ஏற்படுத்துகிறது என்பதை அறியலாம். --since மற்றும் --until ஆகியவற்றைச் சேர்த்து கால அளவை வரையறுக்கவும், உங்கள் version-க்குத் தேவையான date format-க்காக npx ccusage@latest daily --help-ஐ இயக்கவும். ஆகஸ்ட் 2026 நிலவரப்படி, இது Codex மற்றும் OpenCode உள்ளிட்ட பிற agent CLI-களையும் வாசிக்கும்; நீங்கள் அவற்றை ஒப்பிடும்போது இது முக்கியமானது.

விலை நிர்ணயம் ஒரு model price table-லிருந்து பெறப்படுகிறது, மேலும் இந்த கருவியில் மூன்று cost modes உள்ளன. --mode auto, Claude Code கோப்பில் எழுதியுள்ள costUSD மதிப்பை அது இருக்கும்போது பயன்படுத்துகிறது, அது இல்லாதபோது token counts-லிருந்து கணக்கிடுகிறது. --mode calculate எப்போதும் tokens-லிருந்து மட்டுமே கணக்கிடுகிறது மற்றும் பதிவு செய்யப்பட்ட எந்த செலவையும் புறக்கணிக்கிறது. --mode display பதிவு செய்யப்பட்ட செலவுகளை மட்டுமே காட்டுகிறது மற்றும் செலவு இல்லாத வரிசைகளுக்கு $0.00 என்று அச்சிடுகிறது. ஒரு மொத்தம் தவறாகத் தெரிந்தால், அதே அறிக்கையை calculate மற்றும் பின்னர் display ஆகியவற்றுடன் இயக்கவும். அவற்றுக்கிடையே பெரிய வித்தியாசம் இருந்தால், பெரும்பாலான பதிவுகளில் பதிவு செய்யப்பட்ட செலவு இல்லை என்று அர்த்தம், எனவே நீங்கள் பார்ப்பது அனைத்தும் ஒரு மதிப்பீடு மட்டுமே.

அதே தரவை உங்கள் prompt-க்கு உள்ளீடாக வழங்கலாம். ccusage statusline, Claude Code status bar-க்காக ஒரு சிறிய வரியை அச்சிடுகிறது, இது மற்ற status line command-களைப் போலவே ~/.claude/settings.json-ல் இணைக்கப்பட்டுள்ளது. settings block மற்றும் அது பெறும் fields பற்றி அறிய Claude Code statusline உருவாக்குதல் என்பதைப் பார்க்கவும்.

இந்த machine-ல் நடக்காத எதையும் log parser-ஆல் பார்க்க முடியாது. இரண்டாவது laptop, claude.ai-ல் ஒரு session, சக ஊழியரின் பணி: இந்த transcripts அந்தந்த disks-ல் மட்டுமே இருக்கும். பழைய தரவுகளும் கிடைக்காது, ஏனெனில் cleanupPeriodDays setting-ன் கீழ் transcripts இயல்பாகவே 30 நாட்களுக்குப் பிறகு நீக்கப்படும், எனவே நீங்கள் archive செய்யாத வரை கடந்த கால தரவுகள் இருக்காது.

இதில் மற்றொரு ஆபத்து உள்ளது, அது கட்டமைப்பு சார்ந்தது. Anthropic-ன் ஆவணங்களின்படி, entry format என்பது Claude Code-ன் உட்புறமானது மற்றும் versions-க்கு இடையே மாறக்கூடியது. எனவே, இந்த கோப்புகளை நேரடியாக parse செய்யும் scripts எந்தவொரு release-லும் செயலிழக்கலாம். இது இந்த வடிவத்தில் உள்ள அனைத்து கருவிகளுக்கும் பொருந்தும். இதனால்தான் JSONL மீது கையால் எழுதப்பட்ட jq one-liner-ஐப் பயன்படுத்துவது பார்ப்பதற்கு எளிதாகத் தெரிந்தாலும், அது தவறான யோசனையாகும்: பராமரிக்கப்படும் parsers உங்களுக்காக format மாற்றங்களைக் கண்காணிக்கும், ஆனால் ஒரு field பெயர் மாற்றப்படும் நாளில் உங்கள் one-liner தவறான எண்ணை நம்பிக்கையுடன் காட்டும்.

இறுதியாக, subscription-ல் டாலர் மதிப்புக்கு ஒரு எச்சரிக்கை தேவை. Pro அல்லது Max திட்டங்களில் நீங்கள் token-க்கு பணம் செலுத்துவதில்லை, எனவே இந்த எண் உங்கள் tokens-ன் API பட்டியல் விலையின் மதிப்பீடு மட்டுமே. இது உங்கள் பயன்பாடு எவ்வளவு அதிகம் என்பதை அளவிடுகிறது. இது உங்கள் கட்டணப் பட்டியல் அல்ல. எந்தத் திட்டத்தைத் தேர்ந்தெடுக்க வேண்டும் என்பதுதான் உண்மையான கேள்வி என்றால், அந்த ஒப்பீடு ஒரு தனி செயல்முறை: API billing மற்றும் Claude subscription ஒப்பீடு என்பதைப் பார்க்கவும்.

வடிவம் 2: எந்த model பட்ஜெட்டை செலவழித்தது என்பதை உள்ளமைக்கப்பட்ட usage screens மூலம் அறிதல்

Claude Code அதன் சொந்த reporting வசதியைக் கொண்டுள்ளது, ஆனால் பெரும்பாலான பயனர்கள் அதைத் திறந்து பார்ப்பதில்லை. ஒரு session-க்குள் /usage கட்டளையை இயக்கவும். மேலே உள்ள Session பகுதியில், தற்போதைய session-க்கான tokens எண்ணிக்கை model வாரியாகவும், டாலர் மதிப்பிலும் காட்டப்படும். இது standard list rates-ஐ அடிப்படையாகக் கொண்டு உள்ளூர் அளவில் கணக்கிடப்படுகிறது. இந்தத் தொகை தள்ளுபடி அல்லது promotional விலைகளை உள்ளடக்கியது அல்ல என்பதால், உங்கள் invoice-ல் உள்ள தொகையிலிருந்து இது மாறுபடலாம். /clear மூலம் புதிய உரையாடலைத் தொடங்கும்போது இந்த மொத்தத் தொகைகள் reset செய்யப்படும்.

Pro, Max, Team அல்லது Enterprise திட்டங்களில், இதே திரையில் உங்கள் திட்ட வரம்பில் எவ்வளவு பயன்படுத்தப்பட்டுள்ளது என்பது காட்டப்படும். மேலும், சமீபத்திய பயன்பாடு skills, subagents, plugins மற்றும் தனிப்பட்ட MCP servers ஆகியவற்றின் அடிப்படையில் மொத்த சதவீதத்தில் பிரிக்கப்பட்டிருக்கும். நீண்ட context அல்லது cache misses போன்ற, சமீபத்திய பயன்பாட்டில் 10% அல்லது அதற்கு மேல் பங்களிக்கும் செயல்பாடுகளை இது சுட்டிக்காட்டும். கடந்த 24 மணிநேரம் மற்றும் கடந்த 7 நாட்களுக்கு இடையிலான தரவுகளை மாற்ற d அல்லது w அழுத்தவும். இந்த எண்கள் தோராயமானவை மற்றும் இந்த machine-ல் உள்ள local session history-லிருந்து கணக்கிடப்படுகின்றன, எனவே இரண்டாவது சாதனத்தின் பயன்பாடு இதில் கணக்கிடப்படாது. அந்தப் பட்டை காலியாக இருக்கும்போது, வரம்பு முடிந்துவிட்டது என்று திரை காட்டும், ஆனால் தொடர்ந்து வேலை செய்வது எப்படி என்று கூறாது. வரம்பை எட்டிய பிறகு என்ன செய்வது என்பது model, context மற்றும் திட்டம் சார்ந்த தனிப்பட்ட முடிவாகும்.

ஒரு developer-க்கு மேல் இருக்கும்போது, எண்கள் account நிலைக்குச் செல்லும். ஒரு API organisation-க்கு Console usage பக்கம் கிடைக்கும். இது ஒவ்வொரு உறுப்பினரின் செலவு மற்றும் ஏற்றுக்கொள்ளப்பட்ட வரிகளை (accepted lines) காட்டும் Claude Code dashboard ஆகும். மேலும், admin key மூலம் தினசரி பயனர் அளவிலான metrics-ஐ வழங்கும் Claude Code Analytics API-யும் இதில் உண்டு. Teams மற்றும் Enterprise திட்டங்களில், தினசரி புதுப்பிக்கப்படும் CSV export வசதியுடன் கூடிய spend report, admin console-ல் கிடைக்கும். Enterprise திட்டத்தில் analytics API கூடுதலாகச் சேர்க்கப்படும். நீங்கள் எதைப் பார்க்கிறீர்கள் என்பது ஒவ்வொரு developer-ம் எவ்வாறு sign in செய்தார்கள் என்பதைப் பொறுத்தது. எனவே, கலப்பு அமைப்பு கொண்ட நிறுவனங்கள் இரண்டு அறிக்கைகளைப் பெற்று, அவற்றை நீங்களே கூட்டிப் பார்க்க வேண்டும்.

பட்ஜெட்டைத் தீர்மானிக்க, ஆகஸ்ட் 2026 நிலவரப்படி Anthropic-ன் cost documentation-ல் வெளியிடப்பட்ட சராசரி புள்ளிவிவரத்தின்படி, ஒரு developer-க்கு ஒரு active நாளுக்கு சுமார் $13 மற்றும் ஒரு மாதத்திற்கு $150 முதல் $250 வரை செலவாகிறது. 90% பயனர்களுக்கு ஒரு active நாளுக்கு $30-க்கும் குறைவாகவே செலவாகிறது. இதை enterprise deployments-க்கான ஒரு benchmark-ஆகக் கருத வேண்டுமே தவிர, உங்கள் குழுவிற்கான கணிப்பாகக் கருத வேண்டாம். ஒரு pilot குழுவை இயக்கி, தரவுகளை அளந்த பிறகு முடிவெடுக்கவும்.

இந்த dashboards-ஆல் ஒரு நாளுக்குக் குறைவான அல்லது ஒரு நபருக்குக் குறைவான விவரங்களைக் காண முடியாது. செவ்வாய்க்கிழமை அன்று Opus அதிகப்படியாகப் பயன்படுத்தப்பட்டது என்பதை இவை சொல்லும். ஆனால் எந்த prompt, எந்த repository அல்லது எந்த CI job-ஆல் அது நடந்தது என்று சொல்லாது. இவை தினசரி புதுப்பிக்கப்படுவதால், இவை ஒரு review கருவியே தவிர, தற்போதைய நேரத்தில் கட்டுப்பாடின்றிச் செயல்படும் agent-ஐக் கண்டறியும் கருவி அல்ல. கட்டுப்பாடின்றிச் செயல்படும் agent-ஐக் கட்டுப்படுத்த அறிக்கைகள் போதாது, அதற்கு வரம்புகள் தேவை. இது VPS-ல் agent செலவுகளைக் கட்டுப்படுத்துதல் பகுதியில் விவரிக்கப்பட்டுள்ளது.

வடிவம் 3: உங்கள் சொந்த OpenTelemetry stack மூலம் எந்த prompt தரம் குறைந்தது என்பதைக் கண்டறிதல்

ஒரு environment variable-ஐ அமைத்தவுடன், Claude Code ஆனது OpenTelemetry metrics மற்றும் events-ஐ வெளியிடுகிறது. உங்கள் கட்டுப்பாட்டில் உள்ள ஒரு அமைப்பிற்கு, பயனர் வாரியான token மற்றும் கட்டணத் தரவுகளை நிகழ்நேரத்திற்கு நெருக்கமான வேகத்தில் அனுப்பும் ஒரே வழி இதுதான். இந்த metrics-ல் USD-ல் claude_code.cost.usage, tokens-ல் claude_code.token.usage, 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-ஆலும் பதிலளிக்க முடியாத கேள்விகளுக்குப் பதிலளிக்க இது போதுமானது: உங்கள் சொந்த பயன்பாட்டை விட 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 ஆனது spans-ஐ அல்லாமல், metrics மற்றும் log events-ஐ மட்டுமே ஏற்றுமதி செய்கிறது. எனவே, OTEL_EXPORTER_OTLP_ENDPOINT-ஐ Langfuse-க்குத் திருப்புவது திட்டத்தை காலியாகவே வைத்திருக்கும் மற்றும் படிக்கத் தகுந்த எந்தப் பிழையையும் காட்டாது. நீங்கள் API-ல் சொந்தமாக உருவாக்கும் agents-க்கு Langfuse சரியான கருவியாகும், அங்கு உங்கள் சொந்த code ஒவ்வொரு span-ஐயும் அதன் prompt, model மற்றும் கட்டணத்துடன் உருவாக்குகிறது. Claude Code CLI-க்கு, ஒரு metrics store-தான் பொருத்தமானது.

உங்கள் சொந்த VPS-ல் Claude Code செலவு கண்காணிப்பை அமைத்தல்

இதற்கு இரண்டு சேவைகள் போதுமானது: அளவீடுகளைப் பெற ஒரு collector மற்றும் அவற்றைச் சேமிக்க Prometheus. இரண்டையும் பொது இணையத்திலிருந்து மறைத்து வைக்கவும், ஏனெனில் திறந்திருக்கும் OTLP port-ஐக் கண்டறியும் எவரும் தரவுகளை எழுத முடியும். /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-ன் முகவரி ஆகும். எனவே, உங்கள் கணினிகளிலிருந்து மட்டுமே collector-ஐ அணுக முடியும். port-க்கு முன்னால் உள்ள முகவரி மிக முக்கியமானது, ஏனெனில் Docker மூலம் வெளியிடப்படும் ports-ஐ ufw வடிகட்டுவதில்லை: 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-க்கு வெளியிடப்படுவதில்லை, ஏனெனில் Prometheus ஆனது Compose network வழியாக service பெயரைப் பயன்படுத்தி 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 பிழையால் log நின்றால், YAML சரியாக parse ஆகவில்லை என்று அர்த்தம்; container தொடர்ந்து restart ஆகிக்கொண்டே இருக்கும்.

இப்போது 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"
  }
}

ஒரு session-ஐத் தொடங்கி, ஒரு prompt-ஐ அனுப்பி, export interval (இங்கே 10 வினாடிகள், இயல்பாக 60 வினாடிகள்) முடியும் வரை காத்திருக்கவும். பிறகு Prometheus-யிடம் தரவுகளைக் கேட்கவும்:

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

claude_code_ என்று தொடங்கும் பல பெயர்கள் உங்களுக்குக் கிடைக்க வேண்டும். Exporter புள்ளிகளை underscore-ஆக மாற்றி, அலகுகளை (units) இணைக்கும்; எனவே துல்லியமான strings உங்கள் collector பதிப்பைப் பொறுத்தது. முடிவு காலியாக இருந்தால், எந்தத் தரவும் வரவில்லை என்று அர்த்தம். Protocol மற்றும் port சரியாக உள்ளதா எனச் சரிபார்க்கவும், ஏனெனில் http/protobuf என்பது 4318-க்கும், grpc என்பது 4317-க்கும் செல்லும்; இவை பொருந்தவில்லை எனில் பிழை காட்டாமல் செயல் தோல்வியடையும். claude --debug-ஐ இயக்கினால், debug log-ல் OTel export பிழைகள் பதிவாகும்.

ஒரே ஒரு கணினிக்கு மட்டும் என்றால், மேலே உள்ள எதையும் செய்யத் தேவையில்லை. OTEL_METRICS_EXPORTER=prometheus-ஐ அமைத்தால், Claude Code ஆனது http://localhost:9464/metrics-ல் ஒரு scrape endpoint-ஐ உருவாக்கும். prometheus மட்டுமே exporter-ஆக இருக்கும்போது, scrape-ஐச் சரியான Prometheus text format-ல் வைத்திருக்க, Claude Code ஆனது USD, tokens மற்றும் s அலகுகளை metric பெயர்களிலிருந்து நீக்கிவிடும்.

இந்த அமைப்பில் ஒரு தனியுரிமை முடிவு உள்ளது. இயல்பாக, எண்ணிக்கை (counts) மட்டுமே கணினியை விட்டு வெளியேறும்; prompt உரையோ அல்லது tool வெளியீடோ வெளியேறாது. OTEL_LOG_USER_PROMPTS=1 மற்றும் OTEL_LOG_TOOL_CONTENT=1 ஆகியவற்றை மாற்றினால், உங்கள் metrics பெட்டியில் source code மற்றும் context-ல் உள்ள பிற தகவல்கள் சேமிக்கப்படும். இவற்றை கவனமாகச் செயல்படுத்தவும், தொடங்கும் முன் agent context-லிருந்து ரகசியங்களை எவ்வாறு பாதுகாப்பது என்பதைப் படிக்கவும்.

ஸ்கிரிப்ட் மற்றும் CI ஓட்டங்களுக்கான செலவைக் கண்காணித்தல்

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 மற்றும் ஒவ்வொரு model-க்குமான தனித்தனி செலவு விவரங்களைக் கொண்டுள்ளது, எனவே ஒரு CI job எந்த dashboard-ம் இல்லாமலேயே தனது சொந்த செலவைப் பதிவு செய்ய முடியும். இந்த மதிப்பை ஒரு கோப்பில் சேர்க்கலாம் அல்லது மேலே குறிப்பிட்ட collector-க்கு ஒரு metric-ஆக அனுப்பலாம். இதுவே செலவைக் கண்காணிக்கக் கிடைக்கும் மிக மலிவான மற்றும் பயனுள்ள வழியாகும், இதற்கு ஒரு ஓட்டத்திற்கு ஒரு jq அழைப்பு மட்டுமே தேவைப்படும்.

தோல்வி முறைகளும் நீங்கள் காண்பவை

அறிக்கை காலியாக உள்ளது. npx ccusage@latest daily எந்த வரிசைகளையும் அச்சிடவில்லை என்றால், Claude Code எழுதும் இடத்தை அது வாசிக்கவில்லை என்று அர்த்தம். CLAUDE_CONFIG_DIR அந்த இடத்தை மாற்றுகிறது, எனவே அதைப்பற்றி parser-க்கு தெரிவிக்க வேண்டும். வரிசைகள் உள்ளன, ஆனால் ஒரு மாதத்திற்கு முந்தைய தரவுகளுடன் நின்றுவிடுகின்றன என்றால், அது cleanupPeriodDays வடிவமைக்கப்பட்டபடி செயல்படுகிறது என்று பொருள்: இயல்பாகவே 30 நாட்களுக்குப் பிறகு உரையாடல் பதிவுகள் நீக்கப்படும்.

இரண்டு கணினிகள் வெவ்வேறு மொத்தங்களைக் காட்டுகின்றன. இது எதிர்பார்க்கப்படுவதுதான், இது பிழை அல்ல. /usage மற்றும் எந்தவொரு log parser-ம் உள்ளூர் அமர்வு வரலாற்றை (local session history) மட்டுமே வாசிக்கும், எனவே மற்றொரு சாதனத்திலிருந்தோ அல்லது claude.ai-லிருந்தோ பயன்படுத்தப்பட்ட தரவுகள் இரண்டிலும் இருக்காது.

உள்ளூர் மொத்தத் தொகை விலைப்பட்டியலுடன் (invoice) பொருந்தவில்லை. உள்ளூர் புள்ளிவிவரங்கள் நிலையான பட்டியல் விலையில் உள்ள token எண்ணிக்கையிலிருந்து கணக்கிடப்படுகின்றன. அவற்றுக்கு விளம்பர விலை அல்லது ஒப்பந்தத் தள்ளுபடி பற்றித் தெரியாது, மேலும் சந்தா முறையில் உங்கள் tokens தனித்தனியாகக் கணக்கிடப்படுவதில்லை. API கட்டணங்களுக்கு Console usage பக்கமே அதிகாரப்பூர்வமானது.

ஒரே வேலையைச் செய்தபோதும் செலவு அதிகரித்துள்ளது. மற்ற எதையும் சரிபார்க்கும் முன் cache நெடுவரிசைகளைச் சரிபார்க்கவும். ஒரு நீண்ட அமர்வு ஒவ்வொரு முறையும் அதன் முழு வரலாற்றையும் மீண்டும் அனுப்புகிறது; cache சூடாக இருக்கும்போது அது குறைந்த விலையிலும், cache குளிர்ந்த பிறகு முழு உள்ளீட்டு விலையிலும் கணக்கிடப்படும், எனவே ஒரு நீண்ட இடைவெளி முழு உரையாடலையும் மீண்டும் செயலாக்கும். இது சிறிய வெளியீட்டு எண்ணிற்கு அருகில் பெரிய உள்ளீட்டு எண்ணாகக் காட்டப்படும், மேலும் input against output token pricing இவை இரண்டும் ஏன் தனித்தனியாக மாறுகின்றன என்பதை விளக்குகிறது.

துணை முகவர்களுடன் (subagents) ஒரு நாள் என்பது சாத்தியமற்றதாகத் தெரிகிறது. ஒவ்வொரு துணை முகவரும் அதன் சொந்த context window-ல் இயங்குகிறது, எனவே எத்தனை முகவர்கள் இயங்கின மற்றும் ஒவ்வொன்றும் எவ்வளவு காலம் நீடித்தன என்பதைப் பொறுத்து token பயன்பாடு அதிகரிக்கும். OTel தரவு மட்டுமே அவற்றை, claude_code.token.usage-ல் உள்ள query_source பண்புக்கூறு மூலம் பிரிக்கிறது. ஒரு log parser உங்களுக்கு மொத்தத்தைக் காட்டும், ஆனால் எதனால் இந்த மாற்றம் என்று நீங்கள் ஊகிக்க வேண்டியிருக்கும்.

FAQ

Max plan-ல் எனக்கு விதிக்கப்படும் கட்டணத்தை ccusage காட்டுகிறதா?

இல்லை. சந்தா (subscription) முறையில் நீங்கள் token அடிப்படையில் கட்டணம் செலுத்துவதில்லை. எனவே, ஒரு log parser உங்கள் token-களுக்கு நிலையான API விலையை நிர்ணயித்து, அதே பணிக்கு API மூலம் எவ்வளவு செலவாகியிருக்கும் என்பதைக் காட்டுகிறது. ஒரு நாளில் எவ்வளவு பணிச்சுமை இருந்தது என்பதை ஒப்பிட்டுப் பார்க்க இது ஒரு சிறந்த அளவீடு; திட்டங்கள் அல்லது model-களை ஒன்றுடன் ஒன்று ஒப்பிடுவதற்கு இது பயனுள்ளதாக இருக்கும். நீங்கள் செலுத்த வேண்டிய கட்டணத்தைப் பொறுத்தவரை, Console usage பக்கம் API கட்டணத்தையும், plan billing பக்கம் சந்தாக் கட்டணத்தையும் காட்டுகிறது.

இந்த கருவிகள் வாசிக்கும் session கோப்புகளை Claude Code எங்கே சேமிக்கிறது?

~/.claude/projects/<project>/<session-id>.jsonl-ல் சேமிக்கிறது. இதில் <project> என்பது working directory-ன் பாதை ஆகும், இதில் எழுத்துக்கள் மற்றும் எண்கள் அல்லாத குறியீடுகள் - மூலம் மாற்றப்பட்டிருக்கும். ஒவ்வொரு வரியும் ஒரு message, tool use அல்லது metadata உள்ளீட்டிற்கான JSON object ஆகும். CLAUDE_CONFIG_DIR முழு directory-யையும் நகர்த்துகிறது, மேலும் cleanupPeriodDays-ல் உள்ள settings.json, 30-நாள் தரவு சேமிப்பு காலத்தைக் (retention) கட்டுப்படுத்துகிறது. இந்த உள்ளீட்டு வடிவம் (entry format) உள்நிலை சார்ந்தது மற்றும் பதிப்புகளுக்கு இடையே மாறக்கூடியது என்று Anthropic குறிப்பிடுகிறது. எனவே, உங்கள் சொந்த script-ஐப் பயன்படுத்துவதற்குப் பதிலாக, பராமரிக்கப்படும் ஒரு கருவியைப் பயன்படுத்தி அதை parse செய்யவும்.

Claude Code telemetry-ஐ Langfuse-க்கு அனுப்ப முடியுமா?

நேரடியாக முடியாது. Langfuse OTLP endpoint traces-களை மட்டுமே ஏற்கும். Claude Code, spans-களுக்குப் பதிலாக metrics மற்றும் log events-களை மட்டுமே வெளியிடுகிறது, எனவே அந்தத் தரவை அங்கு அனுப்ப முடியாது. Claude Code metrics-களை ஒரு OpenTelemetry collector-க்கு அனுப்பி, அவற்றை Prometheus-ல் சேமிக்கவும். நீங்கள் API-ல் சொந்தமாக உருவாக்கும் agents-களுக்கு Langfuse-ஐப் பயன்படுத்தவும்; அங்கு உங்கள் சொந்த code, prompt, model மற்றும் செலவு விவரங்களைக் கொண்ட spans-களை வெளியிடும்.

எனது உள்ளூர் எண்கள் ஏன் Console usage பக்கத்துடன் ஒத்துப்போவதில்லை?

ஏனெனில் அவை கணக்கிடப்படும் முறை வேறுபட்டது. /usage மற்றும் log parsers, நீங்கள் பயன்படுத்தும் கணினியில் உள்ள session கோப்புகளிலிருந்து token எண்ணிக்கையைக் கூட்டி, நிலையான விலையில் கணக்கிடுகின்றன. Console, உங்கள் நிறுவனத்திற்கு அனைத்து கணினிகள் மற்றும் அனைத்து keys-களிலும், தள்ளுபடிக்குப் பிறகு உண்மையில் விதிக்கப்பட்ட கட்டணத்தை அறிக்கையாகத் தருகிறது. இதில் சிறிய வித்தியாசம் இருப்பது இயல்பானது. பெரிய வித்தியாசம் இருந்தால், மற்றொரு சாதனம், CI runner அல்லது குழுவின் மற்றொரு உறுப்பினர் அதே கணக்கைப் பயன்படுத்துகிறார்கள் என்று அர்த்தம்.

CI-ல் ஒரு claude -p run-ன் செலவை எவ்வாறு கண்காணிப்பது?

அதை --output-format json உடன் இயக்கி, முடிவிலிருந்து total_cost_usd-ஐ வாசிக்கவும். உதாரணமாக claude -p "..." --output-format json | jq '.total_cost_usd'-ஐப் பயன்படுத்தலாம். அதே payload-ல் model வாரியான பிரிப்பு மற்றும் session ID ஆகியவை அடங்கும். ஒவ்வொரு job-க்கும் அந்த மதிப்பைச் சேமிப்பதன் மூலம், எந்தவொரு agent, dashboard அல்லது கூடுதல் சேவை இல்லாமலேயே pipeline வாரியான செலவை நீங்கள் அறியலாம்.