What Ten AI Code Reviewers Actually Charge

AI code review prices are measured in different units. CodeRabbit Essentials starts at $24 per developer per month on annual billing, with five included PR reviews per developer per hour, subject to rolling limits and fair use; Greptile Pro charges $1 per shared credit and no seat fee, with Base, Plus and Apex reviews consuming one, three and ten credits. A team cannot forecast either bill from its monthly pull request count alone. It needs the number of authors, review runs, timing, files and review depth. The figures below are maker list prices, read on November 9, 2026, before tax or negotiated discounts.

Compare what each reviewer bills

This table compares ten routes for reviewing pull requests. Annual prices are monthly equivalents charged under an annual commitment; they are not month-to-month prices. A free trial is not a permanent free allowance. Each row links to the maker’s current pricing or billing page.

Reviewer	Published starting point	What changes the bill or limits reviews
CodeRabbit	Essentials $24 per developer/month, billed annually; $30 month to month	Five included PR reviews per developer per hour, subject to rolling limits and fair use; eligible continued reviews cost $0.25 per reviewed file if usage billing is enabled.
Greptile	Pro $1 per shared organization credit; no seat fee	Base uses 1 credit, Plus 3, Apex 10. Starter gives one developer 50 credits/month. Enterprise is quoted.
cubic	Team $30 per developer/month, billed yearly	40,000 reviewed lines per developer/month; Starter offers 20 PR reviews/month. Check the account’s extra-line terms before forecasting overage.
GitHub Copilot code review	AI credits from the Copilot plan, plus GitHub Actions minutes where applicable	GitHub estimates $0.05–$1 in credits for Lite, $0.25–$5 for Balanced and $1.50–$25 for Max per review. These are estimates, not flat rates.
Cursor Bugbot	Usage-based billing for current plans	Each review is billed once to the account with Bugbot enabled; effort and PR size affect usage. Legacy seat plans may remain for existing customers.
Qodo	Pro Team shows $30 for 2,000 pooled credits at $0.015 each.	Each review draws credits according to PR size and complexity. The plan is marketed for up to 30 users, but the same page’s FAQ says users are unlimited; confirm team eligibility before buying. Overage uses the same credit rate, subject to a chosen cap.
Graphite	Team $40 per user/month, billed annually	Team lists unlimited AI Reviews. Free Hobby has limited reviews and personal-account repos; Starter is $20/user/month annually.
Bito	Team $12 per seat/month annually, or $15 monthly	Includes 5,000 reviewed lines per seat/month; additional lines cost $5 per 1,000. Fair usage applies.
DeepSource	Team bundles $10 per contributor/month on monthly billing, or $100 per contributor/year allocated upfront on annual billing; the plan fee is separate from metered overage.	Standard AI Review costs $8 per 10,000 processed lines; Advanced costs $15. Context beyond the diff counts as processed lines.
Sourcery	Pro $12 per developer/month annually, or $15 monthly	Private-repo AI review is included with higher review limits than Open Source; the public page does not quantify those limits. Team is $24 annually or $30 monthly.

The units cannot be collapsed into a universal cost per PR. One large PR may use more GitHub credits, Qodo credits or DeepSource processed lines than a small one. Bito and cubic meter reviewed lines, while Graphite’s Team price is a seat commitment. Read the allowance and Git-host requirements before treating the lowest number in the table as your price. For example, Cursor and GitHub Copilot plans also cover coding work; a subscription you already pay for is different from the incremental cost of enabling review.

Greptile deserves a fresh check if your shortlist came from older comparison guides. Its live Pro page says there are no seat fees and that credits are shared across the organization. The cubic comparison still describes $30 seats with 50 credits per seat. The calculation below uses the maker’s current page, without claiming when that change occurred. GitHub’s published per-review ranges are estimates; Actions minutes and any prerequisite plan spending need their own line.

Count billable runs, not just pull requests

Start a trial ledger with one row per review event. Record the PR identifier, author, timestamp, trigger, reviewer and plan, review depth, reviewed files or processed lines, the published allowance, the billed units and the invoice charge. Keep the platform’s event or request ID so you can reconcile a rerun without counting the same event twice in your spreadsheet. This is bookkeeping advice, not a claim that a vendor waives duplicate requests.

A PR can receive an initial review and another after a push or a manual request. The second review may cover a smaller diff, but its price can still differ from the first. Cursor says Bugbot bills each review once; GitHub calculates AI credits from tokens and model choice; Qodo’s credits depend on the change. Do not multiply one average review price by the number of PRs until you have checked how often your workflow triggers reviews. If your repo creates many small pushes, the run count may be substantially larger than the PR count.

For a monthly forecast, keep two totals. Committed spend is the subscription or seat fee you would pay even with no new reviews. Incremental review spend is the metered charge beyond included use. The total is committed plus incremental spend, plus any separately billed infrastructure. For a broader comparison of how a shared meter can hide behind a plan fee, see AI agent monitoring costs; that article uses different units and its numbers cannot be reused for code review.

Ten reviews can cost more when they arrive together

CodeRabbit’s pricing page lists five included PR reviews per developer per hour on Essentials, subject to rolling limits and fair use. Eligible reviews beyond the allowance can continue at $0.25 per reviewed file when an administrator enables usage billing. It also offers Automatic, On demand and Off controls and a monthly spending cap.

Here is an illustrative worksheet, not a product test or an invoice. Assume one paid Essentials developer starts with five available reviews, with no recent activity reducing the normal allowance, no trial waiver, eligible paid continuation enabled and a sufficient spending cap. Five requests at 09:00 and five at 10:01, after capacity returns, use the included allowance and add $0 in this example. If all ten requests arrive at 09:00, five are paid continuations. At four billable files each, the incremental charge is 5 reviews × 4 files × $0.25 = $5. The base seat fee is identical in both cases. Reviews age out of a rolling window, rather than resetting at clock-hour boundaries; sustained activity can reduce availability. Usage-based continuation and file accounting still need to be checked in the account before using $5 as a forecast.

Setting usage billing to Off or reaching a cap can stop or defer a review instead of adding a charge. A low invoice does not prove all requested reviews ran. Log completed reviews as well as requests, then compare them with the billing export.

Review depth changes the credit total

Greptile’s current Pro price is $1 per credit, shared across the organization, with Base at one credit, Plus at three and Apex at ten. In a hypothetical month with no trial or free credits, 100 Base reviews consume 100 credits, or $100. If 80 are Base and 20 are Apex, the same 100 reviews use 80 × 1 + 20 × 10 = 280 credits, or $280. The difference is $180 for the same 100 billable review runs.

If the same billable mix runs twice, and every repeat consumes the same depth and credits, those two examples become $200 and $560. That is a constant-depth arithmetic scenario. Real reruns, discounts and account credits can change the invoice. The point is to record the chosen review level per event, not infer it from the number of PRs. Depth also changes GitHub’s estimated credit range and DeepSource’s per-line rate, but their meters and included balances are different, so do not transfer the Greptile totals to them.

Reconcile a trial before committing

Choose tools that support your Git host and required deployment first. Then run a bounded trial on representative PRs: small fixes, broad changes and repeated pushes. Record each review’s completion, billed unit and useful findings. Human reviewers still need to decide whether a suggestion is correct; the price list provides no quality ranking. The comparison is a budgeting guide, not a claim that any reviewer catches more bugs.

At the end of the trial, compare your ledger with the vendor’s usage export and invoice. Count active billed authors or committers according to the vendor’s definition. Check included credits, expiry, overage caps, any free or trial credits, line or file counts, and review depth. On DeepSource, processed lines include context beyond the diff. On Qodo, unused credits expire at the end of the monthly cycle. For GitHub, include Actions minutes separately from AI credits. If an export does not identify an event, leave its cost unresolved instead of assigning an invented average.

Finally, write a budget with separate columns for seat or plan fees, included use, extra reviews or credits, infrastructure and tax. Compare the resulting monthly total with your own engineering workflow. A cost per accepted finding can help compare trial results if you actually measure accepted findings; it is not a return-on-investment figure or proof of time saved. If you use your own model key with a review workflow, the AI API price guide and the AI API cost calculator can estimate model-token spend, but neither calculates reviewer platform fees.

Sources

• CodeRabbit pricing: plans, hourly allowance, continuation charge and controls.
• CodeRabbit review rate limits: rolling review allowance and fair use.
• CodeRabbit usage-based reviews: paid continuation and per-file charge.
• Greptile pricing: current Pro credit model and review depth.
• cubic pricing: plans and reviewed-line allowances.
• cubic comparison: example of the older Greptile seat-price description.
• GitHub Copilot models and pricing: AI-credit and Actions-minute billing, effort estimates.
• Cursor Bugbot documentation: usage billing and review triggers.
• Qodo pricing: pooled credits, packs and overage.
• Graphite pricing: annual seat prices and review access.
• Bito pricing: seat and line allowances.
• DeepSource billing: contributor credits and processed-line rates.
• Sourcery pricing: seat prices and plan limits.

All pages read on November 9, 2026.

Free toolWhat will 10,000 chats a month cost?Estimate my bill