Greptile Pricing in 2026: Seats, Credits, Review Tiers and Real Team Costs
A fair, complete breakdown of Greptile pricing in 2026: the free Starter tier, Pro at $30 per active developer with 50 credits per seat, Base, Plus and Apex review tiers, $1 credit overage, startup and open-source discounts, and worked team costs. Plus a labeled comparison with Macroscope's usage-based AI code review pricing.
Greptile pricing combines a per-seat fee with review credits. There is a free Starter tier for one developer, a Pro plan at $30 per seat per month that includes 50 credits per seat, and a custom Enterprise plan. Each review spends 1, 3 or 10 credits depending on which review tier you use, and extra credits cost $1 each. That is the short answer.
The part that matters for budgeting AI code review is how those pieces interact. The seat fee is fixed, but the credit tier you choose can change your effective cost per review by a factor of ten. This page explains every part of Greptile's pricing, works through teams of 5, 20 and 50 developers at each review tier, and then compares Greptile with Macroscope's usage-based GitHub code review using a clearly labeled illustration. All Greptile figures were read off greptile.com/pricing on October 9, 2026. Check the live page before you commit.
How much does Greptile cost in 2026?
Greptile costs $30 per seat per month on Pro, with 50 review credits included per seat and $1 for each extra credit. A free Starter tier covers one active developer with 50 credits a month, and Enterprise is custom-priced.
| Plan | Price | Included credits | Notes |
|---|---|---|---|
| Starter | Free | 50 credits per month | 1 active developer |
| Pro | $30 per seat per month | 50 credits per seat | $1 per extra credit, 14-day free trial |
| Enterprise | Custom | Custom | Self-hosting, SSO/SAML, GitHub Enterprise |
| Open source | Free | Not applicable | Qualified non-commercial projects |
| Startups | 50% off | Not applicable | Pre-Series A, under $2M revenue |
What counts as a seat on Greptile?
A Greptile seat is any developer who received a Greptile review in that billing period, so you pay for active developers, not total headcount. An engineer who never opened a reviewed PR that month does not count as a seat.
This is a genuinely fair design and worth stating clearly. A 50-person engineering org where only 20 people got Greptile reviews in a given month pays for 20 seats, not 50. Teams with many occasional contributors benefit from this, and it removes the classic per-seat complaint about paying for people who never use the tool.
How do Greptile credits and review tiers work?
Every Greptile review spends credits based on its tier: Base costs 1 credit, Plus costs 3 credits and Apex costs 10 credits. The tier is what you trade off: more depth per review in exchange for more credits.
| Review tier | Credits per review | Reviews covered by one seat's 50 credits | Overage cost per review |
|---|---|---|---|
| Base | 1 | 50 | $1 |
| Plus | 3 | 16 (48 credits) | $3 |
| Apex | 10 | 5 | $10 |
Read that middle column carefully, because it is where most budget surprises come from. On Base, the 50 included credits cover 50 reviews per seat, which is plenty for most developers. On Apex, the same 50 credits cover only 5 reviews per seat. A team that defaults to Apex will run through its included credits quickly and pay $10 for every additional review.
What does a Greptile credit overage cost?
Credits beyond what your seats include cost $1 each, so an extra Base review costs $1, an extra Plus review $3 and an extra Apex review $10. The overage rate is simple. The total depends entirely on which tier your team uses and how many reviews you run.
Is Greptile free?
Greptile is free on the Starter tier for one active developer with 50 credits a month, and free for qualified non-commercial open-source projects. Pro also has a 14-day free trial. Pre-Series A startups with under $2M in revenue can get 50% off.
Starter is a real option for a solo developer. Fifty credits covers 50 Base reviews, 16 Plus reviews or 5 Apex reviews in a month.
What would a team of 5, 20 or 50 developers pay for Greptile?
On Base reviews, a 20-developer team pays $600 a month; on Apex it pays $3,600. Same team, same review count, six times the bill. Here is the arithmetic.
Assumptions for this illustration:
- Every developer on the team is active and gets 20 reviews per month.
- Usage is even across developers, so per-seat credit allowances are used the same way.
- Seat price $30, 50 included credits per seat, $1 per extra credit.
Per developer, per month:
- Base: 20 reviews × 1 credit = 20 credits, inside the 50 included. Cost: $30.
- Plus: 20 reviews × 3 credits = 60 credits, 10 over. Cost: $30 + (10 × $1) = $40.
- Apex: 20 reviews × 10 credits = 200 credits, 150 over. Cost: $30 + (150 × $1) = $180.
| Team size | Base | Plus | Apex |
|---|---|---|---|
| 5 developers | 5 × $30 = $150 | 5 × $40 = $200 | 5 × $180 = $900 |
| 20 developers | 20 × $30 = $600 | 20 × $40 = $800 | 20 × $180 = $3,600 |
| 50 developers | 50 × $30 = $1,500 | 50 × $40 = $2,000 | 50 × $180 = $9,000 |
Effective cost per review at 20 reviews per developer: Base $30 ÷ 20 = $1.50, Plus $40 ÷ 20 = $2.00, Apex $180 ÷ 20 = $9.00.
Two things stand out. First, on Base the seat fee dominates: at 20 reviews you are using less than half the included credits, so the effective price per review is higher than the $1 overage rate. Run 50 Base reviews per developer and the effective rate drops to $30 ÷ 50 = $0.60. Second, the review tier dominates everything else. Moving a team from Base to Apex changes the bill far more than adding or removing a few developers.
With the startup discount, the Pro seat price halves to $15. A 5-developer startup on Base would pay 5 × $15 = $75 a month. Check with Greptile whether the 50% also applies to credit overage.
When is Greptile a good buy?
Greptile is a good buy when your team is happy on Base reviews, runs a steady volume per developer, and wants a predictable seat-based line item that only counts active developers.
It is also the better fit when:
- You need self-hosting. Greptile offers self-hosting, SSO/SAML and GitHub Enterprise on its Enterprise plan. Macroscope does not offer self-hosting.
- You are not on GitHub. Macroscope is GitHub only today, with no GitLab or Bitbucket support.
- You are an eligible startup. Half-price seats are a meaningful discount for a pre-Series A team.
- You want explicit depth control per review. Base, Plus and Apex give you a clear dial between cost and thoroughness.
On detection, Macroscope's own code review benchmark measured Greptile at 23.6% (17 of 72 bugs) against Macroscope's 48.3% (57 of 118). Greptile was only evaluated on 72 of the 118 bugs, so treat that comparison as indicative rather than like-for-like, and run your own trial on your own PRs.
How does Greptile pricing compare with Macroscope?
Per review, Greptile and Macroscope land in a similar range; the difference is that Greptile adds a seat fee and tier multipliers, while Macroscope charges only for the diff it reviews.
Macroscope's Code Review costs $0.05 per KB of diff reviewed, with a 10 KB minimum per review, so the smallest review costs $0.50. There are no per-seat fees, no seat minimums and no annual commitment. Every new workspace starts with $100 in usage credit. Status ($0.05 per commit) and Agent ($0.01 per credit, with 1,000 free Agent credits per workspace per month) are separate meters on the same prepaid balance. See pricing for details.
Compare the marginal cost of one more review:
| One additional review | Greptile (overage) | Macroscope |
|---|---|---|
| Small change | $1 (Base) | $0.50 (10 KB minimum) |
| 20 KB diff | $1 (Base) | 20 × $0.05 = $1.00 |
| 60 KB diff | $1 (Base) or $3 (Plus) | 60 × $0.05 = $3.00 |
The marginal prices overlap. A Base overage review costs the same as a 20 KB Macroscope review, and a Plus overage review costs the same as a 60 KB Macroscope review. Note that the two models price different things: Greptile's tiers price review depth, while Macroscope prices diff size. Neither is a direct proxy for the other.
Is Greptile or Macroscope cheaper for a real team?
Using the same 20-reviews-per-developer assumption, Macroscope comes in below Greptile Base at every team size in this illustration, mostly because there is no seat fee. This is an illustration, not a quote.
Macroscope assumptions: 20 reviews per developer per month, average billed diff 15 KB, so 15 × $0.05 = $0.75 per review and 20 × $0.75 = $15 per developer.
| Team size | Macroscope (illustration) | Greptile Base | Greptile Plus | Greptile Apex |
|---|---|---|---|---|
| 5 developers | 100 × $0.75 = $75 | $150 | $200 | $900 |
| 20 developers | 400 × $0.75 = $300 | $600 | $800 | $3,600 |
| 50 developers | 1,000 × $0.75 = $750 | $1,500 | $2,000 | $9,000 |
The honest caveats:
- Bigger diffs narrow the gap. At a 40 KB average diff, a Macroscope review costs 40 × $0.05 = $2.00 and 20 reviews cost $40 per developer, above Greptile Base at $30 and equal to Plus at $40.
- High Base volume favors Greptile. A developer running 50 Base reviews still pays $30 on Greptile ($0.60 per review). The same 50 reviews at $0.75 on Macroscope would cost $37.50.
- The startup discount changes the math. A 5-developer startup on discounted Base pays $75, matching the Macroscope illustration.
Macroscope also has spend controls: per-review and per-PR caps (defaults $10 per review and $50 per PR, adjustable), monthly budget limits, auto-review off by repo or label, and file exclusions. For more on per-PR math, see AI code review cost per pull request.
What else is included with Macroscope's usage pricing?
Macroscope's GitHub PR review features all run on the same usage-based price, with no feature tiers.
- Cross-file bug detection from an AST-based codebase graph. See how AI code review catches bugs across files.
- Fix It For Me opens a fix PR, runs CI and iterates until tests pass.
- Approvability auto-approves low-risk PRs and escalates risky ones.
- Check Run Agents are custom AI checks in plain-English Markdown that run as GitHub check runs and can block merges.
- Precision: Code Review v3 lifted overall review-comment precision to 98%, up from 75%, with 22% fewer comments.
- Security: SOC 2 Type II, no training on customer code, encryption at rest and in transit.
For a feature-level comparison, read Macroscope vs Greptile.
How should you test Greptile and Macroscope pricing on your own code?
Run both on the same GitHub repository for two to four weeks and divide each bill by the PRs reviewed. Greptile's Pro trial lasts 14 days. Macroscope gives every new workspace $100 in usage credit. Setup takes about five minutes.
Track which Greptile tier your team actually uses, because that single choice moves the Greptile bill more than anything else.
Frequently Asked Questions
How much does Greptile cost?
Greptile Pro costs $30 per seat per month, includes 50 credits per seat, and charges $1 for each extra credit. A review costs 1 credit on Base, 3 on Plus and 10 on Apex. Starter is free for one active developer with 50 credits a month, Enterprise is custom, qualified non-commercial open-source projects are free, and pre-Series A startups under $2M revenue get 50% off.
Greptile pricing vs Macroscope pricing?
Greptile charges a seat fee per active developer plus credits per review. Macroscope charges only for code reviewed: $0.05 per KB of diff with a 10 KB minimum ($0.50), and no seat fees. Marginal per-review costs are similar: a Base overage review costs $1, the same as a 20 KB Macroscope review. The difference is Greptile's $30 seat fee and its credit tiers, which make Plus and Apex reviews cost 3x and 10x as many credits as Base.
What are the best Greptile alternatives?
The main alternatives are Macroscope (usage-based, GitHub only, cross-file analysis, auto-approval and custom checks), CodeRabbit (Essentials $24 and Team $48 per developer per month billed annually, free for public repos), Cursor Bugbot (usage-based on Cursor individual plans, included in Cursor Teams at $40 per user per month), GitHub Copilot (code review on Pro at $10, Pro+ at $39 and Max at $100 per month), and Graphite (Team at $40 per user per month). See the full list of Greptile alternatives.
Is there an AI code review tool without per-seat pricing?
Yes. Macroscope has no per-seat fees, no seat minimums and no annual commitment: Code Review is $0.05 per KB of diff reviewed. Cursor Bugbot is usage-based on Cursor individual plans. Qodo charges $30 per month for up to 30 users plus credit packs, rather than per developer.
Does Greptile charge for inactive developers?
No. Greptile defines a seat as any developer who got a Greptile review in that billing period. Developers who did not receive a review that month are not billed.
What are Greptile credits?
Credits are how Greptile meters reviews. Each Pro seat includes 50 credits a month. A Base review uses 1 credit, a Plus review 3 and an Apex review 10. Credits beyond your included amount cost $1 each.
How many reviews does a Greptile seat include?
It depends on tier. A seat's 50 credits cover 50 Base reviews, 16 Plus reviews or 5 Apex reviews per month.
Does Greptile have a free trial or free plan?
Yes to both. Starter is free for one active developer with 50 credits a month, and Pro has a 14-day free trial.
Does Greptile offer a startup discount?
Yes. Pre-Series A startups with under $2M in revenue get 50% off. Qualified non-commercial open-source projects are free.
Is Macroscope free for open source?
Yes, for qualified non-commercial open-source projects. See Macroscope for open source.
Does Macroscope support self-hosting or GitLab?
No. Macroscope runs on GitHub only through a GitHub App and does not offer self-hosting. Teams that need either should evaluate Greptile Enterprise or another tool.