Everything you need to monitor APIs and web apps
From a single HTTP check to a full multi-step browser journey across regions — CheckBeacon covers the API and the UI your users actually touch.
HTTP checks for any endpoint
Configure exactly how a request should be made and exactly what a healthy response looks like.
- Any HTTP method: GET, POST, PUT, PATCH, or DELETE
- Custom headers, request body, and content type
- Authentication: none, Basic, Bearer token, or API key header
- Validate expected status codes (e.g.
200,201,204) - Response-time thresholds — flag slow responses, not just failures
- Response MIME type validation
- Body assertions on JSON fields or text: exists, equals, contains, numeric greater-than/less-than
- Per-check schedule, from every minute up to every hour
Real-browser checks with Playwright
CheckBeacon can drive an actual browser through your application — the same way a user would.
- Multi-step journeys: load a page, log in, click through, and assert content
- Tests the rendered UI your users see — not just the API responses behind it
- Catches frontend regressions that pure API checks can't see — broken JS, missing elements, failed renders
- Same scheduling, multi-region runs, alerting, and result history as API checks
- Lives alongside API checks in the same dashboard and groups
Chain requests and pass data between steps
Capture a value from one step's response and use it in the next — perfect for "log in, then call an authenticated endpoint."
// Step 1: log in and capture the token { "method": "POST", "url": "https://api.example.com/auth/login", "body": { "email": "checks@example.com", "password": "{{secrets.password}}" }, "expected_status_codes": [200] } // Step 2: call a protected endpoint with the token { "method": "GET", "url": "https://api.example.com/account", "headers": { "Authorization": "Bearer {{step.1.body.token}}" }, "expected_status_codes": [200], "assertions": [ { "field": "body.plan", "op": "equals", "value": "active" } ] }
Real workflows, not just single requests
Most outages aren't "the homepage returns a 500" — they're "login works but the next call fails." Multi-step checks let you reproduce that exact flow:
- Reference any prior step's response with
{{step.N.body.field}} - Each step gets its own status, response time, and assertions
- A failure on any step marks the whole check as failed
- Works the same way for API steps and browser steps
Run checks from where your users are
Schedule the same check to run from multiple regions so you can tell a global outage from a regional routing or DNS problem.
Run from anywhere
Attach one or more regions to a check — each region runs the check independently on the same schedule.
Per-region results
Result history records which region a result came from, so you can spot region-specific latency or failures.
Flexible intervals
Set a check interval per check — from every minute for critical endpoints to every hour for low-priority ones.
Alert on real incidents, not noise
Set alert_after_consecutive_failures on each check so a single transient blip doesn't trigger a page — but a real outage does.
- Configure the failure threshold per check
- Each result is recorded with one of four statuses
- Status and history are visible per check and across your dashboard
See trends, not just the latest result
Every check page includes response-time and status charts with time-range filtering and auto-bucketed aggregation, plus a paginated, filterable result history.
- Filter results by status: healthy, warning, unhealthy, or error
- Pick a time range and the chart automatically buckets data points
- Drill into any individual result for full request/response detail
Groups keep large dashboards readable
Organize related checks — by service, environment, or product area — so your team can find what matters quickly.
By service
Group checks for "Checkout API", "Auth", and "Billing" so an on-call engineer can see one service's health at a glance.
By environment
Separate production, staging, and internal tools into their own groups with their own alerting expectations.
Across API and UI
Mix API checks and browser checks in the same group when they cover the same product surface.
Built for teams, not just individuals
Invite your team into a shared organization with role-based access control.
Organizations
Every account belongs to an organization. Checks, groups, and results are scoped to your organization.
Admin & read-only roles
Admins can create, edit, and delete checks and manage members. Read-only users can view dashboards and history without changing anything.
Session-based auth
Sign in once and your session lasts 8 hours. The same auth protects both the web UI and the API.
Automate it, or run it yourself
Everything available in the CheckBeacon UI is also available over a REST API with Bearer token authentication — manage checks, fetch results, and pull stats programmatically.
- Full CRUD on checks and groups via REST
- Trigger an on-demand run with
POST /checks/{id}/run - Self-host with a Docker image or the official Helm chart
- Runs on SQLite for small deployments or MySQL for scale
# Log in and store the token curl -X POST https://api.checkbeacon.com/api/v1/auth/login \ -H "Content-Type: application/json" \ -d '{"email":"you@example.com","password":"..."}' # Create a check curl -X POST https://api.checkbeacon.com/api/v1/checks \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{ "name": "Checkout API", "url": "https://shop.example.com/api/health", "method": "GET", "expected_status_codes": [200], "check_interval_minutes": 5 }'
See it running on your own endpoints
Book a demo and we'll set up a check against your API or UI live, or get started on your own in minutes.
Book a demo Get started