The three highest-ROI ways to reduce OpenAI API costs: (1) Switch tier-1 tickets to GPT-4o mini — $0.15/MTok vs $2.50/MTok on input, a 16.7× difference. (2) Enable prompt caching — OpenAI charges $1.25/MTok for cached GPT-4o input vs $2.50 standard. (3) Use the Batch API for non-real-time jobs — 50% off inputs and outputs.
Why OpenAI API costs vary so much
Support automation spend swings fast because three variables move at the same time: model price, input length, and output length. On GPT-4o, output tokens cost 4× more than input tokens — $10 per million output tokens versus $2.50 per million input tokens. That means a workflow that produces long summaries, verbose JSON, or repeated reasoning chains can get expensive even when prompts look modest.
Ticket shape matters just as much. A simple tier-1 request may only need 500 to 1,500 total tokens. A billing investigation, product bug triage, or account review can run 4,000 to 15,000+ tokens once logs, prior conversation turns, and system instructions are included. Across a real queue, that creates a 5–20× spread in cost per ticket before model choice enters the picture.
Then there is the model spread. GPT-4o mini costs $0.15 per million input tokens while GPT-4o costs $2.50, making mini 16.7× cheaper on input. Most teams still default to GPT-4o for every task. The bigger opportunity is usually routing work by ticket type, urgency, and reasoning depth instead of sending the full queue through one model path.
The 9 levers
Route tier-1 tickets to GPT-4o mini
GPT-4o mini costs $0.15/MTok input vs $2.50/MTok for GPT-4o — a 16.7× difference. Simple tickets such as password resets, status checks, and documentation lookups do not need GPT-4o's capability. A routing layer that classifies ticket intent before calling the LLM can cut expensive model calls by 40–60% on mixed queues.
Enable prompt caching
OpenAI prompt caching applies automatically to prompts ≥1,024 tokens. Cached input is charged at $1.25/MTok vs $2.50/MTok for GPT-4o — 50% off cached reads. Anthropic charges 0.1× base price on cache hits, or about 90% off. A system prompt with 10,000 tokens hits the cache on each later request that shares the same prefix.
Use the Batch API for non-urgent processing
The Batch API gives 50% off both input and output tokens on OpenAI, and Anthropic also offers a 50% batch discount. The trade-off is up to 24-hour processing time. It fits post-resolution tagging, quality scoring, escalation review, and async analysis. It does not fit real-time ticket responses.
Trim prompt bloat
Audit your system prompt length. Many prompts carry formatting instructions, repeated context, or field definitions the model does not need. Strip them. Every 1,000 tokens removed from a prompt called 1,000 times per month saves $2.50 on GPT-4o or $0.15 on GPT-4o mini in input cost.
Keep static context at the prefix for cache hits
OpenAI caching works on exact prefix matches. Put static content such as system instructions, product documentation, and policy text at the start of the prompt. Put dynamic content such as ticket text and customer data at the end. If the prefix moves around, the cache breaks. This one structural fix can double cache hit rates.
Cap max_tokens on structured outputs
Output tokens cost $10/MTok on GPT-4o. When you ask for structured outputs such as JSON or short summaries, set max_tokens tightly. A model that stops at 150 tokens instead of 500 saves $3.50 per 1,000 calls on GPT-4o. Use a high cap only when you really need long output.
Summarize long conversations before re-sending
Multi-turn support threads get more expensive each turn because the full history is usually re-sent. After three or four turns, summarize earlier messages into a compact block before appending new context. That keeps token count steady and prevents costs from compounding on long-running tickets.
Cache at the application layer for repeated queries
If your support bot fetches the same customer data, account state, or knowledge base entries on each ticket, move that content into the cached prompt prefix instead of fetching it dynamically every time. Application-layer caching in Redis or memory stops the same context from burning API tokens again and again.
Audit and right-size output format
Verbose JSON with many fields costs more output tokens than a targeted summary. Measure average output length across ticket types. If average output is 400 tokens but 60% of responses use under 150 tokens, redesign the schema so the common case stays concise.
Cost comparison: four scenarios at 1,000 tickets/month
Here is a simple way to see how the first three levers change spend. Start with a baseline ticket that uses 2,000 input tokens and 500 output tokens on GPT-4o. The math is straightforward: 2,000 input × $2.50/MTok = $0.005, and 500 output × $10/MTok = $0.005, for a total of $0.01 per ticket. At 1,000 tickets per month, that lands at $10.
Now add routing. If 600 tickets move to GPT-4o mini and 400 stay on GPT-4o, the worked example comes out to about $4.36 per month: $0.0006 × 600 = $0.36 for mini, plus $0.01 × 400 = $4.00 for GPT-4o. Add caching and batch processing for part of the queue, and the number drops again. The table below shows rounded planning figures rather than exact invoice totals, which is usually how operators size savings before implementation.
| Scenario | Model | Levers applied | Monthly API cost |
|---|---|---|---|
| Baseline | GPT-4o | None | ~$10.00 |
| Model routing | GPT-4o mini (60%) + GPT-4o (40%) | Lever 1 | ~$4.20 |
| Caching added | GPT-4o mini + 70% cache hit rate | Levers 1+2 | ~$2.10 |
| Full optimization | Mini + caching + batch (30% async) | Levers 1+2+3 | ~$1.40 |
What these levers don't fix
API cost tuning matters, but it is usually not the biggest line item in B2B technical support. When a ticket needs data from Stripe, Linear, and ClickHouse to diagnose a billing error, the bigger question is whether the system gets to the right answer fast enough to save support and engineering time. A cheaper model that misses the issue can cost more in follow-up work than a higher-priced model that closes the investigation correctly on the first pass.
That is why pricing model choice often matters more than model selection alone. Per-seat pricing can punish teams with many agents. Per-resolution pricing can work when automation handles a large share of common tickets. Per-investigation pricing can better match the hard cases where system access, reasoning, and speed carry the value. These nine levers reduce token spend, but they do not replace a sound operating and pricing model.
Altor builds AI investigation systems for B2B support teams. Usage-based pricing — you pay per investigation, not per seat.
FAQ
Does OpenAI prompt caching work automatically?
Yes. Prompt caching on the OpenAI API is enabled automatically for prompts over 1,024 tokens. Cached input tokens are charged at $1.25/MTok instead of $2.50/MTok for GPT-4o — a 50% reduction. The cache is most effective on high-frequency ticket patterns with shared system prompts.
How much does the OpenAI Batch API save?
The Batch API gives 50% off both input and output tokens. A 1,000-ticket/month queue running GPT-4o at $10/month drops to about $5/month. The trade-off is up to 24-hour processing time, which rules it out for real-time responses but works for async investigation, tagging, or post-processing.
Is GPT-4o mini good enough for support automation?
For tier-1 tickets — password resets, status checks, and documentation lookups — GPT-4o mini handles the job at a fraction of GPT-4o cost. The quality gap shows up on multi-step investigation and reasoning over complex account state. Route by intent, not by blanket model assignment.
What is the cheapest way to run AI on 10,000 support tickets per month?
Routing with GPT-4o mini for simple queries, Batch API for non-urgent processing, and prompt caching for shared context is the low-cost setup. At 2,000 input and 500 output tokens on average, GPT-4o mini plus caching and batching can bring API cost below $1.50 per 1,000 tickets.