AI code review cost is easy to underestimate in both directions. Some teams assume every automated review burns dollars; others assume it is free because it is bundled into a seat. If you run your own reviewer over an OpenAI-compatible API, the cost is just tokens: how much diff and context you send in, and how much feedback comes back out. This post shows how to estimate that number per pull request, using illustrative token counts and AtmoRouter's live per-token rates at the time of writing. It is AtmoRouter-authored and not an independent benchmark.
Why this question came up again
On November 6, 2026, GitHub shipped API management for Copilot code review: admins can now read and update review settings through REST and GraphQL, review sessions show the AI credits a review consumed, and "balanced" effort reviews use three reviewer models with another model combining their findings.
That last detail is a useful mental model even if you never touch Copilot. A serious automated review is often several model calls, not one. Once you see a credit or token count per review, the natural next question is what the same workflow costs when you call models directly.
The formula for AI code review cost
For one model call:
textcost = (input_tokens / 1,000,000) x input_rate
+ (output_tokens / 1,000,000) x output_rateFor a review, input_tokens is usually your system prompt, repository review guidelines, the diff, and any surrounding file context. output_tokens is the review itself. Output is priced higher than input on almost every model, but reviews are input-heavy, so diff size usually dominates.
For the examples below, assume a mid-sized pull request: 30,000 input tokens and 3,000 output tokens per reviewer call. Your numbers will differ, so measure a week of real PRs before budgeting.
Cost per pull request at live rates
These are the lowest "from" rates on AtmoRouter's models page when this was written, in USD per million tokens. Rates refresh, and each model page is authoritative.
| Model ID | Input / Output (from) | One review (30k in / 3k out) | 200 PRs per month | |---|---|---|---| | cc/claude-sonnet-4-6 | $0.5625 / $2.8125 | about $0.025 | about $5.06 | | cc/claude-sonnet-5-5 | $0.32 / $1.60 | about $0.014 | about $2.88 | | oai/gpt-6.1-sol | $0.09 / $0.45 | about $0.004 | about $0.81 | | mm/MiniMax-M3 | $0.012 / $0.048 | about $0.0005 | about $0.10 | | zai/glm-5.3 | $0.0035 / $0.011 | about $0.00014 | about $0.03 |
The spread is large, which is the point: the model you pick matters far more than whether you review every PR.
Multi-model review panels
A panel copies the pattern GitHub describes: several cheaper reviewers look at the diff independently, then one stronger model merges and de-duplicates their findings.
Example panel per PR:
- Three reviewers, each 30k in / 3k out:
zai/glm-5.3,mm/MiniMax-M3,oai/gpt-6.1-sol - One merger with 12k in / 2k out:
cc/claude-sonnet-5-5
At the rates above that comes to roughly $0.012 per PR, or about $2.35 for 200 PRs, cheaper than a single cc/claude-sonnet-4-6 pass in this example. Whether a panel finds more real bugs is something you should test on your own repositories; the arithmetic only tells you it is affordable to try.
Cut input cost with prompt caching
Most of a review prompt repeats across PRs: the system prompt, your style rules, maybe a module map. On models that support it, AtmoRouter bills cached input at 10% of the input rate. If 20k of the 30k input tokens are a stable prefix, a cc/claude-sonnet-4-6 review drops from about $0.025 to about $0.015. Keep the stable part first and the diff last so the prefix actually matches. The prompt caching guide covers the details.
A minimal reviewer you can run in CI
This script reads a diff, asks one model for a review, and prints the reported token usage so you can track real cost instead of guessing.
pythonimport os, subprocess
from openai import OpenAI
client = OpenAI(
base_url="https://atmorouter.dev/v1",
api_key=os.environ["ATMOROUTER_API_KEY"],
)
base = os.environ.get("BASE_REF", "origin/main")
diff = subprocess.run(
["git", "diff", f"{base}...HEAD"],
capture_output=True, text=True, check=True,
).stdout[:120_000] # hard cap so a huge PR cannot blow the budget
resp = client.chat.completions.create(
model="oai/gpt-6.1-sol",
messages=[
{"role": "system", "content": "You are a strict code reviewer. "
"List concrete bugs, security issues and missing tests. "
"Skip style nitpicks. Reply in Markdown."},
{"role": "user", "content": diff},
],
max_tokens=3000,
)
print(resp.choices[0].message.content)
u = resp.usage
print(f"\n<!-- tokens: in={u.prompt_tokens} out={u.completion_tokens} -->")In GitHub Actions, run it on pull_request, store the key as a secret, and post the output with gh pr comment. The character cap and max_tokens are your two cost guardrails; a prepaid balance is the third, since spend cannot exceed what you loaded.
FAQ
How much does AI code review cost per pull request? With 30k input and 3k output tokens, from well under a cent on zai/glm-5.3 to about $0.025 on cc/claude-sonnet-4-6 at the live rates above. Large diffs scale roughly linearly.
Is a self-hosted reviewer cheaper than a bundled tool? Sometimes. Bundled tools include hosting, UI and settings management you would otherwise build. Compare your measured token cost plus maintenance time, not token cost alone.
Which model should I start with? Start cheap, such as oai/gpt-6.1-sol or mm/MiniMax-M3, on a sample of past PRs, then compare findings against a stronger model before switching everything.
Am I billed for failed requests? No. On AtmoRouter, failed requests are never billed, and there are no seat fees.
Next step
Pick two models, replay ten recent pull requests through the script above, and record tokens and useful findings for each. Then check current rates on the AtmoRouter models page and set a monthly budget from real numbers.