TokenWatch monitors Claude Code and Cursor token costs by developer, project, and client — so agencies stop eating AI margin on fixed-price contracts.
Set up in 5 minutes. No onboarding call required.
Maintains session continuity across Claude Code, Cursor, and Cline — no tagging, no workflow changes.
Live billing report — May 2026
| Client / Project | Tokens | Est. Cost | Billable | Margin | Status |
|---|---|---|---|---|---|
Acme Retail E-Commerce Replatform |
48.2M | $6,840 | $6,840 | 3.8% | Unbilled |
BuildFast Inc ▲ spike CI/CD Modernisation |
36.1M | $5,120 | $5,120 | 7.2% | Unbilled |
| TTheo ▲ 3.1× avg | 24.4M | $3,460 | $3,460 | 68% | |
| JJordan | 11.7M | $1,660 | $1,660 | 32% | |
NovaSpark AI Feature Sprint |
21.8M | $3,090 | $2,860 | 2.1% | Billed |
Meridian Labs Data Pipeline Rebuild |
15.3M | $2,290 | $2,290 | 1.6% | Billed |
| 8 projects · 11 developers | $17,340 | $14,820 | |||
The problem
01
Claude, Cursor, Cline — one invoice, no breakdown. Your team can't remember what they were working on. You have no evidence either way.
02
Without attribution, cost allocation is political, not factual. The client who ran a tight sprint pays the same as the one who ran three rewrites.
03
You quoted the job. You didn't quote the AI. There's no line item to pass through — so the cost comes straight out of your profit.
TokenWatch only captures token counts, costs, model, git branch, and developer identity. Zero code content. Zero prompt content. Nothing leaves your machine except usage metadata.
One command sets up the repo. After that, every Claude Code, Cursor, and Cline session flows to the dashboard automatically — developer identity from git config, project from git remote.
The output is a per-client cost summary you can attach to an invoice. The analytics page gives you client, project, and developer-level attribution — so you know exactly where spend is going before it hits your margin.
Captured per session
Never captured
What you can do
Built for agency billing workflows — not developer monitoring or ops dashboards.
Filter AI spend by client before every invoice. See exactly what's recoverable and what needs review — before you send the bill.
Unusual sessions flagged automatically with the developer and project responsible. Catch cost anomalies before your client sees them.
Know who spent what, on which project. Identity resolved from git config automatically — zero manual tagging required.
Every session tied to the feature branch it was worked on. Attribution at the feature level, not just the developer.
Export a per-client summary ready to attach to an invoice. One click. No spreadsheet wrangling, no copy-paste.
All three major AI coding tools captured from a single install. One dashboard, one billing report, regardless of what your team uses.
We just stare at the bill and argue. Someone pastes it into a doc and everyone tries to remember what they were working on that week.
— Dev Agency, Toronto
TokenWatch captures token usage from Claude Code, Cursor, and Cline and maps each session to a client project via git remote URL — no manual tagging required.
No. After a one-time npx @tokenwatch/cli init per repo, every Claude Code session is captured automatically — developers use their tools exactly as before.
Export a per-client cost summary from TokenWatch and add it as a line item — the report breaks down spend by developer, project, and model so clients can verify the charges.
Yes. TokenWatch captures the active git branch on every session, so the dashboard shows cost per branch alongside cost per developer and project — useful for identifying which features drove the bill.
Limited early access
Recover AI coding costs from client work.
Founding price locked for life
for early customers.
Common questions
TokenWatch is an AI coding cost attribution tool for dev agencies. It tracks AI usage from Claude Code, Cursor, and Cline by client, project, and developer so agencies can recover that spend as billable revenue.
TokenWatch supports Claude Code via MCP stop hook, and Cursor and Cline via an HTTP proxy. Windsurf support is in progress.
TokenWatch uses git remote URLs to infer the project automatically, and git branch to capture context. Developer identity comes from git config user.email. Every AI session is mapped to a developer, project, and client without manual tagging.
Claude token monitoring means tracking exactly how many tokens each developer consumes across Claude Code sessions — broken down by project, client, and billing period. For dev agencies on fixed-price contracts, the total Anthropic invoice is visible but the breakdown is not. Without per-developer, per-project token monitoring, agencies absorb AI costs as unattributed overhead. TokenWatch captures every Claude Code turn at the IDE level, attributes tokens to the correct project using git context, and surfaces the breakdown in a billing dashboard your PM or agency owner can act on.
TokenWatch installs a stop hook into Claude Code via an MCP server. After every response, it reads token usage — input, output, cache creation, and cache reads — from the session transcript, resolves the git remote URL to identify the project, and attributes the cost to the developer whose git identity ran the session. Agency owners see a cost breakdown by client, project, and developer for any billing period. Each line item is exportable as a PDF invoice or CSV, ready to attach to a client bill or use internally for margin analysis.
Claude cost monitoring for dev teams means converting a single monthly Anthropic bill into attributed line items — which client, which project, which developer, and which billing period generated each dollar of spend. This matters most for agencies running fixed-price contracts, where unattributed AI costs come directly out of margin. TokenWatch tracks Claude Code usage across your entire team, maps every session to a project using git remote URL, and lets you recover those costs as billable revenue on client invoices instead of absorbing them silently.
Yes. Claude Code cost monitoring for teams is TokenWatch's core use case. One agency-wide ingest key covers your entire team — each developer runs a one-time setup via npx @tokenwatch/cli init, and from that point on every Claude Code session is captured automatically. Token usage is attributed by developer identity (resolved from git config), project (resolved from git remote URL), and branch. The agency owner sees a unified dashboard showing total AI spend by client and project, with per-developer breakdowns. Cursor and Cline are also supported. Pricing is $99/month per agency regardless of team size.
We'll reach out when TokenWatch is ready for your team.