Where uptime monitoring endsAnd synthetic telemetry begins
Better Stack is an excellent all-in-one uptime + incident + status product. Yorker is focused on what happens after the uptime check fires: OTel-native synthetic telemetry, full Playwright filmstrips, private locations, and W3C trace propagation — included in one plan.
Last verified 2026-04-11
# Yorker platform — $29.99/mo
browser_checks included in plan
filmstrip every run
private_locations included
otel_export included
# Better Stack Uptime
uptime_monitors 10 free; $25/50 more
browser_checks $1 per 100 min
private_locations not supported
otel_export not supported
Different products for different problems
Better Stack's UI is built around incidents as the primary object. Yorker's is built around telemetry and check results. Both are valid — they answer different questions.
Screenshot: Better Stack, via betterstack.com/uptime — accessed April 11, 2026.
Why teams add Yorker alongside Better Stack
Yorker emits OTLP metrics, traces, and logs from every check run to your existing observability backend. Better Stack ingests telemetry but Uptime checks do not emit OTLP — synthetic results stay inside Better Stack's platform.
Yorker captures a per-step screenshot sequence for every browser check run — pass or fail. Better Stack captures screenshots when an error occurs. Debugging intermittent visual regressions requires the full sequence, not just the failure frame.
Yorker private location agents run outbound-only from your network — no inbound firewall rules, included in the platform plan. Better Stack Uptime does not offer private location agents for behind-firewall monitoring.
Yorker injects a W3C traceparent header into every browser-check HTTP request. Synthetic runs appear as spans in your distributed traces — queryable in the same backend as your application traces, without any per-monitor configuration.
Yorker's platform plan includes browser checks with a monthly run allowance. Better Stack bills Playwright checks at $1 per 100 minutes — purely consumption-based with no inclusion. Predictable billing matters when you're scaling check coverage.
Yorker check definitions are plain YAML — one config file, no Terraform state, no provider SDK. Readable by any engineer. Better Stack's MaC approach uses a Terraform provider, which adds a build dependency to your monitoring workflow.
Feature-by-feature, tier-by-tier
Better Stack Uptime is priced per monitor block rather than in named tiers — 10 monitors free, additional 50-monitor blocks at $25/month each. Browser checks are $1/100 Playwright minutes on top. This table shows both columns against Yorker's platform plan.
| Capability | Yorker Platform · $29.99/mo | Better Stack Uptime Free (10 monitors) | Better Stack Uptime + monitor blocks ($25/mo each) |
|---|---|---|---|
HTTP / uptime checks Ping a URL, verify status and response. | Included | Included (10 monitors) | Included (50/block) |
Browser / Playwright checks Full headless browser with filmstrip. | Included in plan | $1 per 100 Playwright minutes | $1 per 100 Playwright minutes |
Check interval How frequently checks run. | 30s – 60m | 30-second minimum | 30-second minimum |
Screenshot filmstrip Per-step visual evidence on every run. | Included | Error screenshots only | Error screenshots only |
Private locations Run checks from behind your firewall. | Included | Not supported | Not supported |
OpenTelemetry export OTLP metrics to any backend. | Included — OTel-native | Not supported | Not supported |
W3C trace propagation traceparent injected into check requests. | Always on | Not supported | Not supported |
Monitoring as Code Check definitions in source control. | YAML (CLI) | Terraform provider | Terraform provider |
Hosted locations Global regions available out of the box. | 14 regions | Multi-location | Multi-location |
Pricing verified April 11, 2026 from betterstack.com/pricing. Better Stack: 10 uptime monitors free; additional 50-monitor blocks $25/mo (annual) or $21/mo (monthly); Playwright browser tests $1/100 minutes. Responder (incident management) licenses are separate: $29/mo per responder (annual). Yorker platform plan $29.99/mo with full pricing at /pricing. Spot something changed? Email [email protected].
Moving from Better Stack
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 better-stack ./monitorsPoint the importer at your exported Better Stack monitor config and it emits Yorker YAML. Uptime monitors translate cleanly. Playwright scripts need the async function wrapper updated — the test logic stays identical. Incident routing is not migrated — that's a separate setup step in your alerting stack.
What to watch for
- Better Stack uses Terraform for MaC; Yorker uses YAML
Better Stack's monitoring-as-code approach uses a Terraform provider. The importer reads exported monitor config and emits Yorker YAML — the key fields (URL, interval, alert contacts) translate cleanly, but Terraform state is not carried over.
- Playwright scripts are JavaScript — same language, different runner
Better Stack Playwright tests are standard JavaScript/TypeScript run inside their infra. Yorker runs async function bodies with // @step: markers instead of top-level scripts. The test logic transfers; only the wrapping changes.
- Incident routing lives in Better Stack Incidents, not monitors
Better Stack separates uptime monitors from incident routing (escalation policies, on-call schedules). The importer captures the alert contact from each monitor but cannot migrate the incident workflow — that's a manual setup step in your incident management tool of choice.
What you keep
Your monitor URLs and alert contacts carry over to Yorker YAML.
Your Playwright test logic — selectors, assertions, waits — transfers as-is; only the function wrapper changes.
Your check frequencies and multi-location configuration map directly to Yorker equivalents.
Where Better Stack Uptime is strongest
No tool is the right answer for every team. Here's where Better Stack Uptime genuinely leads today — if your use case matches, start there.
Better Stack bundles uptime monitoring, incident management (on-call scheduling, escalations, phone/SMS alerting), and status pages into one product. If you want a single vendor for monitoring + incident + status, Better Stack delivers that. Yorker is focused on synthetic telemetry — you bring your own incident management.
Better Stack's free tier gives you 10 uptime monitors with 30-second check intervals and unlimited SMS/phone alerting — genuinely useful for small projects. Yorker's pricing starts at $29.99/month. If you need zero-cost uptime pings for a side project, Better Stack's free tier is a solid starting point.
Better Stack's UI is built around incidents as the primary object — monitors feed incidents, incidents drive status pages, status pages notify customers. That incident-first workflow is well-executed. Yorker's UX is built around checks and telemetry, not incident workflow.
Frequently asked
Is Yorker more expensive than Better Stack?
For uptime-only monitoring of a small fleet, Better Stack's free tier (10 monitors) costs nothing. Yorker starts at $29.99/month. However, for teams that need browser checks, private locations, or OTel telemetry, Better Stack's per-minute Playwright pricing ($1/100 min) and lack of private location support mean costs diverge quickly as usage grows.
Does Better Stack do OTel export like Yorker?
Better Stack has an observability product (logs, metrics, traces ingestion) but its Uptime monitoring does not emit OTLP telemetry from synthetic checks to external backends. Yorker's synthetic results emit OTLP directly to your chosen backend — ClickStack, Grafana, Honeycomb, or any OTLP-compatible destination.
How do Playwright browser tests compare between the two?
Both products support Playwright-based browser tests. Better Stack prices browser runs at $1 per 100 Playwright minutes — a pure consumption model with no inclusion in the base price. Yorker includes browser checks in the platform plan with consumption pricing for volume above the monthly allowance, and every run produces a full filmstrip, not just error screenshots.
Does Yorker do incident management like Better Stack?
Yorker sends alerts to your existing incident management tools (PagerDuty, Opsgenie, Slack) but does not include built-in on-call scheduling or escalation policies. If that all-in-one stack (monitor + incident + status) is your primary requirement, Better Stack has the more integrated solution today.
What about private locations — can Better Stack run checks behind a firewall?
Better Stack Uptime does not offer private location agents for running checks inside a private network, based on their current public documentation. Yorker includes private location agents in the platform plan — outbound-only, no inbound firewall rules required.
Is migration from Better Stack difficult?
The declarative config (URL, interval, alert contact) migrates cleanly via the importer. Playwright scripts need the async function wrapper swapped for Yorker's format — typically a 5-minute change per script. Incident routing needs a manual re-setup in your incident management tool.
Related Reading
Ready to go deeper than uptime pings?
Start free — no credit card — and run your first OTel-native synthetic check in minutes. Private locations, browser filmstrips, and W3C trace propagation all in one plan.