Book a Demo
Book a Demo
CubeAPM
CubeAPM CubeAPM

Last9 Pricing Calculator

Verified June 2026  ·  Source: last9.io/pricing →

Last9 Pricing Calculator

Estimate your Last9 Pro monthly bill. See how CubeAPM's $0.20/GB compares.

Profile

① Log Ingestion $2,250

Each log line counts as 1 billable event on Last9.

Log volume ≈ 15.0B log events
GB/mo

Last9 Pro: $1,150/mo includes 1B events, then $150/B (up to 5B total), then $75/B (5B-100B), then $38/B (100B-500B). Assumes ~5M lines per GB (avg. 200-byte log line).

② Trace Ingestion $255

Each trace span counts as 1 billable event on Last9.

Trace volume ≈ 1.7B span events
GB/mo

Last9 Pro: $1,150/mo includes 1B events, then $150/B (up to 5B total), then $75/B (5B-100B), then $38/B (100B-500B). Assumes ~1M spans per GB (avg. 1KB per span including tags).

③ Metrics Volume $1,294

Each metric sample counts as 1 billable event on Last9.

Metrics volume ≈ 8.6B samples (Last9 events)
GB/mo

Last9 Pro: $1,150/mo includes 1B events, then $150/B (up to 5B total), then $75/B (5B-100B), then $38/B (100B-500B). Enter compressed metric storage - assumes 16 bytes/sample (TSDB). Last9 Pro cap: 20M active timeseries/day.

ℹ️ Last9 Pro cardinality cap: 20M active timeseries/day. Exceeding this requires Enterprise (custom pricing). CubeAPM has no cardinality cap. A typical K8s cluster with default Prometheus exporters emits 50K–500K active series.
Monthly event estimate  ·  1 event = 1 log line / trace span / metric sample
15.0B
Log events
1.7B
Trace events
4.3B
Metric samples
21.0B
Total events
Last9 annual rates not published - showing monthly × 12
Last9 Pro last9.io/pricing · June 2026
$4,501
estimated / month
Base plan (1B events incl.) $1,150
Events 1B-5B (0.00B × $150) $0
Events 5B-100B (0.00B × $75) $0
Events 100B-500B (0.00B × $38) $0
Events 500B+ (0.00B, tiered $28-$20) $0
🚫
Pro plan limit exceeded
Your active timeseries exceed Last9 Pro's 20M/day cap. Enterprise plan required - pricing is custom.

Contact Last9 sales →
CubeAPM $0.20/GB · per GB
$1,000
estimated / month
* $1,000/mo minimum applies
4,838 GB × $0.20 $726
Cloud infra (~$0.02/GB, billed by your cloud provider) ~$97
APM included
Users / hosts unlimited
Retention unlimited
Estimated monthly savings with CubeAPM
$3,501
78% savings
+ ~$66/mo cloud infra billed by your cloud provider (AWS/GCP/Azure) - not paid to CubeAPM.
Last9 Pro: 20M active timeseries/day cap  ·  90-day metrics retention  ·  14-day logs & traces retention  ·  SaaS only (BYOC requires Enterprise).

Cost Breakdown by Dimension monthly

Dimension Your Usage Events / Volume Last9 Pro Cost CubeAPM Cost
Base Plan ? Last9 Pro starts at $1,150/month which includes 1B events. Additional events: $150/B (up to 5B total), $75/B (5B-100B), $38/B (100B-500B). CubeAPM has no base plan fee - you only pay for data ingested.
Fixed monthly 1B events incl. $1,150 included
Log Ingestion ? Last9 bills each log line as 1 event. Base plan: $1,150/mo includes 1B events, then $150/B up to 5B total, $75/B (5B-100B), $38/B (100B+). At 5M lines/GB, that's $0.75/GB in tier 1 vs CubeAPM's $0.20/GB.
3,000 GB 15.0B events $2,250 $450
Trace Ingestion ? Last9 bills each span as 1 event. At 1M spans/GB that's $0.15/GB of trace data, the same unit cost as CubeAPM for this workload. The gap widens when span size is smaller.
1,700 GB 1.7B events $255 $255
Metrics ? Last9 bills each metric sample as 1 event. Compressed metric storage (16 bytes/sample TSDB estimate) converts to raw sample count for Last9 billing. CubeAPM bills the same compressed GB at $0.20/GB.
138 GB 8.6B events $1,294 $21
Cloud Infra (est.) ? CubeAPM runs inside your own cloud (BYOC). Your cloud provider bills ~$0.02/GB for storage, compute, and egress. This is NOT paid to CubeAPM - it's an additional line on your AWS/GCP/Azure bill.
3,304 GB N/A N/A (SaaS) ~$66
Total 4,838 GB data 25.3B events $4,501 $1,000

What's included with CubeAPM at $0.20/GB

One platform. One bill. One per-GB rate that covers everything Last9 bills as separate per-billion-event SKUs, plus no cardinality caps, no retention limits, and no mandatory platform fee.

  • APM: distributed tracing & code profiling
  • Log management: unlimited retention
  • Infrastructure monitoring (hosts, containers, K8s)
  • Metrics: unlimited timeseries, no cardinality cap
  • Dashboards & alerting: unlimited
  • Unlimited team members: no per-seat charges
  • Unlimited data retention: no expiry date
  • OpenTelemetry & Prometheus compatible
  • No per-host, per-node or per-user fees
  • On-prem / BYOC: deploy inside your own cloud
Runs entirely inside your own AWS / GCP / Azure account. Your data never leaves your infrastructure. No per-series fees, no mandatory platform charge, no separate APM license; one $0.20/GB rate covers metrics, logs, traces, and APM together.

See how much you'd save with CubeAPM

No per-event counting. No cardinality caps. No platform fee. Flat $0.20/GB with APM, logs, metrics, and infrastructure all included, running inside your own cloud account.

Book a Demo → See CubeAPM Pricing
How we calculate this: sources & assumptions

Last9 Pro Pricing (June 2026)

Base plan: $1,150/month includes 1B events. Additional event tiers (source: last9.io/pricing page JS, June 2026): $150/B above 1B up to 5B total, $75/B (5B-100B), $38/B (100B-500B), $28/B (500B-1T), $24/B (1T-5T), $20/B (5T+). Source: last9.io/pricing (verified June 2026). Cardinality cap of 20M timeseries/day sourced from last9.io/pricing and docs.last9.io.

Event conversion assumptions

Logs: 1 GB ≈ 5,000,000 log lines (average ~200 bytes/line). Actual varies by log verbosity and format (JSON logs average ~300–500 bytes; single-line logs ~50–150 bytes). Traces: 1 GB ≈ 1,000,000 spans (average ~1 KB/span including tags and events). Metrics: Enter compressed metric storage in GB. Uses 16 bytes/sample TSDB compression estimate (standard for Prometheus/VictoriaMetrics). 1 GB ≈ 62.5M samples ≈ 0.0625B events billed by Last9.

CubeAPM Pricing

$0.20/GB for all telemetry (logs, metrics, traces, APM). $1,000/month minimum applies. Cloud infrastructure overhead ~$0.02/GB paid separately to your cloud provider (not included here). Source: cubeapm.com/pricing.

CubeAPM data volume estimate

Total GB = log GB + trace GB + metric storage GB. Metric storage: series × samples/mo × 16 bytes ÷ 1,000,000,000 (TSDB compression approximation). At scale, metric storage is typically « log and trace volume.

What this calculator does NOT model

Last9 Enterprise plan (custom pricing, BYOC deployment, longer retention, custom cardinality quotas). Annual commitment discounts on Last9 (not publicly listed). Log compression ratios (Last9 events count lines pre-compression).

Estimates based on publicly available Last9 list pricing verified June 2026 via last9.io/pricing (pricing tiers extracted from page JavaScript). Actual bills vary by contract terms, negotiated discounts, data formats, and usage patterns. This calculator is not affiliated with or endorsed by Last9, Inc.

Why use this Last9 pricing calculator?

Last9 pricing is event-based. An event is any log line, trace span, or metric sample your systems generate. Every piece of telemetry counts toward a single unified unit, and as your systems grow, events accumulate faster than most teams expect.

The Pro plan starts at $1,150/month for 1 billion events. Beyond that, usage pricing applies. Because everything is measured in events, a spike in trace volume, a new log source, or denser metric collection all draw from the same pool and push costs upward simultaneously.

This calculator helps you:

  • Estimate your Last9 spend before committing or scaling workloads
  • Understand how your current telemetry volume translates into events per month
  • Model cost scenarios across different retention and cardinality configurations
  • Compare Last9's event-based pricing against a self-hosted alternative using the same assumptions

The goal is not to produce an exact invoice. Actual costs depend on your usage patterns and whether you qualify for volume discounts. But it gives you a realistic cost range to plan with.

What Makes Last9 Costs Hard to Predict

Everything feeds one pool

Unlike platforms that separate billing for logs, metrics, and traces, Last9 collapses all signals into a single event count. This is simpler in one way: there is one number to track. But it also means that changes to any signal type affect the same budget line.

Adding a new microservice increases log events, trace span events, and metric sample events at the same time. Increasing Prometheus scrape frequency multiplies metric events. Enabling verbose logging for a debugging session can spike your daily event count by orders of magnitude. All of these compete for the same 1B event monthly allocation.

mattis, pulvinar dapibus leo.

On the Pro plan, log and trace retention is fixed at 14 days. Metrics retention is fixed at 90 days. If your compliance requirements, incident postmortem workflows, or capacity planning needs require data older than these windows, you have two options:

  • Push data to your own S3 using Last9’s cold storage feature and rehydrate when needed (this adds S3 storage and data transfer costs outside of Last9’s billing)
  • Move to Enterprise for custom retention periods

The Pro plan also caps metrics cardinality at 20 million timeseries per day. High-cardinality environments (for example, Kubernetes clusters with many pods, or applications that use fine-grained label sets) can approach this limit. Exceeding it requires contacting Last9 to move to Enterprise with custom cardinality quotas.

Last9 has no published middle tier between Pro ($1,150/month) and Enterprise (custom spend commitment). If your usage outgrows the Pro event allocation and you do not yet qualify for volume discounts (which start at 3T events/month), you pay on-demand usage pricing on top of the $1,150/month base. What that usage pricing works out to per event is not publicly listed and requires a conversation with their sales team.

For teams in the growth zone between Pro and Enterprise scale, costs can be difficult to estimate without direct engagement with Last9.

Last9 does not offer a free tier. The entry point is the Pro plan at $1,150/month. Teams evaluating Last9 before committing to production use need to either pay for Pro or request a demo and trial access directly.

What Typically Drives Last9 Costs Up

High trace sampling rates

Distributed tracing at 100% sampling in a high-throughput microservices environment generates trace span events at very high volume. A service handling 1,000 requests per second, each touching 5 downstream services, produces over 430 million span events per month from that single service alone.

Debug or info-level logs from all production services, left on after a debugging session, can double or triple log event counts quickly.

Short Prometheus scrape intervals (every 15 or 30 seconds) across many targets multiply metric sample events. Reducing scrape intervals or dropping unused metrics directly reduces event volume.

Each new instrumented service contributes log, trace, and metric events simultaneously, compounding the total.

While cardinality does not directly add to the event count, approaching the 20M timeseries/day Pro limit forces a move to Enterprise with negotiated pricing.

How to Manage Last9 Costs

Use ingestion rules to drop noise at the source

Last9’s Control Plane includes ingestion rules that let you drop, remap, or filter telemetry before it is stored. Events dropped by an ingestion rule are not counted toward your bill. Filtering out noisy, low-value log lines (for example, health check endpoints, static asset requests) before they reach storage reduces your event count proportionally.

Configure trace sampling to retain signal, not volume

Rather than sampling traces at a fixed rate, use tail-based sampling to keep traces that carry information (errors, slow transactions, anomalies) and drop traces from routine successful requests.

Last9’s ingestion pipeline supports this at the collector level. Reducing trace volume by 50-80% through intelligent sampling is achievable without reducing observability over failures.

Audit metric scrape intervals and targets

Metric events are generated every time a scrape occurs. Reducing the Prometheus scrape interval from 15 seconds to 60 seconds for low-priority targets reduces metric event volume by 75% from those targets.

Similarly, reviewing which exporters are active and dropping unused metrics at the collector level avoids counting metrics that no dashboard or alert ever queries.

Use cold storage for long-retention data

If you need to keep data beyond 14 days (logs and traces) or 90 days (metrics) but do not need it to be instantly queryable, Last9’s cold storage feature pushes data to your own S3. You pay S3 storage rates rather than in-platform retention costs, and data can be rehydrated into Last9 when needed for investigation.

Monitor usage against billing thresholds

Last9 sends email notifications when you reach 50%, 75%, 90%, and 100% of your plan limits. The Control Plane also shows usage breakdowns by signal type (logs, traces, metrics) for the last 30 days, including hourly views.

Reviewing this regularly lets you identify which signal type is growing fastest and take action before you cross into overage pricing.

Consolidate environments onto a single workspace

Running separate Last9 workspaces for development, staging, and production multiplies your plan costs.

Where possible, use ingestion rules to tag and filter data by environment within a single workspace rather than maintaining separate paid instances.

Last9 Pricing vs CubeAPM: A Structural Difference

Last9 and CubeAPM are both positioned as modern, OpenTelemetry-native observability platforms built as alternatives to the per-host, per-seat pricing of Datadog and New Relic. Both remove seat taxes and aim for predictable billing. But the deployment model and cost structure are fundamentally different.

Last9 is a fully managed SaaS platform. Your telemetry is collected, processed, and stored on Last9’s cloud infrastructure. You pay per event (log line, trace span, or metric sample), and the platform manages all infrastructure on your behalf.

CubeAPM is a self-hosted platform that runs inside your own cloud account or on-premises environment. Your telemetry never leaves your infrastructure. You pay $0.15/GB of ingested data, and you control your own storage and retention without paying per event or per retention period.

AreaLast9CubeAPM
DeploymentFully managed SaaSSelf-hosted in your own cloud or on-premises
Pricing unitPer event (log line, trace span, or metric sample)Per GB of data ingested
Entry price$1,150/month (1B events included)$0.15/GB ingested
Data residencyLast9's cloud infrastructureYour own infrastructure; data never leaves
Log and trace retention14 days on Pro; custom on EnterpriseUnlimited at no extra cost
Metrics retention90 days on Pro; custom on EnterpriseUnlimited at no extra cost
Cardinality limits20M timeseries/day on Pro; custom on EnterpriseNo separate cardinality limits
RUMAvailable (web, iOS, Android, React Native, Flutter)Available (web and mobile)
Synthetic monitoringAvailable (HTTP/HTTPS uptime checks, multi-region)Available (browser transactions, API, multi-location)

Where the cost models diverge in practice

Last9’s event-based pricing means costs are tied to instrumentation density. The more granularly you instrument your services and the more signals you collect per request, the more events you generate. This creates a tension between observability depth and cost: teams that want comprehensive telemetry (high trace sampling rates, verbose metrics, full log retention) pay more than teams that restrict coverage.

CubeAPM’s per-GB pricing means costs are tied to data volume, not event count. The distinction matters because a GB of logs and a GB of traces have very different event counts but cost the same under CubeAPM’s model. Unlimited retention also removes the decision between cost and data longevity: you keep everything without paying per day of retention.

For teams with compliance requirements, regulated data that cannot leave their cloud, or unlimited retention needs, the self-hosted model changes the cost equation structurally rather than incrementally. Infrastructure cost (compute and storage in your own cloud) replaces per-event and per-retention fees, and that infrastructure cost scales more linearly with growth than tiered SaaS pricing.

Last9 is the right fit for teams that want a fully managed SaaS experience, zero infrastructure overhead, and fast time to value, and are comfortable with event-based pricing as their usage scales. CubeAPM is the right fit for teams that need data sovereignty, unlimited retention, or a self-hosted deployment with predictable per-GB cost regardless of instrumentation depth.

Read our Last9 vs CubeAPM guide to understand the differences between the two platforms in detail. 

The calculator above is designed to help you model both sides of that tradeoff using your own event and data volume estimates.

×
×