# Output token creep, and why your input metrics miss it

> Output token creep raises cost while input stays flat, so prompt-size monitoring shows nothing. Output bills 5x to 8x input. Worked math inside.

URL: https://getculpa.com/output-token-creep
Last reviewed: 2026-08-01

## Answer
Output token creep is a rise in tokens generated per call while input stays flat, so any monitoring built around prompt size sees nothing at all. It matters because output bills five to eight times input on most models here. Culpa, a local-first LLM cost, margin, and forecast ledger, tracks input and output separately per feature, so the two curves stop being reported as one number.

## Why this happens
Teams instrument prompt length because prompts are the part they write. Output is the part the model decides, so it drifts without a commit behind it. A one-line instruction asking for more thorough answers, a model swap to something more verbose, or a format change from a list to prose can all raise output length sharply. On a model where output bills eight times input, four hundred extra output tokens cost the same as three thousand two hundred extra input tokens, and only one of those two would have been noticed.

## What this usually looks like
- Cost per call rose while average prompt size stayed flat.
- Responses got noticeably longer and everyone read that as a quality improvement.
- A model change shipped and nobody compared output length before and after.
- Your dearest feature is the one that returns prose rather than structured fields.

## Common mistakes
- Monitoring prompt size without monitoring response size. Why it hurts: Output is the expensive side on nearly every model, so you're watching the cheaper half of the bill. Do instead: Track both series per feature, and alert on output length the same way you alert on latency.
- Asking for thoroughness in the prompt with no length bound. Why it hurts: Thoroughness has no upper limit, so the instruction quietly buys as many tokens as the model feels like. Do instead: State a target length or a structure, and set a max token limit that reflects what you actually render.
- Swapping models without comparing output length. Why it hurts: Two models at the same rate can differ substantially in verbosity, which changes cost with no rate change. Do instead: Measure tokens per response on both models over the same inputs before switching.

## Self-check
- Plot average output tokens per call per feature over the last six months.
- Find your model's output-to-input ratio, then multiply any output growth by it before judging its size.
- Check whether your max output token setting matches what the interface actually displays.
- Look at your most verbose feature and count how much of a typical response the user reads.
- Compare output length before and after your last model change, if anyone recorded it.

## One instruction asking for thoroughness (illustrative)
A summarisation feature on Gemini 2.5 Flash at real rates of $0.0003 per 1k input and $0.0025 output, an output-to-input ratio of 8.33. The prompt stayed at 3,000 tokens throughout. Volumes are modelled.
  Before: (3 x $0.0003) + (0.25 x $0.0025) = $0.0009 + $0.000625 = $0.001525
  After: (3 x $0.0003) + (0.7 x $0.0025) = $0.0009 + $0.00175 = $0.00265
  Cost per call rose 74% with input completely unchanged
  At 4 million calls a month: $6,100 becomes $10,600
  One output token here costs what 8.33 input tokens cost, so 450 extra output tokens price like 3,750 extra input tokens
A $4,500 monthly increase from a single instruction, invisible to every prompt-size metric on the dashboard, because the prompt never changed.

## Cost figures
Every figure carries its confidence and its source. No figure on this site is provider-reported.
- $0.001525 to $0.00265 — modelled cost per call before and after an output-length increase on Gemini 2.5 Flash [estimated] Source: Both endpoints at real Gemini 2.5 Flash rates per 1k tokens from the price book, effective 2026-07-02. A range because the output lengths are modelled.
- 8.33x — output-to-input price ratio on Gemini 2.5 Flash, the widest in the price book [calculated] Source: $0.0025 output divided by $0.0003 input per 1k, from the price book, effective 2026-07-02.

## FAQ
Q: Why does output cost more than input?
A: Generation is sequential and compute-bound in a way that reading a prompt isn't, and providers price it accordingly. Across the models in Culpa's price book the ratio runs from about 1.34x on some open-weight models to 8.33x on Gemini 2.5 Flash.

Q: How do I stop responses getting longer?
A: Set a max output token limit that matches what your interface renders, ask for a specific structure rather than for thoroughness, and track output length per feature so a change shows up as a metric rather than as a bill.

Q: Does a reasoning model make this worse?
A: It can, because reasoning tokens bill as output on most providers while never reaching the user. That makes the gap between what you pay for and what you display wider, so measuring rendered length alone understates the cost.

## Sources
- Gemini API pricing: https://ai.google.dev/gemini-api/docs/pricing

Run the free Cost Leak Scan: https://app.getculpa.com/scan?source=pseo&slug=output-token-creep&cluster=problem

Machine-readable index of every guide: https://getculpa.com/api/pages
Human-readable index of every guide: https://getculpa.com/guides
Site overview: https://app.getculpa.com/llms.txt

Privacy: Culpa runs on your infrastructure. Your prompts and responses never leave it. Culpa counts calls to run your plan, and it fails open, so if it ever breaks your app keeps running.