Cursor Bugbot Pricing (2026): PR Review Cost & Worth It

# Cursor Bugbot Pricing (2026): What PR Review Actually Costs and When It’s Worth It

You do not need another “AI reviews your PRs now” pitch. You need the billing model after the May-June 2026 shift, the difference between Individual and Teams meters, what Autofix adds on top, and a clean comparison to seat-priced reviewers like CodeRabbit. As of 2 September 2026, Bugbot is usage-based - not the old per-seat product many directory pages still quote.

Concrete numbers get quoted from primary docs. Estimates are labeled. Adjectives do not substitute for either.

Some product links may earn a commission. That does not change the math. We also list Cursor in the Vantaige directory; weigh that bias if you see a listing.

1. TL;DR
2. What Bugbot actually is
3. The 2026 billing shift (seat → usage)
4. Individual vs Teams: which meter burns
5. Effort levels, Autofix, and other multipliers
6. Cost scenarios you can put in a budget
7. SCM constraints (not “GitHub-only” anymore)
8. Bugbot vs CodeRabbit (comparable axes only)
9. Watch out / when NOT to buy
10. Setup checklist that protects the bill
11. FAQ
12. References
13. Related from Vantaige

TL;DR {#tldr}

Billing model: Bugbot moved from per-seat to usage-based (announced 11 May 2026). New customers: immediate. Existing customers: at the next renewal after 8 June 2026 (annual plans wait until their renewal year). Cursor’s help center states the average Bugbot run costs between $1.00 and $1.50, depending on PR size and complexity.
Individual plans: Bugbot first spends included usage, then on-demand if enabled. Staff clarification on the Cursor forum: Individual Bugbot draws from the API usage pool, not the first-party model pool. Empty API pool + on-demand off → reviews pause with “usage limit reached.”
Teams: Bugbot reviews bill from on-demand spend. Forum staff: you still need at least one active paid Team seat; there is no separate “Bugbot seat,” but zero paid seats stops Bugbot.
Worth it when: high-volume PR orgs already on Cursor, willing to set effort = Low/Default on noisy repos, with spend caps and “run once / mention-only” on low-risk paths.
Skip when: you want predictable per-developer seats, Autofix/cloud agent loops would dominate spend, or human review is already the bottleneck and AI noise would slow merges.
Vs CodeRabbit: different price shapes. CodeRabbit Essentials is $24/developer/month annual ($30 month-to-month) per CodeRabbit docs; Bugbot is $/review on top of Cursor. Compare monthly expected reviews × ~$1-$1.50 (plus Autofix) against seat × PR-openers, not against Cursor IDE seats alone.

What Bugbot actually is {#what-it-is}

Bugbot is Cursor’s automated pull-request (and merge-request) reviewer. Per Cursor’s Bugbot docs, it:

Analyzes the PR/MR diff and posts comments with explanations and fix suggestions.
Runs automatically on each PR update (configurable) or on manual triggers (cursor review / bugbot run).
Reads existing PR comments so it is less likely to spam duplicates.
Links findings into Fix in Cursor / Fix in Web (cursor.com agents).
Can publish a CI check (Cursor Bugbot on GitHub; analogous statuses on Bitbucket / Azure DevOps).
Supports rules (team, repo, .cursor/BUGBOT.md), effort levels, incremental review, optional Autofix via Cloud Agents, and (Team/Enterprise) MCP tools and admin APIs.

It is not a replacement for:

Human architectural review on risky changes.
Static analysis / SAST you already run in CI (Bugbot can complement; it is not your license scanner by default unless you write rules for it).
The Cursor IDE itself. Bugbot is a review product that sits on your SCM + Cursor billing account.

Older Vantaige / directory copy that still says “Bugbot is $40/user/month” reflects the legacy seat plan. Treat that number as historical unless you are still on a grandfathered seat cycle that has not renewed yet.

The 2026 billing shift (seat → usage) {#billing-shift}

Primary source: Bugbot usage-based billing.

Fact	Detail (Cursor Help, accessed Sep 2026)
Announcement	11 May 2026 - move from per-seat to usage-based for Teams and Individual
New customers	Usage-based immediately
Existing customers	Applies at next billing renewal after 8 June 2026
Monthly example	Cycle starting 1 May 2026 → new model on the cycle starting 1 July 2026, not 1 June
Annual example	Annual bought May 2026 → usage-based at renewal May 2027
Early switch	Existing customers can switch early in the dashboard; Cursor applies pro-rated credits for pre-paid seat fees
Stated average	$1.00-$1.50 per Bugbot run (size/complexity dependent)

Cursor forum staff (May 2026) also clarified marketing residue: old “monthly plan / 14-day free trial” copy on some surfaces lagged the product. The accurate settings copy is billed based on underlying agent usage. Prefer the help center + dashboard over stale landing-page fragments.

What “a run” means for your bill

Assume one PR update = one billed review unless you change defaults:

Default incremental review reviews changes since the previous Bugbot pass (docs). Turning incremental off re-reviews the full PR on every push - more thorough, more spend.
“Run only once per PR” (repo or personal setting) stops follow-up commits from re-billing automatically.
Manual triggers (bugbot run) still bill when they run.
Enterprise dry-run API reviews (dryRun: true) still bill like normal reviews per Bugbot API docs - they just skip posting to the SCM.

If your culture is “push 12 times before asking for review,” automatic-on-every-update is the expensive mode. Fix process first, or flip to mention-only / once-per-PR.

Individual vs Teams: which meter burns {#individual-vs-teams}

Individual (Pro / Pro+ / Ultra)

From Cursor Help + forum staff clarification (July 2026):

1. Bugbot spends included usage first.
2. Overflow goes to on-demand if you enabled it.
3. If on-demand is off and included usage is gone, Bugbot pauses until the next cycle.
4. Included usage for Individual Bugbot means the API usage pool, not first-party model allocation. You can have first-party headroom left and still see “usage limit reached.”

Practical implication: heavy Cursor agent days that burn the API pool will starve Bugbot unless on-demand is on - or you wait for reset. Budget Bugbot as part of the same API meter you already watch for agents, not as a free side product.

Individual plan list prices (Cursor Help, Sep 2026): Pro $20/mo, Pro+ $60/mo, Ultra $200/mo. Those buy IDE + included usage pools; they are not a separate Bugbot subscription anymore.

Teams

From Cursor Help + forum staff (Team seat thread):

Bugbot Teams reviews bill from on-demand usage (enable on-demand in the dashboard).
No dedicated Bugbot per-seat fee under the new model.
Bugbot still requires an active paid Team - ≥1 paid seat. Drop to zero paid seats → Bugbot stops.
One paid seat can keep Bugbot available across enabled repos; access for manual triggers / IDE use still follows Team membership and Bugbot access settings.
Hitting a spend limit pauses Bugbot until you raise the limit or the cycle resets.

Teams seat list prices (Cursor Help / June 2026 Teams pricing blog): Standard $40/user/mo (annual $32), Premium $120/user/mo (annual $96). Those seats buy Cursor for humans. Bugbot is additional on-demand, not included as unlimited free reviews.

Effort levels, Autofix, and other multipliers {#multipliers}

Effort levels (usage-based plans only)

Cursor documents four levels (Bugbot docs / Help):

Level	Intent (vendor language)	Bill / latency skew
Low	Optimize for cost; quality close to Default	Cheaper; takes longer
Default	Efficiency and speed	Mid
High	More reasoning; may find more bugs	More expensive; slower
Smart	Natural-language policy for when to use Low/Default/High	Variable - write the policy carefully

Set these in Bugbot Automations. Defaulting every monorepo PR to High is how you turn a $1.20 average into a surprise.

Autofix (separate meter)

Autofix can spawn a Cloud Agent to fix findings, push to a new branch (recommended) or the existing branch (max 3 attempts), and comment back. Requirements from docs: on-demand usage enabled, storage enabled (not Legacy Privacy Mode). Billing: Autofix uses Cloud Agent credits at plan rates - on top of the Bugbot review cost.

If Autofix is on for every medium finding, model your bill as:

> Bugbot reviews + Cloud Agent minutes/credits for attempted fixes

Not as “~$1.25 × PR count” alone.

Rules and `.cursor/BUGBOT.md`

Rules are how you reduce noise (and wasted follow-up reviews). Caps from docs: 30k characters per rule, 100k combined per review; required team rules prioritized. Cursor project *.mdc rules do not apply to Bugbot - use BUGBOT.md / Bugbot Automations rules instead.

Verbose mode (bugbot run verbose=true) prints which rules loaded - use it when costs spike and you suspect giant rule packs.

Cost scenarios you can put in a budget {#scenarios}

Method: use Cursor’s stated average $1.00-$1.50 per run. These are illustrative envelopes, not invoices. Your mix of PR size, effort level, incremental setting, and Autofix will move the number. Always label them estimate in a finance memo.

Assume Default effort, incremental on, Autofix off, unless noted.

Team shape	Assumed review runs / month	Envelope at $1.00	Envelope at $1.50	Notes
Solo / Individual, 20 PRs, ~1.5 updates each	~30	~$30	~$45	Comes out of API included usage first
5-dev product team, 80 merged PRs, ~2 updates each	~160	~$160	~$240	Teams: pure on-demand
10-dev team, 200 PRs, ~2.5 updates each	~500	~$500	~$750	Turn on once-per-PR on low-risk repos
25-dev platform org, 600 PRs, ~3 updates each	~1,800	~$1,800	~$2,700	Spend caps mandatory; High effort will blow this

Autofix sensitivity (estimate): if 20% of runs spawn a Cloud Agent fix and that fix costs as much as another review-scale agent job, add a second mid-three-figure line - do not invent a Cloud Agent dollar figure here; pull your real Cloud Agent rates from the Cursor dashboard before you commit.

Vs legacy seat math (historical): when Bugbot was roughly $40/user/month, a 10-seat Bugbot add-on was ~$400/mo flat regardless of PR volume. Under usage billing, a quiet month can land under that; a noisy monorepo month can land over it. Usage is better for spiky or small teams; seats were better for “always-on, high volume, want predictability.” Pick consciously.

Worked Individual example (labeled estimate)

Ultra Individual ($200/mo list) with a large included usage pool still hits the API pool wall for Bugbot. If Bugbot needs ~40 runs/month (~$40-$60 at the published average) and your IDE agents already emptied the API pool by mid-cycle, those 40 runs either:

pause (on-demand off), or
bill on-demand (on-demand on).

Worth-it test: did Bugbot catch ≥1 merge-blocking bug per month that would have cost more than the on-demand line? If you cannot point to examples after 30 days, turn it to mention-only.

SCM constraints (not “GitHub-only” anymore) {#scm}

Early Bugbot coverage was GitHub-centric. Current Cursor docs list:

GitHub (including GitHub Enterprise Server)
GitLab (including self-hosted)
Bitbucket (including Data Center)
Azure DevOps Services - limited availability

If your org is still on an older mental model of “Bugbot = GitHub only,” re-check the integration pages before you disqualify it - and re-check Azure DevOps specifically if that is your primary host.

Constraints that do still matter:

Repo must be connected and enabled in Bugbot Automations.
Branch protection: requiring the Bugbot check ensures it runs, but findings default to neutral, so requiring the check alone does not block merges on findings unless you enable fail-on-unresolved behavior where available.
Self-hosted SCM needs the networking / install guides (GHES, GitLab self-hosted, Bitbucket DC).

Bugbot vs CodeRabbit (comparable axes only) {#vs-coderabbit}

Do not compare “AI code review” as a vibe. Compare price shape, where review runs, and what else you already pay for.

Axis	Cursor Bugbot (usage, 2026)	CodeRabbit (public plans, 2026)
Price shape	~$1-$1.50/run average (vendor); Individual via API pool then on-demand; Teams via on-demand	Per developer who opens PRs: Essentials $24/dev/mo annual ($30 MoM); Team $48 annual ($60 MoM); Advanced $90/dev/mo monthly USD; Enterprise custom (CodeRabbit plans docs; pricing page)
Needs Cursor IDE seats?	Yes for the Cursor org / Team context; Bugbot is not a free sidecar	No - review product stands alone
Rate limits	Usage / spend caps; pauses when limits hit	Hourly review allowances per plan (e.g. Essentials 5 PR reviews/dev/hour) + optional usage add-on
Autofix	Cloud Agent path; separate Cloud Agent billing	1-click fixes / agent loops included in paid tiers (vendor feature list)
Rules / learning	Team + repo + `BUGBOT.md` + learned rules	Learnings, custom pre-merge checks (tiered)
Best fit	Teams already standardized on Cursor who want review + Fix-in-Cursor continuity	Teams that want a dedicated review vendor with seat predictability, or mixed-IDE shops

Rough comparable math (estimate, annual CodeRabbit seats)

10 developers who open PRs on CodeRabbit Essentials annual: 10 × $24 = $240/mo.

At Bugbot’s $1.25 midpoint average, $240/mo ≈ 192 review runs. If your team exceeds ~200 Bugbot runs/month with Autofix off, seat-priced CodeRabbit Essentials can look cheaper on review alone - until you factor that Bugbot’s value is partly the Cursor handoff. If you run under ~150 Bugbot runs/month, usage Bugbot may undercut Essentials seats.

That crossover is the only honest comparison. Everything else is feature preference.

Watch out / when NOT to buy {#when-not}

Watch out

1. Stale $40/seat quotes in blogs and directories - verify against the usage help page.
2. API vs first-party pool confusion on Individual - Bugbot does not cross over to first-party allocation (forum staff).
3. Autofix without a Cloud Agent budget - second meter, easy to miss in a pilot.
4. High effort + full-diff on every push - multiplies the $1-$1.50 average.
5. Branch protection theater - neutral findings do not block merges by default.
6. Dry-run API still bills (Enterprise) - “dry” ≠ free.
7. Zero Team seats - Bugbot stops even if repos stay connected.

When NOT to turn Bugbot on

Your PR volume is tiny (a handful of reviews/month) and humans already catch what matters - the comment noise may cost more attention than the dollars.
You need hard predictability for a procurement sheet and refuse on-demand lines - CodeRabbit seats (or waiting on a Cursor quote) may fit better.
You are not on Cursor and will not be - buying Cursor seats *just* for Bugbot is usually the wrong stack order; evaluate dedicated reviewers first.
Compliance forbids sending diffs to a third-party review agent without a signed DPA / residency story you have not reviewed (Bugbot follows Cursor privacy processing per docs - still your legal call).
Your “review problem” is missing tests / flaky CI, not missing LLM comments. Fix the pipeline; do not paper over it.

Setup checklist that protects the bill {#setup}

1. Connect SCM → enable Bugbot per repository (start with 1-2 critical repos).
2. Set spend limits / on-demand consciously (Teams: required for runs; Individual: decide pause vs overage).
3. Start with Default or Low effort; add High only on paths like payments/, auth/.
4. Prefer Create New Branch if you enable Autofix; keep Autofix off for week one.
5. Add a short root .cursor/BUGBOT.md (house style, banned APIs, “do not nitpick formatting”).
6. Use once per PR or mention-only on docs-only / generated-code repos.
7. After 14 days, pull Automations analytics: runs, accepted findings, cost. Kill or expand based on accepted issues, not comment count.

FAQ {#faq}

Is Bugbot still $40 per user per month?

Not under the current usage-based model. That figure matches the legacy seat era. New billing is usage; existing customers convert at the renewal rules above. Confirm your dashboard.

How much does one Bugbot review cost?

Cursor Help states an average between $1.00 and $1.50 per run, varying with PR size and complexity. Effort level and Autofix change the all-in number.

Does Bugbot use my Cursor Pro included usage?

On Individual, yes - from the API usage pool first (not first-party). On Teams, reviews bill from on-demand spend.

Can we run Bugbot with one Team seat for the whole company?

Staff guidance: one active paid Team seat can keep Bugbot available across enabled repos under usage billing. Manual triggers and IDE-side behavior still follow membership / access settings. Confirm against your admin settings; do not assume contractors without access can trigger reviews.

Does Bugbot work only on GitHub?

No. Current docs cover GitHub, GitLab, Bitbucket, and Azure DevOps (limited). Self-hosted variants have separate networking guides.

Is Bugbot better than CodeRabbit?

Wrong question. Bugbot wins when Cursor continuity + usage economics fit your PR volume. CodeRabbit wins when you want seat predictability or a review vendor independent of your IDE. Run the crossover math in the comparison section.

Will Autofix fix everything Bugbot finds?

No. Autofix spawns a Cloud Agent with attempt limits on the same branch mode. Treat patches as untrusted until a human reviews them - same rule as any agent PR.

Privacy - does Bugbot train on our code?

Cursor states Bugbot follows the same privacy compliance as other Cursor requests. Your Privacy Mode / storage settings still matter (Autofix requires storage, not Legacy Privacy Mode). Read Cursor’s current privacy docs before enabling org-wide.

References {#references}

All accessed September 2026:

1. Cursor Help - Bugbot usage-based billing
2. Cursor Docs - Bugbot
3. Cursor Help - Pricing and plans
4. Cursor Blog - Improvements to Teams Pricing (Standard / Premium seat list prices)
5. Cursor Forum - Confusion of Bugbot Pricing (staff: usage-based; no separate monthly Bugbot subscription)
6. Cursor Forum - Bugbot Usage and Team Seat Requirements
7. Cursor Forum - Can Bugbot use First-Party Model plan allocation? (staff: API pool only on Individual)
8. CodeRabbit Docs - Plans and pricing
9. CodeRabbit - Pricing

Cursor in the Vantaige directory - product profile (verify any legacy Bugbot seat wording against this article)
Claude Code vs Cursor vs Codex vs Devin vs Replit Agent 3: 2026 Scorecard - where review bots sit relative to coding agents
Fix MCP Server Not Working: Stdout Bug & 1-Line Fix - if you wire MCP tools into Bugbot on Team/Enterprise

---

One short email a week: the billing shifts that actually hit renewals, the crossover math vs seat-priced reviewers, and the “when NOT” notes vendors skip. Subscribe at vantaige.io.

Cursor Bugbot Pricing (2026): What PR Review Actually Costs and When It’s Worth It

Table of contents

TL;DR {#tldr}

What Bugbot actually is {#what-it-is}