---
title: 'Yorker vs Grafana Synthetic Monitoring'
description: 'Yorker vs Grafana Synthetic Monitoring: vanilla Playwright and OTLP to any backend, versus ''powered by k6'' browser checks tied to a Grafana Cloud subscription.'
canonical_url: 'https://yorkermonitoring.com/compare/grafana-synthetic-monitoring'
---

# Vanilla Playwright, OTLP everywhere

**Without the k6 complexity**

Grafana Synthetic Monitoring is built on the k6 engine and the k6 browser API (a scripting layer you have to learn), and the results stay inside Grafana Cloud. Yorker wraps vanilla Playwright, the same code as your local tests, and emits standard OTLP into the backend you already run. No k6 API, no Grafana subscription required to start.

Last verified 2026-06-13.

## The browser check scripting difference

```js
// Grafana Synthetic Monitoring: k6 browser API

export default async function () {
  const page = await browser.newPage();
  await page.goto('https://example.com');
  await page.close();
}

// Yorker: vanilla Playwright
// @step: Visit homepage
await page.goto('https://example.com');
// No imports, no wrapper, same Playwright API
```

## Understanding Grafana's synthetic landscape

Grafana has multiple overlapping synthetic/testing products. Here's how they relate: it matters for understanding what you're buying.

- **Grafana Synthetic Monitoring** (Active). The uptime and browser check product inside Grafana Cloud. Ping, DNS, TCP, HTTP, and k6 browser checks. Free tier available. This is what this comparison page covers.
- **Grafana Cloud k6** (Active, k6 Cloud migration target). Grafana's cloud platform for k6 load tests and performance testing scripts. k6 Cloud (the standalone SaaS) is winding down; users are migrating here. This is a performance testing tool, not a synthetic monitoring tool.
- **k6 Cloud** (Sunsetting). The original k6 SaaS for running load tests. Being sunset; existing users are migrating to Grafana Cloud k6. If you came here because of k6 Cloud news, note that Grafana Synthetic Monitoring is a different product.

## Why teams pick Yorker over Grafana Synthetic

**Vanilla Playwright, not the k6 browser wrapper.** Grafana browser checks use the k6 browser API, a wrapper around Playwright with its own JavaScript interface. Yorker runs vanilla Playwright async functions: the exact same code as your local Playwright tests. No k6 API to learn, no import statements, just page.goto().

**OTLP to any backend, not just Grafana Cloud.** Grafana Synthetic Monitoring results live in Grafana Cloud's internal data stores. Yorker emits OTLP from every check run: send it to ClickStack, Grafana Cloud, Honeycomb, Dash0, or any OTLP-compatible backend. You don't need a Grafana subscription to get synthetic telemetry.

**W3C traceparent, always on.** Yorker injects a W3C traceparent header into every browser check request, linking synthetic runs to your backend distributed traces. Grafana Synthetic Monitoring does not document traceparent injection; trace correlation requires a Grafana Tempo setup on the backend trace side.

**Simpler pricing model.** Grafana counts 'executions' as probes x tests x runtime-minutes x frequency-factor. A 5-minute browser test from 3 probes every 5 minutes = 3,024 executions/day. Yorker counts check runs. One model is simpler to forecast, especially when scaling up coverage.

**Screenshot filmstrip on every run.** Yorker captures a per-step screenshot sequence for every browser check run: the full filmstrip is how you debug what changed between a passing and failing run. Grafana Synthetic Monitoring does not include per-step filmstrips in its browser check output.

**Private locations included in the base plan.** Grafana Synthetic Monitoring private probes run as a self-hosted Synthetic Monitoring Agent you deploy and operate yourself. Yorker includes private location agents in the $29.99 platform plan with private-location runs at half the hosted rate, managed alongside your hosted checks, no separate infrastructure to babysit.

## Feature-by-feature, tier-by-tier

Grafana's pricing model counts "executions" (probe x test x runtime-minutes x frequency-factor), not check runs. The free tier caps at 100k API / 10k browser executions/mo. The Pro tier ($19/mo platform fee) removes the hard cap and bills overage at $5/10k API and $50/10k browser executions. Private probes run as a self-hosted agent on either tier. Enterprise requires a $25k/year minimum commitment.

| Capability | Yorker (Platform, $29.99/mo) | Grafana Synthetic (Free, 100k API / 10k browser/mo) | Grafana Synthetic (Pro, $19/mo + overage) |
| --- | --- | --- | --- |
| **HTTP / API checks** (HTTP, DNS, TCP, ping, traceroute probes.) | Included | Included (100k/mo free) | Included + pay-per-use |
| **Browser checks** (Headless browser with user-journey testing.) | Included in plan (Playwright) | 10k executions/mo free | $50 per 10k executions overage |
| **Browser engine** (What powers browser checks.) | Playwright (vanilla) | k6 browser (k6 API) | k6 browser (k6 API) |
| **Private locations** (Run checks from behind your firewall.) | Included, half-rate runs | Self-hosted agent | Self-hosted agent |
| **OpenTelemetry export** (OTLP metrics to any external backend.) | Included, OTel-native | Grafana Cloud only | Grafana Cloud only |
| **W3C trace propagation** (traceparent injected into check requests.) | Always on | Not documented | Not documented |
| **Monitoring as Code** (Check definitions in source control.) | YAML (CLI) | Terraform / API | Terraform / API |
| **Screenshot filmstrip** (Per-step visual evidence on every run.) | Included | Not included | Not included |
| **Scripting language** (What you write browser check scripts in.) | TypeScript / async function | k6 JavaScript API | k6 JavaScript API |

Pricing verified June 13, 2026 from grafana.com/pricing and grafana.com/products/cloud/synthetic-monitoring/. Grafana Free: $0, 100k API + 10k browser executions/mo; Pro: $19/mo + $5/10k API overage + $50/10k browser overage; Enterprise: custom, $25k/year minimum. Yorker platform plan $29.99/mo, full pricing at /pricing. "Test execution" definition: one test x one probe location x one minute of runtime. Spot something changed? Email hello@yorkermonitoring.com.

## Frequently asked questions

### What is the k6 Cloud wind-down and how does it affect Grafana Synthetic Monitoring?

k6 Cloud was Grafana's standalone SaaS for k6 load testing (not synthetic monitoring). It is being sunset and users are migrating to Grafana Cloud k6. Grafana Synthetic Monitoring (the synthetic check product built into Grafana Cloud) is a separate product that continues. If you use Grafana Synthetic Monitoring for uptime checks, the k6 Cloud wind-down does not directly affect you, though the underlying browser engine is 'powered by k6 browser.'

### Does Yorker integrate with Grafana?

Yes. Yorker emits OTLP metrics and traces, and Grafana Cloud accepts OTLP natively. Point Yorker's OTLP endpoint at your Grafana Cloud stack and synthetic check results appear in your Grafana dashboards alongside your other metrics, without paying for Grafana Synthetic Monitoring separately.

### How does the 'test execution' pricing model compare to Yorker's plan pricing?

Grafana counts one execution as one test running in one probe location for one minute of runtime. A 5-minute browser test from 3 probe locations = 15 executions. The Pro tier includes 10,000 browser executions ($50/10k overage). Yorker includes browser check runs in the platform plan with a monthly allowance: a simpler model if your usage is predictable.

### Do both tools support private locations / private probes?

Grafana Synthetic Monitoring private probes run as a self-hosted Synthetic Monitoring Agent: you deploy the agent via Docker or Kubernetes and it registers as a custom probe (the documented requirement is the Grafana Admin role). Yorker includes private location agents in the platform plan ($29.99/month) with private-location runs at half the hosted rate. Both are outbound-only agents.

### What's different about k6 browser checks vs Yorker's Playwright checks?

Both are Playwright under the hood, but k6 browser exposes a JavaScript API wrapping Playwright (import { browser } from 'k6/browser') rather than vanilla Playwright. Yorker runs vanilla Playwright async functions, the same code that runs in your local Playwright tests. No k6-specific API to learn.

### Does Grafana Synthetic Monitoring export OTel like Yorker?

Grafana stores synthetic monitoring results in Grafana Cloud's internal data stores; they are queryable via Grafana's UI and API but do not emit OTLP to external backends. Yorker emits OTLP from every check run to any backend you configure, including Grafana Cloud if that's your stack.

## Synthetic monitoring without the stack lock-in

Start free, no credit card, and send synthetic telemetry to any OTel backend. Yorker works alongside Grafana Cloud, not instead of it. [Start free](/sign-up) or [see pricing](/pricing).