AI cost attribution per client for agencies and consultancies

AI cost attribution per client is the discipline that turns "we spent €4,000 on AI last month" into "€1,200 was for Acme, €900 for Beta Corp, €500 for Gamma, and €1,400 across the other twelve accounts". For an agency or consultancy that bills clients for work partly delivered through AI, that breakdown is the difference between a defensible invoice and a rounding exercise. This guide describes AI cost attribution per client for agencies at any size, three billing models that survive audit, the metadata your requests must carry, and worked examples for the most common European service-firm shapes.

The audience is the founder, operations lead, or finance partner at an agency, consultancy, or delivery firm who has clients paying for work where AI does part of the production. Team size does not gate this problem: a three-person consultancy running client work across two or three AI providers already has AI cost attribution per client to solve, and often has less operational slack than a larger firm to reconcile it manually.

If you are asking the question "how do I attribute AI costs to specific clients" — that is the question this page answers, in full. For the broader four-dimensional attribution framework (team, workflow, client, jurisdiction) see AI spend attribution. For the team-attribution grain see attribute AI costs to teams. This page owns the client dimension.

AI cost attribution per client: what the term means

Client-level attribution is a stricter question than team-level attribution. At team level, the answer is which internal group ran a workflow. At client level, the answer is which external customer's project drove the cost, and by how much. Two extra properties make client attribution harder than team attribution.

The mapping is many-to-many. One employee often works on multiple clients in a week; one client engagement often involves multiple employees. Attributing by user is not enough; you need per-request context that says "this request was for client X's project" independent of who ran it.

The financial stakes are higher. Team attribution is an internal management tool; a wrong number hurts a planning conversation. Client attribution is a billing input; a wrong number lands in an invoice a client can dispute. The tolerance for error is lower and the audit trail requirements are stricter.

The result is that AI cost attribution per client requires slightly more metadata discipline than team attribution alone, and it usually justifies infrastructure investment sooner because the payback (correct invoices, defensible unit economics) is directly financial.

The three billing models that survive audit

Agencies attribute AI costs to clients through one of three billing models. Each has a different implication for how you must capture data.

Model 1: bundled into retainer

The retainer covers all AI-assisted work up to a defined scope. AI cost is a firm-level expense line, not a client-level pass-through. Clients see one number per month; internally you still track per-client cost for your own margin analysis.

Attribution required internally: yes. You want to know which clients are consuming disproportionate AI cost relative to their retainer, because those are the retainer renewals that need repricing.

Metadata to capture: client_id or engagement_id per request. That is enough to compute internal per-client cost.

When it works: mature relationships where the client trusts the firm's judgment on tool usage. Common for retainer-based agencies (design, content, ongoing advisory).

When it breaks: when one client's project unexpectedly consumes ten times the AI budget of the others and the retainer no longer covers it. Attribution is what makes this visible before it becomes a margin problem.

Model 2: direct pass-through with markup

AI costs are billed to clients directly, often with a documented markup to cover overhead (10% to 30% is a common range). The client sees a line item on their invoice: "AI compute, project X: €300 at 20% markup = €360".

Attribution required: yes, with high precision. Every request must be attributable to a client with an audit trail that survives a client questioning the bill.

Metadata to capture: client_id, engagement_id or project_code, workflow (so the client can see what the AI was doing), model, tokens, timestamp, and provider. This is the tightest metadata requirement of the three models.

When it works: project-based engagements with defined deliverables, especially where AI usage varies materially by project. Common for consultancies, technical delivery firms, and agencies with clear project accounting.

When it breaks: without per-request attribution, an itemised invoice is impossible. Trying to reconstruct client-level cost from provider dashboards after the fact almost always misses 15% to 20% of usage and produces disputes.

Model 3: metered chargeback with client-visible dashboard

The client sees a live or monthly dashboard of exactly what their AI usage cost. No markup, or a transparent standing fee for the platform. Common in technical consultancies or platform engagements where the client has their own finance discipline and prefers auditable transparency.

Attribution required: yes, and it has to be exposed to the client. Which usually means the attribution layer needs a client-facing UI or a routine export.

Metadata to capture: everything model 2 captures, plus the ability to filter and export by client.

When it works: technical clients (in-house engineering, data teams) who want the audit trail and prefer paying at cost. Also fits when a firm handles a client's platform layer for them.

When it breaks: when the operational overhead of exposing a dashboard exceeds the trust benefit. For small agencies working with non-technical clients, a monthly PDF summary is often the right compromise between transparency and effort.

The metadata every AI cost attribution per client setup needs

Regardless of which billing model you pick, six fields have to be attached to every AI request or the attribution breaks.

1. client_id: a stable identifier per client. Use the identifier your CRM already uses so exports reconcile.
2. engagement_id or project_code: for firms where a single client has multiple concurrent projects. Skip if your model is one project per client.
3. workflow: a short label naming what the AI was doing (e.g., content_draft, code_review, research_summary). Not strictly required for billing, but required for the "why did AI cost so much on this project" post-mortem.
4. provider: which AI vendor served the request. Required because the same workflow can route to different providers on different days and the audit trail must reflect the actual provider used.
5. model: the specific model that ran, not the requested model. Failovers matter.
6. token_counts: input, output, and cached-input tokens, since input-output asymmetry dominates the actual cost. Provider dashboards sometimes obscure cached-input pricing; capture it yourself.

Missing client_id or engagement_id is the single most common failure mode. Without them, per-client cost is a manual reconstruction exercise every billing cycle, which agencies invariably stop doing after two or three months.

Worked example: three-person creative consultancy, two providers

A three-person creative consultancy uses OpenAI for concept and copy work and Anthropic for long-form editing. They bill four active clients on retainer plus occasional project engagements. Monthly AI invoice is around €800 split roughly two-to-one between OpenAI and Anthropic.

Before attribution: the €800 was an unattributed line in the operations budget. The founders assumed it was "mostly Client A" but had no way to check. When Client B renewed their retainer at a lower rate, no one noticed that Client B had actually been the biggest AI consumer for two months.

After attribution (via a proxy layer that stamps every request with client_id from the internal tool passing the prompt): the breakdown showed Client A at €120/month, Client B at €340/month, Client C at €180/month, Client D at €80/month, and €80 across occasional project work. Two consequences followed: Client B's retainer was flagged for repricing at the next renewal, and Client D's usage was so low that the retainer scope could be modestly expanded to increase perceived value.

Total effort to set up: half a day for the proxy configuration, one hour of internal-tool changes to pass client_id on every request. Ongoing cost: negligible.

Common mistakes with AI cost attribution per client

Four failure modes come up repeatedly at agency scale.

Attributing after the fact from provider dashboards. Provider dashboards do not know which client each request was for. Trying to reconstruct client attribution from cost totals plus employee time sheets after the month closes usually loses 15% to 20% of usage to gaps, and the reconciliation takes a full day of finance work each month. Capture client_id at request time, not at invoice time.

Not distinguishing internal vs client-billable AI work. Agencies use AI for their own operations (internal drafting, research, admin). Mixing that spend with client-attributable spend inflates the client denominator and misrepresents which clients are actually expensive. Tag every request as either client_billable or internal.

Choosing a billing model that does not fit the client relationship. Pass-through with markup fits project work; retainer bundling fits ongoing relationships. Using pass-through on a retainer client feels like nickel-and-diming; using bundling on a project client leaves margin on the table when a project runs AI-heavy. Match the model to the engagement type.

Not capturing the fallback chain. When a request fails on the primary provider and succeeds on the fallback, both cost the client something. Log the fallback so the invoice question "why did the cost on Tuesday spike" traces back to a specific provider incident, not a mystery.

Related reading

• How to attribute AI costs to teams: the team-attribution counterpart. Client attribution builds on the same metadata plumbing.
• AI spend attribution: the pillar page covering four attribution dimensions (team, workflow, client, jurisdiction) with cross-cutting examples.
• How to route between OpenAI and Anthropic cheaply, with audit logs: the routing counterpart. Attribution and routing produce the two sides of the same audit trail.
• What is an EU-hosted LLM proxy: the infrastructure layer that makes automatic client attribution practical across providers.

Frequently asked questions

How do I attribute AI cost per client if my team also works on internal projects?

Add a boolean client_billable flag on every request in addition to client_id. Requests without a client_id (or with a null value) are internal. Reports filter on client_billable=true for billing rollups and on client_billable=false for internal overhead analysis. This avoids inflating client denominators with agency-overhead spend.

Do I need a proxy layer to attribute AI cost per client?

Not strictly, but the alternative (adding client_id handling to every code path that calls an LLM, and reconciling across two or three provider dashboards each month) is more work than adopting a proxy. Small multi-provider consultancies typically find the proxy pays back within one billing cycle because it eliminates the monthly manual reconciliation and reduces client-invoice disputes.

What's the right markup for direct pass-through billing?

There is no universal number. Common ranges are 10% to 30% depending on how much operational overhead the firm carries around the AI usage (procurement, security review, incident response). Below 10% the pass-through does not cover the firm's own operating cost; above 30% clients typically start asking. A defensible position documents the specific overheads the markup covers and shows the calculation on request.

Can clients see other clients' data if they see the attribution dashboard?

No. Attribution dashboards are per-client by construction. A client dashboard shows only that client's requests, filtered at the API level before rendering. Cross-client visibility is a firm-internal report only. This is a design property of the metadata setup, not a permission-layer afterthought.

How does AI cost attribution per client change under the EU AI Act?

The EU AI Act adds a jurisdiction-attribution requirement on top of the cost-attribution one. For each request, you must be able to document which provider processed the prompt in which region. For agencies handling clients in regulated sectors (healthcare, legal, financial services), the client-facing attribution layer usually needs to show jurisdiction alongside cost, not just total spend.