Independently operated. Not affiliated with Datadog, New Relic, Grafana Labs, Dynatrace, Splunk, or Elastic. Pricing sourced from public pages and may not reflect current rates. Verify on each vendor's pricing page before purchasing.
MonitoringCost.comRun Calculator

Vendor

Grafana Cloud pricing 2026: an independent read

Verified April 2026

Grafana Cloud charges per active metric series, not per host. Cardinality is the bill, labels are the lever, and the free tier is the most generous in the market. Here is the math at three real-world scales.

TL;DR

Metrics: $8 per 1,000 active series above 10K free. Logs (Loki): $0.50/GB above 50 GB free. Traces (Tempo): $0.50/GB above 50 GB free. Pro seats: $8/user/mo (3 free). A 100-host team with disciplined Kubernetes labelling sits at $1K to $1.5K/mo. Cardinality explosion can push that to $10K+ on the same hosts.

The pricing model

Why active series, not per host

The active-series model is the most architecturally honest cost meter in the cloud monitoring market. Grafana Cloud charges based on the number of unique time series being actively reported, where a series is one metric name plus one specific combination of label values. This maps directly to the underlying Prometheus storage cost. The vendor pays for the storage and compute proportional to series count, the customer pays a margin on top of that. There is no per-host fiction, no per-GB fiction, just the actual cardinality being collected.

For customers running a clean monitoring stack, this model is genuinely cheap. A 10-host Kubernetes cluster with Prometheus-style metrics produces roughly 1,500 to 5,000 active series, comfortably inside the 10,000-series free tier. A 100-host cluster with disciplined labelling produces 30,000 to 60,000 series, billing $160 to $400 per month. The same workload on Datadog at $18 per host per month plus custom metric overages typically lands at $2,500 to $4,500 per month.

For customers who do not control cardinality, the same model is brutally expensive. A single metric with one label that has 100,000 unique values (a request path with high-cardinality user IDs in the URL, a Kubernetes container ID, a Kafka offset) creates 100,000 series. Multiply by ten hosts and you are at one million billable series, $7,920 per month, on a single misconfigured metric. The Datadog model would have absorbed the first hundred custom metrics per host for free and only charged overage above that.

The other meters work the way Prometheus operators expect. Loki indexes log labels rather than full text, which makes log storage roughly five to ten times cheaper than Splunk-style indexing on equivalent volumes. Tempo charges per gigabyte of trace data, with sampling expected at the source via OpenTelemetry collectors. Pyroscope (continuous profiling, integrated since the 2023 acquisition) charges per gigabyte. The bundle is structurally cheaper than per-host vendors at small to mid scale and structurally more expensive at high cardinality without discipline.

Every product line

The Grafana Cloud product matrix

Six bundled product lines, each with its own meter. Verified against grafana.com/pricing in April 2026.
ProductFree tierPaid (Pro)How it bills
Metrics (active series)10,000 series$8 per 1,000 series above freeCardinality drives cost, not host count
Logs (Loki)50 GB/month$0.50/GB above freeIndexes labels, not full text, much cheaper than Splunk-style indexing
Traces (Tempo)50 GB/month$0.50/GB above freeOpenTelemetry-native; sampling at the source recommended
Profiles (Pyroscope)50 GB/month$0.50/GB above freeContinuous profiling integrated since 2024
Syntheticsk6 100K virtual user hoursTiered above freek6 acquisition consolidated load testing into the platform
User seats3 users$8/user/mo (Pro)Editor and Admin seats; viewer seats free

Three scenarios

What real teams pay

List pricing only; negotiated and committed-use pricing typically reduces enterprise rates by 20 to 35 percent. Verify against the Grafana Cloud pricing page before purchasing.

Scenario

Startup, 10 hosts

  • Active series (10 hosts x ~150 series)1,500 series
  • Logs (10 GB/mo)0 GB billable
  • Traces (10 GB/mo)0 GB billable
  • Users (3 max)$0

Total: $0/month

10K active series, 50 GB logs, 50 GB traces and 3 users cover small Kubernetes clusters comfortably. Grafana's free tier is the most generous in the market for Prometheus-shaped stacks.

Scenario

Mid-market, 100 hosts + 50 GB/day logs

  • Active series (100 hosts x ~150 series + 200 custom each)35,000 series
  • Billable series (above 10K)25,000 series
  • Series cost (25K x $8/1,000)$200
  • Logs (1,500 GB/mo)1,450 GB billable
  • Logs cost (1,450 x $0.50)$725
  • Traces (200 GB/mo)$75
  • Pro user seats (~5 editors)$40

Total: ~$1,000 to $1,500/month

Cardinality is the main lever. A team that keeps Kubernetes labels disciplined can run 100 hosts for under $1,000.

Scenario

Enterprise, 1,000 hosts + 500 GB/day logs

  • Active series (~1.2M total)1.2M series
  • Series cost (1.19M x $8/1,000)$9,520
  • Logs (15,000 GB/mo)$7,475
  • Traces (2,000 GB/mo)$975
  • Pro user seats (~15 editors)$120

Total: ~$15,000 to $25,000/month list

Negotiated rates apply. Grafana Labs typically discounts heavily on annual commitments above $10K/month.

Where it bites

Three cardinality traps that blow up Grafana Cloud bills

The Kubernetes pod label

A single metric labelled with the Kubernetes pod name creates one series per pod restart per host. A deployment that rolls every two hours produces 12 pod identities per day per pod position. With 100 pods cycling, that single label adds 36,000 series per day, $9,600/month. Drop pod_id at the agent.

The high-cardinality status code

Engineers sometimes label HTTP status with the full string ("200 OK for /users/12345/profile"). Ten thousand unique paths times five status codes is 50,000 series per metric. Use status_code (the three-digit integer) and a separate path normaliser; recover 99 percent of the visibility at one percent of the series.

The third-party exporter without limits

Many community exporters (mysqld_exporter, kafka_exporter, nginx_vts_exporter) emit thousands of high-cardinality metrics by default. A single MySQL exporter on a busy database can produce 5,000 to 15,000 active series. Audit and drop unused exporter metrics at the Grafana Agent.

Where the model rewards

When Grafana Cloud is the right call

Grafana Cloud is the natural choice for three customer profiles. The first is the team already running open-source Prometheus, Loki, or Grafana on-premises and wanting to migrate the storage tier to managed without rewriting dashboards, alert rules, or instrumentation. The dashboards transfer one-for-one, the PromQL queries are identical, and the migration risk is low. Teams with 50 to 200 hosts on self-managed Prometheus often find Grafana Cloud cheaper once they account for the engineering time spent on Prometheus federation, long-term storage with Cortex or Thanos, and the on-call rotation for the observability stack itself.

The second is the small startup running a Kubernetes-native stack with disciplined labelling. The free tier is large enough to cover real production workloads, the paid tier is honest about how cardinality drives cost, and the operational complexity is lower than self-hosting. A seed-stage company with 20 hosts and three engineers can run on the free tier indefinitely, then graduate to Pro at $200 to $500 per month as the business scales.

The third is the platform engineering team standardising the entire organisation on OpenTelemetry. Grafana Labs has invested heavily in OpenTelemetry support since 2024, and the Tempo trace backend is purpose-built around OTel native ingest. Teams that have already adopted OTel for vendor independence find Grafana Cloud the most natural commercial backend, with no proprietary agent lock-in.

Grafana Cloud is less suited to teams that want zero-config monitoring with one auto-instrumented agent (Datadog and New Relic are stronger here), teams without Prometheus or PromQL comfort, teams running deep APM workloads on legacy languages where vendor instrumentation is more mature than community OTel libraries, and teams with regulatory requirements that make the multi-tenant SaaS model non-viable (Grafana Enterprise self-managed is the answer there, not Grafana Cloud).

Tier deep-dive

Grafana Cloud Advanced: what enterprise teams actually need it for

The Free and Pro tiers are usage-priced and self-serve; the "Advanced" (enterprise) tier shifts to a custom-quoted contract and adds the controls that procurement, security, and platform-engineering teams need before they can roll Grafana Cloud out across a regulated organisation. The differences from Pro are mostly governance and trust features, not monitoring features.

What Advanced adds over Pro:

  • SAML / SSO integration with the corporate identity provider (Okta, Azure AD, Google Workspace), so engineers do not authenticate against a separate Grafana Cloud login. This is the single most common gate-keeper requirement from internal IT before a Grafana Cloud rollout is approved beyond the platform team.
  • Fine-grained role-based access control across organisations, folders, teams, and individual dashboards. Pro role assignment is folder-level at best; Advanced supports the per-resource control that compliance reviews look for.
  • Audit logs of admin and editor actions exportable to a SIEM. Required for SOC 2 Type II evidence collection for many organisations.
  • Enhanced support SLA with named technical account management, response-time guarantees, and access to escalation paths beyond the standard ticket queue. The exact response-time commitment is negotiated in the contract.
  • Premium and enterprise-only data source integrations (Snowflake, Databricks, ServiceNow, Splunk, Oracle, SAP HANA, and similar). These are not available on the Pro tier and are often the line-item reason a team upgrades.
  • Mutual TLS, customer-managed encryption keys, IP allow-listing, and VPC-peering options for organisations with stricter network-isolation requirements than the default multi-tenant SaaS provides.

How Advanced is priced: Grafana Labs does not publish a list price for Advanced. Pricing is negotiated based on total committed usage (active series, GB of logs / traces / profiles, user count) plus the feature bundle the customer requires. The published per-unit Pro rates ($8 per 1,000 active series, $0.50 per GB on logs / traces / profiles, $8 per Pro seat) are the reference baseline; the Advanced quote folds those usage charges into an annual commit with discount, plus a platform fee for the enterprise features. There is no canonical "Advanced is X% more than Pro" multiplier - the answer depends entirely on negotiated volume and which feature bundles you take.

What to ask for in an Advanced quote:

  • Annual commit discount on the usage-based components (series, log GB, trace GB). 15-30% is common at meaningful volume; ask explicitly.
  • Burst protection on series ingestion so a runaway cardinality bomb does not blow the annual commit in a single quarter. Get the per-component overage rate in writing.
  • Named-account technical contact and a defined escalation path for production incidents, not just a ticket queue.
  • Data residency commitment (US, EU, or APAC region) if you have a regulatory requirement, and the contractual language that data does not leave that region.
  • A documented migration path to Grafana Enterprise self-managed if compliance or cost considerations later push you off SaaS. Avoiding lock-in is a real negotiation lever.

When Advanced is overkill: if the only thing you need from it is one premium data source connector, ask whether that connector is now available on the Pro tier - the line between Pro and Advanced shifts as Grafana Labs rolls features down. For small teams (under 25 engineers) without SOC 2 obligations, Pro is almost always the right answer; Advanced procurement overhead exceeds the value.

Cost reduction levers

Three ways to cut a Grafana Cloud bill

Drop labels at scrape time

Add Prometheus relabel_configs at the Grafana Agent or Prometheus scraper to drop high-cardinality labels before they reach the cloud. A single drop rule on pod_name across 100 hosts can cut active series by 80 percent. The most consequential single optimisation.

Recording rules for hot paths

Pre-aggregate high-cardinality queries into lower-cardinality recording rules that store the aggregate as its own series. A histogram_quantile across 50,000 series compiled into a per-service recording rule reduces the live series count by 90 percent for dashboards and alerts.

Loki structured metadata

Use Loki structured metadata for high-cardinality fields (request ID, user ID, trace ID) instead of indexing them as labels. Structured metadata is queryable but does not contribute to the label cardinality that dominates Loki ingestion cost.

Verify before you buy

Grafana Cloud publishes pricing publicly at grafana.com/pricing. Numbers above are list rates verified in April 2026. Annual commitments above $10K per month typically discount 20 to 35 percent versus list. Grafana Enterprise (self-managed) is a different product with separate licence pricing; contact sales for quotes.

Cross-references

Related pages

/datadog-pricing

Datadog pricing breakdown

/new-relic-pricing

New Relic pricing breakdown

/datadog-vs-grafana-cloud

Datadog vs Grafana Cloud

/new-relic-vs-grafana-cloud

New Relic vs Grafana Cloud

/datadog-vs-prometheus-grafana

Datadog vs Prometheus + Grafana

/comparison

Six-vendor comparison

/calculator

Multi-vendor cost calculator

/open-source-vs-paid

Open source vs paid TCO

/kubernetes-monitoring

Kubernetes monitoring cost mechanics

Frequently asked

How does Grafana Cloud pricing work?
Grafana Cloud charges per active metric series, per gigabyte of logs (Loki), per gigabyte of traces (Tempo), per gigabyte of profiles (Pyroscope), and per Pro user seat. The free tier covers 10,000 active series, 50 GB of each telemetry type, and three users. Paid usage above the free tier is $8 per 1,000 active series per month, $0.50 per GB for logs, traces and profiles, and $8 per user per month for Pro editor and admin seats. Verify on the current Grafana Cloud pricing page before purchasing.
What is an active series in Grafana Cloud?
An active series is a unique combination of a metric name plus its label values that has reported a sample in the last 30 minutes. A single host running NGINX with one metric (http_requests_total) and three labels (method, status, path) generates one series per unique combination. If method has 5 values, status has 4 values, and path has 100 values, that single metric on one host generates 2,000 series. This is why Kubernetes labels become the primary cost driver on Grafana Cloud.
Why is Grafana Cloud cheaper than Datadog at small scale?
Two reasons. First, the free tier is genuinely usable for small clusters. Ten thousand active series covers a 10 to 20 host Kubernetes cluster with disciplined labelling, and 50 GB of free logs covers most small workloads. Second, the per-series rate of $8 per 1,000 is fundamentally cheaper than Datadog custom metric overage at $5 per 100 metrics per month for high-cardinality workloads. The trade-off is that Grafana Cloud requires Prometheus comfort, OpenTelemetry comfort, and a willingness to manage cardinality discipline yourself.
How do I control active series cost?
Three levers. First, drop labels at scrape time using Prometheus relabelling rules. Most cardinality bombs come from one or two labels (pod name, request path, user ID). Drop them at the agent before they reach Grafana Cloud. Second, use recording rules to pre-aggregate high-cardinality metrics into lower-cardinality summaries. Third, set per-tenant limits on series ingestion in Grafana Mimir; if you cross the limit, the agent stops sending the offending series rather than billing through the roof.
Is Grafana Cloud worth paying for if I already run Prometheus?
It depends on team size and reliability requirements. Self-hosting Prometheus + Loki + Tempo + Grafana costs nothing in licence but consumes engineering time for storage scaling, high-availability setup, long-term retention, and on-call rotation for the observability stack itself. A team of three engineers spending one day per week each on observability infrastructure costs roughly $30,000 per month in fully loaded compensation. Grafana Cloud often becomes cheaper above 50 to 100 hosts when fully loaded engineering cost is honest.
What is Grafana Cloud Pro vs Advanced?
Grafana Cloud has three commercial tiers. Free covers the limits described above. Pro is the standard paid tier with usage-based billing on metrics, logs, traces and profiles plus $8 per editor seat per month. Advanced adds enterprise features (SAML SSO, fine-grained access control, audit logs, advanced data sources, support SLA) for teams that need them. Pricing for Advanced is typically negotiated; published list rates are not the full picture.
Does Grafana Cloud include alerting?
Yes. Grafana Cloud includes Grafana Alerting at no additional charge, with rule storage and notification delivery covered by the platform. There is no per-alert or per-notification fee, which differentiates it from PagerDuty integrations on some other platforms. Alert rule complexity and contact-point count are not metered.