How do I monitor Claude Code sessions?

Install ClawMetry (pip install clawmetry, or the one-liner installer at clawmetry.com/install.sh). The daemon auto-detects Claude Code and renders every session, tool call, model, and token in one dashboard at http://localhost:8900. No SDK, no code change, no wrapper around your API key.

Does ClawMetry track Claude Code token cost per session?

Yes. ClawMetry reports cache-aware cost per turn, so cached reads are priced separately from fresh input and computes cache-aware cost per session, per model, per hour. The Cost tab rolls up per-runtime so you can compare Claude Code spend against Codex, Cursor, and the other 19 runtimes ClawMetry observes.

Does ClawMetry work with the Claude Code Max plan and Pro OAuth?

Yes. ClawMetry reads the transcripts Claude Code writes regardless of how it authenticates: Anthropic API key, Claude Pro OAuth, or Claude Max. The Cost tab labels turns billed against a subscription (rather than API) so you see cost coverage correctly.

How do I see prompt cache hit rate for Claude Code?

ClawMetry surfaces cache-read vs uncached-input tokens for every Claude Code call. The Cost tab shows cache hit rate per session and per prompt, so you can identify sessions that would benefit from prompt caching (long system prompts, many turns) and confirm caching is actually landing after you enable it.

Can ClawMetry catch a Claude Code sub-agent that goes into a runaway loop?

Yes. ClawMetry watches per-turn token growth and message-repeat signals across parent sessions and sub-agents. When a session is token-maxing (a runaway loop) the approval queue flags it and the kill switch (Pro) stops the session before the next call. This is the same guard that catches the Claude Code Task tool spawning sub-agents that stall.

Claude Code × ClawMetry

Observability and cost tracking for Claude Code

See every Claude Code session, tool call, and token as it happens. ClawMetry detects Claude Code automatically and renders sessions, tokens, cost, and sub-agent trees in one dashboard. No SDK. No wrapper around your API key.

3rd most-observed runtime Zero config, auto-detected Cache-aware cost tracking Sub-agent trees Official Claude Code site ↗

📦 631k+ installs 🌍 128+ countries ⭐ 392 on GitHub 🏆 #5 Product Hunt

What ClawMetry sees on Claude Code

Claude Code records every session locally. Every user message, assistant turn, tool call (Bash, Read, Edit, Task), and sub-agent run is captured, and ClawMetry turns that into a readable timeline with per-turn tokens and cost.

Sessions: which workspace, which model (Sonnet, Opus, Haiku), started at, last activity, message count, per-session token totals.
Live activity: every tool call as it lands, with args and result. Turn-level tokens split into input, output, cache-read, and cache-write.
Sub-agent trees: when Claude Code spawns a Task sub-agent, ClawMetry shows the tree with each child's own tokens and tools rolled up under the parent turn.
Cost per session, per model, per hour: cache-aware, so cache-read tokens are billed at the cache rate. Compare Claude Code spend against Codex, Cursor, and the other 19 runtimes side by side.
Model routing: which Claude model each turn used, when the session switched models, and whether the routing choice made sense in retrospect.
Approval + kill switch: watch parent + sub-agent for token-maxing signals (message repeat, no-progress heuristic, cost-per-hour threshold), pause or kill the session before the next call.

Enable it in about two minutes

1. Install ClawMetry

Pick the line that matches your OS. Windows users: paste the install.cmd line, not the shell one.

# macOS or Linux
curl -fsSL https://clawmetry.com/install.sh | bash

# Windows (cmd.exe or PowerShell)
curl -fsSL https://clawmetry.com/install.cmd -o install.cmd && install.cmd

Already have Python? pip works too; onboard is the interactive first-run wizard.

# Any OS with Python 3.9+
pip install clawmetry && clawmetry onboard

Or skip the terminal entirely and grab the desktop app: macOS (.dmg) · Windows (.exe) · Linux (.AppImage). It installs and updates ClawMetry for you.

2. Run the daemon

clawmetry

The daemon auto-detects Claude Code and starts reading Claude Code transcripts immediately. No env var, no config, no runtime restart.

3. Open the dashboard

Open http://localhost:8900. Switch the runtime chip to Claude Code.

Start the free trial →

Works with Anthropic API, Claude Pro, and Claude Max

ClawMetry reads the transcripts Claude Code writes regardless of how it authenticates: Anthropic API key, Claude Pro OAuth, or Claude Max subscription. Turns billed against a subscription (rather than API) are labelled correctly on the Cost tab so you see cost coverage rather than a false zero.

Cache hit rate: the single biggest cost lever

For long-system-prompt sessions (most Claude Code workflows have a 3000-6000 token system prompt), Anthropic prompt caching saves about 90 percent of input cost on cache hits. ClawMetry surfaces cache-read vs uncached-input tokens per call, so you can:

Identify sessions with low hit rate that would benefit from restructuring the prompt.
Confirm caching is actually landing after you enable it (a common bug: the cache breakpoint drifts and hit rate silently drops to zero).
Compare cache ratios across Sonnet, Opus, and Haiku on the same workload.

See the caching and reuse guide (in the pipeline) for the tactics themselves; ClawMetry shows you which ones are actually working.

Sub-agent trees the Task tool creates

Claude Code's Task tool spawns sub-agents that run their own turn tree, and their tokens land on the parent session's bill. ClawMetry shows the parent turn with each sub-agent as a nested tree, per-sub-agent token totals, and the tool calls each one made. A parent that spawns 4 Task sub-agents that each burn 20k tokens is now a single visible number (80k) instead of five separate mysteries.

What each tab shows for Claude Code

Tab	What it shows	Scope
Sessions	Every Claude Code session, sorted by last activity, with workspace, model, and token totals	All workspaces, or one
Brain	Live entries as they land: user messages, tool calls, sub-agent spawns, thinking	Whole node, or one session
Cost	Per-session, per-model, per-hour token spend; cache-read vs uncached-input split	Runtime = claude_code, or all
Sub-agents	Task tool spawn tree with per-sub-agent tokens and tools	Per session
Approvals	Pause + kill switch for token-maxing sessions and risky tool calls	Runtime-filtered

How this compares to Claude Code's own view

Claude Code shows current session state and per-turn tokens inside the CLI. What it does not show is cost per hour across sessions and workspaces, cache hit rate per model, sub-agent token attribution rolled up under the parent, or a kill switch when a Task sub-agent is token-maxing. Those are the things a team running Claude Code on a real budget needs on day one; they are what ClawMetry adds. See the cost-per-hour visibility page and the token-maxing page for how these work end to end.