---
title: The best synthetic monitoring tools in 2026 for browser and Playwright checks
description: Your homepage returns 200 while nobody can sign in. Catching that takes a browser that walks the journey on a schedule. Here are eight synthetic monitoring tools sorted by how you want to write the check (Playwright code, a vendor's script dialect or a recorder), what one journey costs a month on each, and where each one loses. Prices checked on 3 October 2026.
canonical: https://watchfor.io/blog/best-synthetic-monitoring-tools
---

# The best synthetic monitoring tools in 2026 for browser and Playwright checks

2026-10-03 · WatchFor Team · Monitoring · synthetic-monitoring, playwright, monitoring

Your homepage returns 200 while nobody can sign in. Catching that takes a browser that walks the journey on a schedule. Here are eight synthetic monitoring tools sorted by how you want to write the check (Playwright code, a vendor's script dialect or a recorder), what one journey costs a month on each, and where each one loses. Prices checked on 3 October 2026.

An uptime check asks one question: does this URL answer? A synthetic browser
check asks the one your customers care about: *can I still sign in, find the
thing and pay for it?* The two disagree more often than you would like. A
deploy renames a button, a third-party script hangs the checkout, a login
page starts returning a friendly error with a 200. Every HTTP check stays
green.

So you need a browser that walks the journey on a schedule. Nearly every
monitoring vendor sells one now, and the products differ less in what they
check than in **how you write the check**. That is how this list is sorted.

Prices and limits were checked against each vendor's public pricing page or
docs on **3 October 2026**. They change without notice, so confirm before
buying. If you are still deciding between synthetic checks and real user
monitoring, [Synthetic vs real user monitoring](/blog/synthetic-vs-real-user-monitoring)
covers that first.

## What a good browser check looks like

Whichever tool you pick, the check itself is code, or a recording that
becomes code. Here is a Playwright Test journey that runs unchanged on your
laptop with `npx playwright test` and, with minor differences, on most of the
tools below:

```ts

test("sign in and reach the dashboard", async ({ page }) => {
  await test.step("Open the login page", async () => {
    await page.goto(process.env.TARGET_URL!);
    await expect(page.getByRole("heading", { name: /sign in/i })).toBeVisible();
  });

  await test.step("Sign in", async () => {
    await page.getByLabel("Email").fill(process.env.MONITOR_USER!);
    await page.getByLabel("Password").fill(process.env.MONITOR_PASSWORD!);
    await page.getByRole("button", { name: /sign in/i }).click();
  });

  await test.step("Dashboard is shown", async () => {
    await expect(page).toHaveURL(/\/dashboard/);
    await expect(page.getByText(/welcome back/i)).toBeVisible();
  });
});
```

Three habits make the difference between a check you trust and one you mute
by Friday:

- **Name the steps.** `test.step()` is what the alert, the result page and
  the trend chart talk about. "Failed at Sign in" is a diagnosis; "line 14
  timed out" is homework.
- **Use roles and labels, not CSS paths.** `getByRole` and `getByLabel`
  survive a redesign that `div.form > button:nth-child(2)` does not.
- **Give the monitor its own account and keep secrets out of the script.**
  Read them from environment variables your tool stores encrypted, and check
  that the tool masks them in traces and screenshots, not only in logs.

## "Our tests are already Playwright"

**Checkly** built the reference version of this idea. Checks are Playwright,
they live in your repository, the Checkly CLI deploys them, and Terraform and
Pulumi providers manage them as code. Playwright Check Suites run a whole
Playwright suite as a scheduled monitor. The free Hobby plan includes 1,000
browser check runs a month for one user; Starter is $24 a month billed
annually with 3,000 runs, three users and six locations; Team is $64 with
12,000 runs, ten users, all 22 locations and private locations. Extra runs
are $4 per 1,000 bought ahead.

*Where it loses:* everything becomes code and CI. That is the point, and it
is also a cost for a team that wants a check working this afternoon. Raw
results are kept for 7 days below the Team plan, and private locations start
at Team.

**WatchFor** (ours, discount accordingly) runs the same kind of file without
the repository machinery. A browser check is one Playwright Test file, up to
64 KB and 10 tests, written in the editor, imported from `codegen`, a
`.spec.ts` or a Chrome DevTools Recorder export, or created over the API,
SDKs or MCP. It runs on a pinned runtime (currently Playwright 1.63.0 with
Chromium 153), so a check that passes today runs on the same software until
you choose to move it.

![A failed browser check run in WatchFor: the journey failed at the step "Signed-in page is shown", with the expected and actual text, a hint explaining the error, the code frame at line 23 and the page as it looked at the failure. Buttons open the Playwright trace and compare with the last passing run](/blog/best-synthetic-monitoring-tools-failed-run.webp)

A failed test is retried once in a fresh browser, and a run that still fails
is confirmed by a second run about a minute later, from another location
when the check has one, before an incident opens. Neither counts against your
plan. Each step keeps its timing and a screenshot, failed runs keep a hosted
Playwright trace, and secrets are masked in logs, step titles, trace text and
screenshots of scheduled runs too. A browser check sits next to 26 other
monitor types, on-call and [status pages](/status-pages) on a flat plan: one
hourly check on Free (750 runs a month), two every 10 minutes on Starter
(€7, 9,000 runs), and 45,000 runs on Pro (€25).

*Where it loses:* Chromium only, no Firefox or WebKit. Runs reach the public
internet only, so there is no private location for staging or an intranet.
There is no CLI or Terraform workflow to deploy checks from a repository the
way Checkly does it; the REST API and SDKs can script it, but you build that
yourself. And no real user monitoring.

## "We already pay for an observability platform"

If your metrics and traces already live somewhere, the browser checks that
come with it have one big advantage: a failed journey sits next to the
backend data that explains it.

**Datadog Synthetics** builds browser tests from templates or a step-by-step
recording, edited in Datadog's own UI. Tests run on Chrome, Firefox and
Edge at laptop, tablet and mobile sizes, every minute up to once a week, from
managed locations on AWS, GCP and Azure or from private locations inside your
network. Browser tests are **$12 per 1,000 runs** billed annually ($15
monthly, $18 on demand).

*Where it loses:* the test lives in Datadog rather than in your test suite,
and per-run pricing adds up fast at short intervals.

**Grafana Cloud Synthetic Monitoring** runs browser checks as k6 scripts with
the k6 browser module, which Grafana describes as a "Playwright-inspired
API". Checks run every 60 to 3,600 seconds from public or private probes,
and results land as Prometheus metrics and Loki logs you can alert on in
Grafana. The free tier is the most generous here: **10,000 browser test
executions a month**. Beyond that, $50 per 10,000 with a $19 monthly platform
fee.

*Where it loses:* Playwright-inspired is not Playwright. A test from your
Playwright suite has to be rewritten for k6, and Grafana's docs note that
browsers on public probes get 1 GB of RAM, which can be too little for heavy
pages.

**New Relic** includes 500 synthetic checks in its free tier and charges
$0.005 per check beyond what an edition includes. Its scripted browser
monitors are driven by Selenium WebDriver, per New Relic's own docs, and
there is a separate step monitor type.

*Where it loses:* Selenium WebDriver scripts are a different, older dialect
from Playwright, with explicit promise chaining in the examples. Fine if your
team knows it; a rewrite if your tests are Playwright.

## "Nobody here wants to write code"

**Uptrends** records transactions in a web-based recorder ("No coding" is its
own headline) and runs them in current Chrome and Edge from what it calls
229 locations. Transaction monitoring starts on the Pro plan, from $60 a
month billed annually, with a credit system you spread across monitor types.
There is a 30-day trial and no free plan.

*Where it loses:* credits take some arithmetic before you know what a given
set of checks costs, and the annual commitment is the model.

**Pingdom** has a web recorder too, or a built-in editor if you prefer to
write the script, and runs transactions in a real Chrome from every 5
minutes to once a day. Plans are bundles of uptime checks plus a smaller
number of "advanced" checks; the smallest, 10 uptime and 1 advanced, lists at
$18 a month (about $16.50 billed annually). There is a 30-day trial.

*Where it loses:* the pricing page does not spell out what an "advanced"
check covers, so ask before you assume it is the transaction you need, and
there is no free plan.

## "I want one vendor for monitoring and on-call"

**Better Stack** sells hosted Playwright transaction checks inside the same
product as uptime monitoring, on-call with phone and SMS alerts, and status
pages. Playwright minutes are **$1 per 100**, checks can run as often as
every 30 seconds, and the pricing page lists Codegen support and inspection
of Playwright artifacts.

*Where it loses:* billing by minute means a slow page costs more than a fast
one, so the bill moves with your site's performance. On-call is a responder
licence on top ($29 a month billed yearly).

## What one journey costs a month

One journey, every 10 minutes, from one location: 4,320 runs in a 30-day
month. Our arithmetic from list prices, before tax.

| Tool | How it is priced | One journey every 10 min |
| --- | --- | --- |
| Grafana Cloud | 10,000 executions free | $0 |
| WatchFor | Starter, 9,000 runs included | €7 |
| Better Stack | $1 per 100 minutes | ~$14 at 20 s a run |
| Checkly | Starter, 3,000 runs + $4/1,000 | ~$32 |
| Datadog | $12 per 1,000 runs | ~$52 |
| New Relic | 500 free, then $0.005/check | Depends on edition |
| Uptrends | Pro, credits | From $60 |
| Pingdom | Bundles with "advanced" checks | From $18 |

Checked 3 October 2026 against published pricing.

Grafana wins this row outright, and if a k6 script is fine for you, that is
hard to argue with. Halve the interval and the picture changes: every 5
minutes is 8,640 runs, which is still inside Grafana's free tier, needs Pro
(€25) on WatchFor, and doubles the Datadog line to about $104.

## Five things to check before you choose

**Does a single failure page someone?** A browser is the flakiest thing you
will ever monitor. Ask whether the tool retries inside a run, whether it
confirms a failure with a second run before alerting, and whether those
retries are billed.

**Will your existing tests run?** Playwright, k6 browser, Selenium and
recorder formats are not interchangeable. If you have a Playwright suite,
that narrows the list to tools that run Playwright itself.

**Which browsers?** If a customer segment is on Firefox or Safari, a
Chromium-only check will not catch their bug. Datadog runs Firefox and Edge
as well as Chrome; WatchFor runs Chromium only.

**Where can it reach?** Public probes cannot see staging behind a VPN.
Private locations exist on Checkly Team, Datadog, Grafana and Uptrends
Enterprise; ask before you assume.

**What is kept when it fails?** A screenshot of the failed step and a trace
you can replay turn a 3 a.m. alert into a five-minute fix. Check how long
they are kept and whether secrets are masked inside them.

For a concrete example of a hard journey, [Monitor a 2FA login with
Playwright](/blog/monitor-a-2fa-login-with-playwright) walks through
one-time codes end to end, and the [browser checks docs](/docs/monitors/browser-checks)
list every limit per plan. For checks that do not need a browser, the
[uptime monitoring round-up](/blog/best-uptime-monitoring-tools) is the
companion to this one.

---

*We make one of the tools on this list. Every entry says where it loses,
including ours: Chromium only, no private locations and no repository
workflow. If something here is wrong or out of date, tell us at
hello@watchfor.io and we will fix it.*

---

Canonical page: https://watchfor.io/blog/best-synthetic-monitoring-tools · All articles: https://watchfor.io/blog/all.md · Site guide: https://watchfor.io/llms.txt