Skip to main content
tool-tweaks intermediate 7 min read

Set up Cursor + Claude API for a $20/mo coding pair (with proper rate limits)

Summary. Cursor Pro is $20/mo. Most devs cap out the included Claude requests by week 2 and either upgrade to Business ($40/mo) or get throttled at 30 seconds per request. The fix: use Cursor's pooled allowance for cheap tab-completion and route your own API key through Composer and Agent sessions with a hard monthly spend cap. You get an uncapped, unthrottled Sonnet-quality pair programmer for a predictable $20 Anthropic ceiling on top of Cursor Pro — cheaper than Cursor Business and fully transparent about what each session costs.

Tools needed: Cursor Pro ($20/mo), Anthropic API key, 10 minutes.

The problem

Cursor Pro's Claude allowance is generous for casual use but not for the sessions that matter most. A single Composer session with a large context — opening five files, asking for a multi-file refactor, reviewing the diff, asking a follow-up — can burn 15–25 requests. Do that three times a day and you have burned through a week's allowance. Throttle mode kicks in: 30-second waits per request. That latency kills the flow state that makes AI-assisted coding valuable in the first place.

The workaround most developers discover: add your own Anthropic API key and bypass the pooled allowance. But without a hard spend cap configured, it is easy to wake up to a $150 bill after a 6-hour debugging marathon. The setup below gives you the benefit (no throttling) without the risk (unbounded API cost).

Step-by-step

  1. Set up the Anthropic API key with a hard spend cap. Go to console.anthropic.com → Billing → Limits. Set a hard monthly limit of $20. This is the only number you need to care about after setup. Anthropic will stop processing requests when you hit it — not a soft warning, a hard stop.
  2. Configure Cursor to use your API key for Sonnet. Open Cursor → Settings (⌘,) → Models. Enable Anthropic. Paste your key. Scroll down to claude-sonnet-4-5 (or claude-sonnet-4) and toggle "Use custom API key" to ON. Leave claude-haiku and cursor-small on Cursor's pooled allowance — those are cheap enough to not matter.
  3. Route intelligently: Composer and Agent on your key, everything else on the pool. In practice: use your API key model for Composer sessions (multi-file context, agentic runs) and Cursor's pooled model for inline suggestions and single-line fixes. The inline suggestion engine runs on cheaper models anyway — your $20 Anthropic budget is 100% consumed by the expensive Composer turns, which is exactly what you want.
  4. Write a proper .cursorrules file for every project. This is the highest-ROI investment for reducing token waste. Without rules, Cursor re-explains your stack conventions through back-and-forth corrections. A 30-line rules file eliminates 80% of that overhead. Create .cursorrules in your project root: 
    You are a senior engineer on this codebase. Rules:
- Stack: Next.js 15 App Router, TypeScript strict, Tailwind, Drizzle + D1
- All API routes in app/api/ as Route Handlers (not pages/api)
- DB queries only in src/db/queries/ — never inline
- Use server components by default; client components need 'use client' + a reason
- Error handling: Result pattern (type Result = Ok | Err), never raw throws in handlers
- Testing: Vitest. Run with pnpm test. Co-locate tests as *.test.ts
- Never add console.log in commits. Use structured logging (src/lib/logger)
- Commits: conventional commits format (feat/fix/chore/refactor)
- When unsure, ask before implementing. Do not make architectural decisions silently.
  5. Set Composer to multi-file mode for refactors, single-file mode for fixes. Cursor's Composer (Cmd+Shift+I) has a context selector. For single-function fixes, pin only the relevant file — it dramatically reduces input tokens and therefore cost. For refactors, add all relevant files explicitly rather than letting Cursor auto-include. Auto-include can pull 20+ files when you only need 4.
  6. Monitor token spend after the first week. In the Anthropic console, go to Usage → API Usage. Sort by model. After 7 days of normal use you will see your per-session burn rate. Most developers land at $0.15–0.40 per significant Composer session. If you are burning faster, your context is too broad or your .cursorrules is not cutting back-and-forth.

Task routing guide — which mode for which job

  • Tab completion (pooled, free): Single-line completions, import suggestions, boilerplate fill-in, function signatures. This is the majority of keystrokes. Let Cursor handle it on the pooled plan — it uses fast cheap models for this layer.
  • Inline edit (pooled or your key): Selected-code rewrites under 20 lines. Use the pooled allowance. Cost is low.
  • Composer single-file (your Sonnet key): Refactoring a function, writing a component from spec, debugging a single module. Typical cost: $0.05–0.15 per session.
  • Composer multi-file / Agent (your Sonnet key): Architecture changes, cross-cutting refactors, test suite generation. Typical cost: $0.20–0.60 per session. Use deliberately — these are the sessions that eat your $20 budget.

Expected outcome

You hit your $20 Anthropic budget around day 22–26 of a normal working month. When you hit the cap, Cursor falls back to its pooled models gracefully (tab-complete still works, Composer throttles but does not break). Total spend: $20 Cursor Pro + $20 Anthropic = $40/month. That is exactly what Cursor Business costs, but you get full per-session cost transparency and zero throttling on the sessions that matter. Heavy users who push Composer daily at 2–3 significant sessions/day may want to set the Anthropic cap at $30–35 instead.

Gotchas

  • Anthropic's budget cap is a hard stop — but it is evaluated at the beginning of a request, not mid-stream. A very long Composer session that starts just below the cap can still push you over by $0.50–1. Budget slightly conservatively ($18 effective if you want to stay under $20).
  • Cursor's Composer with Sonnet 4.5 on a large repo can cost $0.40–0.80 per agentic run that reads 10+ files. Use the context selector aggressively. Reading only the files you need is the single biggest cost lever.
  • If you work on a regulated-industry codebase, BYO key means your Composer requests go directly to Anthropic rather than through Cursor's enterprise privacy layer. Review Anthropic's data processing agreement (Zero Data Retention option is available on scale tiers) before routing sensitive code through your key.
  • The .cursorrules file is the most under-used feature in Cursor. If you are skipping step 4, you are leaving the biggest efficiency gain on the table.

Time to set up: 10 min. Estimated savings: $20/mo vs Cursor Business + zero throttling on your most important sessions + full cost transparency.