# Can FOCUS billing data carry AI token spend? A field mapping

URL: https://infro.io/blog/can-focus-billing-data-carry-ai-token-spend-a-field-mapping
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-11-18
Last modified: 2026-11-18
Last reviewed: 2026-11-18 (next review due 2026-12-18)
Topic: Cost and FinOps
Format: Guide

> Yes, in part. FOCUS 1.4 can carry AI usage in its Cost and Usage dataset, and the 1.5 release candidate adds labels for model, cache action and token direction. Batch, service tier, modality and reasoning effort still have no standard home, so plan for custom x_ columns.[^focus-1-5-scope][^focus-1-4-intro]

Key takeaways:
- FOCUS 1.4 can hold AI usage today as ordinary Cost and Usage rows; what it lacks is shared labels for model, cache action and token direction, which the 1.5 release candidate adds as recommended properties.
- Map each meter (input, output, cache read, cache write) to its own row and SKU, and never fold cached tokens into input rows, or token totals double count.
- Batch, service tier, modality and reasoning effort have no standard property in the 1.5 candidate, so carry them as documented x_ columns and keep the value sets stable.
- Gateway cost is a rate calculation: put it in ListCost and ContractedCost, and fill BilledCost only from the provider's own reported figure.
- Write a one-page mapping contract per provider before loading anything, and test it by summing the dataset back to the provider's invoice.

## The short answer

FOCUS is described as an open specification that normalizes billing datasets across AI, cloud, SaaS and other vendors.[1] In practice, a token line item already fits the shape of a Cost and Usage row: a charge, a quantity, a unit, a price and a cost. Where it breaks is the labeling. Two providers can sell the same model, meter caching differently, and name their meters differently, and FOCUS 1.4 gives you no common way to say which is which.

FOCUS 1.5 addresses part of that. Per the project's release-scope page, the release candidate was completed on 2 November, with ratification scheduled for 3 December 2026 and public announcement on 10 December.[2] Today is 18 November, so 1.5 is a candidate, not a published version. This guide maps onto 1.4 columns and flags where 1.5 properties would apply.

A note on how to read the mapping. The column choices below are a proposed convention for a team building its own pipeline, not text copied from the specification. Check each against the [column library](https://focus.finops.org/docs/column-library/) before you freeze it.

## Three sources, one dataset

AI spend usually arrives from three places, and each fills a different part of a FOCUS row.

- **Direct provider usage and cost exports.** Accurate and late, grouped by the provider's own project or key. They carry the invoiced figure, so they are the only honest source for `BilledCost`.
- **The cloud bill.** Bedrock, Azure and Vertex usage is already in the cloud invoice. The FOCUS home page lists AWS, Microsoft and Google Cloud generators at v1.2 when read, so check which version your cloud export produces before you expect any 1.4 column from it.[1]
- **Gateway request records.** Timely, and they carry your own dimensions (feature, customer, team). Their cost is a rate-table estimate, not an invoice.

The Framework treats AI as a Technology Category alongside Public Cloud and SaaS,[3] so the same Allocation and Reporting capabilities apply. The [capability map](https://infro.io/blog/where-ai-spend-fits-in-the-finops-framework-a-capability-map) covers that side. This guide covers the column-level work underneath it.

## The mapping, line item by line item

FOCUS 1.5 says plainly that FOCUS has carried token counts since version 1.0 and that what it adds is the labels that make them comparable.[2] So the usage side is not new. The table is the working proposal.

| Line item | Quantity and unit | Where the label goes | Fit |
| --- | --- | --- | --- |
| Input tokens | Usage quantity in tokens | SKU Price Details: `TokenDirection` = Input (1.5) | Clean in 1.5; custom key in 1.4 |
| Output tokens | Same, per output meter | `TokenDirection` = Output | Clean |
| Reasoning tokens billed separately | Own meter | `TokenDirection` = Output, per the 1.5 text | Clean, but you lose the reasoning split |
| Cache read | Own meter | `TokenCacheAction` = Read | Clean in 1.5 |
| Cache write | Own meter | `TokenCacheAction` = Write | Clean in 1.5 |
| Model identity | Not a quantity | `ModelDeveloper`, `ModelFamily`, `ModelId`, `ModelVersion` | Recommended in 1.5, optional |
| Batch input and output | Same units | Nothing standard | No clean fit |
| Service tier (Standard, Flex, Priority, Reserved) | Same units, different rate | Nothing standard | No clean fit |
| Image, video, audio input tokens | Tokens per modality | Nothing standard | No clean fit |
| Per-image, per-second, per-character, per-hour units | Non-token units | Usage and pricing unit columns | Fits as units, not as a shared metric |
| Provider-issued units | Own currency | Pricing Currency as a consumption currency (1.5) | Clean in 1.5 |
| Gateway estimate | Request-level cost | `ListCost` and `ContractedCost` | Clean, with a flag |

Table: Proposed mapping of AI line items to FOCUS Cost and Usage fields, with the 1.5 release candidate noted.

The four model properties, and the two token properties, live in SKU Price Details, which the 1.5 page describes as a Cost and Usage column carrying properties that describe what a price is for, with FOCUS defining common names so queries work across providers.[2] Including them is recommended, not required, so a conformant dataset can omit them.[2]

## Tokens and cache: one row per meter

The 1.5 text gives three rules that you can adopt now. `TokenCacheAction` takes Uncached, Read, Write or Other, and `TokenDirection` takes Input or Output.[2] A price that bills several kinds of tokens on one meter omits the property that would misdescribe them.[2] And a cached token counted on a Read or Write row is not counted again on another row, so totals do not double count.[2]

The practical consequence is that you need one row per meter, not one row per request. If your provider export reports `input_tokens`, `cache_read_tokens` and `cache_write_tokens` as columns on a single line, unpivot it. Then check one thing before anything else: whether the provider's input count includes cached tokens or excludes them. If it includes them, subtract the cache reads from the uncached input row, or the same token is billed twice in your dataset.

Cloud providers show why labels matter. Bedrock's page notes for Amazon Nova that cache read input tokens are priced 75% below the on-demand input token price.[4] With a `TokenCacheAction` label, a rising bill from a falling cache hit rate can be told apart from a bill that rose because of traffic. The 1.5 page makes the same point and lists cache hit rate by model as an example query.[2]

> **Example: Illustrative rows (invented figures)**
> Two request-level meters for one model on one day, expressed as FOCUS-shaped rows. Quantities are made up to show the shape.
> 
> ```json
> [
>   {
>     "ChargeCategory": "Usage",
>     "ServiceName": "Example Model API",
>     "ConsumedQuantity": 1200000,
>     "ConsumedUnit": "Tokens",
>     "SkuPriceDetails": {"ModelId": "example-model-1", "TokenDirection": "Input", "TokenCacheAction": "Uncached"},
>     "x_pricing_tier": "standard",
>     "x_processing_mode": "synchronous"
>   },
>   {
>     "ChargeCategory": "Usage",
>     "ServiceName": "Example Model API",
>     "ConsumedQuantity": 800000,
>     "ConsumedUnit": "Tokens",
>     "SkuPriceDetails": {"ModelId": "example-model-1", "TokenDirection": "Input", "TokenCacheAction": "Read"},
>     "x_pricing_tier": "standard",
>     "x_processing_mode": "synchronous"
>   }
> ]
> ```

## Batch and service tiers: where the spec has no clean fit

Bedrock offers Standard, Flex, Priority and Reserved tiers,[4] and offers select models for batch inference at a 50% lower price than on-demand.[4] Both change the rate for identical tokens. In the 1.5 release scope I read, neither batch nor service tier appears among the properties; the AI items it lists are model identity, cache action, token direction and a consumption currency, plus worked examples.[2]

That leaves you three honest options.

1. **Separate SKUs.** If the provider bills batch and standard on different meters, the SKU already differs, and your reports can group by SKU. This costs nothing but is unreadable without a lookup.
2. **A custom column.** Custom Columns is a supported feature in the 1.4 specification,[5] and the 1.4 introduction says generators carry native dataset columns as custom `x_` columns.[6] Use `x_processing_mode` (synchronous, batch) and `x_service_tier` with a closed value list you document.
3. **A key inside SKU Price Details.** Workable, but those are properties of a price, and the spec reserves FOCUS-defined names for itself. Use a clearly vendor-prefixed key.

Pick option 2 for anything finance filters on. Whichever you choose, the meaning belongs in a mapping contract you version, because the next person to query the data cannot guess it.

## Media: units that are not tokens

Text is the easy case. The Nova 2 Omni rows on Bedrock's page list separate input prices per million tokens for text, image, video and audio, and a separate output price for image,[4] so one model produces several meters with the same unit and different modalities. The 1.5 page is explicit that modality, reasoning effort, cache retention duration and context window size are not values of the new token properties.[2] Modality is therefore a gap you fill yourself, with an `x_modality` column.

Non-token media is a different problem. INFRO's own docs list the metering units across its endpoints as token for text, image for image generation, second of output for video, character for speech and hour of audio for transcription.[7] That is a normal situation for FOCUS: the usage unit and pricing unit columns can hold images, seconds or characters. What breaks is any cross-model unit metric. "Cost per million tokens" has no equivalent that you can compare against cost per generated second, so keep unit economics per modality and do not blend them into one rate.

## Provider-issued units and drawn-down commitments

Some AI usage is priced in a provider's own unit rather than in a national currency. The 1.5 candidate adds a consumption currency: a provider-issued unit such as platform units or normalized billing units, with ISO 4217 currency codes reserved for national currencies.[2] Under 1.4, put the provider unit in a custom column and keep Pricing Currency to a real ISO code, so a validator does not reject the row.

For commitments, the 1.4 rule is the one to know. A covering charge (a purchase that pays for other charges) carries an effective cost of 0, and its cost flows to the covered usage as that usage is consumed.[6] If you track a committed-spend agreement with an AI provider, your consumption rows carry the recognized share and the purchase row must not also count. Treating both as cost double counts the commitment.

## Gateway estimates: which cost columns they may fill

A gateway records tokens and computes a cost at request time. That is useful for allocation, because the request carries your feature and customer, but it is not an invoice. FOCUS defines `BilledCost` as the amount invoiced by the invoice issuer, and INFRO's export documentation quotes the requirement that it must reflect invoiced amounts, not estimated or inferred values.[8]

INFRO's FOCUS v1.4 export follows that. Its estimate goes to `ListCost` and `ContractedCost`, which carry the same figure, priced at the customer's negotiated rate when one is on record and the vendor's published rate otherwise.[8] `BilledCost` is filled only with `cost_basis=reconciled`, from the provider's own cost API, allocated to rows in proportion to their share of the estimate for that provider-day.[8] Otherwise it is absent, not zeroed.[8] The dataset is available from `GET /v1/usage/focus` as JSON or CSV; the [FOCUS export page](https://infro.io/docs/observability/focus-export) states which columns are populated and which are deliberately empty.[8]

Copy the discipline even if you build your own pipeline. A report that mixes estimated and invoiced rows in one cost column cannot be reconciled afterwards. Keep a flag, such as `x_cost_basis` with values estimated and reconciled, on every row.

## Where there is no clean fit: the short list

- **Batch and service tier.** No standard property in the 1.5 candidate; use documented `x_` columns.
- **Modality, reasoning effort, context window, cache retention.** Named in the 1.5 text as outside the token properties.[2]
- **Request-level attribution.** Per-request feature, customer and agent are not provider billing facts. The 1.5 candidate lets cost rows name the principal and credential behind a charge,[2] but a feature or workflow tag still has to come from your application and a gateway.
- **Failed and cancelled calls.** Whether a provider bills them is provider-specific, and FOCUS has no property for it. See [do providers bill cancelled or failed streams](https://infro.io/blog/do-providers-bill-cancelled-or-failed-streams-what-to-forecast).
- **Response-cache hits.** A request answered from a gateway cache never reaches the provider, so it has no provider charge. Record it as zero-cost usage with a custom flag or leave it out, and decide which before the first report.

## A checklist to run before you load anything

- [ ] Write a mapping contract per provider: which export field becomes which column, and which are unmapped.
- [ ] Unpivot cache meters into separate rows and check whether provider input counts include cached tokens.
- [ ] Add `x_processing_mode`, `x_service_tier`, `x_modality` and `x_cost_basis` with closed value lists.
- [ ] Put estimates in `ListCost` and `ContractedCost` only; fill `BilledCost` from provider cost data only.
- [ ] Enter negotiated rates so the estimate uses them; otherwise list-rate rows drift from the invoice.
- [ ] Sum each provider-day back to the provider's reported cost and investigate any persistent gap.
- [ ] Record the FOCUS version and the correction style of each source, since a 1.2 cloud export and a 1.4 gateway export will not share columns.
- [ ] Re-check the mapping once 1.5 is ratified and generators adopt it.

The reconciliation step is where the effort goes. The 1.4 post introduces Invoice Detail and the Invoice Reconciliation feature for tying usage to invoices,[6] and INFRO's reconciliation compares estimated spend daily with the cost reported by OpenAI's and Anthropic's own cost APIs. Method detail is in [reconciling estimated LLM spend with provider invoices](https://infro.io/blog/reconcile-llm-spend-provider-invoices).

## Where to start

Do not wait for a perfect schema. Pick the provider with the largest spend, write its mapping contract, load one month, and check that the totals match the invoice. The rest of the work is repeating that per provider, with the same custom columns, so one query works across all of them.

## Questions

### Should I wait for FOCUS 1.5 before loading AI spend?

No. Data that conforms to 1.4 stays valid as 1.4, and the 1.5 changes are additions rather than renames or removals, so rows you load now keep working.[2] Put the 1.5 property values into SKU Price Details or x_ columns today so the later change is a rename of a key, not a rebuild.

## Sources

1. FOCUS: FinOps Open Cost & Usage Specification — FinOps Foundation (FOCUS project). https://focus.finops.org/ (accessed 2026-11-18)
2. FOCUS 1.5 Release Scope: Confirmed, In Review and Deferred — FinOps Foundation (FOCUS project). https://focus.finops.org/focus-1-5-release-scope/ (accessed 2026-11-18)
3. FinOps Framework Overview — FinOps Foundation. https://www.finops.org/framework/ (accessed 2026-11-18)
4. Amazon Bedrock pricing — Amazon Web Services. https://aws.amazon.com/bedrock/pricing/ (accessed 2026-11-18)
5. FOCUS Specification 1.4 — FinOps Foundation (FOCUS project). https://focus.finops.org/docs/specification/v1-4/ (accessed 2026-11-18)
6. Introducing FOCUS 1.4: Invoice Reconciliation, Commitment Details, and Specification Maturity — FinOps Foundation. https://www.finops.org/insights/introducing-focus-1-4/ (accessed 2026-11-18)
7. INFRO documentation overview — INFRO. https://infro.io/docs (accessed 2026-11-18)
8. FOCUS export — INFRO. https://infro.io/docs/observability/focus-export (accessed 2026-11-18)
