Maple vs Dash0

Dash0 and Maple start from the same place: OpenTelemetry in, usage-based pricing, no per-seat fees for observability, an MCP server for agents. The difference is ownership: Maple's source is public and you can self-host it, while Dash0 is a closed SaaS.

Maple
maple.dev
Dash0
dash0.com

Surfaces

What Maple shows, and what Dash0 does instead

Dash0 is OpenTelemetry-native too, so the signals match. The difference is where the platform runs and what ships beside the telemetry.

Maple on your laptop

One binary with an embedded ClickHouse. `maple start` runs the platform locally with no containers and no account, and self-hosting is one container on your own infrastructure.

On Dash0: the platform is SaaS only, in Dash0-operated regions. SignalControl Edge can filter data in your own cluster before it is sent on.

See the surface →
local · 127.0.0.1:4318 DEMO
maple start
🍁 maple · local mode
listening on http://127.0.0.1:4318
OTLP/HTTP POST /v1/{traces,logs,metrics}
query POST /local/query
dashboard https://local.maple.dev
· bundled UI: pass --offline
data ~/.maple/data
pid 48213 · stop with maple stop
one binary · one port telemetry stays on 127.0.0.1

Uptime checks

HTTP, TCP and DNS checks as often as every 30 seconds, plus cron heartbeats. A failed HTTP check opens as a trace of the request inside your app.

On Dash0: synthetic API checks at $0.20 per thousand runs, retained 13 months.

See the surface →
uptime · 5 monitors DEMO
status monitor checks p95 30d
DOWN checkout-api GET /health · every 30s 212 ms 99.71%
UP auth GET /v1/session · every 60s 84 ms 99.98%
UP postgres-primary TCP db.internal:5432 · every 30s 3 ms 100%
UP acme.com MX DNS MX acme.com · every 5m 21 ms 100%
UP nightly-backup cron 0 3 * * * · grace 15m n/a 100%
incident opened 14:32:07
checkout-api is down
Status 503, expected 2xx · failed 2 checks in a row
trace 7c1e40a9
e21f service checkout sent to #oncall
failed checks 2/2 · closes when it passes again

AI investigations and MCP

A hosted MCP server runs the dashboard's own queries for Claude, Cursor or any agent, and investigations diagnose an alert or issue and write up what broke.

On Dash0: an MCP server and AI-assisted views.

See the surface →
mcp · agent session DEMO
> ask maple
list services that errored in the last 15m
→ list_services { window: "15m", filter: "errors > 0" }
← 3 services
paymentserrors142p992.4s recoserrors38p99840ms shippingerrors6p99320ms
> investigate payments
→ find_errors { service: "payments", window: "15m" }
← 1 issue
stripe.charge declined  Â·  142 events  Â·  98 users
→ error_detail { issue_id: "iss_8a91" }
← root cause: idempotency key collision
sample trace: trace_9f3c · order 8421
→ propose_fix { issue: "iss_8a91", fix: "scope idempotency_key by user_id" }
← fix attached. opened pr#412.
> 
4 tool calls · 4.2s open mcp protocol

Differences

Where Maple and Dash0 differ

The marker beside each row shows which tool is ahead on it. Rows where both do the same thing are grouped into one line at the end.

Where Maple and Dash0 differ
Topic Maple Dash0 Edge
Where they differ
Source code On GitHub under FSL-1.1, converting to Apache 2.0 two years after each release. Closed. Dash0 open-sources its OpenTelemetry distribution and Kubernetes operator, not the platform. 2 Maple
Self-hosting Yes. One container on your own infrastructure for one team. Alerting and team accounts are on Cloud only for now. No. The platform is SaaS only, in Dash0-operated regions. SignalControl Edge, a filtering collector, can run in your own cluster before data is sent on. 4 Maple
Pricing model $39 a month with 100 GB per signal included, then $0.30 per GB. Per data point: $0.60 per million spans or log records ($0.06 ingestion plus $0.54 storage at 30-day retention) and $0.20 per million metric data points ($0.02 plus $0.18 at 13-month retention). 1 Even
AI and agents Investigations that diagnose an alert or issue and write up what broke, plus a hosted MCP server that can also create dashboards, alerts and SLOs. An MCP server and AI-assisted views. Even
Where Dash0 is ahead
Retention 30 days for traces, logs and replays, 90 for metrics, 12 months for service charts. Longer on Enterprise, and your call when you self-host. 30 days for spans, logs and web events and 13 months for metrics, included in the storage rate. 1 Dash0
Synthetic monitoring HTTP, TCP and DNS checks as often as every 30 seconds, plus cron heartbeats. A failed HTTP check opens as a trace. No scripted browser tests. Synthetic API checks at $0.20 per thousand runs, retained 13 months. 1 Dash0
PromQL compatibility PromQL for metric queries and dashboards, plus a visual builder and SQL. PromQL alert rules aren't supported yet. PromQL for metrics and Perses-based dashboards-as-code. 3 Dash0
Kubernetes tooling Kubernetes monitoring through the OpenTelemetry Collector. No operator of Maple's own. A Kubernetes operator and an OpenTelemetry distribution, both maintained in the open. 2 Dash0
Both have
  • Distributed tracing
  • Log management
  • Metrics and dashboards
  • Alerting
  • Error tracking
  • Kubernetes monitoring
  • Public API
  • MCP server for agents
  • OpenTelemetry ingest

In production : Superwall sends Maple more than 80 billion traces, logs and metrics a month, about 18 TB, with nothing sampled out. Read the Superwall story

Enterprise : Custom volume pricing and retention, priority support, SSO (SAML/OIDC) with SCIM provisioning, and Bring Your Own Cloud to run Maple in your own cloud account. See pricing

Surfaces

Service map

Every service, queue and database, drawn from the spans themselves. There is no topology file to maintain. Edges carry throughput, error rate and latency, and clicking one opens the traces behind it.

See the surface
The Maple service map: services, their dependencies and the request flow between them

Price

The same month, billed twice

A reference workload priced on both at list price. Change the sliders underneath for your own numbers.

The Maple overview page: the logs, traces and metrics received, over request volume and latency
What the meter reads: logs, traces and metrics received, on Maple's overview page.

Reference workload Spans / mo 100 M · Log records / mo 100 M · Metric data points / mo 500 M

Maple

$39 per month

Startup plan 100 GB per signal included $39
Team seats No per-seat fees Free
Total $39

Dash0

$220 per month

Spans 100M × $0.60/M $60
Logs 100M × $0.60/M $60
Metrics 500M × $0.20/M $100
Total $220

$181 less per month on Maple · $2.2k a year

Adjust for your usage

100 M
100 M
500 M
Maple
$39/mo
Dash0
$220/mo
Difference
$181 less per month on Maple$2.2k a year · 82% less

List prices checked September 2026. Sources at the foot of the page. Maple pricing based on the Startup plan ($39/mo with 100 GB included per signal (logs, traces, metrics), then $0.30/GB, billed per signal), metered on uncompressed (decoded OTLP) bytes. Dash0 bills per data point, ingestion plus storage at the default retention. The Maple estimate converts at 1 KB per span or log record and 0.1 KB per metric data point; your ratio depends on attribute sizes.

Migration

Moving from Dash0

Telemetry moves with one exporter change. Dashboards and alert rules don't cross vendors, so plan those as the real work.

  1. 01

    Keep your OpenTelemetry pipeline

    Both platforms ingest standard OTLP, so SDKs, auto-instrumentation and semantic conventions carry over unchanged.

  2. 02

    Add a second exporter

    Add Maple next to the Dash0 exporter in the Collector and ship to both while you verify.

  3. 03

    Recreate dashboards and alerts

    Dashboards, saved views and alert rules don't travel over OTLP. Rebuild the ones that matter in Maple; the MCP server can draft them.

otel-collector.yaml The change
exporters:  otlp/dash0:    endpoint: ingress.eu-west-1.aws.dash0.com:4317    headers:      Authorization: Bearer ${env:DASH0_AUTH_TOKEN}  otlp_http/maple:    endpoint: https://ingest.maple.dev    headers:      x-maple-ingest-key: ${env:MAPLE_INGEST_KEY} service:  pipelines:    traces:      exporters: [otlp/dash0, otlp_http/maple]    logs:      exporters: [otlp/dash0, otlp_http/maple]    metrics:      exporters: [otlp/dash0, otlp_http/maple]
Add Maple as a second exporter, run both, then drop the first.
FAQ

Common questions

How is Maple different from Dash0?
The fundamentals match: both are OpenTelemetry-native, both price on usage with no per-seat fee for observability, both expose an MCP server. The difference is ownership. Maple is source available under FSL-1.1 and self-hostable on your own infrastructure with retention you control. Dash0 is a closed, SaaS-only backend.
Is there an open-source alternative to Dash0?
Several. Maple is source available under FSL-1.1 and becomes Apache 2.0 two years after each release; you can self-host it as one container for one team. SigNoz has an MIT core, and Grafana's stack is AGPL-3.0. Dash0 open-sources client-side tooling, its OpenTelemetry distribution and Kubernetes operator, but not the platform, and offers no self-hosting.
How hard is the migration?
The pipeline is one exporter change: both platforms ingest standard OTLP. Dashboards, saved views and alert rules don't transfer, so plan to recreate those.
How does the pricing compare?
Both are usage-based with no per-seat fee for observability. Dash0 bills per data point; Maple bills per GB of decoded OTLP. Which is cheaper depends on how large your spans and log records are. The receipts above convert at one kilobyte per span or log record and 0.1 KB per metric data point; the calculator lets you change the counts.
Does Dash0 have anything Maple doesn't?
PromQL alert rules, Perses dashboards-as-code, synthetic API checks, and a vendor-maintained Kubernetes operator and OpenTelemetry distribution. Those rows are marked above.
The Maple services page: latency percentiles, error rate and throughput per service
The services page: latency percentiles, error rate and throughput for every service.

Sources

Where the Dash0 claims come from

Vendor facts on this page link to the vendor's own pages and carry the month they were last checked. If one is stale, tell us.

  1. 1 Dash0 pricing checked September 2026
  2. 2 Dash0 on GitHub checked August 2026
  3. 3 Dash0 documentation checked August 2026
  4. 4 Dash0 SignalControl checked November 2026

Compare

Other comparisons

Engraving of a long Roman aqueduct crossing a valley

See the difference on your own traces.

Point one exporter at Maple and run both for a week. The free trial needs a card, with no charge until it ends.