Checkly pricing is built on check runs: every time a monitor fires, it consumes one check run from your monthly allowance. At publicly listed rates as of June 2026 (verify current pricing at checklyhq.com), a team running 10 browser checks every 5 minutes accumulates roughly 87,600 check runs per month, pushing well past the Team plan's included allowance and into overage territory. Browser checks are the expensive line item. Frequency multiplies everything.
Three numbers drive your Checkly bill. The first is your monitoring frequency translated to check runs per month: a single browser check running every 5 minutes generates roughly 8,760 runs, and every minute tightens that to 43,800. The second is the per-run premium browser checks carry over API checks, a reflection of the Chromium execution overhead behind each run. The third is the overage rate that kicks in once you exceed your plan's included allowance.
None of these numbers are hidden. The billing model is transparent. The challenge is that teams configure monitors first and model the math second, so the first overage bill arrives as a surprise rather than a forecast. This post lays out all three numbers explicitly, with a worked example, so you can estimate your real bill before you commit to a monitoring cadence.
All pricing figures below are estimates based on publicly listed plans at checklyhq.com as of June 2026. Checkly updates its pricing, so verify current rates before making a purchase decision.
How Checkly Bills
Checkly's billing unit is the check run. Each time a monitor fires, it consumes one check run. Your monthly plan includes a fixed number of check runs. When you exceed that allowance, you pay for additional runs at an overage rate.
Two check types matter for cost modeling. API checks verify an HTTP endpoint and return a pass/fail result. They are lightweight. Browser checks drive a headless Chromium browser through a user flow using Playwright scripts. They take longer to execute, consume more infrastructure, and historically have been priced higher on a per-run basis because of that resource cost.
The officially listed plan tiers, based on publicly available information as of June 2026:
| Plan | Included Check Runs | API Checks | Browser Checks | Price (approx.) |
|---|---|---|---|---|
| Hobby | Stated as free tier | Included | Included (limited) | $0/mo |
| Team | ~1,000,000 / mo | Yes | Yes | ~$80/mo (listed) |
| Enterprise | Custom volume | Yes | Yes | Custom |
Checkly does have a free tier with limited check runs. It is useful for evaluating the platform, but it is not a realistic option for teams with multiple production monitors. The Team plan is where most self-serve customers land. Enterprise pricing is quote-based and typically involves committed spend with volume discounts.
The numbers in this table are estimates reconstructed from publicly available sources. Checkly's actual per-plan allowances and overage rates may differ from what is shown here. The goal of the table is to illustrate the billing structure, not to serve as a substitute for the current pricing page.
The Cost of Frequent Browser Checks
Browser checks are where Checkly costs tend to surprise teams. Here is a worked example using round numbers so the method is transparent.
Suppose you have 10 browser checks covering your critical user journeys: login, checkout, account creation, and similar flows. You run each check every 5 minutes across two environments (production and staging).
The run count math:
At every-5-minutes frequency, one check generates 8,760 runs/month. Ten checks across two environments multiply that to 8,760 x 10 x 2 = 175,200 runs/month.
Now apply the per-check billing model. If the Team plan includes roughly 1,000,000 runs and you are at 175,200, you are well inside the allowance. But now consider a team that runs those same 10 browser checks every minute instead of every 5 minutes. That produces 43,800 x 10 x 2 = 876,000 runs/month, which is approaching the Team plan ceiling before a single API check is counted.
Add another environment (a canary or a regional endpoint), and you cross the threshold. Every environment you add, every frequency increase, and every new check you add feeds directly into your monthly run total.
If browser checks cost more per run than API checks (which is typical given the Chromium execution overhead), the math tightens further. The exact per-run overage rate depends on your plan and should be verified at checklyhq.com. The structural point is that browser check cost is not fixed. It is a product of check count, frequency, and environment count. Change any one of those variables and the bill changes proportionally.
For comparison, see how similar per-run or per-parallel billing models compound in Cypress Cloud pricing and the true cost of BrowserStack at scale. The pattern repeats: what looks like a flat subscription is often a metered model where usage behavior drives the real bill.
How Autonoma Covers What Browser Checks Were Really Testing
Browser checks are, at their core, E2E browser flows executed on a schedule. You write a Playwright script that logs a user in, completes a purchase, or submits a form, and Checkly runs that script against your production endpoint on a cadence you define. The value is continuous verification of critical user journeys in production. The cost is metered per execution, compounding with frequency and environment count.
That overlap between "browser check" and "E2E test" is where Autonoma is relevant, with one important carveout: Autonoma is not a synthetic monitoring or uptime product. It does not ping production endpoints on a schedule, does not alert you when your site goes down, and does not replace Checkly for pure uptime and latency monitoring. If you need SLA dashboards, alerting on endpoint availability, or production health monitoring, Checkly remains the right tool for that job.
What Autonoma addresses is the critical-flow verification layer: the part of your browser checks that is really confirming that the login flow works, the checkout succeeds, and the account creation does not regress. Our Planner agent reads your codebase and plans test cases derived from your routes, components, and user flows. The Executor agent runs those tests against a managed preview environment spun up per PR. The Reviewer agent classifies each result as a real bug, an agent error, or a test-plan mismatch. The Diffs Agent runs on every PR, adding new tests for new flows and deprecating tests for removed ones, keeping the suite aligned with your codebase without manual maintenance. Autonoma's managed tier is Free & Pay As You Go: $0 to start, 100K credits free, then $100 per 150K credits, with optional auto top-up and no minimum. Self-hosted is Free, forever: run on your own infrastructure with no limits and no usage costs. For teams where the synthetic monitoring bill is driven primarily by browser checks on critical user journeys, the question worth asking is whether that verification layer belongs in production monitoring on a frequency schedule, or in per-PR E2E coverage on a managed preview.
Teams evaluating the full spectrum of testing infrastructure cost (not just monitoring) will find the flaky test cost analysis and the Testsigma pricing breakdown useful for broader context.
Final Thoughts
Checkly's billing model is logical once you understand it: check runs are the unit, frequency and environment count are the multipliers, and browser checks are the expensive line item. The model is transparent. The challenge is that teams often configure monitors first and model the cost second, which means the first overage bill is a surprise rather than a forecast.
Before committing to a monitoring frequency or expanding your browser check coverage, model the run math explicitly. Multiply your intended check count by your frequency in runs per month, multiply by your environment count, and compare to your plan's allowance. That arithmetic takes five minutes and will tell you whether you are comfortably inside your plan or heading toward the overage rate.
For the critical-flow verification layer, Autonoma handles the E2E side of that equation on per-PR preview environments. Managed Autonoma is credit-based after 100K free credits, while Self-hosted is Free, forever with no limits and no usage costs. For production uptime and endpoint monitoring, Checkly's synthetic monitoring remains the right tool. The two layers are complementary, not competing. Getting both right is how teams avoid both the production surprise (Checkly catches it) and the regression that should have been caught before merge (Autonoma catches it).
FAQ
Checkly offers a free Hobby tier with limited check runs, a Team plan publicly listed at approximately $80/month with a monthly check-run allowance, and custom Enterprise pricing. The actual bill on paid plans depends on how many check runs you consume. Browser checks running at high frequency across multiple environments can push you toward or past the included allowance quickly. Verify current rates at checklyhq.com before buying.
A check run is a single execution of a monitor. Every time Checkly fires a check, that counts as one run against your monthly allowance. A browser check configured to run every 5 minutes generates approximately 8,760 runs per month. An API check running at the same frequency generates the same number of runs but typically costs less per run due to lower infrastructure requirements. Your plan includes a fixed number of runs; going over results in overage charges.
Yes. Checkly's Hobby plan is free and includes a limited number of check runs per month. It is useful for evaluating the platform and monitoring a small number of low-frequency checks. For teams with multiple production monitors or high-frequency browser checks, the Hobby plan's run allowance will typically be exhausted before the month ends. The Team plan is where most production teams land.
Browser checks consume check runs like any other Checkly check, but they are more resource-intensive because they drive a headless Chromium browser through a Playwright script. This means they typically cost more per run than API checks. The exact per-run cost depends on your plan and Checkly's current rates. At high frequency (every 1-5 minutes) across multiple environments, browser checks are usually the largest line item in a Checkly bill. Model your run count before configuring frequency.
Self-hosting Playwright (or a similar E2E framework) in CI means you pay for CI compute time rather than per check run. For teams running tests on every PR, CI-based E2E testing can be more predictable in cost because you control the infrastructure. The tradeoff is that CI-based tests run on code changes, not on a production schedule, so they do not catch regressions introduced by infrastructure or third-party changes outside of a deploy. Checkly's synthetic monitoring and self-hosted Playwright tests serve different verification purposes. The flaky test cost breakdown at /blog/cost-of-flaky-tests covers the CI infrastructure cost side in more detail.
