Skip to main content
New customers have been on usage-based pricing since March 27, 2026. On April 27, 2026, we moved all existing customers over from the legacy pricing plan, so everyone is now on the same plan.
Macroscope features are billed based on usage, so your costs are tied to the actual work Macroscope does reviewing and processing your code.

​
Pricing

Macroscope is purely usage-based pricing; we do not charge for seats.
Pricing as of August 28, 2026.

​
How Billing Works

Macroscope uses a prepaid usage model. Each workspace has a single balance that covers Code Review, Status, and Agent, and decreases with usage. Enable Auto-refill to have your balance top up automatically when it falls below a threshold you configure, so there’s no disruption.
Usage data in your billing dashboard may be delayed by a few minutes due to how Stripe’s metering system works.
Admins can manage auto-refill and spend controls, and view their workspace’s balance, usage history, and usage costs in Settings → Billing. To zoom into a specific date range, click and drag on the usage chart — the usage summary and breakdown tables update to match the selected window. The breakdown table shows each meter’s Rate — the per-unit price it is billed at — alongside the usage recorded and the cost that produced.
Go to Settings → Billing and configure your balance threshold and refill amount. We recommend enabling auto-refill to ensure Code Review and Status processing run without interruption. If your balance hits zero without auto-refill, processing pauses until your balance is topped up.
Whenever an auto-refill payment is made, you’ll receive a receipt. Your invoice at the end of your usage period will be $0 since top-ups are prepaid. You can view all receipts and invoices in Settings → Billing, powered by Stripe.
Add, update, or remove payment methods in Settings → Billing.
There can be up to a few minutes of delay in meter data due to how Stripe’s metering system works. If something still looks off after accounting for that, reach out to us at support@macroscope.com.
No.
Access continues until the end of your billing period. Your balance stays in your account. If you resubscribe, it picks up where you left off.

​
Spend Controls

You can set several limits to control your costs. Configurable by a workspace admin in Settings → Billing.
Default caps are $10 per review and $50 per PR. Both always apply — there is no setting that removes them — and both are adjustable in Settings → Billing.Where each limit lives. In Settings → Billing, the per-PR controls are grouped by which review they govern, because they are separate budgets with different rules:The per-review cap, the Correctness per-PR cap and the Check Run Agents per-PR limit cannot be turned off. Each one always resolves to a value, so leaving one of those fields blank means “leave this unchanged”, not “remove the limit” — blank the Correctness fields and save, and the stored caps are kept. Only the monthly and CLI limits can genuinely be cleared.What differs between them is how they are updated: the two Correctness limits move as a pair, so changing either one submits both, while the Check Run Agents limit is configured independently of them. Each group links to the documentation for the review type it governs, and the What if? simulator sits with the Correctness limits because it models those two only.

​
What the Correctness per-PR cap counts, and what it stops

The per-PR cap measures one thing and stops two, and the difference matters when you are working out why a check did not run. What counts toward the cap: Code Review (correctness) runs on that PR, and nothing else. Check Run Agent and Approvability spend on the PR does not add to the total, and neither does spend that is not attached to a PR at all — Ask Macroscope Anything, Macros, and CLI reviews. What stops once the cap is reached: Code Review and Approvability on that PR. Approvability is stopped by a cap its own spend never counted toward. That is deliberate: the cap is a statement about what one pull request may cost in total, and Approvability reads the correctness review’s findings, so continuing to run it once correctness has stopped would report a verdict from incomplete input. Check Run Agents used to be stopped by this cap too. They are not any more — they are governed by a separate workspace limit, so raising or lowering the Correctness cap no longer changes when agents stop. Two further details:
  • Code Review stops before exceeding the cap; the agents stop after reaching it. Code Review’s maximum cost is known before it runs, so it is skipped when the spend already booked plus this review’s estimate would go over. An agent’s cost cannot be estimated up front, so agents are stopped only once booked spend has already reached the cap.
  • Spend before usage-based billing began does not count. Only Code Review runs recorded under usage-based billing are totalled, so a long-lived PR is not charged against the cap for work that predates it.
Commenting @macroscope-app review this PR bypasses the per-PR cap and reviews the PR now. The monthly spend limit is not bypassable this way — it applies to on-demand reviews too.

​
The Check Run Agents per-PR limit

Check Run Agents have their own workspace-wide per-PR limit, separate from the Correctness caps above. It defaults to $100. It is one shared budget across every agent on the PR. A workspace running ten agents gets one ceiling for all of them, not ten. Once their combined recorded spend on a PR reaches the limit, remaining automatic agent runs on that PR are created and concluded skipped, naming the limit. Automatic runs are gated; a deliberate invocation is not. Agents that run automatically on a push are checked against the limit. Naming an agent yourself — mentioning @macroscope-app — bypasses the workspace limit and runs it, exactly as on-demand review bypasses the Correctness cap. The per-PR limits pace what a single pull request spends on its own, so a deliberate request is let through. The monthly spend limit is the opposite by design: it bounds your total exposure for the billing period and cannot be overridden, on-demand runs included.
The limit is best effort, and a PR can overshoot it. An agent’s cost is only known once it finishes, so the check compares spend already recorded before dispatching — it does not reserve budget, estimate a run’s cost, or hold agents back to find out. Several agents dispatched at once therefore all see the same pre-run total and can all be allowed through, taking the PR past the limit by up to one round of agents.This is a deliberate trade: the alternative is serialising every agent behind a billing read. Treat the limit as “stop shortly after this much”, not as a hard ceiling. The monthly spend limit is the hard one.
Per-agent budgets are separate and stack with it. For finer control than one workspace-wide ceiling, an individual agent can declare its own caps in the front matter of its .macroscope/*.md file. The two do different jobs:
  • maxBudgetPerRun bounds a single run. The agent re-checks it after each turn and stops as soon as the cap is reached, which makes it the control to reach for when you want to cut off an agent that would otherwise keep investigating. Work already done is still billed, and a run stopped this way should be read as incomplete rather than clean. Not supported with input: code_object.
  • maxBudgetPerPR bounds that agent’s total across every run it makes on one PR. It is checked before a run is dispatched, so it stops a further run from starting rather than interrupting one in flight.
Both cap one agent only; the workspace limit caps all of them together. Whichever ceiling is reached first stops that agent, so raising an agent’s own budget will not clear a workspace limit that has already been reached.
If you don’t have auto-refill on and your balance runs out, all processing pauses — Agent, Code Review, and Status. Commits and PRs pushed during that window are skipped and are not retroactively processed when your balance is topped up.
Agent, Code Review, and Status processing pause for the rest of the billing period. Auto-refill does not trigger when the monthly max is hit. Commits and PRs pushed during that window are skipped.Processing resumes when the next period starts or an admin increases the limit.
Auto-refill tops up your balance but does not override the monthly spend limit. If you hit your monthly limit, processing pauses even if you still have balance remaining. They are separate controls.

​
CLI Review Limits

Macroscope CLI reviews consume Agent credits, and admins can cap them separately from the rest of your usage under Settings → Billing → CLI Spend Controls. Both workspace-level fields are blank by default and accept any amount above $0. Per-user overrides are added and removed under Per-user overrides; an override of $0 blocks that developer from running CLI reviews, and removing the override returns them to the default. How the limits behave:
  • Checked before a review starts, so a review that would exceed a limit is declined and costs nothing.
  • Only CLI reviews count. Code Review on GitHub, Status, and other Agent usage draw on the workspace budget but not on these limits.
  • The workspace limit wins. Once it’s reached, every developer is blocked for the rest of the billing period, whatever their own limit allows.
  • Best effort, not a reservation. Reviews already running are not stopped, so spend can land slightly past a limit.
  • Resets each billing period. Raising a limit takes effect immediately — no need to wait for the reset.
When a limit is reached, the CLI declines the review and names the limit it hit:
CLI review spend is Agent credit spend, so it also draws on your balance and counts toward the workspace’s monthly spend limit. CLI limits sit on top of those controls — they never raise them.

​
Agent

Credits are a usage-based billing unit for Macroscope’s Agent features: Slack queries, Macros, Webhooks, Check Run Agents and Approvability. 1 credit = $0.01. Credit usage is calculated by taking the raw LLM cost of each agent run (based on your prompts and parameters), then adding a 5% markup, then dividing by the value of each credit ($0.01). Every workspace includes 1000 free credits per month. Free credits do not roll over. Usage beyond the free credits draws from your balance.
Credit calculation: raw LLM cost of the agent run × 1.05 markup ÷ $0.01 per credit = credits consumed.
Approvability is the one exception: it is priced per run at a flat 30 credits ($0.30), regardless of the size of the PR or what the run cost to produce. Runs Macroscope decides without an agent are free.

​
What uses credits

Code Review and Status are billed separately via their own meters. They do not consume credits.

​
Transparency

Workspace admins can view detailed Agent usage logs in Settings → Billing, including exporting a full CSV with cost and metadata for every agent invocation. The Agent Credit Usage card offers two views of the same data, grouped by Type, Repo Name, or Check Run Name:
  • Pie chart — how the billing period’s usage splits across slices.
  • Daily chart — usage per day across the period. Pick a single slice to drill into just that series, with its run count, period total, and per-run low, average, and high.
Both views follow the usage summary’s credits/dollars toggle.
Credit usage scales with LLM cost — a quick Slack question uses fewer tokens than a complex multi-step research task, so it costs fewer credits. Approvability is the exception: every approvability verdict costs the same 30 credits, so the price does not move with the size of the PR.
Usage beyond the free credits draws from your balance, the same one used by Code Review and Status. Auto-refill and spend limits apply normally.
Yes. Go to Settings → Billing to view usage logs or export a CSV with detailed cost and metadata for every invocation.

​
Code Review

Code Review is charged per review, based on the byte size of the PR diff that Macroscope reviews. The per-KB price depends on the Detection Mode the review runs in. Every review has a minimum of 10 KB. If the reviewed diff is under 10 KB, you are charged for 10 KB at that mode’s rate.
Anytime Macroscope’s correctness check runs on a PR counts as one review. This can happen:
  • Automatically on each push to a PR (if automatic Code Review is enabled for that repo)
  • Manually, by commenting @macroscope-app review on any PR in GitHub
We pull diffs from GitHub in unified diff format (u3) and measure diff size by the raw u3 diff bytes.For the first push to a PR (or any force push), we compare HEAD to the merge base of the target branch. For subsequent pushes, we always compare HEAD to the previous reviewed HEAD.Any files Macroscope doesn’t review, such as binaries or files excluded by your .macroscope/ignore.md file, are excluded from the diff, so you only pay for the files Macroscope actually reviews.
Detection Mode enables you to choose how Macroscope code review balances precision, recall, and latency. Learn more about Detection Mode.
Every review has a minimum of 10 KB. If your diff is under 10 KB, you’re charged for 10 KB. The minimum applies in every Detection Mode; at the default Balanced rate ($0.05/KB), the minimum review cost is $0.50.
The effective dollar amount varies by Detection Mode, and may vary if you’re on a plan with custom rates. 
Most reviews are under 10 KB and thus cost $0.50 at the default Balanced rate. Assuming that rate of $0.05/KB, here are some ballpark approximations:
Yes.That said, we try to be clever and detect trivial force pushes and rebases to save you money.

​
Per-Repo Code Review Controls

Configure in Settings → Repos. Learn more about repo settings.
Skip and force-review controls apply to both Correctness checks and Check Run Agents. Skipping a PR (by label, author, target branch, draft status, or Dependabot) skips both, and a force-review label runs both — even when auto-review is off. The one exception: a Check Run Agent that defines its own authors, labels, or targets filter follows that filter instead of the repo-level skip on that axis.

​
On-Demand Reviews

Even if automatic Code Review is off for a repo, you can always invoke a review manually by commenting @macroscope-app review on any PR in GitHub.

​
Excluding Files from Code Review

You can exclude specific files from review using a .macroscope/ignore.md file. See .macroscope/ignore.md for details.

​
Status

Status is powered by per-commit summarization. This feeds your dashboards, weekly digests, productivity metrics, and sprint reports.
Code Review runs on PRs and analyzes the diff for bugs and correctness issues. Status runs on individual commit summaries and powers features like executive summaries and productivity insights. They’re separate processes billed independently.
A commit is charged after Macroscope successfully summarizes it. All branches are in scope and each commit is billed at most once.Not charged:
  • Commits pushed while your balance is exhausted or spend limit is hit (skipped)
  • Commits on repos with Status disabled
Bot commits (e.g. Dependabot, CI) are processed and billed like any other commit.
Commits on that repo won’t be summarized, classified, or included in productivity metrics. No Status charges for that repo.

​
Common Questions

Per-seat pricing charges a fixed rate per developer regardless of activity. Usage-based pricing means you only pay for what Macroscope actually processes. Teams with lighter activity pay less; teams that push more code pay proportionally more.
Yes. New workspaces receive a one-time $100 in free usage to get started.

​
Annual Discounts

If you’re interested in discounted rates, reach out and we can discuss options for annual commitments. Contact enterprise@macroscope.com.
Questions? Email support@macroscope.com or reach out in your shared Slack channel.