If you are building on the OpenAI, Anthropic, or Google AI API, token costs are not a theoretical concern — they compound. A prompt that wastes 200 tokens per call costs an extra $0.002 at GPT-4o pricing. At 100,000 calls per day, that is $200/day, $6,000/month in unnecessary spend.
The good news: most token waste comes from a small set of fixable prompt patterns. None of them require reducing the quality of your instructions.
Where Tokens Go to Waste
Verbose framing sentences
Developers write prompts like emails. Emails need social framing. Prompts do not.
Before (17 tokens):
I was hoping you could help me understand what might be causing the following error
message that I'm seeing in my application.
After (5 tokens):
Explain this error:
The instruction is identical. The token cost is 70% lower.
Redundant context
Everything in a prompt that does not change the correct answer is waste. Background stories, project history, and team context that do not constrain the output consume tokens and bury the actual instruction.
Before:
We are a B2B SaaS company building a project management tool. Our stack is Next.js.
We have been working on this feature for several weeks. Our designer handed off
the mockups last Tuesday. I need to...
After:
Stack: Next.js 15. Task:
Keep only facts that change what the model should output.
Asking for explanations you will not use
Explain your reasoning, then give me the answer doubles output length. If you only need the answer, say so.
Return only the result. No explanation.
Repeating instructions across turns
In multi-turn conversations, developers often re-state constraints in every message. Move persistent constraints to the system prompt once — the model applies them to all turns without token cost per message.
Five Reduction Techniques
1. Colon compression
Replace sentences with key: value pairs. Models parse them equally well at a fraction of the token count.
| Verbose | Compressed | Savings |
|---------|-----------|---------|
| I am using version 3.12 of Python | Python: 3.12 | ~75% |
| Please respond using JSON format | Output: JSON | ~70% |
| Make sure not to include any markdown | No markdown. | ~60% |
2. Reference by position
Refactor the function on line 23 is cheaper than Find the authentication function and refactor it. Positional references are unambiguous and short.
3. Batch related questions
One prompt with three sub-questions is cheaper and produces more coherent answers than three separate API calls. The shared context does not need to be transmitted three times.
Given the following function:
[code]
1. Identify any security vulnerabilities
2. Suggest performance improvements
3. List any missing edge case handling
4. Specify output length upfront
Unconstrained, models generate outputs that feel complete — which means longer than necessary. Setting an explicit length constraint cuts output tokens directly.
Answer in 3 bullet points. Maximum 15 words per bullet.
5. Use structured output instead of asking for formatting
If your application parses the output anyway, request raw structured data and skip the prose.
Return JSON: { "issue": string, "severity": "low" | "medium" | "high", "fix": string }
Do not include any other text.
Before/After: A Real Prompt
Before (94 tokens):
Hi! I'm working on a Node.js project and I've been trying to figure out why my
async function isn't working correctly. I have a function that's supposed to fetch
some data from an API and return it, but I keep getting undefined instead of the
data. I would really appreciate it if you could help me understand why this is
happening and also maybe show me the correct way to do it. Here's my code:
[code]
After (28 tokens):
Language: Node.js 20. Bug: returns undefined instead of fetched data.
Fix the function and explain the root cause in one sentence.
[code]
Same task. Same expected output. 70% fewer input tokens.
The Quality Trade-off (and Why It Is Smaller Than You Think)
The concern with compression is accuracy loss. In practice, removing verbose framing never reduces accuracy — it only removes noise. The accuracy risk comes from removing legitimate context: stack constraints, output requirements, failure handling instructions. Those should stay.
The rule: compress framing language aggressively, preserve constraint language exactly.
Promptuner's 1-click refactor applies this rule automatically — it compresses filler, preserves constraints, and shows you the before/after prompt quality score so you can see that accuracy is maintained while token count drops.
Token optimization is not about writing shorter prompts. It is about writing denser prompts — every token doing work. Audit your highest-volume prompts first: compress framing, batch questions, constrain output length. The cost reduction compounds faster than you expect.