If you keep bumping into Cursor usage limits or getting surprised by usage-based charges, the cause is rarely the price per token — those keep falling. It is how agentic coding tools spend tokens. Here is where the money goes and concrete ways to cut it, from habits you can adopt today to work a gateway like merido does for you automatically — without making Cursor slower.

Guide · open source · self-hosted · BYOK

Why Cursor gets expensive

Cursor, Claude Code, Cline and Copilot agents all share one cost mechanism: every turn resends the entire conversation. The model is stateless, so to keep working it has to re-read everything that came before. That makes cost dominated by cumulative input tokens, not the output you actually see.

The first turn might send ~5K input tokens. By turn 30, each request can carry 25–35K input tokens — and you pay for it on every request. An agent task can accumulate millions of input tokens over a session, and input typically accounts for the large majority of the bill. The context fills with things you no longer need: full file dumps, long tool output, and failed attempts that are still being paid for, turn after turn.

Cursor layers its own pricing on top of that. Without going into figures that drift constantly, the shape is: a base plan that includes some allowance, then usage-based requests once you go past it, with premium-model usage costing more per request. So the same habit that inflates input tokens — dragging a bloated context through a long session on the most expensive model — is exactly what burns the allowance and pushes you into overage and usage limits.

The lever

Because the bill is driven by re-sent input, the durable way to cut it is to shrink and cache the input that gets resent — not just to switch to a cheaper model. Keep that in mind as you read the tactics below: the high-leverage ones all target cumulative input.

8 ways to reduce your Cursor bill

01Keep context clean — start a fresh chat often

The cheapest token is the one you never resend. When you finish a sub-task, start a new chat instead of continuing the same thread. A fresh context for a new task means turn 1 pays for ~5K tokens again instead of dragging 30K of stale history into every request. This is the single most impactful habit, and it costs nothing.

02Scope what the agent reads

Pointing the agent at a whole folder or pasting large files inflates every subsequent turn. Reference specific files and functions with @-mentions, and prefer targeted searches over dumping entire trees into context. Tight context is faster and cheaper.

03Use a cheaper model for simple work

Not every step needs the flagship premium model. Renaming, boilerplate, simple edits and routine Q&A can run on a smaller, cheaper model and only escalate the hard reasoning to the expensive one. This is task-level routing — match the model to the difficulty of the step, which also keeps premium-request usage for when it earns its keep.

04Use prompt caching — strategically

If a stable prefix (system prompt, project rules, key files) is reused across many turns, caching it lets you pay full price once and a small fraction thereafter. The caveat: caching the whole, constantly-changing context can backfire. The win comes from caching the fixed part with high reuse — which is exactly where a gateway can decide the boundary for you.

05Compress bulky tool and file output

Tool results — test logs, git output, file reads, build errors — are often huge and then get resent on every following turn. Compressing that output before it enters the context removes a major source of cumulative input. Depending on the command, these specific payloads can shrink substantially, losslessly — without losing the information the model needs to keep going.

06Cap a budget so a limit is yours, not a surprise

Visibility without a brake still leads to bill shock. A hard per-session spend cap — optionally auto-downgrading the model as you approach it — turns “how much did that cost?” into a number you set in advance, instead of finding out when you hit a usage limit.

07Spread load across the keys you already own (BYOK)

Most developers pay for more than one provider or sit on unused free-tier quota. With bring-your-own-key, routing requests across every account you own — by cost and latency, with failover when one is rate-limited or down — uses capacity you are already paying for instead of funneling everything through a single capped lane.

08Measure before you trust a number

Plenty of tools advertise eye-catching savings percentages. Treat any number without a baseline and conditions with suspicion — including your own. The honest way to know you are saving money is a ledger that compares against measured spend, shows the conditions, and reports $0 when it cannot prove a saving. Optimize what you can measure.

Let a gateway do the tedious parts

Tactics 1–3 are habits. Tactics 4–8 are the kind of work you do not want to do by hand on every request — and that is what merido is for. merido is an open-source, local-first AI gateway written in Rust that sits between your coding tool and your LLM providers:

  • Tool-output compression shrinks bulky results before they enter context (tactic 5), losslessly.
  • Cost-, quota- and latency-aware routing spreads requests across every provider and account you own, with automatic failover (tactics 3 & 7).
  • Strategic prompt-cache control manages the cache boundary so caching helps instead of backfiring (tactic 4).
  • A live burn-rate meter and per-session budget caps show what you are spending and stop it where you set the line (tactics 6 & 8).
  • A savings ledger records measured savings against a baseline — and shows nothing when it cannot prove one (tactic 8).
ToS-clean by design

merido uses your own API keys, runs self-hosted, and never pools, shares or resells credentials. It is bring-your-own-key, your billing, your machine — the compliant way to put a gateway in front of an OpenAI-compatible client like Cursor.

It speaks an OpenAI-compatible API and supports Cursor, Claude Code, Codex, Cline and Continue as first-class clients, so you point your tool at one endpoint and keep working exactly as before — just cheaper and with the bill in plain sight. The same mechanism applies to other agentic CLIs: see our guide to reducing Claude Code costs.

See, cap, and prove your AI coding spend

Open source, single self-hosted binary, on your own keys. Get started in a couple of minutes.

Get started →Read the docs

Related guides

Frequently asked questions

Why is Cursor AI so expensive?

Because every turn resends the whole conversation, so cost is driven by cumulative input tokens. Long sessions pay for the same context repeatedly, and file dumps, long tool output and failed attempts pile up. By turn 30 each request can carry 25–35K input tokens — and usage-based and premium-model requests multiply that.

How do I stop hitting Cursor usage limits?

Spend less per request: keep context clean, scope what the agent reads, route simple edits to a cheaper model, cache stable prefixes, and compress bulky tool output. With BYOK you can also route across the providers and accounts you already own with failover, so you are not funneling everything through one capped lane.

Can I use my own API keys (BYOK) to cut the bill?

Yes. Point an OpenAI-compatible client at a gateway like merido to bring your own provider keys, route by cost and latency across the accounts you own, and apply tool-output compression and caching. merido is self-hosted and uses your own keys — it never pools, shares or resells credentials.

Can merido lower my bill automatically?

merido applies these tactics for you — compressing tool output, routing across the accounts you own, showing a live burn-rate meter with budget caps, and recording measured savings — using your own keys, self-hosted, never pooling or reselling them. Get started here.