Post

Paid & Enterprise Observability Platforms Compared: Pricing, Signals & Fit

Compare 29 paid & enterprise observability platforms on pricing models, signals (logs, metrics, traces), free tiers, and hidden cost traps in 2026.

Paid & Enterprise Observability Platforms Compared: Pricing, Signals & Fit

Open-source platforms cover a lot of ground, but many teams still buy a managed commercial platform to eliminate backend operational overhead. When evaluating paid observability platform pricing, a direct “$/month” comparison is almost meaningless without knowing what is being metered — hosts, ingested GB, events, data points, active metric series, users, or compute credits.

This post provides a comprehensive enterprise observability pricing comparison across 29 commercial platforms supporting logs, metrics, and traces. The unified table below acts as the canonical benchmark: comparing signal coverage, primary pricing meters, public list pricing structures, trial/free tier access, and official vendor documentation. Detailed notes expose the most common pricing traps. For self-hosted alternatives, see our companion open-source observability platform comparison and hands-on benchmark study measuring real hardware and ingestion costs.

Pricing changes often. All figures reflect public list prices as of September 2026, sourced directly from vendor pricing cards. Committed-use contracts are typically negotiable and lower. Always verify directly on vendor sites before finalizing infrastructure budgets.

TL;DR: Quick Recommendations

Use caseBest fitWhy
Broadest feature set, deep integrationsDatadogWidest module catalog; metered per dimension
Predictable, ingest-based billNew RelicOne meter (GB ingested) + per-seat users
Deepest automatic full-stack + AIDynatraceOneAgent auto-discovery, Davis AI
Streaming metrics at scaleSplunk ObservabilityReal-time SignalFx-based analytics
Prometheus/OTel-native, PAYGGrafana CloudLGTM stack managed, generous free tier
Search + logs heritageElastic CloudResource- or ingest-based, OTel-native
High-cardinality wide eventsHoneycombEvent-based pricing, cardinality is free
Cost-controlled metrics at huge scaleChronosphereControl plane trims data before you pay
Cheapest usage-based, OTel-firstSigNoz Cloud$0.30/GB, no per-host/per-user fees

The questions that matter when buying:

  • What exactly is metered, and can one noisy service blow up the bill?
  • Are logs, metrics, and traces billed on the same meter or separately?
  • Do I pay per user/seat on top of data?
  • Is there a usable free tier, and where’s the enterprise-feature boundary?

Table of Contents


Selection Criteria

CriterionRequirement
SignalsSupports logs + metrics + traces (all, or a strong minimum of two with the third available)
DeliveryCommercial SaaS / managed (paid) — self-managed enterprise editions noted where relevant
OTel supportAccepts OpenTelemetry (OTLP)
ScopeGeneral-purpose observability, not single-signal only

Excluded: single-signal-only tools, pure SIEM, and free-only OSS (covered in our open-source platform comparison, or dedicated guides for open-source logging, metrics & TSDBs, and distributed tracing).


The Candidates: Unified Comparison

Reading the table: ✅ = clearly supported, ◐ = partial/newer/available through an integration, — = not a focus. Prices are current public list prices or starting prices where published; rows marked quote-based mean the vendor does not publish a usable rate card. “Free” means a continuing free tier; “Trial” means time-limited access.

PlatformLogsMetricsTraces / APMRUMOTLPPricing meterCurrent public pricing structureFree / trialOfficial pricing or product page
Datadog✅✅✅✅✅Host + GB + product unitsInfrastructure from ~$15/host/mo; APM, logs, custom metrics, RUM and synthetics are separate metersFree up to 5 hostspricing
New Relic✅✅✅✅✅Data ingest + users or compute100 GB/mo free; paid plans combine data ingest with core/full-platform users or computeFree tierpricing
Dynatrace✅✅✅✅✅Hourly consumptionFoundation $7/host/mo; Infrastructure $29/host/mo; Full-Stack $58 per 8 GiB host/mo; logs from $0.20/GiB ingestTrialpricing
Splunk Observability Cloud✅✅✅✅✅Host bundleInfrastructure $15/host/mo; App & Infra $60; End-to-End $75, billed annually14-day trialpricing
Grafana Cloud✅✅✅✅✅Active series + GB + add-onsFree tier; Pro has a $19/mo platform fee plus usage; Enterprise customFree tierpricing
Elastic Cloud✅✅✅✅✅Resource-based or ingest/retentionHosted is resource-based; Serverless Observability is usage-based; self-managed is license/node basedTrialpricing
Sumo Logic✅✅✅◐✅Flex creditsProduct/data configuration is quoted at subscription; credits cover logs, metrics, traces and query/scan usageLimited free tierpricing
Honeycomb◐✅✅—✅Events + metric data pointsFree and Pro tiers with event-volume limits; Enterprise is custom; Pro includes up to 3.75B metric points/moFree tierpricing
Chronosphere✅✅✅—✅Persisted datapoints or capacityContract/quote-based; consumption measures persisted metric datapoints and supports data shaping before storageDemoplatform
SigNoz Cloud✅✅✅—✅GB + metric samplesTeams starts at $49/mo including $49 usage; logs/traces $0.30/GB; metrics $0.10/million samples; Enterprise from $4,000/moTrial / self-hosted communitypricing
IBM Instana✅✅✅✅✅Managed virtual server hoursPay-per-use from $0.03 per MVS-hour; 14-day full-access trialTrialpricing
SolarWinds Observability SaaS✅✅✅✅✅Service + node + GB + checksApp $27.50/service/mo; infrastructure $15.75/node/mo; logs $5/GB/mo; RUM $10/100k page viewsTrialpricing
LogicMonitor (LM Envision)✅✅✅◐✅Monitored resourcesQuote-based; LM Envision is the current LogicMonitor platform and pricing is tied to monitored resourcesDemoplatform
Observe by Snowflake✅✅✅—✅Lakehouse compute + storageQuote/consumption-based; Snowflake credits can be applied, but no public unit rate is shownDemoproduct
Kloudfuse✅✅✅✅✅Fixed capacity in your cloudFlat-pricing, Self-SaaS/BYOC model; public per-unit price is not shown; no overage or per-seat feesDemoproduct
Coralogix✅✅✅✅✅GB by signal + AI tokensLogs $0.42/GB; traces $0.16/GB; metrics $0.06/GB; AI $1.50/million tokens; features, users and hosts includedNo public free tier shownpricing
Sematext Cloud✅✅✅✅✅Per app/host/GBLogs from $4.50/mo; infrastructure $2.80/mo; tracing $19/mo; 14-day trial; usage depends on hosts, containers, data and retention14-day trialpricing
ManageEngine Site24x7✅✅✅✅◐Monitor bundles + add-onsPlans start at $9/mo; fixed monitor allocations, with APM, logs, RUM and other capabilities sold in packs/add-ons30-day trialpricing
Apica Observe (Ascent)✅✅✅—✅Quote / telemetry capacityQuote-based; Ascent combines collection, shaping, storage and observability, positioning pipeline optimization as the cost leverDemoproduct
ScienceLogic AI Platform✅✅◐—✅Managed devicesSkylar One from $5/device/mo; Advanced from $6; Compliance from $12; HA from $20; Analytics/Advisor quoteTrial / demopricing
BMC Helix Observability & AIOps✅✅✅—✅Enterprise capacity / quotePublic product page describes usage across events, metrics, logs and topology; no public rate cardDemoproduct
Splunk AppDynamics✅✅✅✅✅Enterprise license / quoteQuote-based business-transaction and application observability licensing; separate from Splunk Observability CloudDemoproduct
groundcover✅✅✅◐✅Average monitored nodesFree; Pro $30/host/mo; Enterprise $35/host/mo; On-Prem $50/host/mo; averages monitored Kubernetes/Linux hostsFree tierpricing
Metoro✅✅✅—✅Kubernetes nodes$20/node/mo; Hobby is free up to 2 nodes; AI SRE model usage passed through at costFree up to 2 nodespricing
Edge Delta✅✅✅—✅AI teammates + creditsHobby free; Pro $20/mo including $20 credits; Custom for retention, private deployment, scale and supportFree tierpricing
Managed ClickStack✅✅✅◐ session✅ClickHouse compute + storageNo event/host/user meter; pay for ClickHouse Cloud compute, storage, transfer and pipelines; 30-day trial with $300 creditsTrialpricing model · billing
OpenObserve Cloud✅✅✅✅✅GB ingested + GB queried$0.50/GB ingested + $0.01/GB queried; retention included; Enterprise custom; annual plans include 30% ingestion discount14-day trialpricing
Sentry◐◐✅◐ replay✅Errors + spans + replays + logsDeveloper free; Team $26/mo; Business $80/mo; 50k errors/mo included on paid plans, then usage-based overagesFree tierpricing
Better Stack✅✅◐◐✅Retained GB + product tiersMetrics: 30 GB/mo free, then $0.50/GB EU or $0.75/GB US; logs/traces/uptime billed by product usageFree tierpricing · metrics billing

The table intentionally combines breadth and cost. For detailed trade-offs, continue to Observability Pricing Models at a Glance and the per-tool notes.


Observability Pricing Models at a Glance

graph TB
    subgraph "Host / node-based"
        DD[Datadog<br/>per host + modules]
        SP[Splunk Obs<br/>per host]
        IN[Instana<br/>MVS-hour]
        GCV[groundcover<br/>per node BYOC]
        MT[Metoro<br/>per node K8s]
        LM[LogicMonitor<br/>per resource]
        SL2[ScienceLogic<br/>per device]
        BM[BMC Helix<br/>capacity quote]
    end
    subgraph "Ingest / volume-based"
        NR[New Relic<br/>per GB ingested]
        SN[SigNoz<br/>per GB + samples]
        SL[Sumo Logic<br/>Flex credits]
        EL[Elastic Cloud<br/>resource / ingest]
        CX[Coralogix<br/>per GB tiered]
        SX[Sematext<br/>per GB / host]
        OO[OpenObserve<br/>per GB]
        S24[Site24x7<br/>per-monitor]
    end
    subgraph "Consumption / hourly"
        DT[Dynatrace<br/>GiB-hour]
        OB[Observe<br/>compute+storage]
        MC[Managed ClickStack<br/>compute+storage]
    end
    subgraph "Signal / event-metered"
        GC[Grafana Cloud<br/>series + GB]
        CH[Chronosphere<br/>datapoints]
        HC[Honeycomb<br/>events]
        SE[Sentry<br/>events]
        BS[Better Stack<br/>volume + uptime]
    end
    subgraph "Flat / pipeline / quote"
        KF[Kloudfuse<br/>in-VPC flat]
        ED[Edge Delta<br/>pipeline + storage]
        AP[Apica<br/>pipeline + storage]
        SW[SolarWinds<br/>entity bundle]
        AD[Splunk AppD<br/>per agent/core]
    end
ModelPlatformsWatch out for
Per host / node / deviceDatadog, Splunk Observability, groundcover, Metoro, LogicMonitor, ScienceLogicEphemeral fleets inflate counts; groundcover and Metoro average monitored nodes
Per managed-server hourIBM InstanaUsage tracks managed virtual server hours rather than a simple host count
Per GB ingestedNew Relic, SigNoz, Elastic (serverless), Coralogix, Sematext, OpenObserveLog-heavy apps drive most of the bill
Per event / datapointHoneycomb, Chronosphere, SentrySampling and cardinality strategy matter
Per series + per GBGrafana Cloud, Better StackActive metric series / mixed meters can surprise you
Credits (ingest + scan)Sumo LogicQueries/dashboards burn credits, not just ingest
Compute + storageManaged ClickStack, Observe by SnowflakeModel warehouse/cluster compute, not events or hosts
Hourly consumptionDynatraceFull-stack billed on host RAM (GiB), min per host
Per-monitor bundleSite24x7Fixed monitor counts per plan; overages as add-ons
Pipeline + storageEdge Delta, ApicaPipeline may be free; you pay on stored/optimized data
Flat / in-VPC / quoteKloudfuse, BMC Helix, SolarWinds, Splunk AppDynamicsEnterprise contracts; get a quote and model your own scale
Per user / seatNew Relic (+ any with seat tiers)Seats stack on top of data costs

Per-Tool Pricing Detail

These deep dives cover the 10 platforms that anchor the main pricing models. The other 19 are in the unified table above with their link, meter, and pricing structure. All rates are list prices, September 2026, usually billed annually. Monthly/on-demand rates run higher.

Datadog

  • Link: https://www.datadoghq.com/pricing/
  • Model: Modular, metered independently per product.
  • Short structure:
    • Infrastructure: ~$15/host/mo (Pro), ~$23/host/mo (Enterprise)
    • APM: ~$31–$40/host/mo
    • Log Management: ~$0.10/GB ingested + ~$1.70 per million events indexed (15-day retention)
    • Custom metrics, RUM, Synthetics billed separately
    • Free tier: up to 5 hosts
  • Gotcha: independent meters compound. Real bills often land 2–3× initial estimates once logs, APM, and custom metrics stack up. Datadog docs — pricing

New Relic

  • Link: https://newrelic.com/pricing
  • Model: Data ingest + per-user, no per-host charge.
  • Short structure:
    • 100 GB/mo free ingest + 1 full-platform user, forever
    • Data: ~$0.40/GB beyond free (Original) or ~$0.60/GB (Data Plus)
    • Users: per full-platform seat (roughly $99–$349/mo depending on edition); core/basic users cheaper or free
    • Editions: Free, Standard, Pro, Enterprise
  • Gotcha: bill = data + users + optional compute units; each scales independently. New Relic — data ingest billing

Dynatrace

  • Link: https://www.dynatrace.com/pricing/
  • Model: Hourly consumption drawn against a platform commitment (DPS).
  • Short structure:
    • Full-Stack Monitoring: ~$0.08/hour per 8 GiB host (billed on RAM, ~$58/mo per 8 GiB host); min 4 GiB/host
    • Infrastructure Monitoring: ~$0.04/hour per host (~$29/mo)
    • Foundation & Discovery: from ~$7/mo per host
    • Logs: ~$0.20/GiB ingest; Real User Monitoring, Synthetics, etc. metered separately
  • Gotcha: full-stack cost scales with host RAM, not host count — a 16 GiB host costs 2× an 8 GiB host. Dynatrace rate card

Splunk Observability Cloud

  • Link: https://www.splunk.com/en_us/products/pricing/observability.html
  • Model: Per host, tiered by bundle; logs can add per-GB.
  • Short structure:
    • Infrastructure Monitoring: from ~$15/host/mo (annual)
    • App + Infrastructure: ~$60/host/mo
    • End-to-End (full observability): ~$75/host/mo
    • Trial: 14-day full access (up to 15 hosts / container pooling; no perpetual free tier)
    • Container allocation pooled (10/host Commercial, 20/host Enterprise)
  • Gotcha: flat per-host bundles are predictable but can cost more than metered rivals at low log volume, and less as logs explode. Splunk observability pricing FAQ

Grafana Cloud

  • Link: https://grafana.com/pricing/
  • Model: Per active series (metrics) + per GB (logs, traces), PAYG.
  • Short structure:
    • Free: 10k metric series, 50 GB logs, 50 GB traces, 14-day retention
    • Pro: from ~$19/mo platform fee + usage
      • Metrics: ~$6.50 per 1,000 active series
      • Logs/traces: ~$0.40/GB write (+ ~$0.10/GB/mo retention)
    • Advanced/Enterprise adds SSO, support SLAs, more meters (profiles, k6, frontend)
  • Gotcha: many meters (metrics, logs, traces, profiles, synthetics, frontend, users). Active-series count is the usual surprise. Grafana Cloud contract pricing terms

Elastic Cloud

  • Link: https://www.elastic.co/pricing/
  • Model: Two paths — Hosted (resource-based) or Serverless (ingest + retention + egress).
  • Short structure:
    • Hosted: pay for compute/storage resources you provision (RAM, storage, zones)
    • Serverless Observability: per GB ingested + per GB retained/mo + egress (50 GB egress free, then ~$0.05/GB)
    • Metrics (TSDS) priced at ~25% of standard per-GB rates (effective July 2026)
    • Self-managed Elastic remains an option (AGPL core)
  • Gotcha: hosted vs serverless are different mental models; pick before you estimate. Elastic serverless observability pricing

Sumo Logic

  • Link: https://www.sumologic.com/pricing
  • Model: Product configuration plus Flex credits; usage is allocated across observability and security products.
  • Short structure:
    • Plans include Free, Essentials, Enterprise Operations, Enterprise Security and Enterprise Suite
    • Sumo quotes the activated products and data volume at subscription time; current public page does not show a universal per-credit rate
    • Free accounts have limited daily credits, users and retention; confirm current limits before budgeting
  • Gotcha: query/scan behavior and activated products affect the quote, not just ingestion. Sumo Logic Flex accounts

Honeycomb

  • Link: https://honeycomb.io/pricing
  • Model: Event volume plus metric data points.
  • Short structure:
    • Free and Pro plans are available; the pricing page currently presents usage limits rather than a universal per-event list rate
    • Free includes Honeycomb Metrics up to 100M data points/month; Pro supports up to 3.75B data points/month
    • Enterprise is custom and adds larger event volumes, SLOs, service maps, private connectivity and support
  • Gotcha: high-cardinality fields are central to the product, but event volume still needs sampling and retention controls. Honeycomb pricing

Chronosphere

  • Link: https://chronosphere.io/platform/
  • Model: Consumption (per persisted metric datapoint) or capacity commitment.
  • Short structure:
    • Metrics billed per persisted datapoint; rate varies by effective datapoint resolution (EDR)
    • A Control Plane lets you aggregate/drop data before it’s persisted, so you pay for what matters
    • Pricing is quote-based (no public per-unit list price); logs and traces also supported
  • Gotcha: value is in cost control at massive metric scale (Kubernetes-heavy shops). Requires investment in shaping rules. Chronosphere consumption licensing

SigNoz Cloud

  • Link: https://signoz.io/pricing/
  • Model: Usage-based, no per-host or per-user fees.
  • Short structure:
    • Logs & traces: ~$0.30/GB ingested
    • Metrics: ~$0.10 per million samples
    • Teams plan starts at ~$49/mo (e.g. ~163 GB logs/traces or ~490M metric samples)
    • Self-hosted OSS (MIT core) remains free
  • Gotcha: cheapest metered option and OTel-first, but a younger platform than the incumbents — fewer turnkey integrations. SigNoz Cloud $49 plan

How to Compare Real Cost & Avoid Pricing Traps

A per-unit rate tells you little until you map it to your telemetry shape. Before comparing quotes:

  1. Measure your volumes — GB/day of logs, active metric series, spans/events per month, host count (including autoscaling peaks).
  2. Identify the dominant meter — for most teams, logs dominate (compare self-hosted storage in our open-source log management guide); for Kubernetes-heavy shops, metric cardinality does (see metrics engines compared).
  3. Add the hidden layers — per-user seats (New Relic, Datadog full-platform), APM host surcharges, trace retention penalties (see distributed tracing tools compared), continuous profiling fees (see continuous profiling tools compared), and indexing/scan fees.
  4. Model a spike — a product launch or incident can 3–5× ingest. Host-based (Splunk) and shaped (Chronosphere) models blunt this; pure per-GB/per-event models don’t (tip: simulate ingestion spikes in staging using a synthetic log generator).
  5. Check the enterprise boundary — SSO, RBAC, longer retention, and anomaly detection often sit behind higher tiers.

Rule of thumb: usage-based platforms (SigNoz, Grafana, New Relic) are cheapest at small/medium scale; shaped or committed models (Chronosphere, Dynatrace, Splunk) win when you can control or predict volume at large scale.


Frequently Asked Questions (FAQ)

Which paid platform is cheapest for a small team? For low volume and OTel-native pipelines, SigNoz Cloud ($0.30/GB, no seats) and Grafana Cloud (generous free tier, PAYG) are typically the least expensive. New Relic’s 100 GB/mo free tier is also strong for getting started.

Why do Datadog bills blow up? Independent per-dimension meters (hosts, APM hosts, log ingest, log indexing, custom metrics, RUM) compound. Teams frequently see 2–3× their estimate once every module is enabled.

Host-based or usage-based — which is safer? Host-based (Splunk, Datadog infra) is predictable if your fleet is stable, but punishes ephemeral/autoscaling workloads. Usage-based (per GB/event) tracks actual data but can spike during incidents. Match the model to your workload’s shape.

Do these support OpenTelemetry? Yes — all listed platforms accept OTLP. SigNoz, Honeycomb, Grafana Cloud, and Elastic are OTel-first; the incumbents (Datadog, New Relic, Dynatrace, Splunk) accept OTLP alongside their own agents.

Can I self-host any of these? Elastic (AGPL core), SigNoz (MIT core), Grafana (LGTM OSS), and Splunk Enterprise offer self-managed options. Dynatrace, Datadog, New Relic, Honeycomb, and Chronosphere are SaaS-first.

🧭 The Complete Observability Guide & Comparison Series


References

List prices as of September 2026. Verify on vendor sites before committing — observability pricing changes frequently.

This post is licensed under CC BY 4.0 by the author.