Dynatrace pricing, explained

01 · The model

How Dynatrace pricing works

The contract is the Dynatrace Platform Subscription (DPS). It includes every generally available capability, so there are no modules to buy, and it has no per-seat fees: every user gets the full platform. What you pay depends on three kinds of meter, and this guide colors each one the same way throughout:

Hourly billing means an autoscaled VM that runs for two hours costs two hours. A host monitored for part of a 15-minute interval is charged for the whole interval.

The annual commitment

The licensing docs define the annual commitment as the minimum you agree to spend each year. Contracts are typically 1 to 3 years, split into 12-month periods, and hosts, logs and sessions all draw from the same amount. Account Management shows consumption by capability with a forecast to the end of the period.

Going over is billed monthly at the same unit prices; Dynatrace says it never charges penalty-style overages. Committing to more lowers the unit price. If your usage at list price comes to less than the commitment, you still pay the commitment.

What Dynatrace doesn't publish

02 · List prices

The Dynatrace rate card

These are the public list prices in USD from dynatrace.com/pricing/rate-card, last verified 2026-10-20. Your contract rate card can be lower. Monthly figures assume 730 hours, an average month; the pricing page rounds the same prices to $58, $29 and $7.

The rate card also lists Mainframe Monitoring, application security, automation workflows ($0.03 per workflow-hour), data egress ($0.15 per GiB), AI units ($0.10 each) and the older "Classic" units. AI exploration inside Dynatrace is included at no charge.

Dynatrace cost per host

A host's monitoring mode sets both its price and its unit. Full-Stack adds APM, code-level profiling, Kubernetes monitoring and 10 days of traces, and is priced by the host's memory. Infrastructure covers process, disk, memory and network metrics at a flat price per host. Foundation & Discovery covers basic health, topology and log collection.

The Full-Stack unit has rules that change the arithmetic, from the Full-Stack billing docs:

• RAM is rounded up to the next 0.25 GiB, and hosts bill at least 4 GiB. Application-only containers have a 256 MiB minimum.
• Each GiB includes 900 custom metric data points per 15-minute interval. Infrastructure Monitoring includes 1,500 per host instead. Unused points don't carry over.
• Each GiB includes 200 KiB of trace data per minute, with a floor of 64,000 KiB per minute for environments under 320 GiB.

Kubernetes and containers

Kubernetes Platform Monitoring is $0.002 per pod-hour for any size pod. Pods on Full-Stack hosts are included in the host price when the node runs OneAgent 1.301 or newer. Pods on other hosts, and pods stuck in Pending, bill per pod-hour. Code Monitoring is a separate $0.005 per container-hour.

Logs, traces and metrics

Logs, traces and events each bill three times: ingest & process per GiB, retain per GiB-day and query per GiB scanned. Metrics bill per 100,000 data points ingested, with queries included and 15 months of retention.

Two details from the log billing docs affect estimates. Logs you filter out in Dynatrace's pipeline still bill ingest; they only skip retain. And processing can grow the stored volume by a factor of 2 or more over what arrived.

For retention you choose per log bucket. Pay-per-query stores at $0.0007 per GiB-day and charges every scan. Retain with included queries stores at $0.02 per GiB-day for a 10 to 35 day window, with a daily scan allowance of 15 times the volume retained in it.

RUM and synthetic

Real User Monitoring is $2.25 per 1,000 sessions, or $4.50 per 1,000 with a session replay, plus $0.0001 for each property attached to a session. Synthetic checks bill per run: an HTTP check every minute from one location makes 43,200 requests in 30 days, $43.20 a month. Every extra location adds the same again.

03 · Worked example

A worked monthly Dynatrace bill

A team runs six 16 GiB application hosts in Full-Stack and four utility hosts (databases, a queue, a bastion) in Infrastructure, around the clock. They ingest 10 GiB of logs a day and keep 30 days queryable. The site has 100,000 real-user sessions a month, and five HTTP endpoints are checked every five minutes from one location.

Traces and metrics cost nothing extra here, on two assumptions. The six Full-Stack hosts bring 96 GiB of included volume; under 320 GiB the trace floor of 64,000 KiB a minute applies, and OneAgent's sampling keeps the hosts roughly within it. Custom metrics have to stay within 92,400 data points per 15 minutes: 900 for each of the 96 GiB plus 1,500 for each Infrastructure host. The four Infrastructure hosts send no traces or code-level data. If the yearly total is below the contract minimum, the minimum is what you pay.

The retention choice

On pay-per-query retention the same 300 GiB costs $6.30 a month to store instead of $180. The $173.70 difference buys about 49,600 GiB of scans a month, roughly 1,650 GiB a day. Dashboards refreshing over 30 days of logs pass that quickly. A team that searches logs only during incidents may never reach it.

What moves the bill

04 · OpenTelemetry

What OpenTelemetry data costs on Dynatrace

Dynatrace ingests OTLP over HTTP with protobuf at https://<environment-id>.live.dynatrace.com/api/v2/otlp. It accepts no gRPC and no JSON, and it wants metrics in delta temporality. Whether the data is covered by a host's included volume depends on where it comes from.

Which traces are included

The included volumes assume telemetry enriched the way Dynatrace recommends (OneAgent, the Dynatrace Operator, or the enrichment steps in its docs). For custom OpenTelemetry deployments the docs say included-volume billing "may still work as described" but is not guaranteed. Metrics from an OpenTelemetry Collector count toward included data points only when the Collector adds Dynatrace's Kubernetes enrichment.

An all-OpenTelemetry setup with no OneAgent has no host charge and no included volume. Every span, log and data point then bills on the data meters.

Drop data in the Collector, before it's metered

Filtering inside Dynatrace still bills ingest, so drop records before they are sent. An OpenTelemetry Collector runs between your services and Dynatrace. This config receives OTLP on port 4318, drops logs below INFO, converts metrics to delta, and exports to Dynatrace with a platform token that has the OpenPipeline ingest scopes:

receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4318

processors:
  filter/drop-debug:
    error_mode: ignore
    logs:
      log_record:
        - severity_number < SEVERITY_NUMBER_INFO
  cumulative_to_delta:
    max_staleness: 25h

exporters:
  otlp_http/dynatrace:
    endpoint: "https://${env:DT_ENVIRONMENT_ID}.live.dynatrace.com/api/v2/otlp"
    headers:
      Authorization: "Bearer ${env:DT_PLATFORM_TOKEN}"

service:
  pipelines:
    traces:
      receivers: [otlp]
      exporters: [otlp_http/dynatrace]
    logs:
      receivers: [otlp]
      processors: [filter/drop-debug]
      exporters: [otlp_http/dynatrace]
    metrics/dynatrace:
      receivers: [otlp]
      processors: [cumulative_to_delta]
      exporters: [otlp_http/dynatrace]

The same filter processor can drop health-check spans or noisy metrics. Set DT_ENVIRONMENT_ID and DT_PLATFORM_TOKEN in the Collector's environment. The component names are the current spelling, tested on Collector contrib 0.163.1; older releases only know them as otlphttp and cumulativetodelta, which 0.163.1 also still accepts.

05 · Comparison

Dynatrace vs New Relic pricing

The two vendors meter different things. Dynatrace bills hosts by the hour and data by volume, with no seat fees. New Relic bills data by volume and people by seat, with no host meter. New Relic figures are from newrelic.com/pricing, last verified 2026-10-20; the New Relic pricing guide covers its model in detail.

For the fleet in the worked example, the Dynatrace bill stays the same whether five or fifty engineers log in. On New Relic the same team pays per full platform user, but adding hosts costs nothing beyond their data. Price both against your own host count, data volume and number of people who need full access.

06 · Maple

How Maple prices observability

Maple bills by data volume only. The Startup plan is $39 a month with 100 GB each of logs, traces and metrics, then $0.30 per GB per signal, with 30-day retention. Nothing is metered per host, seat or query, and a per-signal overage cap rejects new data for that signal once it is reached. Current numbers are on the pricing page.

Compare both on the same data

Maple ingests OTLP directly, so the Collector from section 04 can send to both during a trial. Add a second exporter with your Maple ingest key from Settings → Ingestion, add it to the traces and logs exporter lists, and add a metrics pipeline of its own. Maple's metrics pipeline skips cumulative_to_delta, so it gets the data as your services sent it:

exporters:
  otlp_http/maple:
    endpoint: "https://ingest.maple.dev"
    headers:
      Authorization: "Bearer ${env:MAPLE_INGEST_KEY}"

service:
  pipelines:
    traces:
      exporters: [otlp_http/dynatrace, otlp_http/maple]
    logs:
      exporters: [otlp_http/dynatrace, otlp_http/maple]
    metrics/maple:
      receivers: [otlp]
      exporters: [otlp_http/maple]

After a few days, compare the GB each signal sent to Maple with Dynatrace's consumption for the same traffic in Account Management.