# What usage data to bring to an AI provider contract renewal

URL: https://infro.io/blog/what-usage-data-to-bring-to-an-ai-provider-contract-renewal
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-11-20
Last modified: 2026-11-20
Last reviewed: 2026-11-20 (next review due 2027-05-19)
Topic: Cost and FinOps
Format: Guide

> Bring seven cuts of 90-day usage (daily spend floor, per-model mix, peak hours, growth, cache and fallback shares, unpriced traffic, and traffic outside the gateway), a price-change exposure table, and proof of tested fallbacks. Size the commit to the demand you can defend, not the average. [^finops-rate-optimization]

Key takeaways:
- Procurement negotiates better when FinOps supplies historical and projected consumption, so build the data pack before the vendor's account team builds theirs.
- Size a commit to the floor of your 90-day demand and the share you can defend, not the mean, because a straight-line forecast ignores launches, seasonality and price changes.
- A price-change exposure table (90-day spend by model, rate basis, retirement date) shows which contract terms matter and which models you could move.
- Evidence of fallbacks that have been tested and that actually carry traffic is leverage; a configured but untested fallback is not.
- Share aggregates and a FOCUS or CSV export, not prompts, and check negotiated rates are not covered by an NDA before they leave your team.

## Start from who holds the demand data

At a renewal, the provider's account team arrives with a usage chart and a growth assumption. The FinOps Framework's Rate Optimization capability describes the counterweight: Procurement leads the negotiation, and the FinOps team supplies data on historical and projected consumption and highlights the cost and business drivers behind it.[1] Procurement and Finance are both core personas in the Framework, so this is a shared job, not an engineering favor.[2]

The same page marks the maturity step that matters here. At "Walk", pricing, commitment and alternative purchasing options are compared against *validated demand* before purchase; at "Crawl", decisions default to what the team already knows, with no comparison step.[1] Validated demand is what this guide builds: a short pack, drawn from gateway records, that you can put on the table whether you are talking to OpenAI, Anthropic, Google or a cloud provider that hosts the same models.

Two cautions before the data. First, the Framework notes that negotiated rates are often private and covered by non-disclosure terms, so check your agreements before sharing anything.[1] Second, a gateway only sees traffic that goes through it. Anything a team calls directly, or through a cloud console, is missing unless you account for it separately (see the cut on traffic outside the gateway below).

## Know which number you are looking at

A gateway records each request's model, latency, unit counts and an estimated provider cost.[3] "Estimated" matters in a negotiation. The gateway prices each request with your own rate for that model and provider if you entered one, otherwise the vendor's list rate, and then reads the cost your provider reports for the same UTC day to store both figures side by side.[4] The provider's reported figure is what you will be held to.

For a commit this gives three tiers of confidence:

- **Reported cost** from the provider's own cost API, which is what the provider counts against a commitment. INFRO's reconciliation reads it for OpenAI and Anthropic.[4]
- **Estimate at your negotiated rate**, which is good once the rate is entered correctly.
- **Estimate at list rate**, which overstates spend if you already have a lower contract rate and is a planning figure only.[5]

Do the reconciliation before you build the pack. A steady one-direction gap is usually a contract rate the gateway was not told about; reconciliation names the likely cause and suggests a rate.[4] Also note what is left out: requests answered from the response cache never reached the provider, so they are excluded from the comparison.[4] If the vendor's chart and yours disagree by more than the unpriced share, resolve that first, because a disputed baseline weakens every other number.

## The seven 90-day cuts

Ninety days is long enough to include a month-end, a quarter-end and one launch or incident, and short enough that the model mix still resembles today's. The usage API takes `granularity` of `hour`, `day` or `month`, a `group_by` such as `model`, `provider`, `project`, `key`, `feature` or `environment`, and `from` and `to` timestamps; one range may not exceed 400 days and remains subject to your plan's history limit.[6] Each bucket carries requests, units, cost, unpriced requests, error rate and latency percentiles.[6]

| Cut | How to pull it | What it supports |
| --- | --- | --- |
| 1. Daily spend by provider | `granularity=day&group_by=provider` | The floor, median and peak day: what a commit can safely cover |
| 2. Spend by model | `group_by=model`, 90-day total | Which models carry the commit, and which rate tiers matter |
| 3. Hourly units by model | `granularity=hour&group_by=model` | Peak versus typical load, the input for provisioned capacity |
| 4. Spend by project or feature | `group_by=project` or `feature` | Which workloads are durable and which are experiments |
| 5. Weekly trend | Cut 1 summed by week | Whether demand is growing, flat or shrinking |
| 6. Unpriced and outside-gateway share | `unpriced_requests` field; provider-reported cost vs estimate | How much of the baseline is uncertain |
| 7. Cache and fallback shares | Cached-share and fallback signals | How much of the volume the provider would bill at all, and where it lands |

Table: The seven cuts, the query that produces each, and the argument each one supports.

Cut 3 needs care. Hourly buckets hide bursts inside the hour, so they understate the minute-level peak a provisioned or rate-limited deployment must cover. For that, pull the request log (`GET /v1/requests/export` returns one request per row as CSV, up to 50,000 rows per file) and bucket by minute yourself.[7] Percentiles do not average either: a week's p95 is not the mean of seven daily p95 values, so ask for the period's own bucket when you quote a latency figure.[6]

```python
import datetime as dt, os, requests

BASE = "https://api.infro.io/v1/usage"
HDR = {"Authorization": f"Bearer {os.environ['INFRO_API_KEY']}"}

def window(start, end, **params):
    q = {"from": start.isoformat(), "to": end.isoformat(), **params}
    r = requests.get(BASE, headers=HDR, params=q, timeout=60)
    r.raise_for_status()
    return r.json()

end = dt.datetime.now(dt.timezone.utc).replace(minute=0, second=0, microsecond=0)
start = end - dt.timedelta(days=90)

# Usage buckets come back together with no cursor, so split into 30-day windows.
rows = []
cursor = start
while cursor < end:
    nxt = min(cursor + dt.timedelta(days=30), end)
    rows += window(cursor, nxt, granularity="day", group_by="model")["buckets"]
    cursor = nxt
```

The response shape here is for orientation; check the field names against the API reference before you depend on them. The reason for the loop is the documented behaviour: a query returns all its buckets together and there is no cursor pagination for usage, so large analyses are split by time window.[6]

## Cut 6 deserves its own check: what the baseline leaves out

Two gaps can quietly shrink or distort the baseline you commit against.

**Unpriced traffic.** Usage analytics counts unpriced requests explicitly so that an incomplete estimate is not mistaken for a complete bill.[6] If a new model was added without a rate, its spend is missing from your cost column but present in the request count. Quote the unpriced share beside every total.

**Traffic outside the gateway.** INFRO's commitment tracking notes that an estimate can miss both unpriced traffic and traffic that does not go through it.[5] Where the provider's reported cost is available, use that for the commit baseline, since it includes everything on the account. If a vendor's invoice is larger than your gateway total, the difference is either unpriced, direct-call or cached-request accounting; find out which before you accept a vendor number or dispute one.

If part of your usage goes through a cloud provider's hosted models, the commit question changes: whether that spend burns a cloud commitment is a separate contract question, covered in [Do Bedrock and Azure AI calls burn your cloud commit?](https://infro.io/blog/do-bedrock-and-azure-ai-calls-burn-your-cloud-commit). Keep a per-provider column so each negotiation sees only its own spend.

## Price-change exposure: a table, not a worry

A renewal fixes some prices and leaves others open. Exposure is the part of your 90-day spend that a rate change, a promotional price ending, a model retirement or a snapshot swap could move. Build it from cut 2, one row per model:

| Model | 90-day spend | Share of provider spend | Rate basis | Retirement or step-up date |
| --- | --- | --- | --- | --- |
| model id | from usage | computed | list or negotiated | from vendor notice |

Table: Exposure table template, one row per model.

The two right-hand columns are the ones procurement can act on. If a model's rate basis is list, the contract may not cover it at all; if its retirement date falls inside the term, you are negotiating for a model that will be replaced by a successor with unknown pricing. INFRO records vendor deprecation and shutdown dates and warns organizations still sending a retiring model, which gives you the dated column without a manual calendar; see [Introductory AI model prices: how to budget for the step-up](https://infro.io/blog/ai-model-launch-pricing-budgets) for the budgeting side.

Cost also moves with no price change at all. Traffic-change findings flag a model answered by a new snapshot (at least 20% of the day's successful requests and at least 50 of them), output tokens per request up 15% or more, the cached share of prompt tokens down 10 points or more, and fallback share up 5 points or more, each with an estimated weekly cost change.[8] These findings read request metadata, never prompts or answers, so they cannot say whether quality moved.[8] Why it matters for a commit: if your 90-day window contains a lost prompt cache or a longer-answer snapshot, the baseline carries a cost step that may not persist. Mark those dates and decide whether to normalise them before sizing.

> **Example: Illustrative exposure arithmetic**
> These figures are made up to show the method. Suppose one model carried 60% of a provider's 90-day spend, and the contract holds its rate for the term. A 20% rate rise on that model would raise provider spend by 12% (0.60 × 0.20) if volume held, which is the number to compare with what a price-hold clause is worth to you. If that model retires in month 4 of a 12-month term and its successor has no agreed rate, the exposed share is the same 60% for the remaining 8 months.

## Fallback options: leverage only if it is real

Procurement leverage comes from credible alternatives. In gateway terms that means: routes with more than one target, failover that actually triggered, and a record of what the fallback cost. Requests served by a fallback are tracked as a share of traffic, and a rise of 5 points or more is raised as a finding.[8]

Bring three things:

1. **Fallback share over 90 days, per route.** A non-zero share shows the path works. A fallback share that rose by 5 points or more is itself a finding.[8]
2. **The price gap on that path.** Fallbacks that land on a dearer model change the bill; [What does failover do to your bill?](https://infro.io/blog/what-does-failover-do-to-your-bill-price-gaps-and-cold-caches) covers the arithmetic.
3. **An equivalence test.** A fallback you have not tested against your own quality bar is a bargaining claim you cannot defend; see [Is your fallback model good enough?](https://infro.io/blog/is-your-fallback-model-good-enough-test-fallback-equivalence).

State the limits honestly in the room. Moving a large share of volume to another provider is a migration with testing, rate-limit and data-handling work, not a switch. What the evidence supports is a narrower claim: which workloads could move, in how many weeks, and what share of spend that is.

## Turn the cuts into a commit you can defend

INFRO's commitment forecast is the amount consumed so far plus the trailing 28-day daily mean times the days remaining, with a band from the variation in daily spend over those 28 days. It is a straight-line projection that does not model seasonality, planned launches or price changes.[5] Treat any vendor projection built the same way with the same suspicion. The FinOps Forecasting capability makes the point from the other side: forecasts should include rate optimisation and be tracked against actuals within an agreed variance, with a revisit point so the estimate is compared with real usage.[9]

A workable sizing rule:

1. Take the lowest weekly spend in the 90 days after removing any one-off event. That is the **floor**; commit up to it with little regret.
2. Take the median weekly spend. Between floor and median is the **contested band**: commit only if the owner of the project behind it signs the demand (cut 4).
3. Everything above the median is **burst**. Leave it uncommitted, or cover it with capacity terms that can flex.
4. Subtract workloads with a retirement date or a planned migration inside the term (the exposure table).
5. Add known launches explicitly, with an owner, since the trend does not contain them.

> **Example: Illustrative sizing**
> Made-up numbers: weekly spend over 13 weeks has a floor of 40, a median of 55 and a peak of 90 (arbitrary units). Of the median, 8 units belong to a model retiring in month 3. Commit near 40, consider up to 47 (55 minus 8) if the project owners confirm, and leave the rest uncommitted. Committing to the peak of 90 would leave the commit unused for most weeks.

For provisioned capacity the same logic applies to load instead of dollars: size to the typical hour and the minute-level peak from cut 3, then run the break-even in [Provisioned throughput vs pay-as-you-go](https://infro.io/blog/provisioned-throughput-vs-pay-as-you-go-when-reserved-capacity-pays). A commit also does not rescue a workload you could still reduce: the Framework warns that commitments and usage optimisation interact, and that waiting for usage to be fully optimised before buying will almost always mean paying more than a balanced approach.[1] Do the obvious cuts (response cache for repeated identical requests, a stable prompt prefix) first, re-pull the data, then size.

## Package the pack and keep it current

Finance teams want the data in the tools they already use. INFRO exports the request log and usage series as CSV and, through `GET /v1/usage/focus`, a FOCUS v1.4 Cost and Usage dataset in JSON or CSV with per-project, per-key and per-tag attribution.[7] In that dataset the gateway's per-request figure is written to `ListCost` and `ContractedCost`, never to `BilledCost`; `BilledCost` is filled only from the provider's own reported cost, and only with `cost_basis=reconciled`.[10] Keep that distinction when you hand it over: label the estimate as an estimate.

Share aggregates (cuts 1, 2, 5 and the exposure table), not request rows. Request exports can carry custom tags or user identifiers that may include personal information, so review before sharing.[7]

After signing, record the commitment so burn-down is tracked against provider-reported cost, with a status of on track, under, over, not started, ended or insufficient data. The contract terms are entered by hand; INFRO does not read them, and it is not a party to the agreement.[5] Enter the negotiated rate itself under custom rates, because the commitment's stated discount is only for reference and changes no estimate.[5]

> **Note: Where INFRO fits**
> INFRO is the layer that records the requests and estimates described above on your own provider accounts, with 0% markup on model spend. It does not hold your contract, and the commit and its rates stay between you and the provider.

### Pre-meeting checklist

- [ ] Reconciliation shows estimated and provider-reported cost within an agreed variance for each provider.
- [ ] Unpriced requests are zero, or their share is stated beside each total.
- [ ] Direct or cloud-console usage outside the gateway is estimated and listed separately.
- [ ] Cuts 1 to 7 are pulled for the same 90-day window and the same time zone (UTC).
- [ ] One-off events and cost steps (lost cache, new snapshot) are marked.
- [ ] Exposure table has a retirement or step-up date for every model above a materiality line you choose.
- [ ] Fallback share and an equivalence test exist for each route you will cite.
- [ ] Each project owner has signed the demand in the contested band.
- [ ] You have checked what your current agreements allow you to disclose.

## Questions

### Should we share our request-level export with the provider?

Usually no. Share aggregates by model and by day, which carry what a commit or capacity discussion needs. Request exports can hold custom tags or user identifiers that may contain personal information, so review them before they leave the company.[7]

### Can the gateway tell us what rate our contract actually carries?

Not from the contract: commitments and rates are entered by hand. Reconciliation can compare estimated cost with the provider's reported cost and suggest a rate when the gap is steady, which helps check that your records match what the provider bills.[5][4]

## Sources

1. Rate Optimization FinOps Framework Capability — FinOps Foundation. https://www.finops.org/framework/capabilities/rate-optimization/ (accessed 2026-11-20)
2. FinOps Framework Overview — FinOps Foundation. https://www.finops.org/framework/ (accessed 2026-11-20)
3. INFRO documentation overview — INFRO. https://infro.io/docs (accessed 2026-11-20)
4. Cost reconciliation — INFRO. https://infro.io/docs/cost/reconciliation (accessed 2026-11-20)
5. Commitments — INFRO. https://infro.io/docs/cost/commitments (accessed 2026-11-20)
6. Usage analytics — INFRO. https://infro.io/docs/observability/analytics (accessed 2026-11-20)
7. Exports and OpenTelemetry — INFRO. https://infro.io/docs/observability/exports (accessed 2026-11-20)
8. Traffic changes — INFRO. https://infro.io/docs/observability/traffic-changes (accessed 2026-11-20)
9. Forecasting FinOps Framework Capability — FinOps Foundation. https://www.finops.org/framework/capabilities/forecasting/ (accessed 2026-11-20)
10. FOCUS export — INFRO. https://infro.io/docs/observability/focus-export (accessed 2026-11-20)
