---
title: 'Yorker vs Checkly'
description: 'A feature-by-feature, tier-by-tier comparison of Yorker and Checkly for synthetic monitoring. Pricing, private locations, OTel export, and migration.'
canonical_url: 'https://yorkermonitoring.com/compare/checkly'
---

# Private locations and OTel

## Without the tier upgrade

Yorker includes private locations and OTel export on the base plan. Checkly gates private locations to the $64 Team tier and OTel export to Enterprise. Pay once for the monitoring, not for the features that unlock the monitoring.

Last verified 2026-06-13.

### What's in the base plan

```
# Yorker platform plan, $29.99/mo
private_locations      included
otel_export            included
dependency_attribution included
trace_propagation      always on

# Checkly Starter, $24/mo
private_locations      team plan ($64)
otel_export            enterprise only
dependency_attribution not standard
trace_propagation      not standard
```

## Why teams are switching

**Private locations in the base plan.** Yorker includes private location agents at $29.99/month. Checkly gates them to the $64/month Team plan, so teams that need monitoring behind a firewall end up paying nearly 3x on day one.

**OTel export without the enterprise surcharge.** Yorker emits OTLP metrics, traces, and logs to any OTel backend as a first-class feature. Checkly reserves OTel export for Enterprise contracts, which puts it out of reach for most mid-market teams.

**Synthetic spans that join your backend traces.** Yorker auto-injects W3C traceparent into every browser-check HTTP request. Your synthetic check and backend distributed trace become one trace, queryable alongside APM in the same backend. No per-monitor flag to toggle.

**YAML monitoring as code.** Yorker's config is plain YAML: one file, no build step, no SDK to install. It reviews cleanly in a pull request, diffs line-by-line, and needs no compile or constructs library to read. Checkly authors checks in TypeScript with the Checkly constructs library, an extra build step and SDK in the path between a config change and a running monitor.

**Transparent, consumption-based pricing.** Yorker's platform plan is $29.99/month, with consumption pricing for runs above the included allowance. Pricing is published in full with a regional calculator at /pricing, no sales call required.

**Playwright as a library, not a framework dependency.** Yorker runs vanilla Playwright as a library dependency. You write async function bodies with step markers, not @playwright/test spec files. Smaller scripts, fewer imports, and no framework lock-in.

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

Most comparison tables show vendor A vs vendor B with green check marks. Ours shows which tier of each vendor includes each capability, because the real question isn't "do they have this", it's "how much do I have to pay before I can use it".

| Capability | Yorker (Platform, $29.99/mo) | Checkly Starter ($24/mo) | Checkly Team ($64/mo) | Checkly Enterprise (Custom) |
| --- | --- | --- | --- | --- |
| HTTP / API checks (ping a URL, assert response time, status, headers, body) | Included | Included | Included | Included |
| Browser checks (headless Chromium with filmstrip + network waterfall) | Included | Included | Included | Included |
| Private locations (run checks from behind your firewall) | Included | Not supported | Included | Included |
| OpenTelemetry export (native OTLP metrics, traces, and logs to any backend) | Included, OTel-native | Not supported | Not supported | Enterprise only |
| W3C trace propagation (traceparent auto-injected into every browser check request, unconditional) | Always on | Not standard | Not standard | Not standard |
| Multi-step API tests (chained request flows with shared variables) | Via browser + HTTP checks | Included | Included | Included |
| Monitoring as Code (CLI + config file in source control) | Included (YAML) | Included (TS) | Included (TS) | Included (TS) |
| Screenshot filmstrip (per-step visual evidence on every run) | Included | Included | Included | Included |
| Hosted locations (public regions available out of the box) | 14 regions | 22 regions (6 on Starter) | 22 regions | 22 regions |

Pricing and tier gates verified June 13, 2026 against Checkly's public pricing and docs. Checkly Starter $24/mo, Team $64/mo, Enterprise custom. Yorker platform plan $29.99/mo with regional pricing available at /pricing. Both offer free trials. Spot something that's changed? Email hello@yorkermonitoring.com and we update these pages when the underlying data moves.

## The same check, both tools

A browser check that navigates through a two-page flow. Here's how each tool expresses it: same Playwright API, different wrapping.

Checkly: `src/__checks__/cart.check.ts`

```ts
// BrowserCheck construct, points at a Playwright spec


new BrowserCheck('cart-flow', {
  name: 'Cart flow',
  frequency: Frequency.EVERY_5M,
  locations: ['eu-west-1'],
  code: { entrypoint: path.join(__dirname, 'cart.spec.ts') },
})

// src/__checks__/cart.spec.ts (Playwright spec file)

test('cart', async ({ page }) => {
  await page.goto('/login');
  await page.goto('/cart');
});
```

Yorker: `yorker.config.yaml` + `./monitors/cart.ts`

```yaml
monitors:
  - name: Cart flow
    type: browser
    frequency: 5m
    locations: [loc_eu_west]
    script: ./monitors/cart.ts

# monitors/cart.ts (async function body)
# @step: Log in
await page.goto('/login');
# @step: Open cart
await page.goto('/cart');
```

Same Playwright API (`page.goto`, `page.click`, `expect(page.locator(...))`) runs in both. The differences are the wrapping: Checkly uses @playwright/test spec files with a BrowserCheck construct; Yorker runs async function bodies with `// @step:` comment markers that drive screenshot boundaries.

## Frequently asked questions

### Is Yorker a drop-in replacement for Checkly?

For HTTP and browser check definitions, mostly yes: about 80% translates cleanly when you re-author Checkly's TypeScript config as Yorker YAML. Playwright script bodies need a small rewrite because Yorker runs async functions rather than @playwright/test spec files. Rewrites are short, typically about 10 minutes per script.

### Can Yorker handle multi-step flows?

Yes. Test real multi-step flows with a Yorker browser check that drives the whole sequence (login, cart, checkout) end to end, with a filmstrip of every step and OTel traces linking each request to your backend. For chained pure-API sequences you compose asserted HTTP checks. Either way the telemetry lands in your own OTel backend as standard OTLP, something a self-contained step builder won't give you.

### How does Yorker's pricing compare?

Yorker's platform plan is $29.99/month and includes private locations and OTel export out of the box. Checkly Starter is $24/month but gates private locations to the $64 Team plan and gates OTel export to Enterprise. For teams needing those capabilities, Yorker is typically 40 to 60% cheaper than the Checkly tier that includes them.

### Does Yorker support OpenTelemetry?

Yorker is OTel-native on every plan. Every check produces OTLP metrics, traces, and logs that land in your backend as standard OTLP: ClickStack, HyperDX, Grafana, Dash0, Honeycomb, or any OTLP-compatible destination. W3C traceparent propagation is always on, so synthetic browser checks link to your backend distributed traces without any per-monitor configuration. Checkly does offer OTLP trace export, but it's gated to Enterprise, so the OTel workflow most teams want sits behind a custom contract there, and ships in the base plan here.

### Can I reuse my existing Playwright test files?

The logic (selectors, waits, assertions, API calls) transfers cleanly, but the wrapping changes. Checkly uses @playwright/test spec files; Yorker runs async function bodies inside a sandboxed runner with // @step: markers for screenshot boundaries. Rewrites are short, typically 10 minutes per script: paste the body into a Yorker async function and remove the @playwright/test imports.

### What about private locations behind my firewall?

Private locations are included on the Yorker platform plan ($29.99/month) with private-location runs at half the hosted rate. On Checkly, private locations require the $64/month Team plan.

## Ready to take a look?

Start free, no credit card, and try Yorker against your existing Checkly checks side-by-side. Hand-author a handful of monitors in minutes via the CLI or web UI to see the OTel-native telemetry and filmstrip experience for yourself.

Start free at /sign-up, or see full pricing at /pricing.