Synthetic monitoring pricing and cost per check compared: Datadog, New Relic, Dynatrace, Grafana, AWS and Checkly
Enter your monitor count, locations and check interval to price the same workload at six metered vendors, using rates read on their own pricing pages this month.
Synthetic monitoring cost calculator
LiveWhat synthetic monitoring actually costs
Synthetic monitoring is almost always billed per check run, so the price you pay is the vendor rate multiplied by your check interval, your monitor count and your location count. Verified rates in August 2026 run from $0.00025 per API check run at Checkly to $0.005 at New Relic, a 20 fold spread, and browser checks cost 10 to 25 times more than API checks at the same vendor. A 30 day month holds 43,200 minutes, so one monitor checked every minute from one location is 43,200 runs.
Every vendor on this page publishes a rate. Almost none of them publish the multiplication, and the multiplication is where the money is. A rate of half a cent per check reads as nothing until you notice that a single monitor checked every minute produces 43,200 of them, and that you were planning to run forty monitors from four continents.
There is a structural consequence worth stating plainly, because it is the reason these bills surprise people. Under per run billing, the setting that controls your cost is the same setting that controls how fast you detect an outage. Cost control and reliability pull directly against each other, and the pull is not gentle: moving from hourly to one minute checks is a 60 fold increase on the same infrastructure.
Runs in a 30 day month
Per monitor, per location. Multiply by both to get your run total.
- 30 seconds
- 86,400
- 1 minute
- 43,200
- 5 minutes
- 8,640
- 15 minutes
- 2,880
- 60 minutes
- 720
Based on 43,200 minutes in a 30 day month, the same basis used on our error budget calculator.
Verified rates
Synthetic monitoring pricing per check run, August 2026
Each rate below was read on the vendor's own pricing page this month. The AWS figure came from the machine-readable AWS Price List, published 6 August 2026, which is worth noting because it is the only rate here that cannot be misread from a JavaScript billing toggle. Where a vendor quotes per 1,000 or per 10,000, we have divided it out, because comparing a per 1,000 price against a per 10,000 price is how teams end up off by an order of magnitude.
| Vendor | Billing unit | API check | Browser check | What the rate includes |
|---|---|---|---|---|
| Checkly | Per check run | $0.00025 | $0.00625 | Team plan overage rate. $64/mo includes 100,000 API and 12,000 browser runs. |
| Datadog Synthetics | Per check run | $0.0005 | $0.012 | Annual rate. $5 per 10,000 API runs, $12 per 1,000 browser runs. Note the units differ. |
| Grafana Cloud | Per test execution | $0.0005 | $0.005 | Pro plan is $19/mo including 100,000 API and 10,000 browser executions. |
| Dynatrace | Per request / per action | $0.001 | $0.0045 | Browser is priced per action, not per run, so a clickpath costs its step count. |
| AWS CloudWatch Synthetics | Per canary run | $0.0012 | $0.0012 | Same rate for both. First 100 runs a month free. Lambda, S3 and Logs billed on top. |
| New Relic | Per check | $0.005 | $0.005 | Charged beyond the allowance included in your edition, plus $0.40/GB ingest over 100 GB. |
| Uptimehub | Flat per monitor | Not metered | Not offered | Plans from $9/mo. Interval and all 6 regions are included, so runs do not affect the bill. |
Read the API and browser columns as a pair rather than separately. The gap between them is the single largest multiplier in synthetic monitoring, and it is disguised at three of these vendors by a change of unit. Datadog quotes $5 per 10,000 API runs and $12 per 1,000 browser runs, which looks like a bit over twice the price and is actually 24 times. Checkly quotes $2.50 per 10,000 and $6.25 per 1,000, which is 25 times. Grafana quotes both per 10,000, so its 10 fold gap is the only one you can read at a glance.
AWS is the outlier, and it is an interesting one. Its price list carries exactly one paid canary run SKU per region, so a canary driving a headless Chrome session through a checkout costs the same $0.0012 as a canary issuing a single GET. That makes AWS expensive for simple checks and unusually cheap for browser work, which is the reverse of how the rest of this market prices.
The multiplication
Cost of one HTTP monitor, one location, for a 30 day month
This is the rate card multiplied out. One monitor. One location. The only thing changing across the columns is the check interval, which on most of these platforms is a dropdown that carries no warning about what it does to the invoice.
| Vendor | 1 minute | 5 minutes | 15 minutes | 60 minutes |
|---|---|---|---|---|
| Checkly (Team overage rate) | $10.80 | $2.16 | $0.72 | $0.18 |
| Datadog Synthetics API (annual) | $21.60 | $4.32 | $1.44 | $0.36 |
| Grafana Cloud API | $21.60 | $4.32 | $1.44 | $0.36 |
| Dynatrace HTTP monitor | $43.20 | $8.64 | $2.88 | $0.72 |
| AWS CloudWatch Synthetics | $51.84 | $10.37 | $3.46 | $0.86 |
| New Relic | $216.00 | $43.20 | $14.40 | $3.60 |
The spread across a single row is 60 fold, because 60 minutes divided by 1 minute is 60 and per run billing is perfectly linear. The spread down a single column is 20 fold, from Checkly to New Relic. Put those together and the same ten monitors can plausibly cost anywhere between about $2 and $2,160 a month depending on two choices that most teams make without consulting the pricing page.
There is a reliability cost hiding in the cheap end of every row. A 5 minute interval means a worst case detection delay of 5 minutes, which spends roughly 12% of a 99.9% monthly error budget before anyone is paged. At 15 minutes it is 35%. We work that arithmetic through properly in how often you should monitor a website, and the short version is that per run pricing quietly charges you to be reliable.
A realistic bill
10 HTTP monitors from 3 locations, priced at every vendor
Ten endpoints watched from three regions is an ordinary setup for a small US SaaS team. At a 5 minute interval that is 259,200 check runs a month. At a 1 minute interval it is 1,296,000. Base fees and included allowances are applied where the vendor has them, so these are all-in figures for the synthetics line rather than raw rate multiplications.
| Vendor | At 5 minutes | At 1 minute | How the figure is built |
|---|---|---|---|
| Uptimehub Pro | $39.00 | $39.00 | Flat. 100 monitors at 30 second checks from 6 regions, no run metering. |
| Checkly Team | $103.80 | $363.00 | $64 base. 100,000 API runs included, then $2.50 per 10,000. |
| Grafana Cloud Pro | $98.60 | $617.00 | $19 base. 100,000 executions included, then $5.00 per 10,000. |
| Datadog Synthetics | $129.60 | $648.00 | No base fee on the synthetics line, purely per run at $5 per 10,000. |
| Dynatrace | $259.20 | $1,296.00 | $1.00 per 1,000 synthetic requests, no included allowance modeled. |
| AWS CloudWatch Synthetics | $310.92 | $1,555.08 | After the 100 free runs, and before Lambda, S3 and CloudWatch Logs. |
| New Relic | $1,296.00 | $6,480.00 | $0.005 per check beyond the edition allowance, before data ingest. |
The honest reading of that table is that the metered vendors are not overpriced. Checkly at $103.80 is charging a fair rate for a genuinely good product, and Datadog's $129.60 buys synthetics that sit inside an APM platform you may already be paying for. What the table shows is that the pricing model, not the price, is what decides the outcome. Every metered row roughly quintuples when the interval tightens. The flat row does not move at all.
That is the trade in one line. Metered pricing is cheaper when you check rarely, and flat pricing is cheaper the moment checking matters. If your monitors are HTTP, API, SSL, DNS, TCP port or cron heartbeat checks, our own plans cover all six regions and every interval down to 30 seconds for a fixed monthly figure, and the full market view is on the uptime monitoring pricing comparison.
Billing models
How each synthetic monitoring vendor meters you
Before comparing prices, compare units. Two vendors quoting a similar number per thousand can produce bills that differ by a factor of five, because they are counting different things. This table is what we check first when a vendor changes its pricing page.
| Vendor | What one unit is | Effect of a faster interval | Effect of more locations | The detail that catches people out |
|---|---|---|---|---|
| Datadog Synthetics | Check run | Multiplies the bill directly | Multiplies the bill directly | Browser is 24x an API run because the quoted units differ: $5 per 10,000 versus $12 per 1,000. |
| New Relic | Check | Multiplies the bill directly | Multiplies the bill directly | Highest per check rate of the group, but bundled into a platform that also charges per user and per GB. |
| Dynatrace | Synthetic request, or synthetic action for browser | Multiplies the bill directly | Multiplies the bill directly | A browser clickpath is billed per action, so a 5 step journey costs 5 units per run. |
| Grafana Cloud | Test execution, per probe per minute of run time | Multiplies the bill directly | Multiplies the bill directly | Run time rounds up to the minute, so a slow check can cost more than a fast one at the same interval. |
| AWS CloudWatch Synthetics | Canary run | Multiplies the bill directly | Multiplies the bill directly | The only vendor here charging the same rate for browser and API. The rate also varies by AWS region. |
| Checkly | Check run, or 30 seconds of Playwright execution | Multiplies the bill directly | Multiplies the bill directly | Cheapest API run rate in the group, and generous included allowances on the paid plans. |
| Uptimehub | Monitor | No effect | No effect | Interval and regions are plan features rather than meters, so the bill is knowable in advance. |
Grafana's unit deserves a second look because it is the only one on this page where the duration of your check affects the price. An execution is a test running in one probe location for one minute of run time, and the run time rounds up. Grafana's own worked example is a test across 5 locations lasting 1.5 minutes, which consumes 10 executions rather than 5. A check that gets slower therefore gets more expensive, which is an unusual incentive: the moment your service starts degrading is the moment your monitoring bill starts climbing.
Dynatrace's browser unit is the other one to read carefully. Browser clickpaths are billed per synthetic action at $0.0045, not per run, so the cost of a journey scales with how thoroughly you test it. A 5 step checkout costs 5 units every time it runs. That produces a crossover worth knowing before you compare headline rates: at $0.0045 an action, Dynatrace is cheaper than Datadog's $0.012 per run at one or two billable steps and more expensive from three steps onward, and it passes Checkly, Grafana and New Relic at two. Below one step it is the second cheapest browser rate on this page; above two steps it is the most expensive. Dynatrace's own documentation also says a step that triggers no web request costs nothing, so scrolls and keystrokes are free and the billable step count is usually lower than the script's step count. We work the whole model through, with the crossover table, in the Dynatrace synthetic monitoring pricing breakdown. Uptrends does something similar with its credit pool, where API monitors consume a credit per HTTP request rather than per monitor, and we go through that model on the Uptrends alternative page.
AWS specifics
CloudWatch Synthetics is priced per region, so a location is not a fixed cost
Every other vendor here charges the same rate wherever the check runs from. AWS does not. A canary run costs $0.0012 in the two US regions we checked, $0.0014 in Ireland and $0.0017 in Singapore. Adding a fourth location therefore does not add a quarter to your bill, it adds whatever that region charges, and the Asia Pacific premium is 42%.
The other thing to budget for is that the canary run rate is not the whole invoice. Each canary run executes a Lambda function, writes results and screenshots to S3, ships logs to CloudWatch Logs and publishes custom metrics. All four are billed separately at their normal rates. For a browser canary taking screenshots, those downstream charges are not a rounding error, and they are the usual reason an AWS synthetics bill lands higher than the run arithmetic predicted.
The free tier is 100 canary runs a month across all regions. Stated in time rather than runs, that is 100 minutes of one canary at a 1 minute interval, or about 8 hours at 5 minutes. It is enough to evaluate the service and not enough to monitor anything.
Canary run price by region
From the AWS Price List, publication 6 August 2026.
- US East (N. Virginia)
- $0.0012
- US West (Oregon)
- $0.0012
- EU (Ireland)
- $0.0014
- Asia Pacific (Singapore)
- $0.0017
Baseline
Same as baseline
17% more
42% more
Choosing
Which pricing model fits your monitoring
Metered wins
Few checks, run rarely
Under roughly 20,000 runs a month, per run rates are genuinely cheap and the included allowances on Checkly's and Grafana's paid plans may cover you outright. Three endpoints at 15 minute checks from one location is 8,640 runs, which costs about $2 at Checkly's rate.
Flat wins
Many checks, run often
Once you want minute-level detection on more than a handful of endpoints, metered pricing turns hostile. The crossover arrives faster than teams expect because the interval multiplies everything at once, and after it the flat plan is not slightly cheaper but several times cheaper.
Depends
Scripted browser journeys
Multi-step checkout and login flows are expensive under every model, so choose on capability rather than price. Checkly and Datadog are the strongest here. We do not run scripted browser journeys at all, which is stated plainly on our Checkly alternative page.
One practical note on evaluating any of this. The prices above are for the synthetics line only. At New Relic and Datadog the synthetics bill sits beside per user charges and per gigabyte ingest charges, and at New Relic a full platform user is $349 a month on the Pro edition. If you are pricing a move away from an APM suite, price the whole invoice rather than the line item, or you will conclude the wrong thing in both directions.
Questions
Synthetic monitoring pricing questions people actually ask
How much does synthetic monitoring cost?
For HTTP and API checks, expect $2 to $45 per monitor per month at a 5 minute interval from a single location, depending on vendor. Browser checks cost far more: a single browser journey checked every 5 minutes from one location runs about $104 a month at Datadog. Flat per monitor tools price the same work from roughly $0.40 to $2 per monitor because they do not meter runs at all.
Why is Datadog so expensive?
Because Datadog bills synthetics per check run, and the two things teams naturally want, a faster interval and more locations, both multiply that number. Ten API tests from three locations cost $10.80 a month at hourly checks and $648 at one minute checks. Nothing about the configuration changed except a dropdown, but the bill moved 60 fold.
How is synthetic monitoring priced?
Almost every vendor meters check runs, so the bill is rate times interval times monitors times locations. A 30 day month holds 43,200 minutes, which means one monitor from one location is 43,200 runs at a 1 minute interval, 8,640 at 5 minutes and 720 hourly. Only flat per monitor vendors break that link, charging for the monitor and treating the interval as a plan feature.
Is browser synthetic monitoring more expensive than API monitoring?
Yes, by 10 to 25 times at the same vendor. Datadog charges $0.0005 per API run and $0.012 per browser run, a 24 fold difference. Checkly is 25 fold, Grafana 10 fold. AWS CloudWatch Synthetics is the exception: its price list carries a single canary run rate of $0.0012 that applies whether the canary drives a browser or calls an endpoint.
What is the cheapest synthetic monitoring tool?
On raw API run rate, Checkly is cheapest of the metered vendors at $0.00025 per run on the Team plan. But for straightforward HTTP, API, SSL and DNS checks, a flat per monitor service is usually cheaper still, because it does not charge more when you tighten the interval. Metered pricing wins when you run few checks infrequently, and loses badly when you run many checks often.
Does AWS CloudWatch Synthetics have a free tier?
Yes, 100 canary runs a month. That allowance is small enough to be worth stating in time rather than runs: at a 1 minute interval it covers 100 minutes, and at a 5 minute interval it lasts about 8 hours. One canary running continuously for a full month at 5 minute checks uses 8,640 runs, so the free tier covers roughly 1% of it.
How many check runs are in a month?
A 30 day month contains 43,200 minutes. One monitor from one location produces 86,400 runs at 30 second checks, 43,200 at 1 minute, 8,640 at 5 minutes, 2,880 at 15 minutes and 720 hourly. Multiply by your monitor count and again by your location count. That single figure is the one to compute before reading any vendor price, because it converts a rate into a bill.
Should I use flat rate or per run monitoring pricing?
Compute your monthly run total and multiply by the metered rate, then compare with the flat plan that covers your monitor count. Below roughly 20,000 runs a month, metered vendors are usually cheaper. Above that, flat pricing wins and the gap widens fast, because flat pricing is the only model where checking more often costs nothing extra.
Keep reading
Related pricing and monitoring pages
This page prices synthetic checks, meaning the metered APM and developer platforms. If you are comparing the flat-rate uptime monitoring market instead, the uptime monitoring pricing comparison has the ten vendor price table and the five billing models. The status page pricing comparison covers the separate ladder vendors charge for the public page your customers read during an outage.
For single vendor detail, the Datadog Synthetics pricing breakdown works the per run arithmetic through in full, and the Datadog Synthetics alternative and Checkly alternative pages compare capability rather than rate. If you are still deciding what to monitor and how often, start with synthetic monitoring versus uptime monitoring, then set the interval using the error budget calculator.
Price your monitoring once, not every time you tighten an interval
HTTP, API, keyword, SSL, DNS, TCP port and cron heartbeat checks every 30 seconds from 6 regions, on a flat monthly plan that does not move when you check more often.