AI code review is usually priced per developer, but the number on the pricing page is rarely the whole answer. What you pay also depends on who counts as a developer, how many reviews each one triggers, how deep those reviews go, and what happens when a busy month goes over the allowance.
This guide works through those questions with MergeHarbor’s pricing as the example, shows the arithmetic for a few team sizes, and lists the controls that keep spend predictable. Prices are as published at the time of writing (November 2026); see pricing for current prices.
The two parts of the price
MergeHarbor charges per active developer per month, and each plan gives every active developer a number of credits that go into one pool for the whole organization. Reviews use credits from that pool.
| Plan | Monthly, per active developer | Annual, per seat per month | Credits per active developer |
|---|---|---|---|
| Essentials | $25 | $20 | 100 |
| Team | $55 | $45 | 200 |
| Advanced | $85 | $70 | 300 |
| Enterprise | Custom | Custom | Set by agreement |
Repositories, reviewers and console users are unlimited on every plan. Credits beyond the pooled allowance cost $0.25 each.
Two optional add-ons are priced the same way, per active developer: the Security add-on (vulnerability management) and Shipyard (the coding agent), each $15 a month or $12 billed annually. Neither is needed for code review.
Who counts as an active developer
This definition decides most of the bill, so it is worth reading carefully. An active developer is a person whose pull request received a review that used credits during the billing month. Each person counts once a month, however many pull requests they open.
People who are never counted:
- reviewers and approvers who do not author reviewed pull requests that month;
- people who only use the console;
- automation accounts such as Dependabot or Renovate.
In practice, a 60-person engineering organization where 40 people opened reviewed pull requests in October pays for 40 in October. Someone on leave for a month does not count that month.
What a credit buys
A credit is a unit of review work. Each review of one pull-request commit runs at a tier:
| Tier | Credits | Included from |
|---|---|---|
| Standard | 1 | Essentials |
| Deep | 3 | Team |
| Max | 10 | Advanced |
| Auto | 1–10 | Picks among the tiers your plan includes |
Standard is the default, so if you never change the tier, one review is one credit. Deep always explores the repository with tools and double-checks every finding. Max uses the strongest models and the longest investigation. A higher tier investigates more; it is held to the same posting bar, so it does not comment more. Review tiers explains how Auto chooses.
What uses no credits
A surprising amount of activity is free, which matters when you estimate:
- Re-reviewing a commit already reviewed at the same tier or higher.
- Failed and skipped reviews, for example a documentation-only change.
- Reviews where only the free deterministic checks ran (secrets, injection patterns, disabled TLS verification and similar).
- Reviews answered entirely from results for identical files.
- Public repositories on the open-source program.
Asking for a higher tier on a commit already reviewed uses only the difference. A commit reviewed at Standard costs 9 more credits at Max, not 10.
A new push is a new review, but MergeHarbor reviews only what changed since the last one.
Worked examples
The examples below show the arithmetic. Your numbers will differ; the method is the same. “Reviews” means reviewed commits, so a pull request that gets three pushes is up to three reviews.
A 10-person team on Essentials, monthly
- 10 active developers × $25 = $250.
- Pool: 10 × 100 = 1,000 credits.
- Suppose the team opens 150 pull requests and each gets about 4 reviewed pushes: 600 Standard reviews = 600 credits.
600 is inside the 1,000-credit pool, so the bill is $250, or $25 per developer.
The same team in a very busy month
- Still 10 active developers: $250, and 1,000 credits.
- 1,200 Standard reviews = 1,200 credits.
- Extra: 1,200 − 1,000 = 200 credits × $0.25 = $50.
Total $300, or $30 per developer. The pool absorbs ordinary variation; only the organization’s total over the allowance is billed.
A 40-person team on Team, mostly Standard with Deep for risky changes
- 40 × $55 = $2,200.
- Pool: 40 × 200 = 8,000 credits.
- Suppose 1,600 Standard reviews (1,600 credits) and 400 Deep reviews (400 × 3 = 1,200 credits): 2,800 credits.
2,800 is well inside 8,000, so the bill is $2,200, or $55 per developer. A team in this position has room to send more pull requests to Deep, for example with a tier rule for payments code, before it pays anything extra.
A 25-person team on Advanced with Max for release branches
- 25 × $85 = $2,125.
- Pool: 25 × 300 = 7,500 credits.
- Suppose 2,000 Standard reviews (2,000), 500 Deep (1,500) and 200 Max (2,000): 5,500 credits.
Inside the pool, so $2,125. Max reviews are the ones to watch: 200 of them used as many credits as 2,000 Standard reviews.
Annual versus monthly
Annual billing is per seat, paid upfront, at the lower rate. For 40 seats on Team:
- Annual: 40 seats × $45 × 12 = $21,600 for the year.
- Monthly, if all 40 are active every month: 40 × $55 × 12 = $26,400.
The difference is real, but monthly billing counts only the people who were active each month. If your active count swings, compare against your actual monthly counts, not your headcount. On annual plans, if more developers are active in a month than you have seats, seats are added automatically with a prorated charge for the rest of the year; seats are never removed mid-term, and you can lower the count at renewal. Extra credits are charged monthly either way.
Model cost versus price
What MergeHarbor spends on models for a review is not what you pay for it, and the two should not be confused when you compare options.
For reference, the benchmarks page records the cost per review measured in its pilot run of 40 cases on October 21, 2026: $0.04 for a Standard review, $0.16 for Deep and $0.21 for Max (Max ran on 34 of the 40 cases before the run reached its spending cap). That is what the reviews cost MergeHarbor to run in a small pilot, with the caveats listed on that page. It is not what customers pay.
If you want to see the cost side for your own organization, Billing → Usage → Cost per review shows the median cost of a review and what 9 in 10 and 99 in 100 reviews cost less than. Under Settings → Review behaviour → AI models & cost, the console quotes what a typical review (8 files, 300 changed lines) costs on each class of model, and lets you simulate a review before saving.
Several things keep model cost low, and they are why a flat credit price is sustainable: deterministic checks run first with no model call, documentation-only changes skip the model, stable instructions are cached by the provider, generated and vendored files are left out of the prompt, and work that can wait runs through batch APIs at about half the price. The review costs page has the details, and keeping AI code review affordable explains the routing.
Controls that keep the bill predictable
Billing admins can set several limits, and it is worth setting them before the first busy month rather than after.
- Monthly credit limit. Choose what happens when it is reached: alert only, review at Standard only, or pause reviews. Billing admins get email at each alert threshold (80% and 100% by default).
- Per pull request cap. The most credits one pull request can use across all its reviews. When a review would go over, it steps down to a tier that fits; when even Standard does not fit, reviews stop with a neutral status check that says why.
- Overage limit. A hard limit on extra spend. When it is reached, new reviews pause with a clear status check until the next month or until the limit is raised.
- Tier rules. Send only the code that deserves it to Deep or Max, for example
release/*orservices/payments/**, and keep everything else at Standard. - Filters. Skip pull requests you do not want reviewed, by author, path, label or size.
Billing → Usage shows credits per day, and by tier, developer and repository, so you can see which repositories or rules drive spend. Each pull request also shows its tier, the credits it used and one line on why it ran at that tier.
Estimating for your organization
A quick way to estimate before a trial:
- Count the people who opened at least one merged pull request in each of the last three months. That approximates active developers.
- Count pull requests per month and multiply by your typical pushes per pull request. That approximates Standard reviews.
- Decide which paths or branches deserve Deep or Max and estimate their share.
- Compare total credits with the pool for each plan. If you are well inside it, the bill is just the per-developer price.
Then check the estimate against reality: the 14-day trial shows real credit use per day in Billing → Usage. The cost estimator on the pricing page does the same arithmetic interactively.
Paying from India
Organizations billed in India pay in Indian rupees through Razorpay, with UPI AutoPay, cards, net banking or a bank mandate, and prices shown at checkout. The plans, credits and limits are the same. See AI code review pricing in India and Paying from India.
Try it on your own pull requests
The fastest way to get a real number is to measure it. Start a 14-day trial of the Team plan, with no card needed, connect a few active repositories, and read Billing → Usage at the end of the first week.