Datadog Pricing: What You Pay and How to Cut the Bill

On a Datadog bill for 50 hosts, the $15 per host is 17% of the total:

Bottom line

Datadog pricing is a price list of separate products, and each product has its own unit.

Infrastructure Monitoring costs $15 per host per month on the Pro plan (billed annually), or $18 on-demand.

APM adds $31 per host.

Logs cost $0.10 per GB to ingest plus $1.70 per million events to index for 15 days.

Custom metrics cost $5 per 100 above what your hosts include.

So the host price tells you very little. The bill follows 4 things your team controls:

1. How many hosts and containers run at the busiest hours of the month
2. How many tag combinations your custom metrics have
3. How many log events you index, and for how many days
4. How much of it you committed to in advance

In the worked example below, 50 hosts cost $4,360 a month at list price, and the $15 host line is 17% of it.

3 changes bring that bill to $2,953.

All prices here are Datadog's public list prices for the US site, in USD, checked on November 14, 2026 against the Datadog price list and the billing docs. Your contract can differ.

Datadog pricing is a price list, one unit per product

The Datadog price list has a row for every product, and you pay for each one you turn on.

These are the lines a typical startup setup uses:

Two things in this table decide most bills.

First: a host with Infrastructure Pro and APM costs $46 a month, 3 times the number on the pricing page.

Second: the last 8 rows are usage.

Nobody signs off on them. They grow with every deploy.

Host = a predictable floor. Usage = the part that surprises you.

A host is billed on the busiest hours of the month

Datadog counts your hosts every hour.

On the default plan (Datadog calls it the high watermark plan) you pay for the highest count of the month after the top 1% of hours is dropped.

A 30 day month has 720 hourly readings. The top 1% is 7.2 of them, and Datadog rounds that up to 8.

The APM billing page spells the rule out for APM hosts: Datadog charges on the ninth highest reading of the month (the eighth in February). Infrastructure hosts follow the same 99% rule.

Here is what that does to an autoscaling cluster:

1. You run 40 nodes all month
2. A load test keeps 100 nodes up during 8 hourly readings → you pay for 40 hosts
3. It shows up in a ninth reading → you pay for 100 hosts, for the whole month

Rule: 9 high readings set the price of the other 711.

The 8 readings are a budget for the whole month, and a test that starts mid-hour uses an extra one.

Datadog drops the top 1% of the 720 hourly readings. A ninth high reading sets the host count for the month.

What counts as a host: a server, a VM, a Kubernetes node, an Azure App Service Plan instance or a Heroku dyno. A VM seen by both the Agent and the cloud integration counts once.

If your fleet scales up and down every day, ask for the hybrid monthly/hourly plan. You commit to a monthly minimum and pay an hourly rate for host hours above it.

The same hourly counting applies to APM hosts and database hosts. (Yes, one long load test can raise the host line, the APM line and the container line.)

If you autoscale on Kubernetes, the settings that decide how long extra nodes stay up are in my guide on Kubernetes autoscaling without cost surprises.

Containers and custom metrics come with the host, up to a limit

Each Infrastructure host includes an allotment of other products:

The allotments are pooled across the account. 50 Pro hosts include 250 containers and 5,000 custom metrics, wherever they run.

A Kubernetes node that runs 20 containers uses 4 hosts' worth of the container allotment.

The on-demand container rate looks small: $0.002 an hour is $1.46 over a 730 hour month, 46% more than the prepaid $1.

Kubernetes pause containers are excluded from the count.

One mistake to avoid: installing the Agent inside every container. Datadog then bills each container as a host.

Run 1 containerized Agent per node.

Custom metrics multiply with every tag

This is the line that is hardest to predict.

A custom metric is any metric that does not come from a Datadog integration: everything you send through DogStatsD, a custom check or a log-based metric.

Datadog counts tag combinations, and 1 metric name can hold thousands of them:

1 custom metric = 1 metric name + 1 unique combination of tag values (the host tag included).

Take a metric named checkout.latency with 3 tags:

• endpoint: 20 values
• status: 3 values
• pod: 50 values

If every combination reports, that is 20 x 3 x 50 = 3,000 custom metrics.

The metric type multiplies it again:

One metric name, one line of code, $1,500 a month.

1 metric name with 3 tags becomes 3,000 custom metrics, and 30,000 as a distribution with percentiles.

Now add a customer_id tag with 200 values and multiply the table by up to 200.

Two details work in your favor:

• Only combinations that actually report are counted, and the count follows your most detailed tag
• Billing uses the monthly average of the hourly count, so a 1 hour burst of new tag values costs 1/720 of a full month

How do you get the tags back under control without changing code? Metrics without Limits.

It lets you pick, per metric, which tags stay queryable. Datadog then bills two volumes:

• Indexed custom metrics: the combinations of the tags you kept, at the $5 per 100 list price
• Ingested custom metrics: everything your code still sends for the metrics you configured, at $0.10 per 100 above the allotment

Keeping only endpoint and status on checkout.latency takes it from 3,000 indexed combinations to 60.

Logs are billed twice: once to ingest, once to index

Every log you send pays $0.10 per GB at ingestion.

Every log you keep searchable pays again, per million events, by retention:

Ingestion is cheap. Indexing is the bill.

500 GB of logs costs $50 to ingest. The same logs, as 300 million events indexed for 15 days, cost $510.

That split is also the way out: you can ingest everything and index a part of it.

An exclusion filter on an index drops matching logs before they are indexed. The excluded logs still show in Live Tail, can still feed log-based metrics and can still go to your archive.

Every log pays for ingestion. Only the logs that pass the exclusion filters pay for indexing.

The two filters I would add first:

status:DEBUG exclude 100% source:nginx AND http.status_code:[200 TO 299] exclude 95% 

The first one can be switched off from the UI or the API during an incident, when you want the debug logs back.

The second keeps every 3xx, 4xx and 5xx request and 5% of the successful ones, which is enough to see the trend.

Two more log facts for your budget:

• Indexed logs above your commitment are billed on-demand, at a 50% premium ($2.55 against $1.70)
• Each index can have a daily quota. When a service starts logging at debug level in production, indexing stops at the quota. The logs still reach Live Tail and your archive, and you still pay the $0.10 per GB

For logs you must keep for months but rarely read, Flex Logs stores them at $0.05 per million events per month, with query capacity bought separately.

APM adds a second host price, with spans included

An APM host is any host that sends traces. It costs $31 a month on top of the Infrastructure price.

Each APM host includes:

• 150 GB of ingested spans a month
• 1 million indexed spans a month, kept for 15 days

Above that: $0.10 per ingested GB, and $1.70 per million indexed spans at 15-day retention.

Both allotments are pooled across your APM hosts.

50 APM hosts include 7,500 GB of ingested spans and 50 million indexed spans a month. The host count is the easier place to overpay: tracing left on for hosts that run batch jobs and internal tools nobody traces.

Only hosts that send traces are APM hosts. A node pool for untraced workloads is $31 a month saved per node.

If you do pass the allotment, set sampling per service in the tracing library:

export DD_TRACE_SAMPLING_RULES='[ {"service": "checkout", "resource": "GET /checkout", "sample_rate": 1}, {"service": "checkout", "sample_rate": 0.2} ]' 

This keeps every trace that starts at GET /checkout and 20% of the other traces that start in the service.

Resource rules need a recent Java, Python, Go or PHP tracer. Other languages take the per-service rule only.

Retention filters then decide which ingested spans are indexed.

The Intelligent Retention Filter keeps a sample of errors and slow traces at no charge, so start by trimming your custom filters and the rate of the Error Default one.

A worked Datadog bill for 50 hosts

The setup, with my assumptions stated:

• 50 Kubernetes nodes, Infrastructure Pro, billed annually
• APM on all 50 nodes, spans inside the allotment
• 1,000 containers on average (20 per node)
• 20,000 custom metrics
• 500 GB of logs a month, 300 million events, all indexed for 15 days

$4,360 a month is $52,320 a year.

The line everyone quotes ($15 per host) is $750 of it: 17%.

The 50 host bill at list price. The $15 per host line is 17% of it.

The same usage with no commitment, at on-demand rates, comes to $5,360 a month. That is 23% more for the same usage.

Now the same company after 3 changes:

$1,407 a month less: 32%.

These are list prices. Datadog lists volume discounts from 500 hosts a month, and a sales conversation changes the numbers long before that.

Commit to your baseline, pay on-demand for the rest

Datadog has 3 price columns: billed annually, month-to-month and on-demand.

Commitment = a quantity per product that you pay for whether you use it or not.

On-demand = everything above it, at the highest price.

The billing docs give the formula:

allotments + committed usage = included usage. Billable usage minus included usage = on-demand usage.

The premium depends on the product:

• Hosts: $18 against $15, 20% more
• Indexed logs and spans: $2.55 against $1.70, 50% more
• Containers: $1.46 against $1 over a full month, 46% more

So my rule is simple: commit to what you used in your quietest month, and let growth run on-demand until the next renewal.

Commit too low and you pay up to 50% extra on the difference (16% on APM hosts, 20% on hosts, 50% on indexed logs).

Commit too high and you pay 100% for something you never used.

Cut the bill in this order

Start where the money is. In the example above that is APM hosts, custom metrics and indexed logs.

1. Read the bill by product: Plan and Usage shows month-to-date and projected cost per product, and the top custom metric names by share of cost
2. Exclude logs you never search: debug logs, health checks and successful requests first
3. Shorten retention: 300 million events at 7 days cost $381 against $510 at 15 days. Send the rest to an archive in your own bucket
4. Set a daily quota on every index: a bad deploy then indexes 1 day's quota at most. Logs past the quota are not searchable, so add the warning threshold
5. Drop tags with Metrics without Limits: start with the 10 metric names at the top of the usage page. Datadog marks the tags queried in the last 30 days
6. Stop percentiles you do not graph: they double the count of a distribution metric
7. Turn tracing off where nobody reads traces: every host that sends traces is an APM host
8. Keep all spikes of the month inside 8 hourly readings, or move to the hourly plan: the high-water mark decides the month
9. Alert on your own usage: Datadog publishes it as metrics

The usage metrics for the last point:

datadog.estimated_usage.hosts datadog.estimated_usage.containers datadog.estimated_usage.metrics.custom datadog.estimated_usage.logs.ingested_bytes datadog.estimated_usage.logs.ingested_events datadog.estimated_usage.apm_hosts datadog.estimated_usage.apm.ingested_bytes datadog.estimated_usage.apm.indexed_spans 

Put an anomaly monitor on the log and custom metric ones. You then hear about a cost spike the same day it starts.

Filter logs.ingested_events by datadog_is_excluded:false to watch what gets indexed.

The same approach works on the cloud bill itself. I wrote it down in how to cut cloud costs without slowing teams.

Pay for Datadog when it saves an engineer

Yes, I help companies lower this bill. My first advice is to cut it before you leave it.

The alternative to Datadog is usually Prometheus, Grafana, Loki and an OpenTelemetry Collector that somebody on your team runs.

The license is free. The engineer is the cost.

My position:

• Up to about 20 engineers: buy it. $4,000 a month is cheaper than the part of an engineer that a self-hosted stack takes
• When the bill passes the cost of an engineer: cut it with the list above before you think about leaving
• When it is still too high after that: move the most expensive signal first (often logs) and keep the rest

The exceptions: if you already run Prometheus well, or you are bound to keep data in your own account, start self-hosted.

Instrument with OpenTelemetry either way. Datadog accepts it, and it keeps the exit open.

Check how your OTLP metrics are billed first: metrics outside a Datadog integration count as custom metrics.

I compare the two paths in how to build a startup observability stack.

The Datadog cost checklist

Always:

• 1 Agent per node
• A commitment equal to your quietest month
• Exclusion filters on debug logs and successful requests
• A daily quota on every log index
• The shortest index retention your on-call needs, and an archive for the rest
• No user, customer or request ID as a metric tag
• Percentiles only on metrics that have a graph or a monitor
• Tracing only on hosts where somebody reads traces
• Monitors on the datadog.estimated_usage metrics
• A look at the projected cost on the 10th of every month

FAQ

How does Datadog pricing work?

Each Datadog product has its own unit and price. Infrastructure Monitoring and APM are priced per host per month, logs per GB ingested and per million events indexed, custom metrics per 100, and Synthetics and RUM per test run and per session. You commit to a quantity per product and pay a higher on-demand rate above it.

How much does Datadog cost per host?

Infrastructure Pro is $15 per host per month billed annually and $18 on-demand. Enterprise is $23 and $27. With APM at $31, a traced host costs $46 a month before containers, custom metrics and logs.

Why is Datadog so expensive?

The host price is a small part of the bill. Custom metrics multiply with every tag, logs are charged at ingestion and again at indexing, and hosts are billed on the busiest hours of the month. In the 50 host example above, the host line is 17% of $4,360.

Is Datadog free?

Partly. Datadog has a free trial, and when it ends you can move to the Free tier: up to 5 Basic hosts with 1-day metric retention, at no cost. Container monitoring is listed from the Pro plan, at $15 per host.

How are Datadog custom metrics billed?

By the number of unique combinations of metric name and tag values, averaged per hour over the month. Pro includes 100 per host and Enterprise 200. Above that the list price is $5 per 100 a month, and a histogram or distribution counts 5 times per combination.

How much do Datadog logs cost?

$0.10 per GB ingested, plus $1.06 to $2.50 per million indexed events depending on retention (3 to 30 days, billed annually). Indexed logs above your commitment cost 50% more. Exclusion filters lower the indexing part, which is the larger one.

Does Datadog charge per user?

Infrastructure Monitoring, APM and Log Management have no per-user fee. The price list has per-seat prices for On-Call and Incident Management, and per-committer prices for CI and code security products.

What is the high-water mark in Datadog billing?

Datadog counts hosts every hour, drops the top 1% of hours and bills the highest remaining count. In a 30 day month that is the ninth highest hourly reading. Scale-ups that touch 8 hourly readings or fewer in the month do not raise the host count. A ninth sets it for the month.

How do I reduce my Datadog bill?

Exclude logs you never search, shorten index retention, drop unused metric tags with Metrics without Limits and turn tracing off on hosts nobody traces. Then commit to your baseline usage. In the example above these steps cut the bill by 32%.

A recap

If you take away 1 thing from this, let it be this:

Your tags, your log filters and your busiest 9 hours set the Datadog bill.

You don't NEED a consultant to fix it. The checklist above is the whole method, and a senior engineer can run it.

If you'd rather have someone who has done it before look at your setup, book a free production setup consultation.

P.S. Before you delete a metric or a log, check that no SLO depends on it. I covered those in SLO vs SLA vs SLI.