Checkly

What Checkly actually is

Checkly is a synthetic monitoring platform built around code instead of click-ops: you define API checks, browser checks driven by Playwright, and uptime monitors as TypeScript files in your repository, test them locally with the Checkly CLI, and deploy them the same way you deploy everything else. The company calls this monitoring as code, and it is the reason Checkly exists — founder Hannes Lenke (previously founder of the mobile testing company TestObject) started it in 2018 with co-founders Tim Nolet and Timo Euteneuer, funded along the way by Accel and CRV ($2.25M seed in 2020, $10M Series A in 2021, a $20M Series B in August 2024). The company is remote-first with its roots in Berlin.

The product has two halves. Detect covers monitoring: HTTP(S), TCP, DNS, ICMP, SSL/TLS, gRPC, traceroute and heartbeat checks on the uptime side, plus scripted browser checks that run real Playwright tests from probe locations around the world, with alerting by email, Slack, SMS, webhooks and more, and status pages on top. The other half is the workflow: npx checkly init scaffolds a project, checkly test runs your checks locally against your code, checkly deploy pushes them to Checkly's infrastructure across the locations you declared. Checks live in __checks__/*.check.ts files next to the tests they came from, so monitoring changes go through code review like any other change.

That workflow is what sets it apart from the incumbents. In Datadog Synthetics or Pingdom you configure checks in a web UI; in Checkly a check is a construct in TypeScript, versioned, diffable, and runnable in CI. The platform has leaned further into this direction recently — the current positioning is "active reliability layer for developers and agents," with first-class support for driving check creation from AI coding assistants (Cursor, Claude Code, Windsurf, and similar) and traces attached to results. Customers shown on the site include Vercel, Airbus, CrowdStrike, 1Password, Fastly, and ServiceNow — a credible list for a company of this size.

Pricing: what you really pay

Checkly's published plans (checklyhq.com/pricing, monthly billing shown here with up to 20% off annual) are: Hobby at $0 per month for personal projects and learning, Starter at $24 per month, Team at $64 per month, and Enterprise with custom pricing. Hobby includes 10 uptime monitors at a two-minute minimum frequency from 6 locations and a monthly synthetic check allowance shown as 1,000 and 10,000 runs on the plan card; Starter raises this to 50 uptime monitors at one-minute frequency and 3,000/25,000 runs; Team gives 75 monitors at 30-second frequency, all 22 check locations, private locations for internal services, and the full alerting channel set including phone calls. Enterprise adds one-second check frequency and parallel scheduling.

The pricing model is usage-based underneath the plan names, and this is where reading the fine print matters. Overage on synthetic check runs is billed at $4.00 per 1,000 runs on Starter and Team, extra uptime monitors cost $8 each on paid plans, and the included run allowances are consumed faster than the headline numbers suggest when you run frequent browser checks. Third-party analyses we looked at agree that the per-run model can surprise teams that set aggressive frequencies without doing the multiplication — a five-minute browser check is cheap, a one-minute check across 22 locations is 22 runs per interval.

Our view: the free tier is genuinely useful for side projects and for evaluating the workflow, and the jump to Team buys the things that matter in production (private locations, more regions, phone alerting). Teams should estimate monthly runs from their check inventory and frequencies before committing, and use the CLI to keep that inventory honest — it lives in your repo, so the count is right there.

Performance & infrastructure

Checkly runs the infrastructure; you bring the checks. Monitoring executes from 22 locations worldwide — the deploy output in their own docs shows regions like us-east-1, eu-west-1, ap-south-1, ap-northeast-1 and eu-central-1 — and Enterprise customers can add private locations that run checks from inside their own network against internal services. Scheduling is round-robin across locations on the lower tiers and can run in parallel on Enterprise; checks report latency per location, and results carry traces for debugging failures rather than just a red mark.

On the reliability of the platform itself, Checkly announced SOC 2 compliance in October 2022 alongside a Playwright test runner, GitHub sync, and improved alerting, and the customer roster implies production trust at a serious scale. There is no public uptime SLA for the monitoring service itself — worth noting for a product whose entire job is telling you when things are down; if your architecture requires a contractual commitment here, that is an Enterprise conversation.

The Playwright choice matters technically. Browser checks run real Chromium sessions with your own scripts, which means they can log in, click through flows, and assert on rendered state — exactly what synthetic monitoring could not do in the ping-and-parse era. The cost side of that choice is consumption: browser runs are the expensive class of check, which is why the allowances are metered per run. For CI, the CLI's local test mode is the piece we like most: catching a broken check before it deploys prevents monitoring from becoming the thing that pages you at midnight.

Where it falls short

The per-run pricing is both the strength and the trap. Monitoring costs scale with frequency times locations times check count, and a team that automates check creation (especially now that agents can generate checks) can scale their bill without anyone deciding to. Budget alerts and run-inventory reviews are necessary hygiene.

Second, depth versus the observability giants. Checkly does synthetic monitoring, uptime, alerting, and status pages — it does not replace an APM, log platform, or metrics stack. Datadog or New Relic will sell you synthetic checks inside a much broader (and much more expensive) platform; Checkly's answer is that focused beats sprawling, which we agree with for teams that already have or don't need the rest. Third, the developer-first posture is a real constraint: there is no click-to-create path that non-engineers will enjoy, and the TypeScript/Playwright toolchain assumes engineering fluency. For marketing or support teams wanting a simple uptime dashboard, this is the wrong tool.

There is also a subtlety with alerting hygiene. A monitoring platform that pages too often trains people to ignore it, and scripted browser checks are particularly good at producing flaky failures when test selectors drift with your UI. Checkly's retry logic and the ability to run checks locally before deploying mitigate this, but the discipline of keeping checks stable is still on the team writing them.

Fourth, company maturity. Checkly is a well-funded but mid-sized company competing with giants; the roadmap is driven by a small team, and features like one-second check frequency sit behind Enterprise pricing.

Who should pick this

We pick Checkly for engineering teams who want monitoring defined next to their code: product companies with real user flows worth testing end to end, platform teams standardizing checks across dozens of services via the CLI and CI, and anyone already living in TypeScript and Playwright who resents maintaining parallel test code in a vendor UI. It is also our pick when synthetic checks must run from specific global regions against APIs your users actually hit.

We would not pick it for non-technical teams, for organisations needing a bundled APM suite, or for very high-frequency monitoring of hundreds of endpoints where per-run billing would exceed a flat-rate competitor's pricing — do that math first. If you want to compare the broader monitoring landscape, our monitoring category lists the alternatives, and our benchmarks page tracks the infrastructure most of these tools sit on top of.

Key takeaways

• Monitoring as code: API, browser (Playwright), and uptime checks defined in TypeScript, versioned in your repo, deployed via the Checkly CLI.
• Founded 2018 (Hannes Lenke, Tim Nolet, Timo Euteneuer), Berlin roots, remote-first; backed by Accel and CRV with a $20M Series B in 2024.
• Pricing: Hobby $0, Starter $24/mo, Team $64/mo (annual billing; monthly $29/$80 via third-party listings), Enterprise custom — with per-run overage at $4 per 1,000 runs.
• 22 global check locations, private locations on Team and up, SOC 2 since 2022, alerting via email/Slack/SMS/webhooks and phone on Team.
• Usage-based billing can surprise teams that raise frequency or let agents generate checks; budget with the run inventory in your repo.
• Best fit: developer teams wanting synthetic monitoring in their CI workflow; poor fit: non-technical teams or flat-rate/high-volume monitoring needs.

Sources

• https://www.checklyhq.com/
• https://www.checklyhq.com/pricing/
• https://www.checklyhq.com/about/
• https://techcrunch.com/2020/04/28/checkly-raises-2-25m-seed-round-for-its-monitoring-and-testing-platform
• https://venturebeat.com/2021/06/30/checkly-secures-10m-for-continuous-api-and-web-app-testing
• https://founderlodge.com/round/Checkly-raises-20000000-Series-B-2024-08-01-Hannes-Lenke-MjAwMzY
• https://thecompanycheck.com/company/b/checkly/0vyvjo4smzk6u3c8w
• https://glassdoor.com/Overview/Working-at-Checkly-EI_IE5638650.11,18.htm
• https://devops.com/checkly-announces-business-milestones-soc-2-compliance-new-playwright-test-runner-github-sync-enhanced-alert-notifications-and-more