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-04-10
# 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. Checkly authors checks in TypeScript with the Checkly constructs library. Both are valid — YAML is friendlier to SREs who don't want a build pipeline for monitoring.
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. | Phase 2 roadmap | 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 | 20+ regions | 20+ regions | 20+ regions |
Pricing and tier gates verified April 10, 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] — 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.
Moving from Checkly
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 checkly ./src/__checks__Point the importer at your Checkly repo and it walks the TypeScript check files, extracts the declarative config, and emits equivalent Yorker YAML. Setup scripts, alert routing rules, and each Playwright spec file get flagged inline with TODO comments so you know exactly what to review before the first run.
What to watch for
- Checkly TypeScript → Yorker YAML
Checkly authors checks in TypeScript constructs (src/__checks__/*.check.ts). The importer reads the exported config (name, frequency, locations, alert channels) and emits equivalent Yorker YAML. Declarative config translates cleanly — the real work is the scripts.
- Playwright scripts need a small rewrite
Checkly uses @playwright/test spec files (import { test, expect } from '@playwright/test'). Yorker runs async function bodies with // @step: comment markers instead — smaller files, no framework imports, but not a direct copy-paste. The importer flags each spec file with a TODO describing the three changes needed per file.
- Setup and teardown scripts
Checkly's setup-scripts run imperative code before the check. Yorker uses declarative check definitions, so the importer surfaces any inline setup code as TODO comments in the generated YAML for you to port by hand.
- Alert channels and routing
Checkly alert channels don't have a 1:1 mapping. The importer emits an alert rule template with your Slack/email/PagerDuty endpoints pre-filled, but channel-specific routing rules need a manual pass.
What you keep
Your Playwright selectors, waits, and assertions — the script body logic is identical, you just paste it into a Yorker async function.
Your monitor names and groupings carry over so dashboards, alert routes, and on-call pages don't need relearning.
Your existing CI workflows (GitHub Actions, GitLab CI) can keep calling checks via the Yorker CLI or API.
Your Checkly-authored assertions translate 1:1 to Yorker YAML without behavior changes.
Where Checkly is strongest
No tool is the right answer for every team. Here's where Checkly genuinely leads today — if your use case matches, start there.
Checkly has a genuinely excellent chained-request builder today. If stitching together API flows is your primary use case right now, that's a reason to start there. Yorker ships HTTP and browser checks with OTel-native telemetry now; multi-step API is on the Phase 2 roadmap.
Checkly runs from 20+ public locations. Yorker runs from 14 today. If you need coverage in a specific narrow geography, check our hosted locations list against yours before switching.
Checkly has been shipping since 2018 and is battle-tested at companies like Vercel, Fastly, and Airbus. If your organization values that proven maturity — the kind that only comes from running in production at scale for years — Checkly has the track record Yorker is still building.
Frequently asked
Is Yorker a drop-in replacement for Checkly?
For HTTP and browser check definitions, mostly yes — the importer (coming in the next release) will emit equivalent Yorker YAML for the 80% that translates cleanly. Playwright script bodies need a small rewrite because Yorker runs async functions rather than @playwright/test spec files. Multi-step API test chains are on the Phase 2 roadmap — if those are your primary use case today, Checkly is the safer choice until that ships.
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. Every check emits OTLP metrics, traces, and logs directly to your backend — 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.
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 — and the importer generates skeletons to paste into.
What about private locations behind my firewall?
Private locations are included on the Yorker platform plan ($29.99/month) with a 50% discount on private-location run consumption. On Checkly, private locations require the $64/month Team plan.
When does the Checkly importer ship?
The importer is planned for the next CLI release. Until it ships, `yorker import --from checkly` exits with a pointer at the Yorker changelog so you know where to watch for the release notes.
Ready to take a look?
Start free — no credit card — and try Yorker against your existing Checkly checks side-by-side. The Checkly importer ships in the next CLI release; until then, you can hand-author a handful of monitors in minutes via the CLI or web UI.