—tokens / month
—net value / month
—break-even reviewer time
Where the tokens go
| Component | Tokens / review | Cost / review | Cost / month |
|---|
The same reviews on different model tiers
| Tier | $ / 1M in · out | Cost / PR | Cost / month |
|---|
Reference rates for broad 2026 tiers, not specific products — check current pricing on the model comparison. A reasoning model also bills its hidden thinking tokens as output, so its real cost sits above the row shown here.
Tune the noise before you tune the model
At any realistic salary, a couple of minutes spent dismissing a bogus comment costs more than a hundred reviews' worth of tokens — which is why the lever that matters is comment quality, not model price. Narrow the review scope, raise the confidence threshold, and stop attaching context the model does not use. Price the underlying tokens on the LLM token cost calculator, see what caching that fixed block is worth on the prompt caching savings calculator, compare paying per seat against calling the API yourself on the subscription vs API calculator, and put the whole assistant spend against hours saved on the AI coding ROI calculator.
How this calculator works
The AI Code Review Cost Calculator builds one review from the bottom up. The diff is lines changed times tokens per line; the fixed context — system prompt, coding guidelines, pinned repository files — is added on top and split into a cached share billed at a fraction of the input rate and an uncached remainder billed in full. Output tokens are the review comments themselves, priced at the output rate, which is typically four to five times the input rate and is usually the largest single line. Multiplying by passes per PR accounts for re-reviews after the author pushes changes, and multiplying by monthly pull requests gives the invoice.
The second half is the part most comparisons skip. Reviewer minutes saved valued at a loaded hourly rate is the benefit; false flags times the minutes spent dismissing each is a real cost paid in the same currency. Netting all three gives the monthly value, and dividing the API cost per PR by the reviewer's per-second rate gives the break-even: the amount of human time the bot must save on each pull request to pay for itself, which is usually seconds. That asymmetry is the whole point — token price is almost never the deciding variable, comment precision is. Rates are reference estimates and change frequently; confirm current pricing with your provider.
How much does AI code review cost per pull request?
For a typical pull request on a mid-tier model the token cost is somewhere between one and five cents, and the number is driven far more by how you assemble the prompt than by the size of the diff. A few hundred changed lines is only a couple of thousand tokens; the system prompt, coding guidelines and surrounding repository context that get attached to every review are usually larger than the diff itself, and they are sent again on every follow-up pass. Output is the other half of the bill, because review comments are long-form text priced at four or five times the input rate, so a bot that writes an essay on every file costs multiples of one that writes three targeted comments. Multiply by the number of passes — most pull requests get re-reviewed at least once after changes — and a team pushing several hundred pull requests a month typically lands in the tens of dollars, not the hundreds. That is small enough that the interesting question is not the token bill but whether the reviews are worth reading.
Does prompt caching actually help for code review?
More than for almost any other workload, because code review is the rare case where a large block of the prompt is genuinely identical every time. Your review instructions, style guide, architecture notes and any pinned files do not change between pull requests, and cached reads are typically billed at around a tenth of the normal input rate. If that fixed block is the majority of your input tokens — which it usually is once you attach real repository context — caching removes most of the input side of the bill. The catch is ordering and lifetime: the cached block has to come first in the prompt and has to be reused before the cache entry expires, so a repository with a trickle of pull requests spread across the day may miss the window and pay full price anyway. The calculator lets you set the cached share directly so you can see the difference between a busy monorepo that hits cache constantly and a quiet one that rarely does.
What actually makes AI code review expensive?
Not the tokens — the false positives. A bot that flags one or two things per pull request that turn out to be non-issues costs a couple of minutes of a reviewer's attention each time, and a reviewer's minute is worth vastly more than a thousand tokens. At any realistic salary, two minutes of dismissing noise costs more than a hundred reviews' worth of API calls. That is why this calculator prices the triage time alongside the token bill and subtracts both from the reviewer time saved: it is the only way to see that tuning the bot to be quieter is worth far more than switching to a cheaper model. The same logic explains why teams abandon these tools despite a trivial invoice — the invoice was never the problem. If the calculator shows a negative net, the fix is fewer, better comments, not a smaller model.
Is a per-seat code review tool cheaper than calling the API yourself?
It depends almost entirely on pull requests per developer rather than on team size. Hosted review tools charge per seat per month, so their cost scales with headcount and is flat in usage; calling the API yourself scales with pull requests and is flat in headcount. A team where each developer opens a handful of pull requests a month will find raw API calls dramatically cheaper, because the token cost per pull request is cents while a seat is tens of dollars. A team shipping many small pull requests per developer per day narrows the gap, and at that point the hosted tool's integration, inline comments, and lack of maintenance burden are usually worth the difference. Use this calculator to get your true per-pull-request API cost, multiply by your volume, and compare it against the seat quote — and remember to add the engineering time to build and maintain the integration, which is the cost most build-versus-buy comparisons quietly omit.