Checkly Pricing (2026): What Check Runs Really Cost

Checkly pricing is a per-run model wrapped in three named plans. On the Detect product (uptime and synthetic monitoring), Hobby is $0, Starter is $29/mo ($24/mo billed annually) and Team is $80/mo ($64/mo annually). Each plan includes a fixed number of uptime monitors and a monthly pool of check runs. Once the pool is empty, Starter and Team bill extra browser runs at $4 per 1,000 prepaid or $6.25 to $6.50 per 1,000 as overage. Status pages (Communicate) and AI root cause analysis (Resolve) are separate modules with their own prices. Enterprise is quote-only.

This guide explains how the three products fit together, what a check run is and how regions, retries and Playwright test length multiply it, what a realistic bill looks like for three team sizes, what the pricing page leaves out, and when the Hobby to Team path stops fitting. At the end I compare it with a flat-rate plan from Hyperping, with my conflict of interest stated plainly.

Figures are from the official checklyhq.com/pricing page as of September 16, 2026, in USD. The page opens on the annual toggle, so the first numbers you see are the discounted ones. I switched to monthly billing and recorded both. Run counts below assume a 30-day month.

Quick summary

• Checkly sells three products on one page. Detect (uptime monitors plus API and browser checks) is the base plan. Communicate (status pages) and Resolve (AI root cause analysis) are add-on modules with their own Hobby, Starter, Team and Enterprise prices.
• Detect costs $0 on Hobby, $29/mo on Starter and $80/mo on Team on monthly billing, or $24 and $64 billed annually. Enterprise has no published price.
• Browser check runs are the number to watch. Hobby includes 1,000 a month, Starter 3,000 and Team 12,000. One browser check every 10 minutes from one location uses about 4,320 runs a month. Extra runs cost $4 per 1,000 prepaid, $6.50 (Starter) or $6.25 (Team) per 1,000 as overage.
• Regions, retries and Playwright test length all multiply runs. Each parallel location counts as a run, each retry counts as a run, and a Playwright Check Suite consumes one run per 30 seconds of execution.
• The full Team stack is $163/mo before any extra runs: $80 Detect, $34 Communicate, $49 Resolve on monthly billing. On-call scheduling is not included at any tier and routes to PagerDuty, incident.io or Rootly.

Why listen to us?

I am Léo, founder of Hyperping. Hyperping competes with Checkly on uptime monitoring, Playwright browser checks and status pages, so I have a stake in how this reads. Checkly also does things Hyperping does not, such as native Playwright test suites, a monitoring-as-code CLI, private locations and OpenTelemetry traces, and I will say so where it matters.

For this piece I read the Checkly pricing page on September 16, 2026, toggled it between annual and monthly billing, and went through the billing FAQ at the bottom of the page where the run-counting rules live. The numbers come from the page itself, not from a third-party summary. I did not run a paid Checkly account for this article, so where the page is silent I say so rather than filling the gap from memory.

How does Checkly pricing work?

Checkly's pricing page is split into three products that you buy separately, each with the same four tiers.

• Detect is the monitoring product: uptime monitors (URL, TCP, DNS, ICMP, SSL, gRPC, traceroute and heartbeat), API and multistep checks, browser checks and Playwright Check Suites. This is the plan most people mean by "Checkly pricing".
• Communicate is status pages and dashboards.
• Resolve is AI root cause analysis, sold as a monthly number of invocations.

Within Detect, two things are metered differently. Uptime monitors are billed by count: you get 10, 50 or 75 depending on the tier, and additional monitors come in blocks of 25 for $8 on Starter and Team. Synthetic checks (API, multistep, browser, Playwright) are billed by check run, which is the number of times they execute in a month.

The annual discount is about 17% on Starter and 20% on Team, which is where the "save up to 20%" banner comes from.

Extra runs are sold two ways. You can prepay additional runs at $4 per 1,000 browser runs or $1.80 per 10,000 API runs on both Starter and Team. If you do not prepay and go over, the overage rate applies: $6.50 per 1,000 browser runs and $2.60 per 10,000 API runs on Starter, $6.25 and $2.50 on Team. Hobby has no overage at all: it is hard-capped, and Checkly stops running your checks when the pool is empty.

The other two products follow the same tiers.

What is a check run, and what makes it multiply?

The check run is the unit that decides your Checkly bill, so it is worth being precise about how the pricing FAQ defines it.

• API check: each execution counts as one run.
• Multistep check: each request counts as one run. A multistep script that makes 3 requests uses 3 runs every time it executes.
• Browser check: each execution counts as one run, with a 4-minute timeout.
• Playwright Check Suite: one run per 30 seconds of execution time. The FAQ's own example is a 45-second suite consuming 2 runs.

Then three multipliers apply on top, all quoted from the same FAQ:

• Frequency. A check every minute uses 60 times the runs of a check every hour.
• Parallel locations. "If your check runs from multiple locations in parallel, each location counts as a run." Round robin scheduling, where each execution rotates through one location, does not multiply.
• Retries. "Each retry counts as a check run. Flaky checks will increase your usage."

Here is what that means for a single browser check on the Team plan, with the runs valued at the $4 per 1,000 prepaid rate you pay once the 12,000 included runs are used up.

The last row is the one to reread. A two-minute Playwright suite counts as 4 runs per execution, so the same schedule that costs $34.56 for a short browser check costs over $400 as a suite from three regions. Retries are not in that table, and each failed run that gets retried adds one more.

API checks are cheaper per run but the same logic applies. One API check every minute from one location is 43,200 runs a month, which is 43% of the Team allowance on its own, and a 3-request multistep check on the same schedule is 129,600.

What does a realistic Checkly bill look like?

Three setups, sized the way I see teams actually configure monitoring. Prepaid run blocks are rounded up to the next 1,000 browser runs or 10,000 API runs, since that is the unit the page sells. All prices are monthly billing.

Solo developer: Hobby, if the schedule is loose enough

Setup: 8 uptime monitors, 1 browser check on the login flow, 3 API checks, 1 location, no status page.

The Hobby plan works for a personal project, but the caps are tight enough that the schedule dictates the plan. One browser check every 30 minutes already exceeds the 1,000-run pool, and because Hobby is hard-capped rather than metered, the check stops running until next month. The practical answer is Starter at $29/mo, or $41/mo with the Starter status page.

Small team, 3 engineers: Starter plus prepaid runs

Setup: 40 uptime monitors, 3 browser checks every 15 minutes from 1 location, 6 API checks every 5 minutes in round robin, 1 status page with a custom domain.

If the team forgets to prepay and takes the overage rate instead, the run lines become $36.66 and $6.98, for $84.64/mo. Two other limits bite at this size: Starter has 3 users and no published price for a fourth, and phone call alerts are 0 on Starter, so the on-call engineer gets SMS (100 a month included) or Slack.

Growing SaaS, 10 engineers: Team with the full module stack

Setup: 75 uptime monitors, 10 browser checks every 10 minutes from 2 parallel locations, 20 API checks every 5 minutes in round robin, 3 status pages, AI root cause analysis.

On annual billing the fixed lines drop to $64, $30 and $39 and the total lands at about $447/mo, or $5,369 a year. The browser run line is three quarters of the bill, and it comes from a schedule most SaaS teams would call ordinary: ten user flows checked every ten minutes from two regions. Move the same checks to every 5 minutes and the browser line doubles to $600. Add one retry on every failure and it grows again.

That is the shape of the model. The plan price is modest, and the run pool is where the money goes once you check often enough to catch a short outage.

What do regions cost on Checkly?

Locations are not priced as a line item, but they set your bill twice.

First, the tier decides how many you get. Hobby and Starter offer 6 public locations (N. Virginia, N. California, Frankfurt, London, Singapore, Sydney) with a maximum of 3 per check. Team and Enterprise get all 22. Private locations, which run checks from inside your own network, are Team and Enterprise only.

Second, scheduling decides whether locations multiply runs. In round robin, each execution runs from the next location in the list, so a 3-location check still uses one run per execution and you see each region once every three runs. In parallel, every execution runs from all locations at once, and every location counts as a run. Parallel is available for synthetic checks on every tier, but for uptime monitors it is Enterprise-only.

A check every 5 minutes from 3 parallel locations is 25,920 runs a month, more than double the entire Team allowance. Retries stack on top: Hobby and Starter get a single automatic retry, Team gets multiple, and each one is a run.

The trade-off is real. Round robin keeps runs flat but means a regional outage is only seen from that region once every N executions. Parallel sees it immediately but costs N times as much. There is no setting on the pricing page that gives you multi-region verification without paying per region.

Hobby, Starter, Team, Enterprise: where each one stops fitting

The gaps between tiers are wider than the price steps suggest, so here is what actually changes at each move.

Hobby to Starter happens the first time a check stops because the pool ran out. Starter costs $29 and lifts the browser pool from 1,000 to 3,000, which is still under one check every 15 minutes.

Starter to Team is the big one, and it is usually forced by something other than runs: a fourth user, phone call alerts, a PagerDuty or incident.io integration, a maintenance window, or a location outside the six. Team is 2.8 times the price of Starter on monthly billing, and reviewers on G2 describe the gap in the same terms I quoted in our Checkly alternatives roundup: "there aren't enough options between the plans".

Team to Enterprise is forced by SAML SSO, an uptime SLA, white-label status pages, uptime monitors that run in parallel, or an 11th user. None of those have a published price.

What the Checkly pricing page does not tell you

I went through the page specifically to note where a buyer would have to ask sales or read the docs. These are the gaps:

• The page opens on annual prices. The default toggle shows $24 and $64 "per month, billed annually". Monthly billing is $29 and $80. Both are on the page, but you have to click.
• Extra users have no price. Starter includes 3 users and Team 10. The page does not say what an additional user costs or whether you can add one without moving up a tier.
• On-call is not a feature. There is no on-call schedule, rotation or escalation policy anywhere on the page. Alert routing to PagerDuty, incident.io, Rootly and Opsgenie is listed as a Team feature, which means a second subscription for the response side.
• The example run counts are not on the pricing cards. The cards show "12k" browser runs. The FAQ at the bottom explains that a check from 2 parallel locations uses 2 runs per execution and that retries count, but the cards do not, and there is no calculator.
• Playwright Check Suite billing is only in the FAQ. The 30-second rule that turns a 2-minute suite into 4 runs per execution appears in the billing FAQ, not next to the "Playwright Check Suites" feature row.
• Enterprise has no numbers. Custom monitors, custom runs, custom users, custom SMS, and Traces as a separate add-on. Nothing is priced.
• The FAQ's own price example is a doubling. The grandfathering answer uses a Team subscriber "at a lower price, e.g., $40 per month" who stays at that rate "even if the advertised price increases to $80 per month". Today's monthly Team price is $80. Read into that what you will about the direction of travel.

To the page's credit, the billing FAQ is more explicit than most competitors' about how runs are counted, and the run-counting rules are all there if you scroll. The problem is that the cards and the FAQ tell different stories about what $80 buys.

Who does Checkly pricing fit?

Choose Checkly if your team writes Playwright tests already and wants to promote them to production monitors with the same code, CLI and CI pipeline. Playwright Check Suites, the monitoring-as-code workflow, Terraform and Pulumi providers and the MCP server are the reasons teams pick Checkly, and the per-run model is the price of running real test suites on a schedule.

Choose Checkly if you need private locations, 10-second API checks, visual regression or OpenTelemetry traces next to your synthetic checks. Those are observability features that flat-rate uptime tools do not offer.

Look elsewhere if you want a handful of browser checks running every 5 minutes from several regions, plus a status page and on-call, and you would rather not watch a run counter. In the growing-SaaS scenario above, $300 of a $477 bill is browser runs, and on-call still needs another tool. The same goes if you are on Hobby and your checks keep stopping mid-month.

A flat-rate alternative without the run counter

This is the section where my stake is most obvious, so read it with that in mind. Hyperping is a flat-rate uptime, status page and on-call tool with Playwright browser checks included in every paid plan. It does not run full Playwright test suites, has no private locations and no traces. If those are why you are on Checkly, nothing below changes that.

For the uptime and browser check slice, the comparison is direct. Hyperping prices by the number of monitors and browser checks. There is no run pool: a browser check runs every 5 minutes on every paid plan, from the regions you pick out of 18, and when a run fails it is re-verified from a different region before any alert fires. That re-verification is the equivalent of Checkly's retry and second parallel location, and it does not cost anything. Seats are priced explicitly, and on-call schedules with escalation policies are part of the plan from Essentials up.

At the small-team size, Checkly's scenario is about 2.4 times Hyperping Essentials, and Essentials includes phone alerts and on-call that Starter does not. At the growing-SaaS size the gap is wider because the ten browser checks that cost $300 in runs on Checkly are simply included on Pro. The Hyperping figures are on our pricing page with the browser check count and interval printed next to them.

The trade-offs run the other way too. Checkly's browser checks can run every 10 seconds on Team where Hyperping's run every 5 minutes. Checkly gives you 22 locations to Hyperping's 18, and Team includes 10 users where Pro includes 8. If you check the same flow every minute from four regions, Checkly is the tool built for that, and you should expect to pay for it in runs. And if your monitoring lives in a repo and deploys from CI, Checkly's CLI is more complete than Hyperping's Terraform provider.

Choose Hyperping if you run a small number of Playwright flows on a 5-minute schedule, you want the retry from a second region without paying for it, and you want the status page and on-call in the same bill.

Stay on Checkly if you need sub-minute browser checks, native Playwright suites, private locations or traces, or your whole monitoring setup is code that deploys with your app.

For the wider market, our Checkly alternatives roundup covers Better Stack, Datadog, Uptime.com and Cronitor alongside Hyperping, and the Checkly alternative page walks through how a Checkly setup, browser checks included, is rebuilt in Hyperping. Hyperping's paid plans come with a 14-day trial and no credit card, and the free plan has no time limit, so the cheapest test is to point both tools at the same login flow for two weeks and compare the bills at the end.