Blog · 2026-07-20 · Vynaris Team
What an AI PR-review bot costs per pull request: the 59x model spread and the re-review tax
An AI code reviewer costs $7.43 to $441 per 1,000 pull requests across six models (verified 2026-07-20). The cache math, the re-review tax, the cache backfire, and when routing cuts 65%.
An AI code reviewer costs between $7.43 and $441 per 1,000 pull requests in model fees, a 59x spread across six models, with prices verified 2026-07-20. Most of that spread is not the model you pick. It is whether you cache the repo context, how many times you re-review each PR, and whether you route the easy diffs away from a frontier model. This is a reproducible cost model, per PR, you can re-run with your own token counts.
The finding, before the model
A PR-review bot reads a diff, pulls in the surrounding repo files and your conventions, and writes back inline comments. The workload has a shape that decides the bill before the model does: a large block of repo context that stays the same while the bot re-reviews a PR across commits, and a small diff that changes each time. Get the caching and the re-review count right and a mid-tier model costs cents per PR. Get them wrong and you pay a 60% penalty for caching that never pays off.
We built this from public pricing only. No product data. Every token count below is an assumption you can edit, and every price is from a provider's live page, captured 2026-07-20.
The workload (edit these)
One batch of 1,000 pull requests. These knobs set the bill.
Assumption Value Note
------------------ ---------------------------------------------------------------------- ----------------------------------------------------------
PRs per batch 1,000 the outcome unit is cost per 1,000 PRs
Diff under review 8,000 [input tokens](https://vynaris.com/glossary/input-tokens)/pass changed hunks plus surrounding lines; different every pass
Repo context 20,000 input tokens relevant files, conventions, prior findings; stable per PR
System + tool defs 1,000 input tokens review rubric and function schemas; stable
Cacheable prefix 21,000 input tokens repo context plus system, identical across a PR's passes
Review output 1,200 [output tokens](https://vynaris.com/glossary/output-tokens)/pass inline comments plus a summary
Passes per PR 3 initial review plus 2 re-reviews on new commitsTwo structural facts drive the cost. First, the 21,000-token prefix repeats on every pass of a given PR, which is exactly what prompt caching is built for. Second, the 8,000-token diff is new on each pass and cannot be cached, so it pays full input rate three times. One PR is 3 passes: 87,000 input tokens and 3,600 output tokens if you cache nothing.
Cost per 1,000 PRs, six models
Same workload, same cost-per-token math, six review-grade models. Uncached, then with the 21,000-token prefix served from cache. Prices verified 2026-07-20.
Model No-cache / 1k PRs Cached / 1k PRs Cache saves
------------------------------------------------------------------------- ----------------- --------------- -----------
[deepseek-v4-flash](https://vynaris.com/models#deepseek-v4-flash) $13.19 $7.43 44%
[Gemini 3.1 Flash-Lite](https://vynaris.com/models#gemini-3-1-flash-lite) $27.15 $17.70 35%
[gpt-5.4-mini](https://vynaris.com/models#gpt-5-4-mini) $81.45 $53.10 35%
[Claude Haiku 4.5](https://vynaris.com/models#claude-haiku-4-5) $105.00 $88.20 16%
[Gemini 3.1 Pro](https://vynaris.com/models#gemini-3-1-pro) $217.20 $141.60 35%
[Opus 4.8](https://vynaris.com/models#claude-opus-4-8) $525.00 $441.00 16%deepseek-v4-flash cached at $7.43 is 59x cheaper than Opus 4.8 cached at $441 for the identical job. Two things in this table surprise people.
The cache savings are uneven, and the reason is the cache-write premium. Anthropic charges a cache-write premium (2x base input for the one-hour window we assume, since commit-triggered re-reviews usually land within the hour). DeepSeek, OpenAI, and Google fold cache writes into the normal input price. So on Haiku 4.5 and Opus 4.8 the 21,000-token prefix costs 2x to store before any read discount applies, which is why caching saves only 16% there against 35% to 44% on the flat-write providers. DeepSeek saves most at 44%, because its cache-hit read is $0.0028 per million, 2% of its input price.
The re-review tax
The "3 passes per PR" assumption is the lever nobody budgets for. An AI reviewer that re-runs on every pushed commit is doing most of its work twice, and often re-flagging the same lines. Here is what each additional pass adds on Haiku 4.5, cached.
Passes per PR Cached / 1k PRs vs single pass
------------- --------------- --------------
1 $56.00 1.00x
2 $72.10 1.29x
3 $88.20 1.57x
5 $120.40 2.15xRe-reviewing 3 times costs 1.57x a single review, not 3x. Caching is why: the 21,000-token prefix is written once and read at a tenth of the price on passes 2 and 3, so only the 8,000-token diff and the 1,200-token output pay full freight on the repeats. Without caching the same three passes cost $105.00, a 1.88x multiplier, because the whole prefix re-bills each time. The cheaper your re-review, the more freely you can trigger it, which is the case for gating the bot on commit rather than on PR-open.
Where a router changes the unit economics
The single-model numbers run every PR on one model. A router runs the whole batch on a cheap model and escalates only the risky PRs to a frontier model for a full second review. The escalation trigger is where PR review differs from extraction: you escalate on a security-sensitive path, a large blast radius, or a low-confidence first pass.
Strategy Cost / 1k PRs vs all-frontier
-------------------------------------------- ------------- ---------------
All Haiku 4.5 (cached) $88.20 80% less
Routed: Haiku bulk + 15% Opus 4.8 escalation $154.35 65% less
All Opus 4.8 (cached) $441.00 —The routed run costs $154.35: $88.20 to review all 1,000 PRs on Haiku 4.5, plus $66.15 to fully re-review the risky 150 on Opus 4.8. That is 65% below running Opus on everything at $441. If your bulk tier is deepseek-v4-flash instead of Haiku, the floor drops to $7.43 for the cheap pass, and the escalated 15% dominate the routed bill. Run your own escalation rate and token shape through the calculator, which takes the per-pass input and output counts directly. This is the same model-routing discipline we applied to the coding-agent cost-per-task model.
The cache backfire
The honest failure mode: caching a PR-review bot can raise the bill. If your re-reviews land after the cache window closes, the prefix is re-written every pass at the write premium and never read at the discount. On Anthropic's one-hour window, a bot that reviews a PR at 9am, 1pm, and 5pm writes the 21,000-token prefix three times at 2x and gets zero read benefit. That costs $168.00 per 1,000 PRs on Haiku 4.5 against $105.00 with no caching at all, a 60% penalty. Opus 4.8 pays the same 60% penalty, $840.00 against $525.00.
Caching a review bot only pays when the passes cluster inside the window. Commit-triggered re-reviews during active development usually do. A nightly re-review of open PRs does not, and there you should either disable caching or use a one-hour cache write only when you know a follow-up commit is imminent. DeepSeek, OpenAI, and Google avoid this trap because their cache write carries no premium, so a missed window costs the same as not caching.
Build notes
PR review has constraints a token model does not capture.
- Latency is a soft constraint, not a hard one. A reviewer can take 30 seconds without blocking a developer the way an inline completion would, so you are rarely forced up-model for speed. The context window matters more: large monorepos push the repo-context block past the token counts here, and past 200k tokens Gemini 3.1 Pro re-rates the whole request to $4 in and $18 out.
- The noise tax is a product cost, not a token cost. A bot that posts 12 comments where 2 matter trains developers to ignore all 12. That waste does not show in the output-token line, which is small, but it decides whether the tool survives. Tune the rubric to suppress low-value comments before you tune the model.
- Repo context is the scaffolding you can shrink. The 20,000-token repo block is the single largest input, and most of it is boilerplate the model does not need. Pruning it is the same discipline we measured in the coding-agent scaffolding overhead post; every 5,000 tokens cut from the prefix removes real money from the write and from every uncached pass.
- Caching mechanics decide half the bill. The 16%-to-44% cache spread above is entirely a function of provider write policy, which we quantified across providers in prompt caching in production.
When this workload does not need a router
The honest tradeoff: if Haiku 4.5 or deepseek-v4-flash clears your review-quality bar on the hard PRs, do not build a router. Pay cents per PR and move on. A router adds a risk classifier, an escalation path, and a second provider integration, and it only earns that complexity when a missed bug in a high-blast-radius PR costs more than the escalation premium. For a repo where a bad merge ships to production, escalating the risky 15% to Opus 4.8 for $66 per 1,000 PRs is cheap insurance. For an internal tool where a missed nit is harmless, the router is over-engineering, and a single cached mid-tier model with a tight rubric is the right build. Route on blast radius, not on vanity.
FAQ
What does an AI PR-review bot cost per pull request? On this model, $0.007 to $0.44 per PR in model fees, which is $7.43 to $441 per 1,000 PRs across deepseek-v4-flash through Opus 4.8, cached, with a 21,000-token repo prefix, an 8,000-token diff, 1,200 output tokens, and 3 review passes per PR. Prices verified 2026-07-20.
Does prompt caching reduce PR-review costs? Usually, by 16% to 44% depending on the provider's cache-write policy, but only when the re-reviews of a PR fall inside the cache window. If they land after the window, caching adds up to 60% on Anthropic models because the prefix is re-written at the 2x premium with no read discount.
How much does re-reviewing on every commit add? Reviewing 3 times instead of once costs 1.57x on a cached Haiku 4.5 setup, not 3x, because the stable repo prefix is read at a tenth of the price on the repeat passes while only the changed diff pays full rate.
When should a PR reviewer route between models? When you can classify a PR's risk and the cost of a missed bug is high. Running every PR on Haiku 4.5 and escalating the risky 15% to Opus 4.8 costs $154.35 per 1,000 PRs, 65% less than running Opus on everything at $441, while still applying the strong model where blast radius is largest.
Which model is cheapest for code review? deepseek-v4-flash at $7.43 per 1,000 PRs cached, driven by its $0.28 output price and near-free cache reads. It is the right choice only if it catches the bugs that matter on your code.
Sources
- Anthropic pricing (Haiku 4.5, Opus 4.8, cache-write and read multipliers, tool-use overhead), captured 2026-07-20: https://platform.claude.com/docs/en/about-claude/pricing
- OpenAI API pricing (gpt-5.4-mini), captured 2026-07-20: https://developers.openai.com/api/docs/pricing
- DeepSeek API pricing (v4-flash, cache-hit rate), captured 2026-07-20: https://api-docs.deepseek.com/quick_start/pricing
- Google Gemini API pricing (3.1 Flash-Lite, 3.1 Pro, >200k tier), captured 2026-07-20: https://ai.google.dev/gemini-api/docs/pricing
- Cost model script and per-PR arithmetic: from the assumptions table above.
Prices change. We re-verify every figure in this post monthly and stamp updates. Numbers here are current as of 2026-07-20.
The lesson from the model: the model line is a small part of a PR-review bill, and caching plus routing decide the rest, in both directions. Vynaris is an OpenAI-compatible gateway that routes each PR to the cheapest right-sized model, escalates on your risk signal, caches the repo prefix correctly, and shows the per-PR cost. One base URL swap. Get an API key at vynaris.com.