FinOps for AI does not start with a token price. AI spend appears as model consumption, provisioned throughput, GPU compute and a collection of supporting services. Some of it reaches AWS, Azure or Google Cloud billing data; some sits on direct provider invoices. None of those bills contains the product outcome.
The work is therefore to connect three things: complete cost evidence, accountable ownership and a measurable unit of product value. Only then does “AI spend” become a decision a team can manage. This guide sets out sources, billing models, fields, diagnosis and review, and points to the deeper article for each question.
Where AI cost actually appears
The FinOps Foundation™ describes FinOps for AI as existing FinOps practice applied to a type of spend with new units, pricing models and stakeholders. For a small team, the practical consequence is an inventory that separates at least four sources:
- Managed models. Amazon Bedrock, Azure OpenAI or Microsoft Foundry, and Vertex AI charge for input, output, cache, images, audio, batch or other units depending on the offer.
- Provisioned capacity. Provisioned throughput reserves performance, and charges continue when model usage is low or absent. Hosting a fine-tuned model behaves the same way.
- Owned compute. Self-hosted models appear as GPU instances, Kubernetes nodes, storage and network rather than one convenient LLM line.
- Supporting services. Vector search, databases, object and cache storage, logging, evaluation, safeguards and egress belong to the solution but sit in other service categories.
Direct model APIs and AI SaaS sit outside the cloud bill. They are missing from every provider dashboard even when they support the same product. There are boundaries inside a cloud too: Microsoft notes that models from other providers are billed through Azure Marketplace and cannot be paid with Azure Prepayment credit. An inventory that only knows “Azure OpenAI” misses those lines.
Alongside the cost categories, the FinOps Foundation lists why AI cost is harder to manage than conventional infrastructure: prices and SKUs change often, new SKUs do not always support tagging, the billed token volume differs from what the user typed, and forecasts need revising more frequently. The State of FinOps 2026 reports that 98 per cent of respondents now manage AI spend, and names visibility into AI cost, allocating it to business units and determining its value or return on investment as the main challenges.
The billing model decides which lever works
Before anyone discusses prompt length or model choice, establish how each line is billed. A variable token charge responds to lower usage; an hourly capacity charge does not. The table below maps the models AWS, Microsoft and Google document today:
| Billing model | Cost behaviour | What the provider documents | Lever that works | Ownership question |
|---|---|---|---|---|
| Standard / on-demand per token | variable with volume and model | Bedrock, Azure and Vertex AI charge by modality, model and meter | model choice, input and output volume, caching | Who owns demand and model mix? |
| Batch | variable, delayed, cheaper | Bedrock: selected models at a 50 per cent lower price than on-demand; Azure: a discounted batch rate | move suitable work off the real-time path | Which tasks tolerate asynchronous results? |
| Flex and Priority tiers | variable with a discount or premium | Bedrock lists, for several providers, Flex at a 50 per cent discount and Priority at a 75 per cent premium to Standard | set a latency requirement per use case | Who decides which request needs priority? |
| Provisioned throughput | fixed per hour or term | Azure: per PTU per hour regardless of tokens consumed, with 1-month or 1-year reservations; Bedrock: per model unit per hour with commitment options; Vertex AI: a fixed-term subscription | size, term and utilisation | Who carries the capacity when usage falls? |
| Fine-tuned model hosting | fixed per hour | Azure charges hosting hourly, even without usage | remove deployments nobody needs | Who deletes a model after the experiment? |
| Owned GPU compute | fixed per runtime | instance or machine price per Region | utilisation, size, shutdown windows | Who watches idle GPU hours? |
The percentages come from the Bedrock pricing page and apply only to the models and providers named there. Check that your model offers the tier in your Region before deciding anything. Microsoft also advises against scaling provisioned deployments up and down with traffic to stay on hourly billing, because capacity might not be available when you scale back up. Capacity is therefore a decision with its own owner, not an optimisation done in passing.
Use billing fields as the evidence layer
The billing export is the financial evidence. It does not expose the same detail in every cloud, and it does not automatically understand the product context.
| Cost source | Starting fields in billing data | What they establish | Where attribution stops |
|---|---|---|---|
| Amazon Bedrock | service, usage type, operation, Region, resource or inference profile; optional CUR 2.0 line_item_iam_principal and activated cost-allocation tags | billed amount by model or usage type, account, caller identity and available attribution | prompt, customer transaction and feature need invocation logs with request metadata |
| Azure OpenAI / Microsoft Foundry | subscription, resource group, resource ID, service tier, meter and the automatic project tag | amount by resource, project and input, output, hosting or capacity meter | a shared deployment does not identify the product feature that invoked it |
| Vertex AI | service.description, sku.id, sku.description, project, labels and usage window in BigQuery billing export | cost by service, SKU, project and available organisational dimensions | resource depth exists only for services in the detailed export; feature and outcome are absent |
| GPU compute | compute service, machine type, resource, Region, runtime and tags or labels | infrastructure cost and provisioned runtime | utilisation, model and individual inference come from operational data |
| Supporting services | the relevant service, SKU or meter, resource, project and period | billed database, storage, logging and network cost | architecture and ownership connect them to the AI application |
| Direct API or SaaS | no row in cloud billing export | nothing in the AWS, Azure or Google Cloud bill | a separate invoice or export is required; never treat absence as zero |
AWS documents several Bedrock attribution paths, each answering a different question. IAM principal attribution captures the calling identity and suits per-user or per-team amounts. Application inference profiles and, on the newer bedrock-mantle endpoint, projects and workspaces carry tags that reach Cost Explorer and CUR 2.0; they answer the per-application question. Request metadata appears only in invocation logs, and AWS explicitly recommends reconciling log-derived cost against CUR at the model and usage-type grain.
On Azure, Cost Management groups Azure OpenAI under the broader Cognitive Services classification; Microsoft suggests filtering on the service tier “Azure OpenAI” at subscription scope. The automatic project tag for Foundry projects is marked as preview and currently covers models sold by Azure, not Marketplace models. On Google Cloud, service and SKU are the dependable first grouping, with project and labels providing ownership context. Label cost data covers usage only from the date the label was applied, and AWS does not activate cost-allocation tags retroactively either.
Apply four FinOps practices to AI
1. Visibility: establish the complete scope
Begin with a source register, not a dashboard. List cloud billing accounts, subscriptions and projects, direct provider invoices, Marketplace purchases and accountable teams. Mark each source as available, delayed or not yet integrated.
Separate pay-as-you-go, batch, hosting and provisioned capacity. Lower token usage does not reduce a fixed capacity charge, and a GPU environment costs money when no inference is running. Microsoft also points out that Foundry charges are only a subset of solution cost, and that logging to Azure Monitor shows up under those other services.
2. Allocation: start with stable boundaries
Assign an owner to each account, subscription or project first. Then refine with resource, deployment, inference profile, tag or label. Feature-level allocation requires a stable key emitted by the application or gateway. AWS recommends stamping those tags in a shared client or LLM gateway rather than relying on every team, because Bedrock does not reject calls that omit request metadata.
Do not put email addresses, prompt content or customer identifiers into billing tags. Low-cardinality values such as application, team, feature and environment are sufficient for the cost layer. High-cardinality data such as session or trace IDs belongs in protected operational logs, retained only for a defined purpose.
Every report should show direct cost, allocated shared cost and the unallocated residual. An allocation percentage with no visible residual rewards optimistic rules rather than accuracy.
3. Budgeting: model drivers, not last year's total
AI workloads often lack stable history. Plan from demand, input and output volume, model mix, cache rate and capacity model. Experiments need a ceiling and end date; production needs scenarios and explicit reforecast triggers.
Budgets and alerts identify a variance. They generally do not stop model calls or GPU resources, nor explain why a meter changed. Microsoft states that Azure OpenAI has no hard spending limit and that automated responses through action groups need custom development. Google notes that an alerts-only budget does not cap usage or spending. If you need a hard stop, build it as a quota, gateway limit or shutdown automation, and test it like any other production feature.
4. Unit economics: connect cost to product value
“Token” is rarely the right business denominator. Tokens explain technical consumption but not value. Completed workflows, reviewed documents, resolved cases or active AI features may be more useful, depending on the product. Define the unit before setting a target; unit economics in the glossary gives the basic form.
The join happens outside the billing export. Aggregate product measures by feature and period, then combine them with reconciled cost. Keep direct model cost, shared platform cost and unallocated residual separate. A metric that only counts model charges understates features that lean heavily on vector search, evaluation or logging.
Diagnose a jump in AI spend
Work in this order so you do not end up optimising prompts when a new capacity commitment was the cause:
- Check data completeness. Costs arrive with a delay; Microsoft recommends trend windows over minute-by-minute comparison, and Google recommends querying on
invoice.monthwhen matching an invoice. Compare only equally complete periods. - Identify the source. Does the increase belong to managed models, capacity, owned compute, supporting services or a direct invoice?
- Separate the billing model. Is the line fixed or variable? A new capacity meter, a forgotten fine-tuned deployment or a new GPU instance explains jumps that are not usage changes.
- Read the meter or usage type. Distinguish input, output, cache, batch and priority. Growing output volume points to different causes than a rising input share.
- Identify the owner. Use the principal, inference profile, project tag or label to narrow down application and team. If allocation is missing, the unallocated residual is itself a finding.
- Bring in operational data. Only now do invocation logs, gateway metrics and request metadata help. Reconcile their total to the bill before using them as an explanation.
- Check side effects. Spillover to a standard deployment, retries after errors and extra logging create their own cost. Microsoft notes that the HTTP status code alone does not determine whether a request is billed.
- Record the decision. Write down cause, evidence, owner, action and the date its effect will be checked.
Common failure patterns
- Tags activated late. AWS does not activate cost-allocation tags retroactively, and Google labels apply from the date they are set. History before activation stays unallocated.
- Capacity spread by tokens. Allocating a fixed PTU or model-unit charge in proportion to consumption hides idle capacity inside feature numbers. Report idle capacity separately.
- A direct invoice counted as zero. A missing source is a gap, not a zero amount.
- High-cardinality tags. Session IDs as cost-allocation tags bloat reports. AWS notes that IAM principal data already multiplies CUR row counts and the S3 storage behind them.
- Hosting after the experiment. Azure charges for fine-tuned models hourly for as long as they are deployed.
- Marketplace models overlooked. On Azure they can appear under global resources or the resource group and are not covered by the project tag.
Limits of this model
A billing export answers what was charged, not why. Prices, tiers and SKUs change quickly, so check every figure in this guide on the provider's pricing page for your Region and currency before using it. Fields vary by service, Region and export version; the field table is a starting point, not a contract. Teams reporting in GBP or EUR should also keep the billing currency and any conversion visible, because a currency movement can look like a usage change. Obligations under the EU AI Act, UK or EU data protection law are outside this guide; whether request logs may contain personal data is for whoever owns data protection in your organisation, with legal advice. How AI cost is treated in gross margin or capitalisation belongs to finance and your accountant.
A practical maturity path for a small team
Sequence matters more than a perfect target model:
| Stage | Outcome | Test |
|---|---|---|
| 1. Inventory | every AI source has an owner and evidence | direct invoices and cloud charges are visible as separate sources |
| 2. Cloud view | managed models, capacity, GPU and supporting services by provider | totals reconcile to each billing export |
| 3. Ownership | cost by team, application or environment | unallocated cost remains visible |
| 4. Budget | scenarios and alerts at stable boundaries | each variance has an owner and a decision |
| 5. Unit economics | cost per defined product outcome | billing and product data share period and scope |
Do not jump straight to stage five. A precise cost per request is meaningless if direct API invoices are missing or provisioned capacity was allocated arbitrarily. The FinOps Foundation frames the same idea as crawl, walk and run phases, each with a different attitude to cost.
The monthly AI cost review
A joint platform, product and finance review does not need a new department. It fits as a fixed block in the general monthly cloud cost review and should answer six questions:
- Which sources and meters explain total AI spend?
- Which change came from demand, model, price, tier or capacity?
- Which amount has no owner or product allocation?
- Which provisioned capacity or hosting was unused or poorly sized?
- Is the forecast still within its documented range?
- What decision follows, who owns it and when will its effect be checked?
The bill supplies financial truth; operational and product data explain usage and value.
Which article answers which question
This guide covers the whole topic; the articles below each go deeper on one step:
- Read Azure OpenAI and Bedrock charges: read it when you are looking at meters and usage types in an export and need to separate PTU or model units from token charges; it includes query sketches for both providers.
- Attribute AI costs to a product feature: read it once the cloud view is in place and you need cost per feature, from separate deployments to token logs reconciled to the bill.
- Cloud cost per customer for SaaS: read it when AI cost should feed a per-customer metric and you need to keep formula, driver and residual apart.
- Cloud costs in COGS: read it when finance needs to settle whether AI inference counts as cost of service; the decision itself stays with finance and your auditors.
- Understand Kubernetes cluster cost: read it when you run models yourself on Kubernetes and need to separate idle capacity from namespace cost.
What Costfluent covers
Costfluent reads AWS, Azure and Google Cloud billing data through read-only native connectors, and Kubernetes cost through an agent in the cluster, without per-pod allocation. Cost reports show AI lines by provider, account, service, resource and tag alongside the rest of your cloud spend. An overview of cost reports is in the docs. Cost allocation assigns cost through ordered rules to teams, products or cost centres and keeps unallocated cost visible.
Costfluent connects OpenAI, Anthropic and Cursor directly and reads their daily cost (Track OpenAI and Anthropic API spend); other model providers wait for file imports, which are Planned. It does not read token telemetry, prompts, invocation logs or product metrics, and it does not claim automatic root-cause analysis. The link to your product outcome stays in your own data.
Sources and method
Checked on 2026-10-10. FinOps Foundation: FinOps for AI Overview, State of FinOps 2026, AWS Bedrock cost-attribution best practices, AWS IAM principal data in CUR 2.0, Amazon Bedrock pricing, Microsoft Foundry cost planning and management, Microsoft Foundry provisioned throughput, Vertex AI Provisioned Throughput, Google Cloud standard billing-export schema, Google Cloud detailed billing export and Google Cloud budgets. The tables, diagnostic sequence and maturity path are Costfluent recommendations, not legal, tax or accounting advice; verify field availability and prices in your own exports and on the provider's pricing page.



