Open-source alternative to Datadog Synthetic Monitoring

Self-hosted Uptime Kuma covers uptime and API checks, and Zabbix can cover browser-style scenarios with more setup. This page maps each capability, the gaps and the work involved.

On this page

Open-source alternative to Datadog Synthetic Monitoring: the short answer

If you pay Datadog for Synthetic tests and want those checks to run inside your own network, Uptime Kuma covers HTTP(s), keyword, JSON query and TCP checks, with status pages and notifications, but browser scenarios need a different tool and more engineering. Uptime Kuma is released under the MIT license, so you can run it on your own servers without a license fee. Its monitor types include HTTP(s), keyword, HTTP(s) JSON query, TCP, ping, DNS record, push and Docker container checks, and it can send alerts through more than 90 notification services.

Datadog bills Synthetic API tests per 10,000 test runs per month and browser tests per 1,000 runs. The Datadog pricing list shows Synthetic API tests at $5 per 10,000 runs per month billed annually ($6 month-to-month, $7.20 on demand) and browser tests at $12 per 1,000 runs billed annually ($15 and $18). Those per-run rates mean your bill rises with check frequency and the number of locations you test from, so the first step is to count your current runs by test type and interval. Pull that count from your Datadog account before you decide which checks move first.

For browser journeys such as logging in, completing a form or walking a checkout, plan for Zabbix browser items or another self-hosted browser testing tool. Zabbix is AGPL-3.0 from version 7.0 onward, and its browser items require more configuration and maintenance than Uptime Kuma's simple monitors. Confirm the browser item behavior, supported browser versions and the proxy placement you need for internal sites with your own proof-of-concept before you commit to a migration plan.

Which Datadog Synthetic capabilities map to open-source options

This table maps each Datadog Synthetic capability to Uptime Kuma, Zabbix or a gap that needs extra tooling. Confirm each cell against the current release of both projects before you commit. The main takeaway is that Uptime Kuma covers uptime and simple API checks well, while browser scenarios and multi-location coverage usually need Zabbix browser items or external runners.

CapabilityUptime KumaZabbixGap or action
API testsHTTP(s), keyword and JSON query monitors cover single-request API checksWeb scenarios can run multi-step HTTP checks; confirm steps and assertions in your releaseLong request chains with complex assertions may need a dedicated test runner
Browser testsNo browser scenario monitor typeBrowser items load pages and collect metrics; confirm supported actions and versionsLogins, clicks and multi-page journeys likely need an external browser runner
Private locationsRun an instance inside the network you need to checkDeploy proxies in the target network that report to the Zabbix serverEach instance reports only from its own network vantage point
Global test locationsDeploy instances in each region you want to test fromProxies in each region; proxy groups redistribute hosts when a proxy goes offlineYou operate, host and patch every location yourself
AlertingMore than 90 notification services, including Slack, Telegram, Discord and SMTP emailTriggers and actions with media types; confirm the integrations you needOn-call scheduling and escalation need a separate tool such as GoAlert
Status pagesMultiple status pages, each mappable to a specific domainNo native public status page feature to confirm; use Uptime Kuma or another toolIncident history and subscriber features should be checked against your requirements
Test historyStores check results in its own database; confirm retention and export optionsHistory and trends with retention set per item; confirm limits for your databaseLong retention drives database sizing and storage cost
Billing unitNo per-run fee; you pay for hosting, storage and staff timeNo license fee for open source; paid support is optionalDatadog bills per 10,000 API runs and per 1,000 browser runs, per the Datadog pricing list

Uptime Kuma, Zabbix and when each fits

Datadog Synthetic tests cover two jobs: lightweight uptime and API checks, and scripted browser journeys. Uptime Kuma and Zabbix each cover part of that work, with different strengths, licensing terms and gaps, so the choice depends on what your team already operates and which checks you must keep.

Uptime Kuma for uptime and API checks

Uptime Kuma is an MIT-licensed, self-hosted monitor that runs HTTP(s), keyword, HTTP(s) JSON query, TCP, ping, DNS and push checks from a single container. It fits the simple end of Datadog Synthetic API tests, where a team needs an endpoint to return the right status or field. Check what it does not do: it runs no multi-step API flows or scripted browser sessions, so multi-step Datadog API tests and all browser tests need a separate tool. Confirm check frequency and probe placement against your network before you migrate.

Notifications and status pages in Uptime Kuma

Uptime Kuma sends alerts through more than 90 notification services, including Slack, Discord, Telegram, Pushover and SMTP email. It also supports multiple status pages, and each page can be mapped to its own domain, which covers public and internal status communication. Map each Datadog monitor's notification rule to a named Uptime Kuma notification, and test every channel with a forced failure. Confirm that your paging tool accepts the webhook or email format you configure.

Zabbix when your team already runs it

Zabbix is a strong fit when operations already monitors servers and networks with it, because web scenarios and items can share the same server, proxies and templates. Its license moved to AGPLv3 starting with Zabbix 7.0, while versions up to 6.4 remain GPL-2.0, so check your obligations before you modify and distribute it. Adding a second monitoring system for a small check set usually costs more in operations than it saves, so count the existing Zabbix skills first.

Zabbix browser scenarios and their limits

Zabbix covers browser-style checks through web scenarios and items that step through pages, logins and responses, rather than through a full browser engine. This works for form submissions and multi-step HTTP flows, but it does not replicate Datadog's browser tests with real rendering, JavaScript interaction and screenshots. Test your most important user journey against Zabbix first, and keep a headless browser tool for anything that depends on rendered content. Ask the vendor or your partner to confirm the exact scenario steps you need.

High availability and proxy placement

Zabbix server supports a native high availability cluster in which several nodes share one database, and failover occurs when the active node exceeds a configurable failover delay. Proxy groups from Zabbix 7.0 redistribute monitored hosts when a proxy goes offline, which matters for checks run from several networks. Uptime Kuma runs as a single instance with no equivalent clustering in its standard setup, so plan a backup of its data volume and a restart procedure. Confirm the database and failover delay you need before sizing the cluster.

Support and lifecycle costs

Both tools are free to download, but the recurring cost sits in hosting, staff time and, for Zabbix, optional paid technical support. Zabbix support tiers run from 8x5 with a one-day response (Silver) up to 24x7 with a one-hour response (Global), so choose a tier that matches the check's business impact. Zabbix standard releases are supported for 12 months, while LTS releases carry a five-year window, so plan upgrades on the LTS line. Ask any partner for a written quote covering setup, check migration and upgrades.

How the checks, private locations and alerts connect

The flow starts with the check runner, not the alert. In a self-hosted design, an Uptime Kuma instance inside the network runs each monitor (HTTP(s), keyword, JSON query, TCP, ping, DNS, push or Docker container) on its own schedule and records the result. When a monitor changes state, Uptime Kuma sends the notification through one of its more than 90 notification services, such as SMTP email, Slack, Discord or Pushover. A status page, mapped to its own domain, publishes the public or private view. Confirm whether your chosen status page updates on its own when a monitor fails or whether an operator must post the incident by hand, because that decision sets your response time during an outage.

Private locations, the self-hosted equivalent of Datadog's managed test locations, come from placing a probe inside each network segment that must be tested, then sending results to one central instance. With Uptime Kuma, the simplest pattern is one instance per segment, with the central team reviewing status from each. With Zabbix, proxies deployed in each segment collect data locally and report to the central Zabbix server, and proxy groups can redistribute hosts if a proxy goes offline. Decide early which segments need their own probe, since each probe is a server you patch, back up and monitor.

Multi-location checks are where the tools differ most, so confirm the behavior before you migrate any Datadog Synthetic test. Ask whether the tool runs one check from several vantage points and compares the results, and how it separates a failing service from a failing probe. A probe that loses its connection to the central instance must not appear as an outage for every application it watches. Also confirm where credentials for scripted browser steps are stored and who can read them. A short proof of concept with one internal application and one external endpoint will answer these questions faster than the documentation.

Moving Datadog Synthetic tests to self-hosted checks

This sequence moves each Datadog Synthetic API and browser test to a self-hosted check with the same assertions, alert routing and public status page, verified against the old results before Datadog is switched off.

  1. Inventory every Synthetic test and its assertions

    The Synthetic owner exports the list of API and browser tests from Datadog, then records for each one the target URL, request method, expected status codes, body or header assertions, locations, run frequency and the monitors and notification channels attached to it. Browser tests need their recorded steps and the assertions made at each step. Keep this inventory as the acceptance list for the rest of the work. The step is done when every test has a row with its assertions and owner, and the team agrees which tests are in scope for the first cutover.

  2. Deploy Uptime Kuma on your infrastructure

    The platform engineer runs Uptime Kuma inside your own network using the Docker Compose file or a single docker run command with the louislam/uptime-kuma:2 image, placing it behind your TLS termination and access controls. If Docker is not allowed on the host, the project also documents running it on Node.js 20.4 or later with Git, optionally managed by pm2. The step is done when the web interface loads over HTTPS, an administrator account exists, and the data volume survives a container restart.

  3. Rebuild API checks in Uptime Kuma

    The engineer recreates each API test as an Uptime Kuma monitor. HTTP(s) monitors cover status code checks, HTTP(s) keyword monitors cover body text assertions, and HTTP(s) JSON query monitors cover assertions on fields in a JSON response. Tests that rely on custom headers, authentication or multi-step request chains need confirmation against the current monitor options in your version, and anything Uptime Kuma cannot express should move to the browser or script layer. The step is done when each monitor passes against a known healthy endpoint and fails against a deliberately broken one.

  4. Rebuild browser scenarios in Zabbix or another tool

    Uptime Kuma does not replace multi-step browser journeys, so the team assigns each Datadog browser test to a second tool, such as Zabbix browser items if the organization already runs Zabbix, or another headless browser runner. The engineer reproduces each recorded step and assertion, sets the same frequency, and confirms the result is written to a place the alerting layer can read. The step is done when each scenario runs on schedule and reports pass or fail for each assertion, with failures visible to the on-call team.

  5. Recreate alert routing and status pages

    The on-call lead maps each Datadog monitor's notification targets to Uptime Kuma notification channels, which support more than 90 services including Slack, Discord, Telegram, Pushover and SMTP email. Public and private status pages are then created in Uptime Kuma, and each can be mapped to a specific domain if a custom domain is needed. Confirm that paging for browser failures reaches the same people, since that path runs outside Uptime Kuma. The step is done when a forced failure produces the expected notification and the status page shows the new monitors.

  6. Run both systems in parallel

    The team keeps Datadog Synthetic tests and the new checks running side by side for a period agreed in the cutover plan, and compares pass and fail results, response times and alert timing for each pair. Discrepancies usually come from different locations, different timeouts or assertions that were written differently, and each one is either fixed or recorded as an accepted difference. The step is done when the agreed comparison window ends with no unexplained mismatches and the on-call team has tested alerts from both paths.

  7. Retire the Datadog Synthetic tests

    Once the parallel run is signed off, the team disables the Datadog Synthetic tests and their monitors, keeps an exported copy of the test definitions for audit and rebuild reference, and removes the notification routes that are now duplicated. The billing owner confirms the change in the next invoice cycle against the Datadog pricing terms in place for the organization. The step is done when no Synthetic tests are running, the exported definitions are stored with the change record, and the new checks appear in the runbook.

Where the open-source approach needs extra work

Replacing Datadog Synthetic tests with Uptime Kuma and Zabbix moves scripting, location coverage, history and alert tuning onto your team. Each card below names one of those decisions and what to confirm before you commit to a cutover.

Browser scenario authoring effort

Datadog browser tests are recorded and maintained inside the product, while Zabbix browser items need scenarios built and kept current in your own tooling. Each multi-step login or checkout flow must be translated, parameterized and re-tested after every front-end release. Confirm which browser steps your team needs, who owns script maintenance, and whether your Zabbix version supports the browser item types you rely on.

Multi-location coverage must be rebuilt

Datadog runs tests from managed global locations and private locations you register. Self-hosted tools only check from the places where you deploy a monitor or probe, so every region, cloud account and branch office you test from needs its own vantage point. Ask for a list of required test origins and confirm how many probe hosts you must operate to cover them.

Test history retention is your job

Synthetic results accumulate in whichever database backs your tool, and storage grows with check frequency and step count. Retention periods that Datadog applies by default must be set explicitly in Uptime Kuma or Zabbix, and any compliance evidence you need must be exported before it expires. Confirm how long your auditors expect results to be kept and who backs up the database that holds them.

Alert noise tuning

Uptime Kuma's notification channels and retry settings are simple, but a single transient timeout from one probe can page the on-call team. Without Datadog's built-in monitor configuration defaults, teams usually spend several rounds adjusting retry counts, thresholds and maintenance windows. Confirm the alert thresholds for each critical journey and test them with a controlled outage before go-live.

Zabbix version and support lifecycle

Zabbix standard releases are supported for 12 months, while LTS releases carry five years in total. Zabbix 7.0 is licensed under AGPL-3.0 from that version onward, which changes the obligations for modified deployments. Confirm which release you will standardize on, when its full and limited support end, and whether you need a paid support tier to meet your response-time requirements.

A probe or proxy in each private network

Checks against internal applications need a component inside each private network, such as a Zabbix proxy or a small Uptime Kuma instance, because the public internet cannot reach those services. Each probe needs patching, certificates, time sync and monitoring of its own health, or a silent failure will look like an application outage. Confirm which networks need probes, how probes report back to the central server, and how they fail over if one goes down.

What buyers ask before replacing Datadog Synthetic Monitoring

What drives the cost of replacing Datadog Synthetic Monitoring?

The cost depends on how many checks you run, how often they run, how many browser scenarios you need, and how much alerting and status page work sits around them. Datadog bills Synthetic API tests per 10,000 test runs per month and browser tests per 1,000 runs, according to Datadog's pricing list, with a lower rate for annual billing. On the open-source side, Uptime Kuma is MIT licensed, so the software itself has no license fee. Your recurring costs are the virtual machines or containers that run the checks, the time to maintain them, and any paid support. Ask any partner for a line-item quote covering build, hosting, maintenance and handover.

Can our team replace Synthetic Monitoring without outside help?

A team with Docker and basic Linux experience can install Uptime Kuma quickly, since it runs from a single docker run command or Docker Compose file using the louislam/uptime-kuma:2 image. Browser scenarios are harder. Zabbix browser items require a Zabbix server, a supported database and enough operational knowledge to keep templates and proxies healthy. Decide early whether you have people who can own both tools for the long term. If you do not, a fixed-scope engagement can cover planning, configuration and handover, with ongoing support available as a retainer.

How long does the work take, and what does it depend on?

Duration depends on the number of endpoints, the complexity of login flows and browser journeys, the alerting targets you must reach, the number of status pages, and whether you need private locations inside your network. A small set of HTTP and API checks with a few notification channels is far less work than dozens of multi-step browser scenarios. We do not publish timelines. Confirm the duration in the written scope, and ask for a list of the assumptions it depends on, such as access to test accounts and approval for network rules.

What skills does the work need from our staff?

You need people who understand HTTP behavior, DNS, certificates and the applications being tested, plus someone who can run containers and manage backups. For browser checks, a developer or QA engineer should own the scripted journeys because they change when the application changes. Security or platform staff should review where probes run and how credentials for test accounts are stored. Plan for named owners on each area so checks do not go stale after handover.

Are Zabbix support tiers and response times worth paying for?

Zabbix software has no license fee, no device limits and no feature gates. Paid technical support is optional and comes in Silver, Gold, Platinum, Enterprise and Global tiers. Response times run from 1 day for Silver, which is 8x5 support, to 1 hour for Global, which is 24x7 support, as listed on Zabbix's support page. Whether a tier is worth buying depends on how critical your synthetic checks are, how many people can troubleshoot Zabbix in-house, and what an outage costs you. Compare the tier cost with your internal on-call coverage before deciding.

What do we get from a fixed-scope quote, and how do we request one?

Most DeployOpen engagements are fixed-scope, and scope, deliverables and timelines are agreed in writing before work starts. DeployOpen does not publish a price list, so a quote follows from that written scope. To request one, list your check inventory (endpoints, frequencies, browser journeys, locations), your alert channels, the status pages you need, the network zones involved, and your compliance evidence needs. Ask the provider to state what is included, what is excluded, what recurs, and who owns each piece after handover.

What should we confirm before we commit to a migration?

Confirm which checks are truly used, because many synthetic tests outlive the applications they monitor. Confirm that Uptime Kuma covers your protocol needs, such as HTTP(s), keyword, JSON query, TCP, DNS and WebSocket checks, and that Zabbix covers any browser scenarios you require in your installed version. Verify your required notification channels against Uptime Kuma's supported services, and confirm your Zabbix version and database requirements against the official documentation. Finally, confirm who will receive alerts during the parallel run.

What the cost components are when you self-host

The cost of self-hosting synthetic monitoring is not a single line item, so start by separating what you pay today from what you would pay to run it yourself. On the Datadog side, the billing unit is the run: Datadog's pricing list shows Synthetic API tests at $5 per 10,000 test runs per month billed annually ($6 month-to-month, $7.20 on demand) and browser tests at $12 per 1,000 runs billed annually ($15 and $18). Those rates scale with check frequency and the number of locations, so pull your current run counts from the Datadog usage page before you compare. Self-hosted Uptime Kuma is MIT licensed and carries no license fee, and Zabbix has no license fee, device limits or feature gates. The costs that remain are the ones you must budget for explicitly.

The recurring costs are hosting, staff time and any paid support. Hosting covers the virtual machines or containers for Uptime Kuma or Zabbix, the database Zabbix requires (MySQL or Percona, MariaDB, or PostgreSQL with optionally TimescaleDB), storage for results, and, for browser scenarios, the worker capacity that runs a headless browser. Staff time is usually the largest recurring item: someone patches the platform, upgrades it on the Zabbix or Uptime Kuma release cycle, reviews failed checks, and maintains scripts when the monitored application changes. Zabbix's life cycle policy sets standard releases to a 12-month support period and LTS releases to five years, so plan a recurring upgrade window. Paid Zabbix technical support is optional and is sold in tiers from Silver to Global, with response times from one day to one hour, according to the Zabbix support page. Whether you need one depends on how quickly you must restore a failed monitoring check.

The one-time costs are the setup and scripting effort, which you should price as a fixed scope before work starts. This includes building uptime and API checks, writing and validating browser scenarios, configuring private locations or proxies, wiring alerts and status pages, and running the Datadog and self-hosted checks in parallel until results match. Ask any implementation partner for a written quote that lists each check group, the number of browser journeys, the environments covered, the alert routing, and the hours or fixed fee for each. Also ask who keeps the scripts current after handover and what is excluded. Request the quote in a form that separates one-time build from recurring operations, so you can compare it with your Datadog run counts over a full contract term.

Running self-hosted synthetic checks beside the rest of Datadog

Most teams do not replace all of Datadog at once. Moving Synthetic checks first means the new checks, the existing APM and log coverage and the alert paths have to agree on who pages whom. The cards below cover the decisions that keep that split stack predictable during and after the move.

Keep APM and logs while moving checks

Synthetic checks are the smallest piece to move on its own, because they only probe endpoints from the outside. Datadog APM traces, log pipelines and infrastructure monitors can stay in place while Uptime Kuma takes over uptime and API probes. Confirm which Datadog services depend on synthetic results, such as SLO calculations or dashboards that embed synthetic widgets, before you switch off any Datadog test. Those dependencies are easy to miss and show up only as empty panels after cutover.

Route alerts from both into one channel

During a split stack, Datadog monitors and Uptime Kuma checks will both raise alerts, so responders need one place to see them. Uptime Kuma supports more than 90 notification services, including Slack, Telegram, Discord, Gotify, Pushover and SMTP email, so it can post into the same channel your Datadog notifications use. Decide which channel is authoritative and label messages by source so an on-call engineer can tell a Datadog alert from an Uptime Kuma alert at a glance.

Share OpenTelemetry instrumentation across both

Application telemetry should not be duplicated just because the synthetic checks moved. Datadog accepts OpenTelemetry data through its Agent, a standard Collector pipeline exporting over OTLP, or direct OTLP ingestion, so services instrumented once can keep sending traces and metrics to Datadog while a self-hosted backend receives the same data. Synthetic checks test the outside view, so they complement, not replace, the instrumentation work. Confirm that trace context from synthetic browser flows reaches your backend if you want correlated traces.

Avoid duplicate paging

Running two synthetic systems against the same endpoint doubles the chance of two pages for one outage. Assign each endpoint to one owner, either Datadog or Uptime Kuma, before the first Uptime Kuma check goes live. If both must probe for a period, route both into a single on-call policy and suppress the second page with a dedication rule in your incident tool. Test the escalation path with a planned failure so you know which alert reaches a person first.

Decide when to retire Datadog tests

Retire Datadog synthetic tests only after the replacement has run long enough to match their results. Datadog bills Synthetic API tests per 10,000 test runs and browser tests per 1,000 runs, so each duplicate test keeps costing money until it is removed. Keep a written list of every Datadog test, its owner, its alert route and its dashboard links, and remove them in batches. Confirm with your Datadog account team how billing changes when tests are paused or deleted, since that depends on your contract.

How DeployOpen scopes a synthetic monitoring replacement

The scoping work starts with an inventory of every synthetic test in the Datadog account: each Synthetic API test, each browser test, its frequency, the locations it runs from, its assertions, and the alert and notification rules attached to it. Teams often discover that a number of tests were created for a release or an incident and never retired, so the inventory also records owners and whether each check still protects a live service. Ask for an export of the test definitions and the monitor list from your own administrators rather than relying on memory, and confirm which tests run from managed Datadog locations versus private locations, because that decides where replacement probes must sit.

The output of scoping is a written fixed scope agreed before any work starts. It names the deliverables (for example, which uptime and API checks move to self-hosted Uptime Kuma, which browser scenarios are rebuilt on Zabbix, the status page and notification routes, and the cutover plan), the acceptance criteria for each, the environments involved and the timelines the parties have agreed. Most DeployOpen engagements are scoped this way, so the reader should expect a written statement of work and should check that browser scenarios, which need more design work than HTTP checks, are sized separately from simple endpoint checks. Ask for the scope to list what is excluded, including any test you intend to keep on Datadog during dual running.

Once the replacement is live, checks drift as applications change and as Zabbix and Uptime Kuma releases arrive. For that stage, DeployOpen offers an optional retainer covering upgrades, periodic review of the test inventory, and continuous checks against the self-hosted monitoring stack. Decide before signing whether your team will own routine test changes or whether a retainer should carry them, and confirm who patches the Zabbix server and proxies, since Zabbix support tiers from the vendor are a separate purchase from the implementation work. DeployOpen does not publish prices, so ask for a quote built from the agreed inventory and deliverables.

How DeployOpen delivers synthetic monitoring replacement

DeployOpen plans, implements, integrates, documents and supports self-hosted open-source monitoring inside your own infrastructure, including replacements for Datadog Synthetic API and browser tests. Engagements start with a written scope that fixes what checks, locations, alert routes and status pages are in play.

How we scope

  • Inventory every Datadog synthetic API and browser test with its frequency, assertions and owning team
  • Agree in writing which checks move to Uptime Kuma and which browser scenarios need a Zabbix build or another approach
  • Define where private probe locations run, which networks they reach and who approves firewall changes
  • Engagements are fixed-scope, with deliverables and timelines agreed in writing before work starts

How we build

  • Deploy Uptime Kuma with Docker Compose or Node.js on your hosts, with persistent storage and backups configured
  • Configure HTTP(s), keyword, JSON query and TCP monitors that mirror the assertions from the Datadog tests
  • Build browser scenarios as Zabbix items or external scripts where Zabbix covers the need, and test each against a staging target
  • Wire notification channels and map each status page to its domain, then test alert delivery end to end

How we hand over

  • Document the monitor inventory, check intervals, alert routes, probe locations and the reasons for each design choice
  • Provide runbooks for adding checks, rotating notification credentials, upgrading the monitoring image and restoring from backup
  • Run a parallel period with Datadog synthetics still active so your team can compare results before retiring tests
  • Record the cost components you will carry, including hosting, storage, maintenance time and any Zabbix support subscription you choose

How we support

  • Ongoing support, upgrades and continuous testing are available as retainers, scoped in writing
  • Upgrades to Uptime Kuma and Zabbix are planned against each project's release and support dates, which you should confirm with the vendors
  • Security testing of the monitoring endpoints and status pages can be added to the retainer where your policy requires it
  • Ask for a written quote based on the agreed scope, since DeployOpen does not publish a price list

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.