Comparison

Everstack vs Langfuse

Both trace and evaluate LLM applications, and both are self-hostable. The difference is that Langfuse watches the request while Everstack is in it, and that Langfuse gates nine enterprise features behind a licence key that Everstack ships under Apache-2.0.

EverstackEverstack
vs
LangfuseLangfuse
View pricingRead documentation

What is Langfuse?

Langfuse is an open source LLM engineering platform for tracing, evaluating, debugging and managing prompts in AI applications. The core is MIT licensed and free to self-host, with an ee/ directory under a separate commercial licence. ClickHouse, Inc. acquired Langfuse in January 2026 and has said it stays open source with no planned licensing changes.

Why teams choose Everstack

  • Traces exist without instrumenting your code, because requests already pass through the gateway
  • One Apache-2.0 licence covers the repository, with no separately licensed enterprise directory
  • Routing, sandboxes, guardrails and evaluations sit in the same control plane as the traces

Langfuse: Strengths & Limitations

Strengths

  • Far larger community and integration surface: 33,900+ GitHub stars as of August 2026.
  • Core tracing, evaluations, datasets, prompt management and playground are MIT licensed and free to self-host with no limits.
  • Backed by ClickHouse, which acquired Langfuse in January 2026 and has committed to keeping it open source.
  • Mature prompt management and a well documented OpenTelemetry ingestion path.

Limitations

  • Not a gateway. Langfuse's own docs state that your requests never pass through Langfuse on the way to a provider, so it cannot route, fall back or enforce anything at request time.
  • Nine enterprise features are gated behind a licence key when self-hosting, including audit logs, data retention policies, server-side data masking and SCIM.
  • No code sandboxes or agent execution runtime: Langfuse observes agents that run somewhere else.
  • Instrumentation is a code change in every service you want traced, not a base URL swap.

Everstack advantage

Zero-instrumentation traces via the gatewaySingle permissive licence, no ee/ carve-outIsolated Docker, Firecracker and Kubernetes sandboxesGuardrails enforced in the request path

The facts, side by side

Licence, deployment model and list price, taken from each vendor's own documentation. Every source is linked at the bottom of this page.

FactEverstackLangfuse
LicenceApache-2.0. One licence file covers the repository, including the enterprise modules.Mixed. The core is MIT (“MIT Expat”), but everything under ee/, web/src/ee/ and worker/src/ee/ is under the separate Langfuse Enterprise Licence, which forbids redistribution or resale without a paid key.
Free self-hostingYes. The full platform, no licence key required to run it.Yes for the core. Langfuse states that all core features are available in the OSS build without limits.
Gated behind a licence key when self-hostingCommercial support, SLAs and directory lifecycle are sold separately; the code in the repository is Apache-2.0.Exactly nine: project-level RBAC, protected prompt labels, data retention policies, audit logs, server-side data masking, UI customisation, organisation creators, Org Management API and SCIM, and the Instance Management API. Note what is NOT gated: enterprise SSO, SSO enforcement, organisation-level RBAC, LLM-as-judge evaluators, annotation queues and the playground all run on the free build, with no seat or retention caps.
Multi-provider gateway with fallbackYes. OpenAI-compatible endpoint with multi-provider routing and fallback.No. Langfuse publishes an explicit answer: “your requests never pass through Langfuse on the way to a provider”.
How traces get createdRoute through the gateway and the trace already exists. SDK spans are available when you want deeper detail.Client-side instrumentation. You change an import, wrap calls in observations, or ship OpenTelemetry spans yourself.
Isolated code executionYes. Docker, Firecracker microVM and Kubernetes sandbox backends.No. Langfuse does not execute your code.
Cloud pricingStarter $0, Build $20/month, Scale $100/month, Enterprise custom (August 2026).Hobby free with 50k units/month and 30 days data access, Core $29/month, Pro $199/month, Enterprise $2,499/month (August 2026). Discount programmes exist for startups, research, non-profits and open-source projects.
OwnershipEverstack Labs, independent.ClickHouse, Inc. ClickHouse acquired Langfuse in January 2026 and stated there are no planned licensing changes.
Community sizeSmall. Everstack is a young project and Langfuse comfortably wins this one.33,900+ GitHub stars as of 30 August 2026.

Prices and star counts checked on 30 August 2026 against each vendor's own pricing page, licence file and repository. Pricing changes; verify before you buy.

Feature comparison

Direct capability comparison across key dimensions

FeatureEverstackLangfuse
Observability
Distributed tracing for LLM calls
OpenTelemetry ingestion
Traces without touching application codeVia the gateway
Sessions and multi-turn grouping
Cost and token attribution
Audit logs when self-hostedPlannedLicence key required
Data retention policies when self-hostedLicence key required
Evaluations
Datasets and experiment runs
LLM-as-judge scoring
Human annotation queues
Prompt management and playground
Gateway
OpenAI-compatible endpoint
Multi-provider routing
Automatic fallback between providers
Request-time guardrails and policy
Runtime
Isolated code sandboxes
Stateful agent runtime and workflows
Deployment
Self-host the whole product for freeCore only
Single permissive licence for the repositoryApache-2.0MIT core plus ee/

The same job, in both products

Working code rather than adjectives. Each snippet follows the quickstart published by the product it belongs to.

Get a traced LLM call into the platform

Everstack traces the call because the call goes through it. Langfuse traces the call because you changed the import. Both work; the difference is where the change lands and how many services you have to touch.

Everstack

traced_call.py
from openai import OpenAI# Point the stock OpenAI SDK at your Everstack gateway.# The trace, cost and token counts are recorded server side.client = OpenAI(    base_url="https://{instance}.{region}.everstack.ai/openai/v1",    api_key=os.environ["EVERSTACK_API_KEY"],)completion = client.chat.completions.create(    model="@openai/gpt-4o",    messages=[{"role": "user", "content": "1 + 1 = "}],)

Langfuse

traced_call.py
# From the Langfuse quickstart: swap the import, keep the call.from langfuse.openai import openaicompletion = openai.chat.completions.create(    name="test-chat",    model="gpt-4o",    messages=[        {"role": "system", "content": "You are a very accurate calculator."},        {"role": "user", "content": "1 + 1 = "},    ],    metadata={"someMetadataKey": "someValue"},)

Add a manual span around your own logic

Both products expose an SDK for spans you create yourself. If you already emit OpenTelemetry, both accept OTLP and neither requires their own SDK.

Everstack

span.ts
import Everstack from "@everstack/node";const client = new Everstack({ apiKey: process.env.EVERSTACK_API_KEY });const span = client.traces.startSpan({ name: "process-request" });try {  await handleRequest();  span.end({ output: "Processing complete" });} catch (error) {  span.recordException(error);  span.end();}

Langfuse

span.py
# From the Langfuse observability quickstart.from langfuse import get_clientlangfuse = get_client()with langfuse.start_as_current_observation(    as_type="span", name="process-request") as span:    span.update(output="Processing complete")langfuse.flush()

Key evaluation questions

What to ask when comparing Langfuse to Everstack

QuestionEverstackLangfuse
Can it route a request to a different provider on failure?Yes. Multi-provider routing and fallback are in the gateway that produces the traces.No. Langfuse is not in the request path by design and documents this explicitly.
What do I lose by self-hosting the free build?The repository is Apache-2.0 and self-hosting the platform does not require a licence key.Nine enterprise features, including audit logs, retention policies, data masking, SCIM and project-level RBAC.
How much code do I change to get first traces?One base URL, if you route through the gateway. SDK spans are optional detail on top.An import swap at minimum, and manual observations for anything that is not a direct provider call.
Who is behind the project, and how stable is that?Everstack Labs, independent and early. Smaller team, shorter track record.ClickHouse, Inc. since January 2026, with a public commitment to no licensing changes.
Can it run untrusted agent code?Yes. Isolated Docker containers, Firecracker microVMs or Kubernetes pods, per sandbox.No. Langfuse does not execute code.

Feature-by-feature analysis

Where each product is genuinely stronger, row by row

Getting a trace in the first place

Everstack wins
Everstack

Requests pass through the gateway, so traces, cost and token counts exist as a side effect of routing. No import changes, no decorators, no per-service rollout.

Langfuse

Tracing is client side. You change an import, add observations, or ship OpenTelemetry spans yourself, in every service you want covered.

Why Everstack

Instrumentation friction is the most common reason an observability trial stalls. Routing through a gateway removes it entirely for the LLM call path.

Doing anything at request time

Everstack wins
Everstack

Guardrails, quotas, provider fallback and caching run in the request path because the request goes through Everstack.

Langfuse

Structurally impossible. Langfuse states plainly that requests never pass through it, so it can analyse behaviour but never change it.

Why Everstack

If you need to block a prompt, cap a spend or fail over to a second provider, an observability platform cannot help you. That is a gateway job.

Community, integrations and mindshare

Langfuse wins
Everstack

A young project with a small community and a much shorter list of framework integrations.

Langfuse

33,900+ GitHub stars, a large integration catalogue, and now ClickHouse behind it. The default answer when someone asks for open source LLM observability.

Why Langfuse

If you want the option that most engineers already recognise and that has the most worked examples on the internet, that is Langfuse today, not Everstack.

Licence terms for self-hosting

Everstack wins
Everstack

Apache-2.0 across the repository. There is no separately licensed directory you have to reason about.

Langfuse

MIT core, plus an ee/ directory under a bespoke Enterprise Licence. Audit logs, retention policies, data masking, SCIM and project-level RBAC need a paid key.

Why Everstack

The features Langfuse gates are exactly the ones a regulated buyer asks for first, which turns a free self-host into a paid one at the compliance review.

Depth of the observability product itself

Close call
Everstack

Traces, sessions, evaluations, datasets, annotation queues, custom columns and faceted trace search.

Langfuse

The same shape of product, longer in the market, with more polish in prompt management and a broader set of native framework integrations.

How to choose

On pure observability and prompt features these are close. Judge them on your own workload rather than on either vendor's feature table, including this one.

What happens after the trace

Everstack wins
Everstack

The same platform runs the agent, executes tool calls in isolated Docker, Firecracker or Kubernetes sandboxes, and gates releases on evaluations.

Langfuse

Langfuse observes and evaluates. Execution, isolation and routing are somebody else's product.

Why Everstack

Teams running agentic workloads otherwise buy a proxy, a sandbox vendor and a tracing vendor, then maintain the seams between them.

Moving from Langfuse to Everstack

Langfuse and Everstack both speak OpenTelemetry, so the telemetry path is the easy part. The work is in the Langfuse-specific SDK surface: decorators, prompt management and the public API. Plan a period of dual-writing rather than a cutover.

  1. 1

    Point your OTLP exporter at Everstack

    If you already ship OpenTelemetry spans to Langfuse, change the OTLP endpoint and the auth header. Spans arrive with the same semantic conventions and no code change beyond configuration.

  2. 2

    Move traffic to the gateway and delete instrumentation

    Change the OpenAI base URL to your Everstack gateway. Every request through it is traced with cost and token attribution, which removes the per-service instrumentation you were maintaining for Langfuse.

  3. 3

    Re-create datasets and scorers

    Export Langfuse datasets through their public API and import them as Everstack datasets. Scorers need to be re-declared: the concepts map closely but the definitions are not wire compatible.

  4. 4

    Dual-write until you trust the new traces

    Keep the Langfuse exporter running alongside Everstack for a release or two. Compare cost totals and span counts before you turn Langfuse off, and keep Langfuse readable for as long as you need the history.

What breaks

  • Langfuse SDK decorators and the `langfuse.openai` drop-in import have no line-for-line Everstack equivalent. Code using them needs editing.
  • Anything calling the Langfuse public API directly (`/api/public/*`) has to be rewritten against Everstack's API.
  • Langfuse prompt management is a different object model, so prompts fetched by name and label at runtime need remapping.

What does not carry over

  • Historical traces. There is no bulk importer, so plan to keep Langfuse readable for your retention window.
  • Saved dashboards, chart layouts and saved views.
  • Existing annotation queue state and past human scores.
  • LLM-as-judge evaluator configurations, which have to be re-declared.

Read this part first

When to choose Langfuse instead

Langfuse is a good product and it is the right answer for a lot of teams. Pick Langfuse over Everstack when any of these is true.

  • Observability and evaluations are the whole problem. You already have a gateway you are happy with, or you call providers directly and want to keep it that way.
  • You want the largest community in self-hosted LLM observability. Langfuse has 33,900+ stars and an integration for nearly every framework; Everstack does not, and will not for a while.
  • You deliberately do not want a proxy in the request path. Langfuse traces client side, so a Langfuse outage cannot affect your inference calls. That is a real architectural advantage.
  • You are already a ClickHouse shop. Langfuse is now a ClickHouse product and sits naturally alongside a commercial ClickHouse plan.
  • You need prompt management maturity today. Langfuse has been iterating on prompts, labels and the playground for longer than Everstack has existed.
  • Your evaluation of vendor risk favours the bigger backer. ClickHouse ownership is a stronger continuity story than an independent young company.

Frequently asked questions

Common questions about choosing between Everstack and Langfuse

Ready to get started?

See how Everstack compares to Langfuse for your specific use case.

View pricingRead docs

Sources & References

Langfuse licence (MIT plus ee/)Langfuse Enterprise LicenceLangfuse self-host licence key featuresLangfuse pricingLangfuse self-host pricingLangfuse: is it an LLM gateway?Langfuse quickstartClickHouse acquires LangfuseEverstack licence (Apache-2.0)

Last reviewed: August 30, 2026. This comparison is for informational purposes and reflects our understanding of competitor capabilities based on publicly available documentation.

← Back to all comparisons
Open-source AI infrastructure

Ship the AI stack
you can actually operate.

Start with one model call. Add agents, sandboxes, evaluations, memory, and traces without replacing the foundation underneath them.

Start with $5 creditSelf-host Everstack

One-time starter credit per account on Everstack Cloud. Expires 30 days after signup.