The OTel storyWithout the k6 complexity
Grafana Synthetic Monitoring is “powered by k6” — a capable product inside Grafana Cloud, but one that adds the k6 browser API layer and execution-count pricing on top of Playwright. Yorker runs vanilla Playwright, emits OTLP natively to any backend (including Grafana Cloud), and doesn’t require a Grafana subscription to get started.
Last verified 2026-04-11
// Grafana Synthetic Monitoring — k6 browser API
import { browser } from 'k6/browser'
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.
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'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.
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
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().
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.
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.
Grafana counts 'executions' as probes × tests × runtime-minutes × 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.
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.
Grafana Synthetic Monitoring private probes require the Pro tier ($19/month). Yorker includes private location agents in the $29.99 platform plan with a 50% discount on private-location run consumption.
Feature-by-feature, tier-by-tier
Grafana's pricing model counts "executions" (probe × test × runtime-minutes × frequency-factor), not check runs. The free tier (100k API / 10k browser executions/mo) is generous. The Pro tier ($19/mo) unlocks private probes and removes the hard cap. 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 | Not available | Private probes (Pro) |
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 April 11, 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 × one probe location × one minute of runtime. Spot something changed? Email [email protected].
Moving from Grafana Synthetic Monitoring
We'll do most of the work. Point the importer at your existing check definitions and it emits Yorker YAML with the 80% that translates cleanly, flagging everything it can't auto-convert with inline comments you can review.
yorker import --from grafana-synthetic ./grafana-sm-checks.jsonExport your check definitions from Grafana Synthetic Monitoring via the Grafana SM API and point the importer at the JSON. HTTP/ping/DNS/TCP checks translate directly to Yorker YAML. k6 browser scripts are converted to vanilla Playwright with common k6 browser API calls mapped to their Playwright equivalents; complex k6-specific patterns are flagged as TODOs.
What to watch for
- k6 browser script API → Playwright
Grafana Synthetic Monitoring browser checks use the k6 browser API, which wraps Playwright but exposes a different JavaScript interface (import { browser } from 'k6/browser' instead of vanilla Playwright). The core selectors and navigation calls are similar but not identical. The importer converts common patterns; complex k6-specific constructs are flagged as TODOs.
- Execution-count pricing model doesn't map to Yorker's plan
Grafana counts executions as (probes × tests × duration × frequency-factor). Yorker bills on check runs with a monthly allowance. The total cost comparison depends on your check count, browser test duration, and probe count — run the math using both calculators before switching.
- Alert rules live in Grafana Alerting
Grafana Synthetic Monitoring integrates with Grafana Alerting, which has its own alert rule format (PromQL-based queries against synthetic metrics). Yorker uses its own alert rule model. The importer captures alert thresholds from Grafana Synthetic Monitoring checks and emits equivalent Yorker alert rules, but complex multi-condition PromQL rules need a manual translation.
- Probe locations vs Yorker regions
Grafana's probe naming (e.g. 'grafana-us-central') does not map 1:1 to Yorker's location IDs (e.g. 'loc_us_central'). The importer matches by geographic region where possible and flags unmatched probes for manual review.
What you keep
Your check URL list and check frequencies carry over to Yorker YAML without changes.
The core test logic (page navigation, element selection, assertions) transfers from k6 browser to Playwright with minor API adjustments.
Your alert thresholds and notification channels map to Yorker alert rules.
Your probe coverage — the importer matches Grafana probe locations to the nearest Yorker regions.
Where Grafana Synthetic Monitoring is strongest
No tool is the right answer for every team. Here's where Grafana Synthetic Monitoring genuinely leads today — if your use case matches, start there.
If your team already runs Grafana Cloud for metrics, logs, and traces, Grafana Synthetic Monitoring results appear in the same Grafana dashboards, trigger the same Grafana alerting rules, and correlate with the same Grafana Tempo traces — with zero extra configuration. That native integration is genuinely valuable and not easily replicated without Grafana Cloud.
Grafana Synthetic Monitoring's free tier includes 100,000 API test executions and 10,000 browser test executions per month — a real workload, not a trial toy. For small teams or open-source projects, that free allowance may be all you need. Yorker starts at $29.99/month with no free tier.
Grafana Synthetic Monitoring supports ping, DNS, TCP, HTTP, traceroute, and browser checks — including network-level probes that Yorker's Phase 1 does not. If you need DNS resolution monitoring or ICMP ping checks alongside browser tests, Grafana Synthetic Monitoring has more protocol coverage today.
Frequently asked
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 supports private probes on the Pro tier ($19/month) — you deploy an agent via Docker and it registers as a custom probe. Yorker includes private location agents in the platform plan ($29.99/month) with a 50% discount on private-location run consumption. 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.