Aider Cost Per PR Calculator (2026)

Aider's token consumption per PR depends on three things: how much of your codebase Aider reads (context), how much code it generates (output), and how many iterations the conversation runs before you accept. The three shapes below cover roughly 90% of real-world Aider PRs.

**Small fix** (~1,000 input + 500 output tokens). A single-file change: typo, off-by-one, null check, formatter fix. Aider reads the affected file (`/add file.py`), you describe the fix in 1-2 sentences, Aider generates a 5-30 line patch, you accept. Often resolved in one conversation turn.

**Medium feature** (~10,000 input + 3,000 output tokens). A small feature touching 2-4 files: a new API endpoint, a UI component, a test suite for an existing module. Aider reads 2-4 files (~5-15k tokens of context), you describe the feature in a paragraph, Aider generates ~80-200 lines of code across the files, you iterate 1-3 times on minor tweaks. Total token consumption includes the multi-turn cost (Aider re-sends the conversation history on each turn).

**Large refactor** (~50,000 input + 15,000 output tokens). A multi-file refactor: rename a core abstraction across 10+ files, extract a service, migrate an API contract. Aider reads 10-20 files (30-60k tokens of context), you describe the refactor in a structured spec, Aider generates 300-800 lines of changes, you iterate 3-7 times catching edge cases. Multi-turn cost is significant — by turn 5, conversation history alone might be 30k tokens.

**Calibration tip:** Aider prints token consumption after each turn (and total session cost if you run with `--cost`). After your first 20 PRs you'll have personal calibration on which shape your typical work matches. Use the population averages as priors until then.

Reference shape: 1,000 input tokens + 500 output tokens. All numbers are first-PR cost without prompt caching (caching kicks in after the second turn referencing the same file context).

**Claude Opus 4.7:** (1000 × $15 + 500 × $75) / 1M = $0.015 + $0.0375 = **$0.053 per small fix.** The premium model for premium work.

**Claude Sonnet 4.6:** (1000 × $3 + 500 × $15) / 1M = $0.003 + $0.0075 = **$0.011 per small fix.** The default 'sensible' choice — strong leaderboard score, mid pricing.

**Claude Haiku 4.5:** (1000 × $1 + 500 × $5) / 1M = $0.001 + $0.0025 = **$0.0035 per small fix.** Good for trivial fixes where you don't need premium reasoning.

**GPT-5:** (1000 × $1.25 + 500 × $10) / 1M = $0.00125 + $0.005 = **$0.006 per small fix.** Top-tier reasoning at mid-tier price — the single best $/quality ratio in the table.

**GPT-5-mini:** (1000 × $0.25 + 500 × $2) / 1M = $0.00025 + $0.001 = **$0.0013 per small fix.** Punches surprisingly hard for the price.

**Gemini 2.5 Flash:** (1000 × $0.30 + 500 × $2.50) / 1M = $0.0003 + $0.00125 = **$0.0016 per small fix.** Comparable to GPT-5-mini.

**DeepSeek V3:** (1000 × $0.27 + 500 × $1.10) / 1M = $0.00027 + $0.00055 = **$0.0008 per small fix.** Cheapest by a wide margin.

Practical implication: at the small-fix shape, model cost doesn't matter much in absolute terms — even the most expensive option (Opus at $0.053) is rounding error compared to a developer's time. Picking the cheap model here saves dollars per *month*, not per task. For small fixes, optimize for quality, not cost.

Reference shape: 10,000 input tokens + 3,000 output tokens. The cost spread widens at this scale.

**Claude Opus 4.7:** (10000 × $15 + 3000 × $75) / 1M = $0.15 + $0.225 = **$0.38 per medium feature.** Material now — pick this model deliberately, not by default.

**Claude Sonnet 4.6:** (10000 × $3 + 3000 × $15) / 1M = $0.03 + $0.045 = **$0.075 per medium feature.** The sweet spot for most production work.

**Claude Haiku 4.5:** (10000 × $1 + 3000 × $5) / 1M = $0.01 + $0.015 = **$0.025 per medium feature.** Significant savings vs Sonnet (~3x cheaper), with the leaderboard tradeoff of ~10pp lower refactor score.

**GPT-5:** (10000 × $1.25 + 3000 × $10) / 1M = $0.0125 + $0.03 = **$0.043 per medium feature.** Cheaper than Sonnet, near-equivalent leaderboard score — increasingly hard to argue against.

**GPT-5-mini:** (10000 × $0.25 + 3000 × $2) / 1M = $0.0025 + $0.006 = **$0.0085 per medium feature.** Cheaper than even Haiku, with comparable benchmark.

**Gemini 2.5 Flash:** (10000 × $0.30 + 3000 × $2.50) / 1M = $0.003 + $0.0075 = **$0.011 per medium feature.** Similar to GPT-5-mini.

**DeepSeek V3:** (10000 × $0.27 + 3000 × $1.10) / 1M = $0.0027 + $0.0033 = **$0.006 per medium feature.** The budget winner.

Practical implication: at the medium-feature shape, Sonnet 4.6 ($0.075) is 12x more expensive than DeepSeek V3 ($0.006). For high-volume teams, this difference compounds — see the monthly spend section below. For occasional users, it's still rounding error vs the developer's time cost.

Reference shape: 50,000 input tokens + 15,000 output tokens. This is where model choice becomes a budget decision.

**Claude Opus 4.7:** (50000 × $15 + 15000 × $75) / 1M = $0.75 + $1.125 = **$1.88 per large refactor.** Not trivial — at 5 refactors/week, that's $40/month on Opus alone.

**Claude Sonnet 4.6:** (50000 × $3 + 15000 × $15) / 1M = $0.15 + $0.225 = **$0.38 per large refactor.** The reasonable default if you can't justify Opus's 5x premium.

**Claude Haiku 4.5:** (50000 × $1 + 15000 × $5) / 1M = $0.05 + $0.075 = **$0.125 per large refactor.** Significant savings but the leaderboard gap matters more on refactor work — failures can require re-runs that erase the savings.

**GPT-5:** (50000 × $1.25 + 15000 × $10) / 1M = $0.0625 + $0.15 = **$0.21 per large refactor.** Half the cost of Sonnet with comparable benchmark — the $/quality leader at this shape.

**GPT-5-mini:** (50000 × $0.25 + 15000 × $2) / 1M = $0.0125 + $0.03 = **$0.043 per large refactor.** ~9x cheaper than Sonnet; significantly weaker on hard refactors per leaderboard.

**Gemini 2.5 Flash:** (50000 × $0.30 + 15000 × $2.50) / 1M = $0.015 + $0.0375 = **$0.053 per large refactor.** Comparable to GPT-5-mini, slightly better on long-context retention.

**DeepSeek V3:** (50000 × $0.27 + 15000 × $1.10) / 1M = $0.0135 + $0.0165 = **$0.030 per large refactor.** The cheap option, with the caveat that DeepSeek's refactor benchmark is lower — expect 20-30% more failed attempts requiring re-runs.

**Hidden cost: re-runs.** A failed refactor that has to be retried on a higher-tier model erases the savings. If DeepSeek fails 30% of large refactors and you redo them on Sonnet, the effective cost = 0.7 × $0.03 + 0.3 × ($0.03 + $0.38) = $0.144 — higher than just using Sonnet from the start ($0.38 vs $0.144 — wait, still cheaper, but you've paid in iteration time, not just dollars). Calibrate by tracking your re-run rate on your actual work.

Per-PR math is interesting. Monthly burn is what matters. Below assumes 22 working days/month, with PR mix: 40% small fix + 40% medium feature + 20% large refactor.

**Light user (1 PR/day = 22 PRs/month):** weighted cost per PR = 0.4 × small + 0.4 × medium + 0.2 × large.

Sonnet 4.6: 0.4 × $0.011 + 0.4 × $0.075 + 0.2 × $0.38 = $0.004 + $0.030 + $0.076 = $0.110/PR × 22 = **$2.42/month.**

GPT-5: 0.4 × $0.006 + 0.4 × $0.043 + 0.2 × $0.21 = $0.002 + $0.017 + $0.042 = $0.061/PR × 22 = **$1.34/month.**

DeepSeek V3: 0.4 × $0.0008 + 0.4 × $0.006 + 0.2 × $0.03 = $0.0003 + $0.0024 + $0.006 = $0.009/PR × 22 = **$0.19/month.**

**Medium user (5 PRs/day = 110 PRs/month):**

Sonnet 4.6: $0.110 × 110 = **$12.10/month.**

GPT-5: $0.061 × 110 = **$6.71/month.**

DeepSeek V3: $0.009 × 110 = **$0.99/month.**

**Heavy user (20 PRs/day = 440 PRs/month):**

Sonnet 4.6: $0.110 × 440 = **$48.40/month.**

GPT-5: $0.061 × 440 = **$26.84/month.**

DeepSeek V3: $0.009 × 440 = **$3.96/month.**

**Practical reading:** even the heavy-user Sonnet bill ($48/month) is barely more than 2 months of Cursor Pro. The Aider-on-DeepSeek heavy user pays less than $4/month — by far the cheapest serious coding-assistant configuration available. The 'free' part of Aider doesn't quite get to zero, but it gets within a rounding error for cost-sensitive setups.

Aider (free) + Sonnet 4.6 API: a medium user spends $12/month — cheaper than Cursor Pro ($20). A heavy user spends $48/month — more expensive than Cursor Pro. So the crossover happens somewhere between medium and heavy use.

Crossover math: Cursor Pro = $20/month. Aider on Sonnet = $0.11/PR weighted average. $20 / $0.11 = ~182 PRs/month before Aider on Sonnet starts costing more. That's ~8 PRs/day — well into 'heavy user' territory.

**Aider on GPT-5: crossover at ~328 PRs/month** = ~15 PRs/day. **Aider on DeepSeek: crossover at ~2,200 PRs/month** = 100 PRs/day, effectively never. For most users, BYOK Aider on a cheap-but-capable model is genuinely cheaper than any subscription.

**But the crossover ignores three subscription advantages:** (1) Cursor/Copilot include the IDE itself — chat, multi-file editing, Composer, Agent mode — Aider is CLI-only. (2) Subscriptions include premium models without API tier gating (Anthropic Tier 1 caps Sonnet at low rate limits; you need to ramp up). (3) Subscriptions don't bill overage — Aider can surprise you if a runaway agent burns 100k tokens in a single session.

**The BYOK-Aider wins for:** terminal-native developers, heavy users of cheap models (DeepSeek/Gemini Flash/GPT-5-mini), teams that want explicit per-PR cost visibility, anyone running Aider as part of CI/CD where pre-budgeted API spend is the requirement. **Subscription wins for:** developers who want a graphical IDE + AI integrated, users hitting Anthropic/OpenAI rate limits on BYOK, anyone who doesn't want to think about per-call cost.

**Hybrid pattern that works:** Cursor Pro ($20/mo) for daily IDE work + Aider on DeepSeek for CI/CD bulk operations (test generation, doc generation, dep upgrades). Total spend: ~$25/mo, you get the best of both. The Aider CLI is uniquely good at scriptable bulk operations because it's a CLI, not a UI.

The aider.chat/docs/leaderboards page publishes a refactor benchmark — percentage of refactor tasks each model completes correctly. Top tier (Opus 4.7, GPT-5) sit at 84-85%. Mid tier (Sonnet 4.6, Gemini Pro) 78-80%. Lower tier (Haiku, GPT-5-mini, Gemini Flash, DeepSeek V3) 70-75%.

The naive read: 'pick the cheapest model with acceptable benchmark.' The sophisticated read: 'factor in re-run cost — a model that fails 25% of the time costs 1.33x its sticker price in effective $/finished-task.'

**Effective cost math:** if DeepSeek's refactor benchmark is 72% (28% fail rate) and your fallback is Sonnet at 80% (20% fail rate), running DeepSeek first costs: 0.72 × $0.03 (success) + 0.28 × ($0.03 + $0.38 retry on Sonnet) = $0.022 + $0.115 = $0.137 effective per refactor. Compare to Sonnet directly at $0.38 — DeepSeek-with-fallback is still 64% cheaper, but the gap narrows substantially from the headline 12x.

**Where the math flips:** if your fallback isn't Sonnet but a senior engineer reviewing and re-running ($60/hr × 15 min = $15), the cost equation becomes 0.72 × $0.03 + 0.28 × $15 = $0.022 + $4.20 = $4.22 effective per refactor. Suddenly DeepSeek is 11x *more* expensive than just running Sonnet from the start.

**Decision rule:** for high-leverage code (production refactors, security-critical paths, architectural changes), pick from the top-tier benchmark — Opus 4.7 or GPT-5 — even at the price premium. The cost of a silent regression dwarfs the model bill. For low-stakes work (test generation, docstring updates, formatter fixes), pick from the cheap tier — the failure rate matters less because you're going to review the output anyway.

Aider supports prompt caching for Anthropic and OpenAI models via the `--cache-prompts` flag (Anthropic) or automatic prefix-caching (OpenAI). When you're iterating on the same file across multiple turns, the cached portion of your prompt costs 10% of standard input — 90% savings on the read.

**Real numbers on a medium feature** (10k input + 3k output, 4 conversation turns): without caching, you pay 4 × (10k × $3 + 3k × $15) / 1M = $0.30 on Sonnet. With caching after the first turn (3 cached reads at 10% rate): $0.075 + 3 × ($0.0075 + $0.045) = $0.075 + $0.158 = $0.233. **Savings: 22%.** Not life-changing.

**Where caching shines: long sessions.** Take a refactor session with 10 conversation turns over the same set of 30k tokens of context. Without cache: 10 × $0.09 (input) + 10 × $0.045 (output) = $1.35 total. With cache (9 reads cached): $0.09 + 9 × $0.009 + 10 × $0.045 = $0.09 + $0.081 + $0.45 = $0.621. **Savings: 54%.**

**The Anthropic 1-hour cache TTL:** cached prefixes persist for 1 hour after the last access. If you run multiple sessions touching the same files within an hour, you get cache hits across sessions — major savings for iterative work on a focused module.

**Practical Aider config:** always run with `--cache-prompts` on Anthropic models. The 1.25-2x cache-write premium on the first hit is paid back after 1-2 reads, so it's basically free to leave on permanently.

**OpenAI's automatic prefix caching:** no flag needed — OpenAI applies caching automatically on prefixes ≥1024 tokens that have been seen recently. The discount is 50% (not 90% like Anthropic), so the savings are smaller but still meaningful. Caching is one of the strongest arguments for using Anthropic models in long-running Aider sessions.

**Cause 1: /add'ing too many files.** Aider sends every file you've added to the chat in every turn — token-by-token. Adding 20 files when you only need 3 means 5-10x the context cost per turn. Prevention: scope tightly. Use `/drop file.py` when a file is no longer relevant. Use `/add **/*test*.py` patterns only when the test files are actually in scope.

**Cause 2: Long conversation history without `/clear`.** Aider re-sends conversation history each turn. By turn 10, history alone can be 30k+ tokens. Prevention: use `/clear` between unrelated tasks. Start fresh sessions for each major change.

**Cause 3: Running Aider in 'whole' edit mode on large files.** Aider has two edit modes: 'diff' (sends only the diff, cheaper) and 'whole' (re-sends the entire file as output, expensive on large files). Prevention: use `--edit-format diff` (the default on most models). Avoid 'whole' format unless you're hitting diff-application errors.

**Cause 4: Picking Opus when Sonnet suffices.** Opus is 5x more expensive than Sonnet for ~5pp better refactor benchmark. For 90% of work, Sonnet is the right pick. Prevention: default to Sonnet; escalate to Opus only for refactors where you've seen Sonnet fail.

**Cause 5: Forgetting to use `--map-tokens 0` on huge repos.** Aider tries to build a repo map (a summary of every file in your repo) by default. On large monorepos this can be 50k+ tokens of just *map* before your actual context. Prevention: `--map-tokens 0` to disable, or `--map-tokens 1024` to cap. Re-enable only when Aider needs cross-file awareness.

Aider's killer non-IDE use case is scripted bulk operations in CI/CD. Because it's a CLI, you can pipe it into shell scripts, GitHub Actions, or cron jobs. Run it nightly to: generate missing tests for every untested file, sweep for missing JSDoc/docstrings, bump deprecated APIs, run security-rule fixes, etc.

**Worked CI example: nightly docstring sweep.** Every untested public function in your codebase, generate a docstring. On a 500-file repo with 200 missing docstrings, Aider on GPT-5-mini runs ~$0.50 total — under a dollar to fully document the codebase, opening 1 PR with all changes. Compare to a senior dev at $60/hr × 8 hours = $480 for the same work.

**Worked CI example: dependency upgrade automation.** Once a week, Aider runs on the package manager output, applies bumps, fixes breaking changes, opens a PR. On a typical Next.js app, weekly bumps cost $0.05-$0.20 on Sonnet. Compare to 1-2 hours of dev time = $60-$120 weekly = ~$3,000-$6,000 annually saved.

**Worked CI example: PR-review augmentation.** Aider runs on every opened PR, reviews the diff, leaves comments on potential issues. ~$0.02-$0.05 per PR review on Sonnet. Adds a useful 'second pair of eyes' to the review pipeline at near-zero cost.

**Why this isn't subscription-tool territory:** Cursor/Copilot don't have first-class CLI surfaces optimized for headless CI workflows. Devin handles autonomous tasks but at $2/ACU vs Aider's per-token pricing — Aider wins on cost for bulk repeatable work. Replit Agent has a programmatic interface but is optimized for prototyping, not maintenance. Aider is the right tool for 'I want AI in my CI pipeline at a known per-task cost.'

Aider supports per-session model switching with `/model <name>`. Sophisticated users route different task shapes to different models — cheap models for trivial work, premium models for hard work — and only pay the premium when they need it.

**Pattern: cheap-first, escalate on failure.** Start every session with `--model gpt-5-mini` (cheapest capable). If Aider's output fails (build breaks, tests fail), run `/model claude-sonnet-4-6` and retry. Most sessions never escalate; the ones that do still get the answer for ~$0.40 instead of $0.40 from the start. Expected savings: 50-70% vs always-on-Sonnet.

**Pattern: by-task-class.** Hard-code your model choice by the kind of work: `aider --model deepseek-v3 file.py` for docstring/comment updates, `aider --model claude-sonnet-4-6 file.py` for feature work, `aider --model claude-opus-4-7 file.py` for refactors. The mental tax of remembering which to use is small; the cost savings on a heavy week are real.

**Pattern: model-per-phase in a single session.** Plan with Opus 4.7 (best at architectural thinking), execute with Sonnet 4.6 (cost-efficient at implementation), validate with GPT-5 (top benchmark on code review). Aider's `/model` command lets you switch mid-session; the conversation history carries forward. Total cost ends up below straight-Opus while preserving quality.

**Caveat: model-switching has friction.** Each `/model` switch re-establishes context (the new model sees the existing chat history but doesn't have any model-specific cached state). For one-off switches it's fine; for switching every turn, you'll burn extra tokens on re-context. Optimize for batching — run a session in one model, switch deliberately when the task shape demands it.