How to Build a GPT-5.2 API Workflow That Saves Money
Two teams can send identical prompts to GPT-5.2 and get bills that differ by 80%. The difference is architecture: which model each request hits, how much reasoning effort it is allowed, and how much of the prompt is cached. Prompt wording is the least important variable.
Here is the cost architecture that matters, in the order you should implement it.
Does Reasoning Effort Actually Change the Bill?
Substantially. Higher effort means more internal tokens generated before the visible answer, and those tokens are billed. A pipeline that defaults to high effort on every request is paying for reasoning that most requests do not need.
Practical settings:
- Extraction and classification: lowest effort. There is no reasoning to do.
- Summarization and rewriting: low to medium.
- Debugging and analysis: medium, escalating to high only on retry.
- Formal math and planning: high, but route to the flagship model only here.
Start every pipeline at the lowest effort that passes your quality bar. Raise it per endpoint, based on measured failures, not on a hunch.
How Should You Route Between Models?
Build a two-tier router from day one. Send all requests to the mini tier first with a validation step. On schema failure or low confidence, escalate the same request to the flagship.
| Pattern | Cost impact | Complexity |
|---|---|---|
| Flagship for everything | Baseline | None |
| Mini + escalate on failure | Large saving | Low |
| Mini + cached context | Largest saving | Medium |
| Fine-tuned small model | Best at very high volume | High |
Most teams stop at the second row and never implement caching. Since system prompts and tool schemas are usually identical across calls, cacheable prefixes often make up the majority of input tokens. GPT-5.2 bills cached input at a steep discount, and the only requirement is that the prefix stay byte-identical.
Why Does Structured Output Save So Much?
Free-form prose is where output tokens explode. When you request a typed schema, the model returns the fields and stops — no preamble, no restating the question, no closing summary. On extraction workloads this routinely halves output tokens.
It also removes an entire class of parsing bugs. A response that always matches your schema is worth more than a slightly smarter response you have to clean up.
What Should You Instrument?
Log four numbers per call: input tokens, cached input tokens, output tokens, and latency, each tagged with the endpoint and model. Almost every team that does this finds one endpoint responsible for the majority of spend.
Watch the output-token column especially. Output is the expensive side, and a chatty summarizer with no length cap is the single most common cause of a surprising bill.
What Are the Traps?
Aggressive caching is not free — if your prefix genuinely varies per user, you are restructuring code for zero benefit. Terse prompts can also degrade quality on tasks that need context; measure quality after each optimization, not just cost. And escalation logic can loop if a validator is too strict, doubling spend on requests that were fine the first time. Cap escalation at one retry.
Quick Summary
- Reasoning effort is a per-request cost dial — start at the lowest that passes.
- Route routine traffic to the mini tier and escalate once on failure.
- Cache identical system prompts and tool schemas.
- Use structured output to cut output tokens roughly in half.
- Log tokens per endpoint and find the expensive one before optimizing.
