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] 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.
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: 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. Multi-step API test chains are on the Phase 2 roadmap, so 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 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.
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 a 50% discount on private-location run consumption. 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.