The AI Code Review Price Book (2026): Normalised 3 Ways

Direct answer

AI code review costs $0 to $200 per developer per month in published list prices, or $0.025 per KB of diff if you buy usage instead of seats. Normalised to cost per 100 pull requests the same market runs $48 to $2,500. The reason those two ranges do not look like each other is that “per developer” means six different things across six vendors, and three of 24 tools publish an enterprise price at all. Verified 2026-10-18.

Every price on this page was re-verified against the vendor’s own pricing page on 2026-10-18. This market reprices monthly: four of the figures below changed during the last 90 days, and two of our own earlier figures were wrong. The price-change log near the end is dated for that reason.

This is the reference page. If you want the shorter buyer-facing answer with worked totals for a budget conversation, read what does AI code review cost. If you want the billing mechanics - monthly versus annual, overage, seat definitions, one-time payment - read AI code review with monthly billing. If you are under 20 developers and doing the worth-it arithmetic, read AI code review for small teams.

AI code review pricing comparison

Direct answer: The cheapest paid AI code review seats on 2026-10-18 are Sourcery Pro, Bito Team and Korbit Pro at $12 per developer per month on annual billing. The most expensive published seat is cubic Max at $160 annual and $200 monthly. The cheapest structure in the market is Qodo Pro Team at $30 a month flat for up to 30 users, and the cheapest usage model is Macroscope Budget mode at $0.025 per KB of diff.

Here is the whole market on the eight columns that actually determine your bill. Entry paid price is the cheapest tier that reviews private repositories. Full-capability price is the highest self-serve tier with a published number, which is the honest ceiling before a sales call.

The master price table

Tool	Entry paid price	Full-capability price	Billing basis	What counts as a billable unit	Overage mechanic	Free tier	Trial	Published enterprise price
CodeRabbit	Essentials $24/dev/mo annual ($30 monthly)	Advanced $72/dev/mo annual	Per seat, repo cap by tier	Developers who create pull requests	$0.25 per reviewed file; $0.40 per agent minute	Public repos free forever; private = 1 summary-only review/hour	14 days, no card	Custom
Greptile	Pro $30/seat/mo	Pro $30 + $1/credit	Per seat + 50 credits per seat	Any developer who received a review that period	$1 per extra credit; credits per author, do not pool	Starter: 1 active dev, 50 credits/mo	14 days	Custom
Sourcery	Pro $12/dev/mo annual ($15 monthly)	Team $24 annual ($30 monthly)	Per seat	Assigned seats only	Review limits by tier, not metered	Free forever on public repos, full features	14 days, no card, org-wide	Custom, billed annually
Korbit AI	Pro $12/user/mo annual ($15 monthly)	Max $18 annual ($24 monthly)	Per seat	Per Git author	Not published; unlimited reviews	Korbit Max free for all open source	14 days of Max	Custom, billed annually
Bito	Team $12/seat/mo annual ($15 monthly)	Professional $20 annual ($25 monthly)	Per seat + 5,000 lines per seat	Per seat	$5 per 1,000 reviewed lines on PR diffs	None permanent	14 days, no card	Custom
Codacy	Team $18/dev/mo annual ($21 monthly)	Team $18, caps at 30 devs	Per seat, 100 private repos	Every Git contributor who commits to a private repo	None published	Developer tier free forever; free on open source	Yes	Custom (Business)
Graphite	Starter $20/user/mo annual ($24 monthly)	Team $40 annual ($48 monthly)	Per seat	Per user	”Limited” AI reviews on Starter, unlimited on Team	Hobby: personal repos, limited AI reviews	Team trial, length not published	Custom
Gitar	Core $20/user/mo annual ($25 monthly)	Pro $40 annual ($50 monthly), up to 50 users	Per seat, unlimited repos	Per user	Not published	Free for OSI-licensed public repos, all Pro features	14 days, no card	Custom
DeepSource	Team $24/user/mo	Team $24 + AI usage	Per seat plus separate AI metering	Every member and admin on the team	$8 per 10K processed LOC (Standard), $15 per 10K (Advanced)	Public repos free, 1,000 PRs/mo	14 days, up to $50 AI credits, no card	Custom
CodeAnt AI	Premium $24/user/mo	Premium $24, unlimited reviews	Per user	Per user	None on Premium	100% off for open source by request	14 days, 100 PR reviews, no card	Custom
cubic	Team $40/dev/mo monthly, yearly -20%	Max $200/dev/mo monthly, $160 yearly	Per seat + reviewed-line allowance	Per developer, 40K/80K/160K lines	Not published	Starter: 20 PR reviews/mo per GitHub org	7 days, no card	Custom
Ito	Pro $40/seat/mo	Pro $40 + $1/review	Per seat + 50 reviews per seat	Per seat; read-only users free	$1 per additional review	Free for MIT/Apache non-commercial projects	First 20 reviews free, no card	Custom, 25+ engineers
Qodo	Pro Team $30/mo flat, up to 30 users	Pro Team $30 + credits	Flat team fee + pooled credits	No seats	Credits at $0.012, pooled, expire monthly	None permanent; open-source programme	14 days, unlimited, no card	Custom (30+ users)
Entelligence	Startup $750/mo, up to 15 engineers	Scale $2,500/mo, 16-50 engineers	Flat band by engineer count	Engineer count band + review allowance	$1 per review past 300 (Startup) or 1,000 (Scale)	None published	No card required	Custom
Macroscope	Budget $0.025/KB, $0.25 floor	Ultra $0.20/KB, $2.00 floor	Per KB of diff, no seats	Nothing. There are no seats	Pure usage. Every re-review billed separately	$100 usage credit per new workspace	Usage credit is the trial	Custom
Cursor Bugbot	Cursor Premium $30/mo + usage	Cursor Ultra $200/mo + usage	Per review, ~$1.00-1.50	Requires a Cursor Premium seat or above	Usage draws on the plan allowance	Not on Free or Plus	14 days	Custom
GitHub Copilot	Pro $10/mo (code review included)	Business $19/user, Enterprise $39/user	Per seat + AI credits + Actions minutes	Per licensed user	AI credits at $0.01; Actions minutes at standard rates	Copilot Free: no code review	Yes	$39/user/mo (Enterprise)
Claude Code Code Review	Claude Team $20/seat/mo annual ($25 monthly)	Team Premium seat $100 annual ($125 monthly)	Per seat + usage at API rates	Per seat	Usage at API rates	None	Not published for Code Review	$20/seat/mo annual, 20-seat minimum (Claude Enterprise)
Snyk Code	Team from $25/contributing dev/mo	Enterprise credit platform	Project counts on self-serve, credits on Enterprise	”Contributing developer”: committed to a monitored private repo in last 90 days	Test caps: 100/mo Free, 1,000/mo Team	Free: 5 projects, 100 Code tests/mo	Yes	1 credit = $1; Code at 1.0 credit per active contributor per day
Semgrep	Teams from $30/contributor/mo (Code)	Teams $30 Code + $30 Supply Chain + $15 Secrets	Per contributor, per product	Contributor with >=1 commit to a scanned private repo in 90 days	AI credits: 20/dev/mo Teams, 50 Enterprise	Free: 10 contributors, 10 private repos, 60 AI credits	Yes	Custom
SonarQube Cloud	Team from $34/mo to 100k LOC	Enterprise custom (over 50 devs)	Lines of code	LOC analysed	LOC tier increments	Free to 50k LOC private, includes PR analysis, no expiry	Yes	Custom
Aikido	Basic $300/mo for 10 users	Advanced $600/mo + 100 credits/mo	Flat monthly by user pack	User pack	Deep PR Review consumes credits	Developer tier free forever, 2 users	Yes	Custom
PR-Agent	$0	$0	MIT licence	None	Your own LLM tokens and infra	Entirely free, any team size	N/A	N/A
Kodus	$0	$0	AGPLv3	None	Your own LLM tokens and infra	Entirely free, any team size	N/A	N/A

Primary sources, all fetched 2026-10-18: CodeRabbit, Greptile, Sourcery, Korbit, Bito, Codacy, Graphite, Gitar via Sonar, DeepSource, cubic, Ito, Qodo, Entelligence, Macroscope docs, Cursor, GitHub Copilot plans, Claude, Snyk, Semgrep, SonarQube Cloud, Aikido.

Two tools are deliberately absent. Tabnine, because it was acquired by Tricentis on 2026-07-30 and its pricing page now redirects to a Tricentis contact form, so every per-seat figure in circulation is unverified. Gemini Code Assist, because its free tier’s status is genuinely unresolved: one source says it stopped serving requests on 18 June 2026, Google’s own documentation still describes a GitHub app install receiving at least 100 pull request reviews a day, and we will not guess at what would be the most generous free offer in the market.

Why “per developer” is not a comparable unit

Direct answer: Six vendors use six different definitions of a billable developer, and three price in something other than developers entirely. CodeRabbit bills only PR authors. Greptile bills review recipients and its credits do not pool. Korbit bills Git authors. DeepSource bills team members whether or not they commit. Snyk bills project counts on self-serve. Macroscope has no seats at all. The same 20-person org produces a 16x swing in the seat line.

This is the insight that organises the whole page, and it is the thing every comparison table in this market quietly ignores. Lining up $12, $24 and $30 as though they measure the same quantity is the pricing equivalent of comparing a per-mile rate to a per-trip rate.

Vendor	Billable unit	Who you pay for	Who is free	What makes it swing
CodeRabbit	PR author	Developers who create pull requests	Reviewers, EMs, QA, anyone who never opens a PR	Typically 30-40% below headcount
Greptile	Review recipient	Any developer who received a review that billing period	Developers who shipped nothing that month	Varies month to month; credits are per author and never pool
Korbit AI	Git author	Every Git author in the scanned repos	App users who are not Git authors	Decoupled from your invite list entirely
Codacy	Private-repo committer	Every Git contributor who commits to a private repo	Public-repo-only contributors	Wider net than PR authors
DeepSource	Team membership	Every member and admin added to DeepSource	Nobody. Membership is the trigger	Dormant accounts cost full price
Snyk	Contributing developer	Committed to a monitored private repo in last 90 days, by Git author email	Public-repo-only committers	90-day window means a leaver bills for a quarter
Semgrep	Contributor	>=1 commit to a scanned private repo in 90 days	Public-repo-only committers	Same 90-day tail as Snyk
Qodo	Nothing	Flat $30/mo for up to 30 users	All of them, individually	Hard cliff at 30 users
Entelligence	Engineer count band	The band, not the people	Nobody inside the band	$750 at 15 engineers is $50/dev; $2,500 at 16 is $156/dev
Macroscope	KB of diff	Nothing. No seats, no minimum	Everyone	Scales with diff volume, not people
Snyk Enterprise	Active contributor per day	1.0 credit ($1) per active contributor per day for Code	Inactive days	A dev active 20 days costs $20; active 30 days costs $30
cubic	Seat plus reviewed-line allowance	Per developer, 40K/80K/160K lines by tier	Nobody	Allowance attaches to the seat, so it does not pool either

Work an example. Take a 20-person engineering org where 14 people open pull requests, 18 commit something to a private repo during the quarter, and all 20 have accounts:

• CodeRabbit Essentials: 14 seats x $24 = $336/mo
• Greptile Pro: depends on who got reviewed. 14 recipients = $420; 18 = $540, before credit overage
• Codacy Team: 18 committers x $18 = $324/mo, and you hit the 30-dev cap at 30
• DeepSource Team: 20 members x $24 = $480/mo, plus AI review metered separately
• Entelligence Scale: 20 engineers lands in the 16-50 band = $2,500/mo
• Qodo Pro Team: $30/mo flat, plus credits
• Macroscope Balanced: 200 PRs at $0.95 = $190/mo, no seats at all

Same org, same month, and the seat line spans $30 to $2,500. That is an 83x range, and none of it is explained by review quality. The number you compare is not the sticker price. It is your own unit count under each vendor’s specific definition. Pull git shortlog -sne --since="90 days ago" against your private repos, pull your distinct PR-author list, and price both.

View 1: cost per developer per month

Direct answer: Useful for stable teams where everybody opens pull requests, misleading everywhere else. On annual billing the published per-developer rates on 2026-10-18 are: $12 Sourcery Pro, Bito Team, Korbit Pro; $18 Codacy Team, Korbit Max; $20 Graphite Starter, Gitar Core; $24 CodeRabbit Essentials, DeepSource Team, CodeAnt Premium, Sourcery Team; $30 Greptile Pro, cubic Team yearly; $40 Gitar Pro, Graphite Team, Ito Pro; $72 CodeRabbit Advanced; $79 cubic Pro; $160 cubic Max.

Tool and tier	Annual $/dev/mo	Monthly $/dev/mo	Annual discount	Hard cap in the tier
Sourcery Pro	$12	$15	20%	Review limits not published
Bito Team	$12	$15	20%	5,000 lines/seat; seat cap reported at 25
Korbit Pro	$12	$15	20%	Unlimited reviews, users, repos
Codacy Team	$18	$21	~14%	30 devs, 100 private repos
Korbit Max	$18	$24	25%	None published
Graphite Starter	$20	$24	~17%	“Limited” AI reviews
Gitar Core	$20	$25	20%	50 users
CodeRabbit Essentials	$24	$30	20%	1 linked repository, 150 files/review, 5 reviews/dev/hour
DeepSource Team	$24	up to 20% more	up to 20%	AI review billed separately
CodeAnt Premium	$24	$30 listed on AWS Marketplace	unconfirmed	No permanent free tier
Sourcery Team	$24	$30	20%	Nightly scans of 50 repos
Greptile Pro	$30	$30	not published	50 credits/seat, do not pool
cubic Team	$30 (see note)	$40	-20% toggle	40,000 reviewed lines/dev
CodeRabbit Team	$48	$60	20%	5 repos, 300 files/review, 8 reviews/hour
Gitar Pro	$40	$50	20%	50 users
Graphite Team	$40	$48	~17%	Unlimited AI reviews
Ito Pro	$40	$40	none	50 reviews/seat, $1 each after
cubic Pro	$79 (see note)	$99	-20% toggle	80,000 reviewed lines/dev
CodeRabbit Advanced	$72	not published	n/a	10 repos, 10 reviews/hour
cubic Max	$160	$200	-20% toggle	160,000 reviewed lines/dev

Note on cubic. The live pricing page on 2026-10-18 shows a “Yearly -20%” toggle but rendered $40, $99 and $200 in both states for us. Twenty percent off those figures computes to $32, $79.20 and $160. The widely published yearly figures are $30, $79 and $160. We report the monthly prices as verified and the yearly prices as approximate, because we could not get the page to render the discounted state.

Where this view lies. It assumes your billable unit count equals your developer count. It does not, for any of the seat-priced vendors in the table above, and it does not exist at all for Qodo, Entelligence, Macroscope or Snyk Enterprise. Use it for a first-pass budget envelope and then correct it with your own unit count.

View 2: cost per 100 pull requests

Direct answer: This is the only view that compares seat pricing against usage pricing honestly. At one review per pull request, 100 PRs costs $48 on Macroscope Budget mode, $95 on Macroscope Balanced, $120 on Sourcery Pro or Korbit Pro, $240 on CodeRabbit Essentials, $300 on Greptile Pro standard, $425 on Cursor Bugbot including the required Cursor seat, $480 on CodeRabbit Team, $750 on Entelligence Startup, and $800 on Greptile Pro at Apex depth.

Assumptions, stated so you can re-run it: 10 pull requests per developer per month, so 100 PRs is roughly 10 developers for one month; one review per PR; 19 KB average diff, which is Macroscope’s own published average review size; seat-priced tools on annual billing. These are the same assumptions repowise’s cost-per-100-PRs model uses, which makes the two sets of figures comparable.

Tool and tier	Model	Cost per 100 PRs	What moves it
PR-Agent / Kodus self-hosted	Licence-free	$0 + your tokens	Model choice and infra
Macroscope Budget	$0.025/KB, $0.25 floor	$48	Diff size; 10 KB floor penalises tiny PRs
Macroscope Balanced	$0.05/KB, $0.50 floor	$95	Re-reviews billed separately
Sourcery Pro	$12/seat	$120	Nothing. Flat
Korbit Pro	$12/seat	$120	Nothing. Unlimited reviews
Macroscope Precise	$0.06/KB, $0.60 floor	$114	Mode choice
Codacy Team	$18/seat	$180	Committer count, not PR count
Korbit Max	$18/seat	$180	Nothing
GitHub Copilot Business	$19/seat + credits	$190 + $25-500 credits	Review effort level; Actions minutes unmodellable
Gitar Core	$20/seat	$200	Nothing published
Graphite Starter	$20/seat	$200	”Limited” AI reviews, unquantified
CodeRabbit Essentials	$24/seat	$240	1-repo cap; $0.25/file past hourly limit
DeepSource Team	$24/seat + usage	$240	~47,500 LOC processed is inside the $100/user/yr AI credit
cubic Team	$30/seat yearly	$300	40K reviewed lines/dev is ample at this volume
Greptile Pro, standard	$30/seat + credits	$300	Depth setting
Macroscope Ultra	$0.20/KB, $2.00 floor	$380	Mode choice
Gitar Pro	$40/seat	$400	Nothing published
Graphite Team	$40/seat	$400	Unlimited AI reviews
Ito Pro	$40/seat, 50 reviews each	$400	$1 per review past 50/seat
Cursor Bugbot	~$1.25/review + $30 Cursor seat	~$425	Cursor seat is unavoidable
CodeRabbit Team	$48/seat	$480	5-repo cap
CodeRabbit Advanced	$72/seat	$720	10-repo cap
Entelligence Startup	$750/mo flat, 300 reviews	$750	Flat until 300 reviews, then $1 each
Qodo Pro Team	$30 flat + $0.012/credit	~$197	~139 credits per review; credits expire monthly
Greptile Pro, Apex depth	10 credits per review	$800	A configuration setting, not a plan change
Claude Code Review	~$15-25/review, unverified	$1,500-2,500 + $200 in Claude Team seats	Anthropic publishes no per-review price

Three readings matter.

The crossover is around 30 reviews per developer per month. Below it, usage pricing wins; above it, seat pricing wins because the marginal review is free. Macroscope’s own break-even arithmetic, which checks out against its published $0.95 average review, puts it cheaper than Greptile Pro up to 31 reviews per developer per month. At the 10 PRs per developer this model assumes, you are comfortably inside usage territory.

Greptile’s 2.7x swing is a dropdown, not a plan. Standard depth is $300 per 100 PRs. Apex depth costs 10 credits a review, which burns a seat’s entire 50-credit allowance in five reviews and lands at $800. Nothing on the pricing page tells you that the depth selector is a 167% price increase.

The Qodo figure needs a caveat. Qodo publishes $0.012 per credit and describes its credit packs as roughly 18 reviews per 2,500 credits, which implies about 139 credits per review and $166.80 of credits for 100 reviews, plus the $30 flat fee, so $197. repowise publishes ~$167 for the same scenario, which appears to be the credit cost without the flat fee. We report ours as $197 and flag the difference rather than pick a winner.

View 3: 3-year TCO at 10, 50 and 200 developers

Direct answer: At list price with flat headcount, 3-year totals run from $1,728 (Macroscope Budget mode, 10 devs) to $1,152,000 (cubic Max, 200 devs). The mainstream band at 10 developers is $8,640 to $10,800, at 50 developers $43,200 to $54,000, and at 200 developers $172,800 to $345,600. Every one of those numbers assumes price stability this market has not demonstrated for a single quarter in 2026.

PR volume scales with headcount at 10 PRs per developer per month, so 10 devs is 100 PRs, 50 devs is 500 PRs, 200 devs is 2,000 PRs.

Tool and tier	3-yr at 10 devs	3-yr at 50 devs	3-yr at 200 devs
PR-Agent / Kodus self-hosted	$0 licence + tokens + ops	$0 licence + tokens + ops	$0 licence + tokens + ops
Macroscope Budget mode	$1,728	$8,640	$34,560
Macroscope Balanced	$3,420	$17,100	$68,400
Sourcery Pro $12	$4,320	$21,600	$86,400
Korbit Pro $12	$4,320	$21,600	Enterprise quote likely
Qodo Pro Team	$7,092	30-user cap: Enterprise quote	Enterprise quote
Copilot Business $19	$6,840 + credits	$34,200 + credits	$136,800 + credits
Codacy Team $18	$6,480	30-dev cap: Business quote	Business quote
Korbit Max $18	$6,480	$32,400	Enterprise quote likely
Gitar Core $20	$7,200	$36,000	50-user cap: Enterprise quote
CodeRabbit Essentials $24	$8,640 (1 repo)	$43,200 (1 repo)	$172,800 (1 repo)
DeepSource Team $24	$8,640 + AI usage	$43,200 + AI usage	$172,800 + AI usage
cubic Team $30 yearly	$10,800	$54,000	$216,000
Greptile Pro $30	$10,800	$54,000	$216,000
Ito Pro $40	$14,400	$72,000	Enterprise, 25+ engineers
Graphite Team $40	$14,400	$72,000	$288,000
Gitar Pro $40	$14,400	$72,000	50-user cap
CodeRabbit Team $48	$17,280	$86,400	$345,600
CodeRabbit Advanced $72	$25,920	$129,600	$518,400
cubic Pro $79 yearly	$28,440	$142,200	$568,800
Copilot Enterprise $39	$14,040 + credits	$70,200 + credits	$280,800 + credits
Entelligence	$27,000 (Startup band)	$90,000 (Scale band)	Enterprise quote
cubic Max $160 yearly	$57,600	$288,000	$1,152,000
Claude Code Review (unverified)	$54,000-90,000	$270,000-450,000	$1,080,000-1,800,000

Three corrections procurement should make to every row before signing.

First, the seat count is wrong. On CodeRabbit you pay for PR authors only, which in most orgs is 60-70% of headcount. At 200 headcount and 140 PR authors, CodeRabbit Team is $241,920 over three years, not $345,600. That is a $103,680 difference produced entirely by reading the seat definition.

Second, the caps bite before the budget does. Qodo dies at 30 users, Codacy Team at 30 developers, Gitar Core and Pro at 50 users, Ito Pro at 25 engineers, Bito Team at a reported 25 seats, Entelligence Scale at 50 engineers. At 200 developers, roughly a third of the market is simply not purchasable self-serve at any price, which is the real reason enterprise quotes exist.

Third, a 3-year number at list price is fiction without a price-protection clause. Read the change log below and then ask yourself what your 2029 bill looks like if it is not contractually fixed.

What the price does not include

Direct answer: Five categories of cost sit outside the quoted price. CI minutes on Copilot private-repo reviews, which GitHub does not publish a per-review figure for and which is therefore unmodellable. Metered overage on CodeRabbit, Greptile, Bito, DeepSource, Ito and Entelligence. Re-review billing on Macroscope. File, repo and hourly caps that force a tier upgrade. And self-hosting, which is a paid add-on or a 500-seat gate.

CI minutes, and why we will not estimate them. Since 1 June 2026, Copilot code review on private repositories consumes GitHub Actions minutes in addition to GitHub AI Credits, because the review moved to an agentic architecture that runs on Actions. GitHub’s changelog announced the date and the 1 June changelog confirmed it shipped. GitHub’s own documentation estimates $0.05 to $1 of AI credits for a Lite review and $0.25 to $5 for the default Balanced review, and states explicitly that “these estimates do not include GitHub Actions minutes”. Standard Linux runners are about $0.006 per minute past your included allowance. GitHub publishes no figure for minutes consumed per review. That makes this line item genuinely unmodellable from public data, and we are going to say that rather than invent a number. The mitigation is a self-hosted Actions runner, which consumes no GitHub minutes. Public repository minutes stay free. Full detail in GitHub Copilot pricing.

Overage, tool by tool, verified 2026-10-18.

Tool	Included	Overage rate	The gotcha
CodeRabbit	5/8/10/12 reviews per dev per hour by tier	$0.25 per reviewed file; $0.40 per agent minute	Fair-use steps the refill rate down; Essentials reportedly drops at 30 and 60 reviews per rolling 7 days, bottoming at 1/hour
Greptile	50 credits per seat	$1 per credit	Credits are per author and do not pool. Apex depth is 10 credits per review
Bito	5,000 reviewed lines per seat per month	$5 per 1,000 lines	Measured on PR diffs; one 3,000-line migration is 60% of a seat
DeepSource	$100 AI credit per user per year	$8 per 10K LOC (Standard), $15 per 10K (Advanced)	The $24 seat buys static analysis, not AI review
Ito	50 reviews per seat	$1 per additional review	Reviews run 30 minutes to 2 hours, so quota is not the only constraint
Entelligence	300 reviews (Startup), 1,000 (Scale)	$1 per review	Band thresholds, not seats, so 16 engineers costs $2,500
Qodo	Credit packs of 2,500 / 5,000 / 20,000	$0.012 per credit	Credits pool across the team but expire monthly with no rollover
Copilot	1,900 AI credits per user (Business), 3,900 (Enterprise)	$0.01 per credit, pooled across the enterprise	Credits expire monthly; paid overage is on by default for orgs
Macroscope	Nothing. Pure usage	$0.025-$0.20 per KB by mode	Every re-review is billed separately, including push-triggered ones
cubic	40K/80K/160K reviewed lines per dev	Not published	Allowance attaches to the seat, so it does not pool

Re-review billing is the one people get wrong. Macroscope’s documentation is explicit: “Every review is billed on its own, whether it was triggered by a push or a manual request.” A pull request that goes three rounds of commits is three charges. On a team that ships stacked diffs with frequent force-pushes, that multiplies the modelled cost by whatever your average rounds-per-PR is. Measure it before you model it.

File, repo and hourly caps that force a tier upgrade.

• CodeRabbit file caps: 150 files per review on Free and Essentials, 300 on Team and above. Usage-priced on-demand reviews hard-stop above 300 files. A vendored dependency bump will exceed that.
• CodeRabbit linked repositories: 1 on Essentials, 5 on Team, 10 on Advanced, 20 on Enterprise. This is the most consequential constraint in the market and the one most comparisons omit. A 4-developer team with 40 services cannot use the $24 tier at any seat count.
• CodeRabbit hourly limits: 5 / 8 / 10 / 12 reviews per developer per hour by tier, all marked subject to a fair usage policy. Augment’s teardown reports the rolling limits degrade to 1 review per hour after 60 reviews in 7 days on Essentials. We could not verify that floor against CodeRabbit’s own documentation, so treat it as single-sourced.
• cubic Starter: 20 pull request reviews a month per GitHub organisation, not per developer.
• Snyk: meters in project counts on self-serve. 5 projects free, 100 on Team. Three developers with a microservice estate can exhaust the project cap on day one.

Self-hosting is a paid add-on or a gate, not a free alternative. Bito charges $5 per seat on top of Professional. CodeRabbit’s self-hosted deployment requires 500+ seats, which means a 200-developer enterprise cannot buy it. Sourcery, Gitar, Qodo, DeepSource and Semgrep all place self-hosting on Enterprise. GitLab Duo’s self-hosted models reached GA in GitLab 18.4. Copilot can run validation on self-hosted Actions runners but the review service stays in GitHub’s cloud, so it is not truly self-hosted. The genuinely free self-host routes are PR-Agent under MIT and Kodus under AGPLv3, both free at any team size, both costing you tokens and ops time instead. See open source AI code review tools.

One more, for regulated teams. Anthropic’s Code Review is unavailable to organisations running zero data retention, the HIPAA configuration, or customer-managed encryption keys. The exact configuration that makes Claude Code PHI-eligible disables Code Review. It does support GitHub Enterprise Server, which Copilot code review does not. Covered in AI code review for enterprise.

Price-change log: what moved in 2026

Direct answer: At least nine material pricing changes landed in this market between April and October 2026. CodeRabbit retired two plans in June and renamed two tiers in September. GitHub retired annual Copilot billing on 1 June, replaced premium requests with AI Credits at $0.01, and cut included Business and Enterprise credits on 1 September. Cursor removed the $40 standalone Bugbot seat. Entelligence replaced per-seat pricing with flat bands. Tabnine’s prices vanished behind an acquisition.

Date	What changed	Who it hits
23 Apr 2026	PR-Agent relicensed to MIT and moved to independent community governance under The-PR-Agent org; Qodo remains a sponsor	Anyone who chose it for licence reasons
1 Jun 2026	GitHub retired annual Copilot billing entirely. Monthly is the only option. Existing annual subscribers drop to Copilot Free at expiry unless they move to monthly	Every Copilot customer on an annual term
1 Jun 2026	Premium requests replaced by GitHub AI Credits at $0.01 each. Seat prices unchanged: Pro $10, Pro+ $39, Max $100, Business $19, Enterprise $39	Everyone modelling Copilot cost
1 Jun 2026	Copilot code review on private repos began consuming GitHub Actions minutes in addition to AI credits	Private-repo teams on Copilot
8 Jun 2026	CodeRabbit retired Lite and Pro Legacy. Any page quoting “CodeRabbit Lite $12” is stale	Legacy CodeRabbit customers
8 Jun 2026	Cursor removed the $40 standalone Bugbot seat, effective at each customer’s first renewal after that date. Bugbot is now pure usage, listed from the Premium plan ($30/mo) upward, with a dash on Free and Plus	Anyone who bought Bugbot as a standalone
30 Jul 2026	Tabnine acquired by Tricentis. Pricing page now redirects to a Tricentis contact form; all per-seat figures unverified	Anyone quoting Tabnine prices
27 Aug 2026	Copilot’s 300-file / 20,000-line PR cap removed; bot-authored PRs now supported. This invalidates any Copilot review evaluation run before September 2026	Anyone citing older Copilot benchmarks
1 Sep 2026	Copilot included AI credits cut. The promotional $30 per user per month for Business and $70 for Enterprise (June to August) ended. Standard allowance is now 1,900 credits for Business and 3,900 for Enterprise, so included credits equal the seat price in dollars	Every Copilot Business and Enterprise org
Sep 2026	CodeRabbit renamed Pro to Essentials and Pro Plus to Team, and added a new Advanced tier at $72 annual. Prices unchanged, names not	Anyone matching an old quote to a current page
During 2026	Entelligence replaced per-seat pricing with flat bands: Startup $750/mo up to 15 engineers with 300 reviews, Scale $2,500/mo for 16-50 engineers with 1,000 reviews, $1 per review after. Legacy pages still show a $20-$29 per-seat Business plan	Anyone quoting Entelligence per seat
1 Oct 2026	GitHub began charging card and PayPal customers for assigned Copilot seats upfront at the start of each cycle	Self-serve Copilot orgs
Added 2026	CodeRabbit Cloud Coding Agent at $0.40 per agent minute	CodeRabbit customers using the agent

Two ownership changes that do not alter a price today but will alter your vendor relationship: Harness acquired DeepSource on 9 September 2026, and Sonar acquired Gitar on 21 May 2026 - Gitar’s pricing now lives on Sonar’s site, which is also where its first published rate card appeared (Core $20 annual, Pro $40 annual, both capped at 50 users). Graphite was acquired by Cursor on 19 December 2025, so Graphite and Cursor Bugbot share an owner, which is worth knowing before you price them against each other. And Aikido acquired Trag in August 2025, with Deep PR Review now consuming credits on Aikido’s Advanced and Enterprise tiers rather than being a separately priced product.

How we verified this

What we checked, and where. On 2026-10-18 we fetched the live pricing page for every tool in the master table directly from the vendor: CodeRabbit, Greptile, Sourcery, Korbit, Bito, Codacy, Graphite, Gitar (now hosted on sonarsource.com), DeepSource, cubic, Ito, Qodo, Entelligence, Macroscope (docs.macroscope.com/pricing, since macroscope.com/pricing returned no pricing content to us), Cursor, GitHub Copilot plans, claude.com/pricing, Snyk, Semgrep, SonarQube Cloud and Aikido. We also read GitHub’s own code review documentation for the AI credit estimates and the Actions-minutes behaviour.

We cross-checked against four third-party teardowns, all of which are published by companies selling a competing reviewer: cubic’s pricing roundup, repowise’s cost-per-100-PRs model, Macroscope’s CodeRabbit teardown and Augment’s CodeRabbit limits guide. Their competitor figures checked out against the primary sources wherever we could verify them. Their conclusions favour the publisher in every case. We used them for corroboration, never as the primary source for a price.

What we found that contradicts commonly published figures.

• Copilot code review is now included on Copilot Pro ($10), not just Pro+. GitHub’s documentation on 2026-10-18 states code review is “included with Copilot Pro, Copilot Pro+, and Copilot Max plans, and with a Copilot Business or Copilot Enterprise license.” Many comparisons, including an earlier version of our own research, say it starts at Pro+ ($39). It does not, as of today. Copilot Free still does not include it.
• Gitar now has a published rate card. Core $20 per user per month annual ($25 monthly) and Pro $40 annual ($50 monthly), both capped at 50 users, free for OSI-licensed public repos, 14-day trial with no card. It lives at sonarsource.com/plans-and-pricing/gitar/ following the Sonar acquisition. Most comparisons still list Gitar as quote-only. (Disclosure: Gitar sponsors this site. The figures above came from the same fetch-and-verify process as every other row and the sponsorship buys no editorial treatment. Gitar still has no published third-party benchmark, which we note wherever review quality is discussed.)
• Macroscope has four detection modes, not two. Budget $0.025/KB with a $0.25 floor, Balanced $0.05/KB with $0.50, Precise $0.06/KB with $0.60, Ultra $0.20/KB with $2.00. That is an 8x spread inside one vendor, selected by a setting. Most writeups only mention the $0.05 default.
• Cursor’s plan ladder is now Free, Plus $8, Premium $30, Super $100, Ultra $200, Teams from $30. Bugbot appears from Premium up. Older comparisons list a $20 Pro tier that is no longer the entry point to Bugbot.
• Snyk Team’s published price is “starting at $25 / month” on Snyk’s own plans page, not an unambiguous per-developer figure. Third-party sources add a 5-developer minimum and a 10-licence maximum, which would make the real Team range $125 to $250 a month. We could not confirm either bound on Snyk’s own page.

What we could not verify.

• cubic’s yearly prices. The page shows a “Yearly -20%” toggle but rendered $40 / $99 / $200 in both states for us. The published yearly figures of $30 / $79 / $160 do not match a clean 20% reduction ($32 / $79.20 / $160). Monthly verified; yearly approximate.
• CodeRabbit Advanced’s monthly price. Only the $72 annual rate is published. Third parties list $90. Unverified.
• CodeAnt Premium’s pricing page. The comparison table did not render for us on 2026-10-18 in two attempts. $24 per user per month is widely reported as the annual rate and CodeAnt’s AWS Marketplace listing shows $30 for a 1-month seat contract. Treat $24 as annual, unconfirmed at source.
• CodeRabbit’s adaptive fair-use floor of 1 review per hour after 60 reviews in 7 days. Single-sourced to Augment, not in CodeRabbit’s own documentation as far as we could find.
• GitHub Actions minutes consumed per Copilot review. GitHub explicitly states its credit estimates exclude Actions minutes and publishes no minute figure. Unmodellable from public data.
• Copilot Pro, Pro+ and Max included AI credit allowances. The plans page showed base allowances of $15, $70 and $200 respectively; GitHub’s AI credits reference page returned 404 for us. Business (1,900) and Enterprise (3,900) are well corroborated. The individual-tier figures are single-sourced.
• Greptile’s annual discount. Greptile publishes only the $30 monthly Pro rate and routes annual and multi-year to custom invoicing. No published percentage.
• Graphite’s and Sourcery’s review limits as numbers. Both gate “limited” or “higher” review limits by tier without publishing figures, so you cannot model the ceiling before purchase.
• Claude Code Review’s per-review cost. The $15-25 figure is cubic’s published estimate. Anthropic publishes no per-review price. Code Review went GA on 15 October 2026 to Claude Team and Enterprise with at least $10,000 in review credits (Anthropic’s own figure; press reports a $10,000-$50,000 range scaled by active Claude Code seats) for eligible Enterprise organisations, which makes the near-term effective price zero and the long-term price unknown. One source still showed “research preview” in the docs on the GA date, so treat the GA status itself as fresh.
• Tabnine’s current prices. Behind a Tricentis contact form since the 2026-07-30 acquisition. We quote nothing.
• Gemini Code Assist’s free tier. Status unresolved. Excluded rather than guessed.
• Volume discount rates at any vendor. The only published discounts in this market are the standard 20% annual reduction, Greptile’s 50% pre-Series A offer for companies under $2M revenue plus one month free and special pricing for Y Combinator companies, 50% education discounts at CodeRabbit and Qodo, and free open-source tiers. No vendor publishes an enterprise volume curve. Every enterprise number in this price book is list price.

A note on what this page deliberately does not do. It does not rank these tools on review quality, because no party without a commercial stake has published a false-positive rate for any shipping commercial AI code reviewer, and every benchmark of a buyable product was published by a vendor that wins it. For that argument see best AI code review tools and the state of AI code review in 2026.

Recommendations

Criteria: lowest verifiable total cost for automated review on every private pull request, with the constraint column read before the price column. Not review quality.

If your PR volume is under 30 reviews per developer per month: buy usage, not seats. Macroscope in Budget mode is $0.025 per KB with a $0.25 floor and no seat fee, which is $48 per 100 pull requests and $1,728 over three years for a 10-developer team. Every new workspace gets $100 of credit, so the evaluation costs nothing. Configure the per-review and per-PR spend caps on day one and measure your average rounds-per-PR first, because re-reviews bill separately.

If your PR volume is above 30 reviews per developer per month: buy seats, because the marginal review is free. The cheapest credible seats are Sourcery Pro and Korbit Pro at $12 per developer per month annual. Korbit’s advantage is unlimited reviews, repositories and users with no published overage; its billable unit is the Git author, which is wider than CodeRabbit’s PR author. Sourcery’s advantage is that custom rules and security checks are in the $12 tier rather than gated above it; its weakness is unpublished review limits.

If you have more than one repository and were about to buy CodeRabbit Essentials: do not. Essentials links one repository. Price CodeRabbit Team at $48, or price Greptile Pro and Gitar Core, both of which advertise unlimited repositories at $30 and $20 respectively. This single constraint changes the right answer for more teams than any price difference on this page.

If you are under 30 users and want the lowest absolute number: Qodo Pro Team at $30 a month flat. It is the only flat team fee in the market and it is 8x cheaper than seat-pricing the same 10 developers. The cliff at 30 users is hard and lands you in an enterprise quote, and credits expire monthly with no rollover, so set the spending cap when you set up the account.

If you already pay for GitHub Copilot: turn code review on before you buy anything, and note that as of 2026-10-18 it is included from Copilot Pro ($10) upward, not Pro+ as widely reported. Then accept that you cannot forecast the Actions-minutes line, and put the review workflow on a self-hosted runner if your Actions budget is tight.

If you need SSO, audit logs or an API: budget for the enterprise tier regardless of headcount. Those three are CodeRabbit Enterprise-only, and they are Enterprise-gated at Codacy, Qodo, Sourcery, Gitar, Graphite, DeepSource and Semgrep too. Self-hosting at CodeRabbit needs 500+ seats, so if you are a 200-developer org that requires on-premises deployment, CodeRabbit is not a candidate and you should look at Gitar Enterprise, DeepSource Enterprise, Semgrep Enterprise, GitLab Duo self-hosted models, or self-hosted PR-Agent.

What I would not sign: a 3-year agreement at list price with no price-protection clause. Twelve material pricing changes landed in this market in six months. Get the rate fixed for the term in writing, or stay monthly and pay the 20%.

For the worked buyer-facing totals at 10, 50 and 200 developers, read what does AI code review cost. For single-vendor deep dives: CodeRabbit pricing, Greptile pricing, Qodo pricing, GitHub Copilot pricing, DeepSource pricing, Snyk pricing, Codacy pricing and SonarQube pricing.