01 · The model
+How Dynatrace pricing works
+ +Dynatrace pricing is pay-as-you-use against a yearly minimum. You agree to spend at least a set amount each year, and everything you monitor is metered by the hour or by the gigabyte and taken out of that amount.
++ 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: +
+ +Monitored hosts, pods and containers, billed per hour in 15-minute intervals.
+Logs, traces, metrics and events, billed per GiB or data point to ingest, retain and query.
+Real-user sessions and synthetic checks, billed per session, action or request.
++ 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
+Ask sales before you sign
+-
+
- The minimum commitment. No dollar amount appears on the pricing page, the FAQ or the licensing docs. +
- The discount schedule. The FAQ says the unit price drops as the commitment rises, without tiers or percentages. +
- Unused commitment. Neither the docs nor the FAQ say whether it expires or carries over at the end of a period. +
02 · List prices
+The Dynatrace rate card
++ These are the public list prices in USD from dynatrace.com/pricing/rate-card, last verified {verified}. Your contract rate card can be lower. Monthly figures assume {HOURS} hours, an average month; the pricing page rounds the same prices to $58, $29 and $7. +
+ +| Meter | Capability | List price | In practice |
|---|---|---|---|
| {meters[r.meter].name} | +{r.capability} | +{r.price} | +{r.month ?? ""} | +
+ 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. +
+ +| Line | Calculation | Per month |
|---|---|---|
| {b.line} | +{b.calc} | +{usd(b.amount)} | +
| Total at list price | {usd(billTotal * 12)} a year | {usd(billTotal)} a month |
+ 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
+{title}
{body}
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:
+
collector.yaml
+
+ 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 {verified}; the New Relic pricing guide covers its model in detail. +
+ +| Dynatrace | New Relic | |
|---|---|---|
| Hosts | $0.01 per GiB-hour (Full-Stack), $0.04 per host-hour (Infrastructure) | No host charge on the default model; compute-based pricing is quoted by sales |
| Data | Logs and traces $0.20 per GiB, plus retain and query | 100 GB a month free, then $0.40 per GB (or $0.60 with Data Plus) |
| Users | No per-seat fees | Per user per month: core $49; full platform on Standard $10 for the first user, then $99 each (5 users at most); Pro $349 on an annual commitment |
| Free option | 15-day trial | Free tier with one full platform user |
| Commitment | Minimum annual spend, amount not published | Standard is monthly pay-as-you-go |
+ 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:
+
collector.yaml (additions)
++ After a few days, compare the GB each signal sent to Maple with Dynatrace's consumption for the same traffic in Account Management. +
+ +Try it with your own telemetry
+Point an OpenTelemetry exporter at Maple
+The ingest reference covers endpoints, keys and compression. The host docs cover infrastructure metrics through the Collector.
+ +Sources, last verified {verified}
+-
+
- Dynatrace: Pricing +
- Dynatrace: Rate card (list price, USD) +
- Dynatrace: Pricing FAQ +
- Dynatrace: Try it free +
- Dynatrace docs: DPS key concepts +
- Dynatrace docs: DPS FAQ +
- Dynatrace docs: Full-Stack Monitoring consumption +
- Dynatrace docs: Infrastructure Monitoring consumption +
- Dynatrace docs: Log Analytics consumption +
- Dynatrace docs: OTLP API +
- Dynatrace docs: Collector configuration +
- New Relic: Pricing +
- Maple docs: Ingest API +