Token Budgets for a Team: Set a Cap That Actually Stops

A budget nobody can enforce is a forecast.

Most AI spend numbers are reached the same way. Multiply a seat price by a headcount, add a contingency, put it in a spreadsheet. Then a workflow moves to the API, an agent runs overnight, and the invoice arrives with a line item nobody recognises. The fix is not a tighter forecast. It is knowing what generates the charge, then setting a ceiling the platform enforces.

Before reading this: Prompt Engineering Fundamentals and Choosing Claude, ChatGPT, Gemini or Copilot for Your Job both help. Neither is essential.

After reading this article, you will be able to: - Convert a workflow into a token count and a dollar figure you can defend - Name the five drivers of an AI bill and the control that moves each - Set a spend limit at team level and recognise the caps that are not caps

What is a token worth in dollars?

A token is the unit a model reads and writes in. Anthropic's rule of thumb is one token to approximately four characters, or 0.75 words in English. A 1,000 word memo is therefore roughly 1,300 tokens.

Documents are heavier than people expect. On Anthropic's own figures, an average web page of 10 kB is about 2,500 tokens and a 500 kB research paper PDF about 125,000. One attachment, before anyone replies.

Published list prices, United States dollars per million tokens, as at 26 September 2026.

Output is priced at five times input on most of this list, so what the model writes costs more than what you feed it. No vendor here publishes Australian dollar prices, so every figure carries an exchange rate.

One trap breaks any budget written in tokens. Claude 4.7 and later models use a newer tokenizer that, in Anthropic's words, produces approximately 30 percent more tokens for the same text, while Sonnet 4.6 and earlier use the previous one. Build a budget on Sonnet 4.6 counts, move to a later model, and identical work costs about a third more with nothing visible changing. Budget in dollars.

What actually drives the bill?

Five things, in rough order of how often they surprise people.

Input volume, which is mostly repetition. Every turn resends the conversation. A long system prompt and an attached policy document are paid for on every request, not once. Context engineering is a cost discipline as well as an accuracy one, and so is the choice between a project and a raw chat.

Output length, including the part you cannot see. Reasoning models generate tokens before they answer. OpenAI states it plainly: reasoning tokens are not visible via the API, still occupy space in the model's context window, and are billed as output tokens. Invisible tokens, charged at the dearest rate on the list. Anthropic describes max_tokens as a hard limit on total output, thinking plus response text.

Cached against uncached input. A cache hit costs 0.1x the base input price on most Claude models, and 0.025x on Fable 5.1. Writing costs more than reading, at 1.25x for the five-minute duration and 2x for the one-hour, and Anthropic publishes the break-even: caching pays off after one cache read on the five-minute duration and two on the one-hour. Cached prefixes still occupy the context window, so caching changes what you pay, not whether those tokens count.

Tool calls, which charge before they run. Declaring a tool adds input tokens whether or not it fires. On Claude Opus 5 the tool-use system prompt is 286 tokens, the computer toolset about 4,500 and the browser toolset about 6,600. Server-side tools charge on top: web search on the Claude API costs $10 per 1,000 searches, plus the tokens the results bring back. Code execution gives each organisation 1,550 free hours a month, then $0.05 per container hour. If files are included in the request, execution time is billed even if the tool is not called, because files are preloaded onto the container.

Frequency. Anthropic's worked example puts the rest in proportion. Ten thousand support tickets at roughly 3,700 tokens each on Haiku 4.5 costs about $37.00. The unit cost is trivial. Volume makes a budget.

The two settings that move the bill further than the model does

Model choice gets the attention. Two settings move more.

The first is effort. Anthropic describes the parameter as controlling how many tokens Claude spends when responding, and says it affects all tokens in the response: text, tool calls and thinking. The default is high on most models and medium on Claude Opus 5.5. Its guidance for Opus 4.7 is blunt about the top of the range. At xhigh, expect meaningfully higher token usage than high. At max, on most workloads it adds significant cost for relatively small quality gains. OpenAI says the same.

Two cautions. Effort is a behavioural signal, not a strict token budget, so it steers spend without capping it. And changing the top-level effort value between requests invalidates prompt caching, so varying effort mid-conversation pays twice.

The second setting is speed. Fast mode on Claude Opus 5 and Opus 4.8 bills at $10 input and $50 output, against $5 and $25 at standard speed. Same model, double the price, selected by a flag.

One threshold trap runs the opposite way most teams expect. On Claude 4.6 and later a 900k-token request is billed at the same per-token rate as a 9k-token request. Anthropic is the exception, not the rule. OpenAI publishes separate short-context and long-context rates, with long-context input at double the short-context rate and output at 1.5 times, and Google charges a long-context premium on its Pro tier. Grok 4.6 is the bluntest, at $2 and $6 under 200,000 tokens and $4 and $12 at or above. Its pricing page states that requests whose prompt reaches the listed token threshold are billed at the higher rate for all tokens in the request. Not the excess. The whole request.

None of this argues for routing everything to the cheapest model, which is a separate decision. It argues for knowing which dial somebody turned.

Which caps will the platform actually enforce?

A cap is only a cap if the platform returns an error. Two vendors publish how theirs behave.

On the Claude API, spend limits and rate limits are separate mechanisms. Each usage tier carries a monthly spend cap: $500 on Start, $1,000 on Build, $200,000 on Scale, none on Custom. Reaching it pauses API usage until 00:00 UTC on the first of the next month, returning HTTP 429 with the error code enforced_spend_limit_reached and no retry-after header, so automatic SDK retries fail against it. An organisation can also set its own limit below the tier cap, which returns HTTP 400 instead.

The team-level control is the workspace. Custom spend and rate limits can be set per workspace but not on the default one, unset workspace limits inherit the organisation limit, and organisation-wide limits always apply even if workspace limits add up to more. A per-team ceiling has to live in a named workspace.

OpenAI's equivalent boundary is the project. Its production guidance names three controls: spend alerts when usage exceeds a dollar amount, a hard spend limit that stops API traffic when tracked spend reaches it, and custom rate and spend limits per project.

Then there are the caps that are not caps.

• A subscription seat is a floor, not a ceiling. On paid Claude plans, reaching a usage limit offers the option to turn on usage credits and keep working at standard API rates, converting a fixed seat cost into metered spend.
• Shared allowances hide coupling. In ChatGPT, Codex, Work and Excel draw on a pooled allowance, so heavy use of one silently consumes another.
• Some limits are not numbers. Google publishes Gemini Apps usage limits only as multipliers of an unpublished baseline, and the baseline moves: 2x and 4x standard limits on the middle tiers, 5x or 20x the tier below on the top one. Google notes they may change.
• In the Microsoft stack, ordinary use is licensed rather than metered. The exception is pay-as-you-go agents, which sit under the management controls of Microsoft's Copilot controls framework alongside licensing and metering, and accrue consumption without anybody holding an API key.

One reading trap closes this out, because a team misreading its telemetry sets the wrong number. On the Claude API the input_tokens field counts only tokens after the last cache breakpoint. In Anthropic's example, a 200k token cached document with a 50 token question reads as 50, when the true total is 200,050. Add cache reads and cache creation.

Build the budget from the workflow, not the seat

Estimate one workflow at a time, from real counts. The prompt below does the arithmetic without letting the model invent the prices.

Build a monthly cost estimate for one AI workflow. Use only the figures below.

Workflow: [WORKFLOW_NAME]
Runs per month: [RUNS_PER_MONTH]
Input words per run: [INPUT_WORDS]
Of that input, the words that are identical every run: [REPEATED_WORDS]
Output words per run: [OUTPUT_WORDS]
Tools called per run, and which ones: [TOOL_CALLS]
Model and effort level: [MODEL_AND_EFFORT]
Input price per million tokens: [INPUT_PRICE]
Output price per million tokens: [OUTPUT_PRICE]
Cache read price per million tokens: [CACHE_READ_PRICE]

Do this, showing the arithmetic at each step:
1. Convert words to tokens at 0.75 words per token.
2. Cost the repeated input twice, once uncached and once as a cache read.
3. Give a monthly total, then a high case at three times the output length.
4. List separately every figure you had to assume rather than read above.

Do not supply prices from your own knowledge, do not round any total, and do
not give a single number without the high case beside it.

Three adjustments turn that estimate into a budget.

Batch anything that can wait. Anthropic and OpenAI both discount asynchronous batch processing by 50 percent on input and output, at up to 100,000 and 50,000 requests per batch. Note the side effect before moving regulated work: batching stores inputs and outputs on the vendor's servers for 29 or 30 days by design. Interactive work does not.

Price the residency you asked for. Pinning Claude API inference to the United States through inference_geo applies a 1.1x multiplier across every token category, and regional endpoints on partner clouds carry a 10 percent premium over global ones.

Date-stamp the model. GPT-5.6 Sol's $4 and $20 are promotional at least to 21 November 2026, Google's introductory $0.75 and $3.75 become $1.50 and $7.50 on 1 January 2027, and the tokenizer change applies on any move to Claude 4.7 or later. Write a review date beside the number.

Try this

Take the workflow your team runs most often. Count the words in one real input and one real output, run the prompt above with current published prices, then compare the total against last month's invoice. A gap of more than a factor of two is usually uncached repeated input, or reasoning at an effort level nobody chose. Set the enforced limit at the high case.

Where to go next

• Reasoning Budgets in Production: How Teams Are Spending Them
• Claude Model Routing for Regulated Work
• Every Model You Rely On Has a Retirement Date
• 2M-Token Multimodal Contexts: Where They Actually Pay Off

Bottom line

A price list tells you what a token costs. It does not tell you how many tokens a habit generates, and habit is where the bill comes from. Five drivers do the work, two settings and one context threshold move a bill further than most model choices, and none of it matters unless something stops the work at a number. The useful output here is an enforced limit on a named workspace, not a forecast. Set the limit first.

Do this Monday

• Estimate your highest-volume workflow with the prompt above, in dollars rather than tokens.
• Set a spend limit against a named workspace or project, never the organisation default.
• Check whether fast mode, xhigh effort or max effort is on where nobody deliberately chose it.
• Move every job that can wait onto the batch endpoint, and record the retention footprint.
• Put the promotional and introductory price expiries in the calendar.

References

1. Anthropic, Pricing. https://platform.claude.com/docs/en/about-claude/pricing
2. Anthropic, Rate limits. https://platform.claude.com/docs/en/api/rate-limits
3. Anthropic, Effort. https://platform.claude.com/docs/en/build-with-claude/effort
4. Anthropic, Context windows. https://platform.claude.com/docs/en/build-with-claude/context-windows
5. Anthropic, Batch processing. https://platform.claude.com/docs/en/build-with-claude/batch-processing
6. Anthropic, Claude pricing. https://claude.com/pricing
7. OpenAI, Reasoning models. https://developers.openai.com/api/docs/guides/reasoning
8. OpenAI, Production best practices. https://developers.openai.com/api/docs/guides/production-best-practices
9. OpenAI, Pricing. https://developers.openai.com/api/docs/pricing
10. OpenAI, Batch API. https://developers.openai.com/api/docs/guides/batch
11. OpenAI, Codex in ChatGPT. https://help.openai.com/en/articles/11369540-codex-in-chatgpt
12. SpaceXAI, Pricing. https://docs.x.ai/developers/pricing
13. Google, Gemini 3.8 Flash. https://blog.google/innovation-and-ai/models-and-research/gemini-models/3-8-flash-and-3-8-flash-cyber/
14. Google, Gemini Apps limits and upgrades. https://support.google.com/gemini/answer/16275805
15. Microsoft, Copilot controls overview. https://learn.microsoft.com/en-us/microsoft-365/copilot/copilot-controls/overview
16. Anthropic, Claude in Amazon Bedrock. https://platform.claude.com/docs/en/build-with-claude/claude-in-amazon-bedrock
17. Anthropic, Claude on Vertex AI. https://platform.claude.com/docs/en/build-with-claude/claude-on-vertex-ai