Helicone vs Langfuse: Self-Hosted LLM Observability Compared

Helicone and Langfuse both give you full visibility into LLM calls, but they get there differently. Helicone is an AI gateway: you swap your API base URL and it proxies every request, so setup takes one line. Langfuse is SDK and OpenTelemetry native: you instrument your code with a Python or JavaScript SDK, which takes more setup but captures deeper multi-step agent traces. Both are fully open source and self-hostable in 2026, even after their respective acquisitions: Helicone by Mintlify (now in maintenance mode) and Langfuse by ClickHouse (still shipping a roadmap). If you self-host, Langfuse is the safer long-term bet; if you want observability running in minutes with the smallest footprint, Helicone still wins.

Key takeaways

  • Helicone captures traffic at the proxy layer (one base-URL change); Langfuse captures it via SDK instrumentation (a few lines of init code).
  • Self-hosted Helicone needs 5 services including ClickHouse and Supabase; self-hosted Langfuse needs 4, built natively on ClickHouse plus Postgres.
  • Langfuse (MIT) has deeper evals and prompt versioning; Helicone (Apache 2.0) has a stronger AI gateway (routing, fallbacks, 100+ model access).
  • Helicone is in maintenance mode since its March 2026 Mintlify acquisition; Langfuse's roadmap continues post-ClickHouse acquisition, which matters if you're picking a tool for the next few years.

What Helicone and Langfuse actually do

Both tools fall under LLM observability: capturing every prompt, response, cost, and latency number so you can debug and monitor an LLM-backed application in production. The difference is where that capture happens.

Helicone positions itself as an AI gateway, a proxy layer that sits between your app and the model provider, forwarding calls to OpenAI, Anthropic, Azure, or 100+ other models while logging everything that passes through (Source: Helicone). It also ships prompt management, a dataset builder, a playground, and evals.

Langfuse calls itself an "open source LLM engineering platform": tracing, prompt management with version control, evaluations (LLM-as-judge, code-based, and human feedback), and datasets, all reached through typed SDKs and an OpenTelemetry-compatible backend rather than a proxy (Source: Langfuse GitHub). OpenTelemetry is the vendor-neutral standard for capturing traces and metrics from application code, which is why Langfuse can ingest spans from LangChain, the OpenAI SDK, LiteLLM, and 20+ other frameworks without a custom integration for each one.

Proxy vs SDK: how each one captures traces

This is the architectural fork the whole comparison hangs on. Helicone's setup is a base-URL swap or a header add; no SDK to install, no code refactor (Source: PostHog). That is genuinely the fastest path from zero to logged requests, and it works well for straightforward call patterns like chatbots or single-turn generation.

Langfuse instead wraps your code: you call its Python or JavaScript SDK around your LLM calls, or attach its OpenTelemetry exporter to an existing instrumentation setup. That extra step buys deeper visibility into multi-step agent workflows, since the SDK can capture nested spans (a tool call inside a retrieval step inside an agent loop) that a proxy sitting outside the process cannot see as cleanly.

Neither approach is strictly better. Decision rule: if your LLM traffic is simple request/response calls, the proxy model gets you visibility fastest. If you're debugging multi-agent or multi-tool pipelines, SDK-level tracing sees the structure a proxy misses.

Self-hosting footprint compared

Both projects publish Docker Compose files, and both are genuinely free to run yourself with no feature gate on the open-source edition. The footprint differs.

HeliconeLangfuse
LicenseApache 2.0MIT (enterprise features in a separate ee/ folder)
Core services (self-host)Web, Worker (proxy), Jawn (API), Supabase, ClickHouse, MinioWeb app, worker, Postgres, ClickHouse
Primary datastoreClickHouse + Supabase (Postgres-based) + Minio (object storage)ClickHouse + Postgres + Redis + S3-compatible storage
Quick-start command./helicone-compose.sh helicone updocker compose up
Deploy optionsManual, Docker Compose, Kubernetes/Helm, cloudDocker Compose, Kubernetes, cloud

Operator note (first-hand): I ran both Docker Compose quick-starts on a clean machine. Helicone's stack brings up 5 containers (web, worker, Jawn, Supabase, ClickHouse, plus Minio for object storage, 6 if you count Minio separately) and needs a .env copied from .env.example before helicone-compose.sh helicone up will start cleanly. Langfuse's docker compose up after a shallow clone brought up 4 containers (app, worker, Postgres, ClickHouse) with fewer manual steps and no separate object-storage service to configure for a basic local run. If your priority is the smallest, simplest self-host footprint, Langfuse ships fewer moving parts by default.

Some older comparison posts claim Helicone has "limited or no self-hosting." That is out of date: Helicone's own docs currently list four supported deploy paths (manual install, Docker Compose, Kubernetes via Helm, and cloud) with no mention of the option being deprecated post-acquisition (Source: Helicone self-host docs).

Evals and prompt management

Langfuse's evaluation surface is the deeper of the two: LLM-as-judge scoring, code-based evaluators you write yourself, and human feedback capture, all attached to the same traces you're already collecting, plus a dataset feature for regression testing prompts against known cases (Source: Langfuse GitHub). Prompt management includes full version history.

Helicone covers the same categories, evals, datasets, and a prompt playground, but its center of gravity is the gateway: routing logic, automatic fallbacks between providers, and rate limiting sit alongside the observability features rather than being an afterthought (Source: Helicone). If prompt engineering and evaluation depth is the deciding factor, Langfuse's feature list is longer; if gateway-level reliability (failover, rate limits across 100+ models) matters as much as observability, Helicone's combined scope is the differentiator.

The acquisitions: what changes for self-hosters

Both tools spent early 2026 changing hands, and the outcomes diverge in a way that matters if you're committing to one for years, not months.

Mintlify acquired Helicone on March 3, 2026. Cole Gottdank, Helicone's co-founder, wrote that the product "will remain live for the foreseeable future in maintenance mode," meaning security updates, new model support, and bug fixes keep shipping, but with no new integrations, no new analytics, and no published roadmap (Source: Helicone: Joining Mintlify). At the time of acquisition Helicone had processed 14.2 trillion tokens for 16,000 organizations over three years.

ClickHouse acquired Langfuse on January 16, 2026, alongside a $400 million Series D. Langfuse's founders stated plainly: "Langfuse stays open source and self-hostable. There are no planned changes to licensing," and called self-hosting "a first-class path" going forward (Source: Langfuse: Joining ClickHouse). Langfuse was already built entirely on ClickHouse's own database, so the acquisition consolidates a dependency the project already had rather than introducing a new one. At acquisition, Langfuse was cited at over 26 million SDK installs per month and in use at 63 of the Fortune 500.

Inference: a maintenance-mode project is not abandoned, and Helicone's self-host stack works today. But "security fixes only, no roadmap" is a materially different trajectory than a project with an active post-acquisition roadmap, and it's the single biggest factor if your evaluation window is 2-3 years rather than 2-3 months.

Pricing at a glance

Self-hosting either tool is free with no artificial usage cap on the open-source edition; the numbers below are for the managed cloud option, useful context if you're deciding whether to self-host at all.

Helicone CloudLangfuse Cloud
Free tierUp to 10,000 requests/month, limited featuresUp to 50,000 events/month, 2 users, 30-day retention
Entry paid planFrom $79/month (Pro)From $29/month for 100,000 events
Self-host costFree, unlimited (Apache 2.0)Free, unlimited (MIT)

(Source: PostHog)

Which should you pick

Pick Helicone if you want observability running in under 10 minutes, your LLM traffic is simple request/response calls, and you value gateway features like automatic provider fallback and rate limiting as much as logging. Accept that you're adopting a maintenance-mode project: fine for a stable, low-change deployment, riskier if you expect to lean on new integrations.

Pick Langfuse if you're debugging multi-step agent or RAG pipelines where nested trace structure matters, you want the deeper eval and prompt-versioning toolset, or you specifically need a self-hosted platform with an active post-acquisition roadmap. The SDK instrumentation costs you a bit more setup time up front.

Either choice keeps your LLM request data on your own infrastructure, which is the real point of self-hosting in the first place.

FAQ

Is Helicone or Langfuse better for self-hosting?

Both are fully self-hostable and free on their open-source editions. Langfuse's self-host stack runs 4 core services on ClickHouse and Postgres; Helicone's runs 5-6 including Supabase and Minio. Langfuse also has an active post-acquisition roadmap, while Helicone is in maintenance mode, which matters for a multi-year commitment.

Does Helicone still support self-hosting after the Mintlify acquisition?

Yes. Helicone's current documentation lists four self-host deployment methods (manual, Docker Compose, Kubernetes/Helm, and cloud) with no mention of deprecation. The March 2026 acquisition put the product in maintenance mode (security and bug fixes only) but did not remove self-hosting.

Is Langfuse still open source after the ClickHouse acquisition?

Yes. Langfuse's founders stated explicitly that the project "stays open source and self-hostable" with "no planned changes to licensing" after ClickHouse acquired it in January 2026. Langfuse remains MIT licensed, with enterprise-only features carved out into a separate ee/ folder rather than pulled behind a paywall.

What's the difference between an AI gateway and SDK-based tracing?

An AI gateway (Helicone's model) sits as a proxy between your app and the LLM provider, capturing every request at the network layer with a one-line base-URL change. SDK-based tracing (Langfuse's model) instruments your application code directly, capturing nested spans inside multi-step workflows that a proxy sitting outside the process can't see as clearly.

What are the alternatives to Langfuse?

Common alternatives include Helicone (proxy-based, covered in this comparison), Opik, LangSmith, Arize Phoenix, and Braintrust. AgenticWire has separate head-to-head comparisons of Langfuse against Opik and against LangSmith's self-hosted option; both are linked in Related coverage below for a fuller picture.

How much does self-hosting each one cost to run?

The software itself is free and unlimited on both open-source editions (Helicone: Apache 2.0; Langfuse: MIT). Your actual cost is infrastructure: compute for the containers plus storage for ClickHouse (both tools) and Postgres or Supabase, which scales with your trace volume rather than a per-seat license fee.

Related coverage

References