API based claude code cost monitoring like LiteLLM

[Palkers76]

Will it possible to use to monitor cc cost when using API like LiteLLM?

[Necmttn]

Yes, but I would treat API/LiteLLM usage as a second usage source, not as another shape inside the current Claude Code JSONL reader.

Current repo shape, as I read it:

• src/claude_monitor/data/reader.py is file-source oriented: load_usage_entries() defaults to ~/.claude/projects, _find_jsonl_files() recursively reads *.jsonl, and _map_to_usage_entry() maps each local transcript row into UsageEntry.
• TokenExtractor already supports a few API-ish token key variants (input_tokens, inputTokens, prompt_tokens, completion_tokens, cache fields), so token normalization can be reused.
• PricingCalculator.calculate_cost_for_entry() has a useful CostMode.CACHED path, but analyze_usage() currently calls load_usage_entries(... mode=CostMode.AUTO ...), so provider/proxy-reported cost is not guaranteed to win.
• UsageEntry only carries timestamp, token counts, cost_usd, model, message_id, and request_id. There is no source, provider, project, account, cost_source, or pricing_known field yet.
• SessionAnalyzer groups everything into 5-hour Claude Code blocks and the UI plan model is subscription-session oriented. API/LiteLLM usage does not naturally share the same quota semantics.

So the durable design would be a small source adapter layer:

class UsageSource(Protocol):
    def load_entries(self, hours_back: int | None) -> list[UsageEntry]: ...

class ClaudeJsonlSource:
    # current ~/.claude/projects reader

class LiteLlmSource:
    # reads LiteLLM spend/log export or API using configured base URL + token

Then extend UsageEntry enough to keep provenance through aggregation:

@dataclass
class UsageEntry:
    timestamp: datetime
    input_tokens: int
    output_tokens: int
    cache_creation_tokens: int = 0
    cache_read_tokens: int = 0
    cost_usd: float = 0.0
    model: str = ""
    message_id: str = ""
    request_id: str = ""
    source: str = "claude_jsonl"      # claude_jsonl | litellm | api_export
    provider: str = "anthropic"       # anthropic/openai/etc when known
    project_key: str | None = None
    cost_source: str = "calculated"   # provider | proxy | cached | calculated | unknown
    pricing_known: bool = True

The most important behavior difference: for LiteLLM/API rows, prefer proxy/provider-reported cost when available. Repricing from local token counts should be fallback only, because the proxy may already include provider-specific discounts, routing, model aliases, or non-Anthropic models. Today unknown model fallback defaults to Sonnet-like pricing unless strict=True; that is fine for local Claude-oriented best effort, but dangerous for a multi-provider API monitor. Unknown API models should surface as pricing_known=False / cost_source='unknown' rather than silently using Sonnet rates.

I would expose this as an explicit mode/source, for example:

claude-monitor --source claude-jsonl
claude-monitor --source litellm --litellm-url http://localhost:4000
claude-monitor --source both --view daily

For --source both, add a no-double-counting rule. If Claude Code is pointed at LiteLLM and local JSONL also has token rows for the same request, the monitor should not sum both. Dedupe needs to use source-specific ids (requestId, LiteLLM request/call id, provider request id) plus timestamp/model fallback, and the UI should be able to show JSONL cost, LiteLLM cost, and drift rather than merging them blindly.

I would also keep API mode out of subscription-limit warnings by default. Daily/monthly/API spend views make sense immediately; 5-hour Pro/Max block projections only make sense for Claude Code subscription sessions. Mixing API spend into the active 5-hour block would make the warning thresholds hard to interpret.

Acceptance tests I would add:

• existing Claude JSONL fixture still maps to the same UsageEntry values
• LiteLLM/proxy fixture with explicit cost uses that cost and marks cost_source='proxy'
• LiteLLM/proxy fixture without cost but known model falls back to calculation and marks cost_source='calculated'
• unknown API model does not silently price as Sonnet; it marks pricing_known=False
• --source both dedupes matching JSONL/proxy rows and can show drift
• API rows appear in daily/monthly totals but do not affect subscription-session limit detection unless a user opts in
• API token/base URL config is read from env/config and never printed in debug logs

---

Generated with ax.