Datadog Pricing in 2026: How the Bill Works and Where It Grows

Datadog charges for the hosts, then charges again for what those hosts have to say. Logs are billed by both volume and indexed event count, APM has its own host and span charges, and custom metric series can multiply when someone adds a high-cardinality tag. None of that requires an extra server.

In the worked example below, a 50-node Kubernetes cluster comes to $10,229 a month at US annual list prices. Log indexing alone accounts for $5,100. Infrastructure Pro accounts for $750. The advertised host rate accounts for less than one-tenth of this modeled invoice.

To predict the bill, trace each major meter back to the engineering decision that moves it. The tables and examples below show how.

Prices use Datadog's US annual list as of October 27, 2026, unless noted otherwise (Datadog price list).

How Datadog's pricing model works

Every Datadog product comes with its own counting rules: a billing unit, an included allotment, and annual, month-to-month, or on-demand rates. For host-based products, usage is sampled hourly and the applicable plan determines the billed host count (Datadog billing docs).

The high-water mark and the seven-hour threshold

On the default high-water mark plan (HWMP), Datadog bills "the maximum count (high-water mark) of the lower 99 percent of usage" and "excludes the top 1 percent to reduce the impact of spikes." A 30- or 31-day month has 720 to 744 hours, so the top 1% is about 7.2 to 7.4 hours (a little less in February). Those excluded hours are the highest readings across the whole month, and they don't have to be consecutive. Any host count you reach in more than roughly seven hours in total becomes the billed count for the entire month. Datadog doesn't state the threshold this way, but it follows from the rule. An isolated one-hour spike drops out. Repeat that same spike eight times, though, and the monthly bill no longer treats it as a spike. It treats it as your host count.

The Hybrid Monthly/Hourly Plan (MHP) takes a different approach: commit to a monthly minimum, then pay hourly for host hours above it.

Annual, month-to-month and on-demand

Running over a commitment costs more, but the surcharge depends on what ran over. Extra Infrastructure hosts cost 20% more; indexed log events cost 50% more. You might think those log events have become more interesting by the time they reach the on-demand tier. Actually, they're just more expensive:

The log billing docs confirm that usage above a log commitment is charged "as on-demand usage at a 50% premium."

Free tier and discounts

The free Infrastructure tier covers up to five hosts and retains metrics for one day. Datadog lists volume-discount thresholds at 500 Infrastructure hosts or 3 billion log events a month (Datadog pricing).

Datadog pricing by product

The main meters are Infrastructure hosts, APM hosts and spans, ingested and indexed logs, RUM sessions, and custom metrics. Their rates are published. Predicting how many units you will actually consume is the harder part.

Infrastructure monitoring

The host price is the easy one to remember. It's what runs on that host that starts complicating the invoice. Containers, custom metrics, and events can each count separately:

DevSecOps Pro ($22) and DevSecOps Enterprise ($34) bundle security features. You can't buy them for only part of your fleet.

Containers above the allotment cost $0.002 per container-hour on demand, or $1 per container per month prepaid. A container running all month on demand costs about $1.46 (730 hours × $0.002), so prepaying for a stable container baseline is cheaper. Datadog meters containers every five minutes and averages them hourly. The Agent and pause containers don't count. GKE Autopilot is billed under Serverless rather than Infrastructure (container billing).

Custom metrics above the allotment cost $5 per 100 per month, and custom events cost $2 per 100,000.

APM pricing

An APM host comes with some room for spans. It doesn't come with unlimited room. Once the per-host allotments run out, Datadog starts charging ingestion and indexing separately:

These prices apply when you buy APM on the Infrastructure pricing model, where every APM host must also have Pro or Enterprise Infrastructure. Datadog also sells standalone APM plans at $36, $41 and $47 that don't require Infrastructure (Datadog pricing FAQ).

Each APM host includes 1 million indexed spans and 150 GB of ingested spans per month. Ingested spans above the allotment cost $0.10 per GB. Indexed spans above the allotment are priced per million by retention: $1.27 for 7 days, $1.70 for 15 days and $2.50 for 30 days.

Datadog's own APM billing example shows how the three charges combine. Five APM hosts that send 30 million indexed spans and 900 GB of ingested spans cost:

• 5 hosts × $31 = $155
• (30M − 5M included) × $1.70 per million = $42.50
• (900 GB − 750 GB included) × $0.10 = $15
• Total: $212.50 per month

Log management pricing

Logs have a way of getting counted twice. First, Datadog charges $0.10 per GB ingested. Then it charges for each million indexed events, at a rate determined by retention. Those are two different things to optimize:

The "Standard indexing $1.70 per million" on Datadog's pricing page is the 15-day annual rate.

Smaller log messages sound like they ought to be cheaper. For indexing, that's not how this works. Two 0.5 KB messages occupy the same space as one 1 KB message, but they're two events, so they cost twice as much to index:

Total cost per GB ingested and indexed (ingest plus indexing), annual list prices.

Flex Logs is the lower-cost tier for data you keep for a long time but rarely query. Flex storage costs $0.05 per million events stored per month, with a one-month minimum. Flex Logs Starter costs $0.60 per million with 6-, 12- or 15-month retention and a three-month minimum.

RUM pricing

RUM follows application sessions, not the machines serving them. The host count can stay unchanged while the number of sessions grows. Datadog bills per 1,000 sessions. A session ends after 15 minutes of inactivity and is capped at four hours (RUM billing). A mobile app with webviews is billed as one mobile session.

Under RUM without Limits, billing has two parts:

• RUM Measure covers every ingested session at $0.15 per 1,000 (annual).
• RUM Investigate covers the sessions you keep after retention filters at $3 per 1,000.

Session Replay is an add-on at $2.50 per 1,000 replays. Existing RUM customers have to contact Datadog to move to the new model.

Custom metrics pricing

A metric can keep exactly the same name while its tags produce thousands of distinct series. The service has not acquired thousands of new metric names. The billable count just makes it look that way. Datadog defines a custom metric as "a combination of a metric name and tag values (including the host tag)," averaged hourly across the month (custom metrics billing). Each unique combination is one billable series. Pro includes 100 per host, Enterprise 200, and each extra 100 cost $5 per month.

The metric type multiplies the count:

Consider a distribution with four tag combinations and percentiles enabled. Still one metric name, but Datadog counts 40 billable custom metrics.

Metrics without Limits lets you choose which tags Datadog indexes, which cuts the number of billable indexed series. It also bills ingested custom metrics above the included ingested allotment at $0.10 per 100. The allotments page shows how many your plan includes. Datadog also offers a Metric Name pricing option, billed on metric names and data-point volume.

Other products

If the core stack doesn't provide enough billing units to keep track of, there are a few more:

• Synthetics: API tests $5 per 10,000 runs, browser tests $12 per 1,000 runs, mobile tests $50 per 100 runs.
• Database Monitoring: $70 per database host, with 200 normalized queries included.
• Serverless: $5 per active function, or $10 per million traced invocations for APM.
• LLM Observability: $160 for the first 100,000 LLM spans, then $3.50 to $7.50 per 10,000 depending on retention.

Security, CI Visibility, Incident Management and Bits AI (sold as AI credits at $500 per 500 credits per month) each have separate pricing on the Datadog price list.

What a Datadog bill looks like: a worked example

The worked example puts all those meters on one invoice. In the 50-node setup, Infrastructure comes to $750. Once the other billing units have had their say, the model reaches $10,229. Here are the assumptions and annual list rates behind it.

Annualized, the model comes to approximately $122,750 before negotiated discounts.

Log indexing accounts for $5,100 of the $10,229 bill. Ingestion costs $300; indexing costs 17 times as much. Getting the logs in is the cheap part. The 3,000 GB of ingested spans fit within the 7,500 GB allowance for 50 APM hosts. Even doubling the assumed span size to 2 KB keeps the modeled ingestion within that allowance. Indexing fraction, event size, and retention deserve more attention than the headline $15 Infrastructure host.

Where Datadog costs scale unexpectedly

Host growth is not the only way to grow the invoice. These six examples show what happens when scaling policies, metric tags, collection settings, or enabled products change. Each uses the reference stack above.

Autoscaling and the high-water mark

Autoscaling is supposed to make extra capacity temporary. It does, at least as far as the cluster is concerned. The high-water-mark billing plan has a slightly different definition of temporary. Suppose the reference cluster scales from 50 to 70 nodes for 10 hours on each of 22 weekdays. That's 220 hours at 70 nodes, far more than the roughly 7-hour allowance. The average node count is about 56, but Infrastructure and APM bill at 70:

20 extra hosts × ($15 + $31) = +$920 per month

Container and custom-metric allotments also rise with the extra hosts, which offsets part of that.

The Hybrid Monthly/Hourly Plan handles this differently: host hours above the monthly commitment are charged hourly instead of turning the burst into a higher monthly host count. Compare both methods against your actual scaling pattern.

Tag cardinality and metric types

A metric tag can multiply the bill without adding a single host. Datadog counts distinct combinations of metric names and tag values, not just how many metrics you named. A request metric tagged by 10 endpoints, 3 status codes and 3 tiers is up to 90 series. Add a customer_id tag with 1,000 values, and if every customer hits every endpoint, status and tier combination throughout the month, it becomes 90,000 series. The reference stack has already used its included custom metrics, so all of them are billable:

90,000 ÷ 100 × $5 = about $4,500 per month for one metric

All from adding a tag to one request metric. That's a fairly ambitious bill for a small instrumentation change.

Fewer real combinations, or combinations that only appear for part of the month, cost proportionally less, since the count is averaged hourly.

The metric type then multiplies again. If that metric is a distribution with percentiles enabled, each tag combination counts as 10 series instead of one. Turning on percentiles alone doubles the series count of an existing distribution.

Metrics without Limits lets you index only the attributes you actually query. Ingested-series overages can still apply at $0.10 per 100, so reducing indexed cardinality does not necessarily remove every charge.

OpenTelemetry and Prometheus metrics billed as custom

OpenTelemetry is a standard, not a discount code. Application metrics that don't map to a Datadog integration are billed as custom metrics (Datadog OpenTelemetry API support). The same applies to Prometheus-style endpoints: the OpenMetrics check forwards the metrics it scrapes as custom metrics. Each series then counts against the $5 per 100 rate, with the cardinality and type multipliers above. In the reference stack, OpenTelemetry application metrics are part of the 25,000 custom series behind the $1,000 custom metrics line, and every additional 1,000 series adds $50 a month.

An autodiscovery annotation scraping too many targets or an OpenTelemetry histogram with unbounded attributes can raise the custom-metric bill. Nobody bought another Datadog product. Someone just changed what the software was measuring. The bill noticed.

Audit OpenMetrics scrape targets and OpenTelemetry metric attributes before ingestion. Use Metrics without Limits for the indexed dimensions you need.

Containers and Kubernetes

The Agent can monitor a thousand containers without being installed a thousand times. With a DaemonSet, it runs once per node, and you pay per node plus containers above the allotment. If you instead install the Agent in each container, Datadog's billing overview is explicit: "each container is counted as a host from a billing perspective." The APM billing docs say the same, excluding Fargate.

For the reference stack, the 1,000 containers would become 1,000 hosts:

Same 50 Kubernetes nodes, but 1,000 billed Infrastructure and APM hosts instead of 50. That's an expensive consequence of where the Agent runs. For this setup, deploy it once per node; for a stable container baseline, prepaid units cost less than the $0.002 per-container-hour on-demand rate.

Logs and spans billed twice

The example spends $300 getting logs in and $5,100 making them searchable. So while the ingestion price looks pleasantly small, it's indexing that deserves most of the attention here. Two changes cut it directly:

• A 50% exclusion filter saves $2,550 per month.
• Moving from 15-day to 7-day retention brings indexing to 3,000M × $1.27 = $3,810, a saving of $1,290.

Spans follow the same pattern: ingested by GB, indexed by count and retention.

Use exclusion filters, shorter Standard retention, Flex Logs for infrequently queried data, and span retention filters to reduce indexing. To avoid log ingestion charges, drop unwanted entries before they are sent, using the Agent's exclude_at_match processing rules or the separately priced Observability Pipelines product.

On-demand overage and add-on creep

A commitment buys a rate for the usage you've committed to. It doesn't promise that the next million log events will cost the same. Beyond the commitment, overage moves to on-demand rates: +20% on Infrastructure hosts and +50% on logs. Suppose the reference stack had committed to 2,000M indexed log events at 15-day retention but used 3,000M. The extra 1,000M would cost $2,550 at the on-demand rate instead of $1,700 at the annual rate: +$850 per month. Under-committing on logs costs more than under-committing on hosts, so size log commitments more carefully.

Add-ons grow the bill through new meters rather than higher usage. In the reference stack, RUM, Session Replay and Synthetics already add $609.20 per month. Turning on Database Monitoring for five database hosts would add another 5 × $70 = $350, and each product you enable brings its own allotments and overages.

Size commitments by product and audit which add-ons are enabled.

How to estimate your Datadog cost

Datadog's public Allotments Calculator does exactly what its name promises: it calculates allotments under standard agreement terms. Fair enough. But that's a rather different calculation from the total multi-product invoice.

Adapt the worked example using measured node counts, container density, span volume, log-event size, custom-metric series, sessions, and retention. Recalculate at peak host count to expose the high-water-mark effect.

After deployment, Datadog Costs breaks down daily spend by product and up to three usage-attribution tags such as team or service. The data arrives with a 48-hour delay. The Plan & Usage page and Log Explorer then show which hosts and services drive indexed-log volume.

What teams actually pay and how discounts work

The public price list is a starting point, not a prediction of somebody else's contract. Negotiated rates can be lower, on-demand overages higher, and third-party purchasing data does not tell you what telemetry those customers sent.

Vendr reports a median annual contract value of $154,080 across 1,141 purchases, with a range of $21,272 to $716,298, and discounts of 15% to 30% for annual contracts, 20% to 40% for multi-year contracts and 30% to 45% for large deployments. These are Vendr's figures from its own customers' purchases, not Datadog's.

Datadog names volume-discount thresholds at 500+ Infrastructure hosts and 3 billion+ log events per month.

What to compare when evaluating Datadog alternatives

The price per unit is only half the story. The other half is how enthusiastically your systems produce that unit. Compare what each backend actually counts, then model the same telemetry at 2×, 5×, and 10× volume. The OpenTelemetry backend guide covers backend selection.

For each candidate, check:

• What the bill grows with: hosts, series and cardinality, GB, events, sessions, users or queries, and which of those your architecture will multiply.
• Ingest versus index: whether storing data is billed separately from receiving it, and how retention changes the rate.
• OpenTelemetry pricing: whether OTLP data follows the standard pricing path, or whether OpenTelemetry metrics are treated as custom.
• Filtering before billing: whether you can drop or sample data before it's charged, and which tools that takes.
• Budget caps and attribution: whether you can cap spend, forecast it, and attribute it by team or service.
• Contract terms: annual commitment versus month-to-month, and the size of the on-demand premium.
• Feature parity and migration effort: Datadog's Profiler, App and API Protection and Data Streams Monitoring require its own SDK, and Database Monitoring isn't available through the upstream OpenTelemetry Collector or OTLP.

The Datadog competitors comparison works through these dimensions in more detail. If you're weighing specific vendors, see the comparisons with New Relic, Dynatrace, Splunk and CloudWatch.

Illustrative cost under Dash0's pricing model

Dash0 counts the telemetry, not the machines sending it. That removes the host meter, but it doesn't make telemetry volume free. There is no host, seat, or core-platform base fee. Spans, logs and web events cost $0.06 per million to ingest plus $0.54 per million to store (30 days). Metric data points cost $0.02 per million to ingest plus $0.18 per million to store (13 months). Synthetic API checks cost $0.20 per 1,000 runs.

The table applies those rates to the reference workload. It is not a like-for-like savings comparison. Product coverage, retention, and metric assumptions differ. A lower total on paper is not enough to declare a winner:

• Product scope differs. Browser synthetics and Session Replay are left out because they have no equivalent on Dash0's pricing page.
• Span retention differs. The Datadog bill indexes 150M spans, while the Dash0 lines store all 3B.
• Infrastructure metrics are billed differently. Datadog's host price includes infrastructure metrics, while Dash0 bills them as data points. The 125,000 series combine an assumed 2,000 infrastructure, container and Kubernetes series per node with the 25,000 custom series. The per-node figure is an assumption, and it moves the result more than any other, so count your own.
• Metric counts don't transfer one to one. The 25,000 figure is Datadog's billable count, carried over unchanged for simplicity. Datadog bills histograms and distributions at 5 or 10 series per tag combination, so the number of series your services actually emit may be lower. Start from your own metric inventory and apply each vendor's counting rules separately.
• Web events per session vary widely. The 50-events-per-session figure is an assumption.

All lines use a 30-day month, as the Datadog bill does.

The comparable Datadog lines (the full bill minus browser synthetics and Session Replay) total $9,931.40.

Two settings move the Dash0 side most. At a 15-second scrape interval, metric data points cost $4,320 and the total rises to $7,969.56. Sampling to keep 10% of spans brings the span line to 3,000M × $0.06 + 300M × $0.54 = $342 instead of $1,800.

Recalculate using your own signal counts, retention, sampling, and product scope at 2×, 5×, and 10× growth.

Final thoughts

Datadog really does list Infrastructure Pro at $15 per host on the annual plan. That's a real price. It just isn't the price of monitoring everything those hosts do. In the worked example, indexing three billion log events costs $5,100, while Infrastructure costs $750. Add a high-cardinality tag, change retention, or run a scheduled scale-out for long enough, and the numbers change again.

Use the billing units and allowances to model your own telemetry, not a generic per-host multiplier. If the model cannot explain event counts, indexed spans, and cardinality, it cannot explain the invoice either.

For a different billing model, the Datadog alternatives overview explains per-signal pricing. The migration guide covers a move to OpenTelemetry and Dash0.

If you'd like to see how an OpenTelemetry-native platform handles telemetry costs, try Dash0 free for 14 days. No credit card required.