Private locations and OTelWithout 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
# 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
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 3× on day one.
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.
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.
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.
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.
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 [email protected] 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.
// BrowserCheck construct, points at a Playwright spec
import { BrowserCheck, Frequency } from 'checkly/constructs'
import * as path from 'path'
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)
import { test, expect } from '@playwright/test'
test('cart', async ({ page }) => {
await page.goto('/login');
await page.goto('/cart');
});
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
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–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.