How to track Claude Code costs across a team in 2026

TL;DR

If you're a Head of Platform or VP Engineering trying to track Claude Code costs across your team, you have five real options: Anthropic's native console, ccusage (free OSS), Datadog LLM Observability, Helicone, and AIWatcher. Each solves a different slice of the problem.

The short answer:

• Solo developer or single team? ccusage is free and good enough.
• Anthropic-only shop? Anthropic Console handles the basics.
• Already on Datadog? Their LLM module is the lowest-friction add.
• Production AI in your product? Helicone or AIWatcher.
• Multi-tool team (Cursor + Claude Code + Codex)? AIWatcher.

The rest of this post explains why.

Why this is harder than it should be

A 50-engineer team running Claude Code, Cursor, and Codex CLI in parallel has three separate billing dashboards, three separate session models, and zero unified view. The CFO asks "what did AI cost us last month, by team?" and nobody has a clean answer.

This isn't a tooling deficit you can fix with a spreadsheet. Each AI tool stores usage differently — Claude Code writes session JSONL files locally, Cursor reports through its admin API, Codex CLI logs to its own format. None of them talks to the others.

So the question "how do we track Claude Code costs across the team?" usually means one of two things:

• "How do we track Claude Code costs just across the team" — solving for one tool, one surface
• "How do we track Claude Code costs alongside everything else we're paying for" — solving for the team-level AI bill

Most of the options below solve #1. Only one or two solve #2.

Option 1 — Anthropic Console (the native option)

What it is: Anthropic's admin dashboard for workspaces. Shows API usage, spend by API key, and basic team usage breakdowns.

What it does well:

• Free for paying Anthropic customers
• Real-time-ish usage data (updates within an hour)
• Per-key attribution if you've set up keys per developer or per project
• Workspace-level rollups

Where it breaks:

• Anthropic-only. Doesn't see Cursor, Codex, OpenAI, Gemini, or anything else
• No anomaly detection. You see the spend climbing but no alert fires
• No per-feature attribution in production AI. The console knows you spent $5K — it doesn't know which feature in your product caused it
• Anthropic themselves point customers toward third-party tools (notably LiteLLM) for proper team cost tracking

Use when: You're committed to Anthropic-only, your team is small enough that you can eyeball the workspace dashboard weekly, and you don't have AI in your product yet.

Honest caveat: Anthropic improves Console every quarter. The gap above is true today and will probably narrow over 2026.

Option 2 — ccusage (the free OSS option)

What it is: A command-line tool that reads Claude Code's local session files and shows token usage and cost by date, model, and session.

What it does well:

• Free, open source, instant install
• Runs locally on the developer's machine
• Shows per-session cost breakdowns
• Single-command setup

Where it breaks:

• Single-developer scope. There's no team rollup
• No alerting. You have to actively run ccusage to see usage
• Claude Code only. Doesn't see Cursor, Codex, or anything else
• No retention. You see what's in your local session files

Use when: You're an individual developer trying to manage your own usage, or you want to see your own session data quickly during a debug. ccusage is excellent for what it is — but it was never built to be a team tool.

Honest caveat: A lot of engineering managers I've talked to start with ccusage, hit the team-view wall, and then go shopping for something more. That's a natural progression, not a flaw in ccusage.

Option 3 — Datadog LLM Observability (the APM option)

What it is: Datadog's LLM observability module, extending their APM platform to include LLM call traces and cost attribution.

What it does well:

• Strong if your team is already on Datadog
• Production-grade reliability and infrastructure
• Real-time anomaly detection on cost and latency
• Integrates with your existing Datadog dashboards and alerts

Where it breaks:

• Requires OpenTelemetry instrumentation. Engineering work, not a switch
• Doesn't see developer-laptop AI usage. Datadog is built for production server-side telemetry; it has no visibility into Claude Code or Cursor running on a developer's machine
• Datadog pricing. The LLM module starts at $8 per 10K LLM requests on annual contracts, with a 100K request minimum

Use when: You're already on Datadog, your AI usage is primarily server-side (RAG pipelines, production agents), and you're willing to do the OpenTelemetry instrumentation work.

Honest caveat: Datadog is shipping fast in this space — their State of AI Engineering 2026 report explicitly calls out cost-aware AI as a future priority. Expect the LLM module to expand over 2026-2027.

Option 4 — Helicone (the LLM proxy option)

What it is: An open-source AI gateway. You route your LLM API calls through Helicone's proxy and get usage tracking, caching, and observability across providers.

What it does well:

• Fastest setup of any commercial tool — usually a single URL change
• Multi-provider support (OpenAI, Anthropic, Google, 300+ models)
• Built-in caching can reduce API costs 20-30% on repeated calls
• Free tier: 10K requests/month. Pro: $79/month. Team: $799/month with SOC 2.

Where it breaks:

• Proxy-based. Adds a network hop and creates a critical-path dependency
• Doesn't see developer-laptop AI usage. Claude Code and Cursor don't route through your proxy when developers use them locally
• Production-side coverage only. Strong for your app's AI calls; invisible to your team's coding tool usage

Use when: Your team's AI usage is primarily product-side (LLM calls flowing through your servers), and you want fast setup with multi-provider support.

Honest caveat: Helicone is the closest analog to AIWatcher in pricing and motion, but the surfaces are different. Helicone instruments API calls flowing through them; AIWatcher reads session files from the developer's laptop. Different problem, different mechanism.

Option 5 — Building it yourself

What it is: Writing a script that parses Claude Code's local JSONL session files, aggregates by user, and dumps to a Postgres table or Grafana dashboard.

What it does well:

• Maximum flexibility — you build exactly what you need
• No vendor risk
• Cheap upfront

Where it breaks:

• Real engineering cost. The pattern: 3 days to build, then ongoing maintenance every time Anthropic changes their session file format
• Doesn't scale beyond Claude Code without a second build
• Someone owns it. When that person leaves, the script breaks within a quarter

Use when: You have a strong platform engineering function with capacity, you only need Claude Code coverage, and you're confident the format won't change much.

Honest caveat: Most teams that build this internally end up replacing it within 18 months — either because the engineer who built it leaves, or because the team expands to a second AI tool and the script doesn't generalize.

Option 6 — AIWatcher

What it is: The operational layer for AI agents. One dashboard for cost and behavior across every coding tool your team uses internally and every AI feature in your product. Zero instrumentation for the local layer, one-line SDK for the product layer.

What it does well:

• Cross-tool coverage. Claude Code, Cursor, Codex CLI, Cline, Windsurf — one view
• Per-developer, per-project, per-team cost attribution
• Real-time anomaly alerts on runaway loops, abandoned sessions, and spend spikes
• Install in under an hour on developer machines. No code changes

Worth knowing (but not the reason to pick it for this problem): The same dashboard also covers the AI features in your product if you have them — RAG pipelines, customer support agents, AI-generated content. That's a bonus for teams that have both surfaces, not the core reason to pick AIWatcher for the laptop problem you're solving today.

Where it doesn't fit:

• If you're Anthropic-only and small, Anthropic Console is probably enough
• If you're already deeply on Datadog and want minimum context-switching, their LLM module is lower friction
• If you only need product-side LLM monitoring and don't care about developer-laptop usage, Helicone is faster to set up

Use when: You're a mid-market AI-native team running multiple coding agent tools, you have AI features in your product, and "the bill arrives as a mystery" is a real and recurring problem.

Honest caveat: We built AIWatcher because we caught a 10-day runaway pipeline on our own team that would have shown up as a $400 mystery on the next bill. If that story sounds familiar, the gap we're filling is the one you're feeling.

Request access: https://www.getaiwatcher.com/#request-access

The decision framework

Strip away the marketing and the question is really: where does your AI live, and how many tools do your team use?

Closing

If you remember one thing from this post: most teams find out about AI cost problems from the invoice, not from a dashboard. Whatever tool you pick from the list above, pick one that surfaces anomalies in real time — not one that just shows you the spend after it's already happened.

Danny is the founder of AIWatcher, the operational layer for AI agents. AIWatcher is in design partner mode with mid-market AI-native SaaS companies in 2026.