Datadog custom metrics cost: How high-cardinality tags multiply your bill

Datadog counts each unique combination of metric name and tag values as a separate custom metric, so one tag that varies per user, request or pod can turn a single metric into thousands of billable custom metrics. Datadog bills on the average number of those combinations reporting each hour across the month, not on how often you send them (Datadog custom metrics billing docs, checked November 2026).

Why is my Datadog custom metrics bill so high?

You’re not paying for how often a metric is sent. You’re paying for how many unique combinations of metric name and tag values exist. Datadog treats http.server.requests{path:/api/v1/users/12345} and http.server.requests{path:/api/v1/users/12346} as two distinct custom metrics.

If your application tags every request with a unique user ID, request ID, or full URL path, each variation counts as a new billable metric. A metric with 50,000 unique user IDs becomes 50,000 custom metrics. That’s not an error, it’s how the billing model works.

Tags multiply. Take a metric with method (4 values) and status (10 values) reporting from 20 hosts. It can produce up to 800 custom metrics, because Datadog counts host as a tag and bills every combination that actually reports. Add a user_id tag with 50,000 values and the ceiling moves into the tens of millions.

Distributions cost more. Datadog counts each tag combination on a distribution metric as five custom metrics (count, sum, min, max, avg), and as five more if you enable percentiles.

How do I find high-cardinality tags in Datadog?

Start with Plan & Usage > Usage in your organization settings and open the Custom Metrics tab. Datadog lists your top custom metrics by average hourly count for the month. Those names drive the line item.

Then open Metrics > Summary, search for each metric from that list, and sort by volume. Click a metric to see its count of distinct tag combinations and how many values each tag key has. A key with thousands of values on a metric near the top of the Usage list is your first target.

Run this query in Datadog’s Metrics Explorer to surface metrics with the highest cardinality:

top(sum:datadog.estimated_usage.metrics.custom.by_metric{*} by {metric_name}, 10, 'mean', 'desc')

To check one metric from a script, use the v2 volumes endpoint. It returns the metric's indexed volume, and its ingested volume once Metrics without Limits is configured. Set DD_SITE to your Datadog site, such as datadoghq.eu or us5.datadoghq.com:

curl -s "https://api.${DD_SITE:-datadoghq.com}/api/v2/metrics/http.server.requests/volumes" \
  -H "DD-API-KEY: ${DD_API_KEY}" \
  -H "DD-APPLICATION-KEY: ${DD_APP_KEY}"

Run it for each name in your top ten and record the numbers. That is your baseline for measuring the fix.

Check your own bill in 2 minutes: https://revelations.consulting/checker?utm_source=blog&utm_medium=organic&utm_content=blog-datadog-custom-metrics-cost

How do I cut Datadog custom metrics costs without breaking anything?

Fix the tag at the source first. Replace raw paths with the route template your framework already knows: route:/api/v1/users/:id instead of path:/api/v1/users/12345. Move user_id and request_id to traces or logs, where per-request detail belongs.

Then use Metrics without Limits for what's left. Metrics without Limits lets you choose which tag keys Datadog indexes for a metric, and queries aggregate across the rest. Indexed custom metrics are billed on the tags you keep, and Datadog bills ingested custom metrics as a separate line item. Read both lines on the pricing page before you count savings.

Set the tag allowlist in Metrics > Summary: open the metric and choose Manage Tags. Through the API, this call keeps five tag keys on http.server.requests and stops indexing the rest. If the metric already has a tag configuration, send PATCH instead of POST and drop metric_type from the attributes, because the update call doesn't accept it. Set metric_type to match the metric (gauge, count, rate or distribution):

curl -X POST "https://api.${DD_SITE:-datadoghq.com}/api/v2/metrics/http.server.requests/tags" \
  -H "DD-API-KEY: ${DD_API_KEY}" \
  -H "DD-APPLICATION-KEY: ${DD_APP_KEY}" \
  -H "Content-Type: application/json" \
  -d '{"data":{"type":"manage_tags","id":"http.server.requests","attributes":{"metric_type":"count","tags":["method","status","route","service","env"]}}}'

Before you stop indexing a tag, find everything that queries it. In Metrics > Summary, open the metric and check Related Assets for the dashboards, monitors, notebooks and SLOs that use it. When you configure tags in Metrics without Limits, Datadog also shows which tags were queried in the last 30 days. Keep those tags until you've rewritten the queries.

A monitor that filters or groups by a tag you stop indexing returns no data. Unless the monitor notifies on missing data, it goes quiet instead of failing. For example, avg(last_5m):sum:http.server.requests{path:/api/v1/users/12345}.as_count() > 100 stops alerting. Rewrite it against the low-cardinality tag first, as avg(last_5m):sum:http.server.requests{route:/api/v1/users/:id}.as_count() > 100, then change the tag configuration.

Change one metric at a time and save the old tag list so you can restore it. Plan as if data for an excluded tag is gone for the period the tag was excluded.

What it usually looks like

The pattern to check for is one or two metric names holding most of your custom metric count. Each one usually carries a tag that maps one-to-one to something short-lived: user_id, request_id, container_id, pod_name or an unbounded URL path. Look for these shapes in your own account:

  • http.server.requests{path:/api/v1/users/12345}: one series per user ID in the path, growing with your user base
  • checkout.latency{request_id:...}: one series per request, so the count tracks traffic
  • queue.depth{pod_name:worker-7d8c9f4b5f-2x9wq}: a new set of series on every deploy, restart and autoscaling event
  • cache.hits{container_id:...}: the same churn as pod_name, one level lower

Many of these tags arrive without anyone writing them into the code. The Agent adds container and pod tags to your DogStatsD metrics based on DD_DOGSTATSD_TAG_CARDINALITY, and to check metrics based on DD_CHECKS_TAG_CARDINALITY. The default is low; orchestrator adds pod_name and high adds container_id. Prometheus and OpenMetrics scrapes carry every label the exporter emits.

Standard metrics from Datadog's built-in Kubernetes integration aren't billed as custom metrics, so pod_name on those isn't the problem. pod_name on your own metrics is.

I cut a ~$1M/yr cloud bill by 26% at a former employer. Observability tools bill outside your cloud invoice, so check the Datadog line in the same pass as compute and storage.

Start with the Custom Metrics tab on the Usage page. Take the top three metrics and, for each, find the tag key with the most values. Fix that tag at the source, or stop indexing it with Metrics without Limits after you've checked what queries it.

Watch datadog.estimated_usage.metrics.custom for a few days to confirm the drop. The bill uses the hourly average across the month, so the invoice lags the change. You don't need to remove every high-cardinality tag, only the ones that cost the most and answer the fewest questions.

Book a free 30-minute consult and we'll look at where your custom metric count comes from: https://revelations.consulting/?utm_source=blog&utm_medium=organic&utm_content=blog-datadog-custom-metrics-cost#contact

Run your own numbers: Custom Metrics Cardinality Estimator.

Frequently asked questions

What is a custom metric in Datadog?

A custom metric in Datadog is any metric that doesn't come from one of Datadog's standard integrations: DogStatsD metrics from your code, custom Agent checks, Prometheus or OpenMetrics scrapes, API submissions, and metrics generated from logs or spans. Each unique combination of metric name and tag values counts as one custom metric for billing, regardless of how often it's sent.

How does Datadog charge for custom metrics?

Datadog bills custom metrics on the average number of distinct custom metrics reporting each hour across the month, where each unique combination of metric name and tag values is one custom metric. Each plan includes a per-host allotment of custom metrics, pooled across the account, and Datadog bills usage above the pool at the rate on its pricing page (https://www.datadoghq.com/pricing/, checked November 2026). Sending a metric once a minute or once a second doesn't change the count.

Which tags are most likely to inflate my Datadog bill?

User ID, request ID, container ID, pod name, instance ID and unbounded URL paths are the tags that most often inflate a Datadog custom metrics bill. Each value of these tags is unique or short-lived, and Datadog bills every tag combination that reports, so one such tag can multiply a metric's billable count by thousands.

Can I still monitor per-pod performance without paying for pod_name?

Yes. Per-pod CPU and memory metrics from Datadog's Kubernetes integration are standard metrics and aren't billed as custom metrics, so use those for per-pod views. On your own custom metrics, tag by kube_deployment or service instead of pod_name, or stop indexing pod_name with Metrics without Limits.

Does turning off a monitor reduce my custom metrics cost?

No. Datadog monitors query metrics but don't create them, so the custom metrics bill comes from the metrics being sent. Deleting a monitor only lowers the bill if you also stop sending, or stop indexing, the high-cardinality metric behind it.

Run the numbers on your own bill: How many custom metrics does one metric create?. Free, in your browser.

Want this kind of thing weekly? Get Cloud Bill Weekly. Want us to find it in your bill? We're taking three founding clients for a free Cost Assessment.