Token-Budget Modeling for Platform Teams: a Spreadsheet Your CFO Can Audit

The AI-tool approval gets signed by engineering. The bill lands on the CFO's desk two quarters later, after the five-person pilot became 300 seats and nobody modeled what 300 seats of token consumption costs. GitHub Copilot mailed that exact memo to finance teams across the industry: premium-request billing started June 18, 2025, then the whole product moved to usage-based billing on June 1, 2026, and the community thread filled with admins watching costs climb on the same headcount. The per-token price was never the problem. Approval happened before anyone priced the load at target scale.

Here is the payoff you leave with: a per-request cost formula and a filled-in spreadsheet you can hand to finance, where every input price links to the vendor's live rate card and the totals are arithmetic your CFO can re-run. Build it before the rollout conversation and your program gets funded once. Skip it and finance freezes the rollout mid-quarter when the first consolidated invoice does not match anyone's mental model.

The four variables that drive the bill

Every LLM cost model reduces to four inputs. Get any one wrong and the forecast is off by a multiple.

• Model tier. Per-token rates span a wide band. On Anthropic's API rate card (fetched 2026-07-31), Haiku 4.5 input is $1/MTok and output $5/MTok; Sonnet 4.6 is $3 input and $15 output; Opus 4.8 is $5 input and $25 output. Output on Opus costs 5x Haiku's.
• Context size per request. This is the variable teams undercount. Cached and uncached input are priced differently: a cache read costs 0.1x the base input rate, and a 5-minute cache write costs 1.25x. Sonnet 4.6 input is $3/MTok base, $0.30 cached, $3.75 to write.
• Requests per user per day. Coding-assistant usage typically runs 10 to 40 requests per developer per day, and it climbs as people find new uses.
• Team size. Linear on everything above. The compounding of the first three is what nobody eyeballs correctly at the rollout meeting.

One structural note for finance: API access is not a seat license. Anthropic bills prepaid Usage Credits drawn down by actual token consumption, with optional auto-reload. Per-seat cost is an emergent property of usage, not a fixed line item, which is the shape finance teams find hardest to forecast.

The worked example

Take a 50-seat engineering team on Claude Sonnet 4.6 via the API (not Claude.ai seats). Assumptions, stated so they can be argued with: 20 requests per developer per day, 22 workdays a month, 4,000 input tokens per request (2,000 of that a cacheable system prompt, 2,000 fresh code context), 800 output tokens, and an 80% cache-hit rate on the system prompt.

The per-request formula, using the Sonnet 4.6 rates above:

cost_per_request =
    system_tokens   x [hit_rate*cache_read + (1-hit_rate)*cache_write]
  + fresh_input_tok x base_input_rate
  + output_tokens   x output_rate

# Sonnet 4.6 per MTok: base_input $3, cache_read $0.30, cache_write $3.75, output $15
# = 2,000 x [0.8*$0.30 + 0.2*$3.75]/M  +  2,000 x $3/M  +  800 x $15/M
# = $0.00198 + $0.00600 + $0.01200  =  ~$0.020 per request

Math for the monthly total: 20 req x 22 workdays x 50 seats = 22,000 requests/mo, then 22,000 x $0.020 = ~$440/mo. The totals below are that arithmetic, computed from the cited Sonnet 4.6 unit prices.

Scenario	Per request	Requests/mo	Monthly	Annual	Per seat/mo
50 seats, 80% cache (baseline)	$0.020	22,000	~$440	~$5,275	~$8.79
150 seats, 80% cache	$0.020	66,000	~$1,319	~$15,824	~$8.79
50 seats, 30% cache (month-one reality)	$0.023	22,000	~$515	~$6,185	~$10.31

Unit prices per Anthropic API pricing (also on anthropic.com/pricing), fetched 2026-07-31; the table cells are Pondero's arithmetic from those rates.

Two things to notice. Scaling to 150 seats is linear, so per-seat cost holds at $8.79 and the model stays honest. And dropping the cache-hit rate from 80% to 30%, the common first-month state, adds only ~$75/mo here, because output tokens ($0.012/request) dominate the bill and caching only trims the input side. What you send in and how much comes back out moves the number more than the caching knob does.

The spreadsheet you hand to finance

The deliverable is a spreadsheet finance can audit and re-run when a rate changes. Tab one: rows are model options (Haiku 4.5, Sonnet 4.6, Opus 4.8), columns are seat tiers (25 / 50 / 100 / 250 / 500), and each cell is monthly API cost at the baseline assumptions, with the per-token rates in a linked, dated source cell. Tab two is sensitivity: hold the model fixed and vary context size and requests-per-day to see which lever moves the total most.

We keep the maintained version behind the AI coding cost calculator; this article is the methodology behind it. Send the sheet, not a screenshot: the auditability is the point.

What breaks first

Three assumptions fail first, and each one is a multiplier on the whole bill. State them as numbers when you present the model.

• Context size, off by 2 to 3x. Pilot context is compressed: short task-specific sessions. Production context carries IDE history, file trees, long system prompts, and multi-turn conversation. Push fresh input from 2,000 to 6,000 tokens and per-request cost goes from ~$0.020 to ~$0.032, a 60% jump: the 50-seat baseline climbs from ~$440 to ~$704/mo on that change alone.

• Caching cold start. Month one runs at a low hit rate before breakpoints are tuned. Price month one at the 30% row (~$515/mo, ~$10.31/seat), not the steady-state 80% row, or your first invoice overshoots the forecast by 17% and finance stops trusting the model.

• Request-volume growth. A static 20/day is realistic at rollout; 35 to 40/day is realistic by month three as developers find new uses. At 40/day the 50-seat bill doubles to ~$880/mo. This is the largest single lever because it scales linearly across every other variable.

What your CFO will ask

Copy this block into the internal deck. Five questions, direct answers.

1. What is the per-seat cost? About $8.79/seat/month at the baseline (Sonnet 4.6, 80% cache, 20 requests/day), ~$10.31 in month one before caching tunes, and roughly $18 if daily volume climbs to 40. Plan the budget around the heavy-usage figure.

2. Is this per-seat or consumption? Consumption. The API bills tokens against prepaid Usage Credits, not a fixed seat license, so a quiet developer costs cents and a heavy one costs several times the average. The per-seat figure is a modeling average, not a contracted price.

3. What happens when we go over budget? On prepaid credits, self-serve usage pauses when the balance hits zero unless auto-reload is on, in which case billing continues. Pick the failure mode you want on purpose: a hard stop that blocks developers, or uncapped spend that protects them.

4. Can we cap spend? Yes. Set a monthly spend limit at the organization level and per workspace, and split API keys per team so one runaway agent can't drain the shared pool. Cap at the key level as well as the org level.

5. What does renewal look like? There is no renewal. API pricing is not a SaaS annual seat commit; the bill is last month's token usage at the posted per-MTok rates, which can change. Model it as a variable utility bill, not a fixed contract.

When self-hosting flips the math

Self-hosting inference (vLLM or Ollama on your own GPU, or a negotiated volume agreement) breaks even against pay-per-token only when annual API spend clears the fully loaded cost of the hardware plus the engineer who keeps it running. At ~$5,275/year for 50 Sonnet seats, the API beats a dedicated GPU and an on-call rotation easily; the crossover for most enterprise coding workloads lands in the low hundreds of seats, roughly 150 to 300, and moves with GPU rental rates and model choice, so verify it against your own numbers. Self-hosting buys data residency and rate control; it costs you higher tail latency, real ops overhead, and a compliance surface you now own end to end. Until modeled API spend crosses that line with margin, the token bill is the cheaper answer.

For where this cost layer sits in the broader rollout, see how enterprises actually ship AI agents in 2026. Build the model first. The team that walks in with a sheet the CFO can audit is the team that keeps its budget when the first big invoice arrives.