AI Coding Cost Attribution: Splitting Token Spend by Team, Project, and Feature

Why "Total Monthly Spend" Isn't Enough

Your finance team gets a single number every month: how much you spent on AI coding APIs. That number is useless for decision-making. It doesn't tell you:

• Which team is the biggest consumer.
• Whether a specific feature project is over-consuming versus its business value.
• If a single developer or a single wrong-model configuration is driving 40% of spend.
• Whether the new AI coding subscription for the design team is delivering ROI.

Cost attribution — tagging API calls with team, project, and feature identifiers, then rolling up by those dimensions — turns the monthly bill from a mystery into a management tool. This guide walks through building an attribution system from scratch or adding it to an existing gateway.

The Attribution Tag Hierarchy

A workable attribution scheme has three levels of hierarchy:

1. Team (or cost center): The organizational unit responsible for the spend. Examples: "platform-engineering", "growth-team", "data-science".
2. Project: A specific initiative within a team. Examples: "user-onboarding-v3", "billing-migration", "search-relevance".
3. Feature or task type: A finer-grained tag for how the spend was used. Examples: "bug-fix", "new-endpoint", "refactor", "test-generation".

Optional fourth level: individual developer. Useful for high-usage teams (10+ developers) where per-person attribution helps identify outliers or training needs.

How to Actually Tag Requests

There are three practical approaches to tagging, from lowest to highest lift:

Approach 1: Per-key attribution. Create a separate API key for each team or project. Roll up spend by key. Simple, but doesn't cross-cut — you can't easily answer "how much did bug fixes cost this month across all teams."

Approach 2: Header-based tagging via gateway. Route all AI coding traffic through a gateway (LiteLLM Proxy, custom proxy, or vendor gateway like OpenRouter). The gateway extracts team/project/feature from custom HTTP headers (or the requesting IAM role) on every request and logs them with the token counts. Provides full cross-cutting visibility.

Approach 3: Inline metadata via SDK wrapper. Wrap your team's Claude/OpenAI SDK calls in a helper that accepts project, feature, and developer_id parameters, records them alongside the API response, and pushes to a metrics store. Highest fidelity but requires code changes.

Most teams start with Approach 1 (easy, gets you 60% of value), then upgrade to Approach 2 once they need cross-cutting analysis (typically at $5,000+/month spend).

The Gateway Setup

A concrete example using LiteLLM Proxy:

• Deploy LiteLLM Proxy on a small cloud VM ($20-50/month).
• Configure it to log every request to a Postgres or ClickHouse database including: timestamp, model, input tokens, output tokens, cached input tokens, cost, and custom headers (team, project, feature).
• Point all your developers' Claude Code, Cursor, or custom SDK integrations at the gateway URL instead of Anthropic/OpenAI directly. Set the API key to a per-team key issued by the gateway.
• Configure Claude Code (or your tool) to send x-team, x-project, x-feature headers via its custom headers config.
• Build a Grafana or Metabase dashboard that rolls up the log table by team/project/feature.

Total setup time: 20-40 hours for the first version. Recurring cost: $50-150/month for gateway hosting and metrics store.

What to Show the Business

Once you have attributed data, the reports that unlock value are:

• Monthly cost by team, sorted descending: Identifies which team is the biggest consumer. Often 20% of teams drive 80% of spend.
• Cost per completed task by project: Compare a well-defined project's AI cost against traditional developer-hour cost. This is how you show ROI.
• Model-mix by team: Some teams may be using premium models (Fable 5, Opus 4.8) when a cheaper tier would suffice. Attribution highlights the mismatch.
• Feature type breakdown: If bug fixes cost 3x what feature additions cost, that's a signal your codebase quality investment is misaligned.
• Trend lines with anomaly flags: Show week-over-week spend by team, flag any team that's grown 40%+ week-over-week.

Common Pitfalls

Cost attribution efforts fail in predictable ways:

Optional tags become garbage tags. If tagging is optional, developers won't do it. Enforce required tags at the gateway — reject requests without team/project headers. Prompt users clearly when their calls are blocked.

Tag taxonomies grow uncontrollably. Left alone, teams create hundreds of overlapping project tags. Establish a canonical list of teams (from HR/Workday) and canonical projects (from JIRA/Linear), and validate incoming tags against those lists. Reject unknowns.

No consequences. Attribution without accountability produces reports nobody acts on. Set team-level monthly budgets, show utilization on a shared dashboard, and put the highest-spend team on the executive review agenda every month.

Attribution overhead exceeds value. For teams under $2,000/month total AI coding spend, a full attribution system is overkill. Start with per-key attribution and upgrade only when spend justifies the operational overhead.

The ROI of the ROI System

Attribution isn't free — it takes ~20-40 hours to build and $50-150/month to run. Does it pay off?

For teams over $5,000/month in AI coding spend, attribution typically identifies 15-30% waste on first pass (wrong-model usage, abandoned projects still consuming, individual runaway sessions). That's $750-$1,500/month in immediate savings — enough to pay back the setup investment in 1-3 months.

The bigger long-term value is not the initial 15-30% waste cut. It's that you can now make informed model-selection, team-budget, and ROI-justification decisions with data rather than guesswork. That's the difference between managing AI coding as a black-box cost center and running it as a strategic engineering investment.