10 Best Langfuse Alternatives Compared & Ranked (2026)

A Langfuse setup in production is rarely just Langfuse. Langfuse has no gateway, so failover when a provider rate-limits, load balancing across providers, and hard spend limits on a leaked key all live in a separate tool. Teams that want output scored on live production traffic, rather than on datasets they assemble by hand, usually add another product for that. Traces and prompt versions sit in Langfuse, and everything around those two jobs gets filled in with something else.

Those seams cost nothing on a normal day. They cost during an incident, when the score is in one system, the trace behind it is in another, the record of which model actually served the request is in a third, and lining the three up is the first hour of the investigation. The same split shows up at renewal, when four vendors bill for one workflow.

This guide ranks the ten best Langfuse alternatives on how much of that work each one does inside a single system, from finding the trace behind a bad result through proving a fix and shipping it.

What Is Langfuse?

Langfuse is an open-source LLM engineering platform covering tracing, prompt management, evaluation, and metrics, founded in Berlin in 2022 and distributed under an MIT license. Teams instrument an application with the Python or TypeScript SDK, or send OpenTelemetry spans from anywhere, and get a nested trace of every model call, tool run, and retrieval step with latency and cost attached.

Evaluation is genuinely part of the product rather than a checkbox. Datasets, experiments run from the SDK or the UI, LLM-as-judge evaluators, custom scores, human annotation queues, and alerts on score movement are all available, including on the free tier. Prompt management ships versioning, release labels, composability, server and client caching, and a playground, and it is the piece teams most often keep even after moving tracing elsewhere.

Instrumentation coverage is broad. Callback handlers exist for the OpenAI SDK, LangChain, LlamaIndex, LiteLLM, the Vercel AI SDK, Haystack, and Mastra, and OpenTelemetry ingest handles Java, Go, and custom instrumentation. Native SDKs are Python and TypeScript only, so teams on other runtimes go through OTel or the API.

ClickHouse Acquired Langfuse: What Changed

ClickHouse announced the acquisition of Langfuse on January 16, 2026, alongside a $400 million Series D led by Dragoneer. Langfuse was already built on ClickHouse for telemetry storage, which is the stated logic behind the deal.

For anyone currently running Langfuse, the roadmap is mostly unchanged. Their commitment to open source and self-hosting continues, and there are no immediate changes to how the product is used. That has held up in the release cadence so far: Langfuse v4 went live on August 17, 2026, marketed as real-time and up to 165 times faster at scale, and the open-source repository is still shipping releases weekly. Anything written this year that treats Langfuse as a frozen product has not been updated.

It's worth keeping in mind what an acquisition does to a roadmap over a longer horizon, especially in this case. Langfuse now sits inside a company whose core business is a database and whose commercial interest in LLM observability runs through making ClickHouse the place that data lives. That is a coherent place for the product to sit, and it also means the prioritization conversation now includes a parent company with its own priorities. Choosing a platform here is a multi-year instrumentation commitment, and this one changed roadmap owners.

Langfuse Pricing

Langfuse Cloud bills a monthly subscription plus usage, where usage is counted in units rather than requests. A unit is a trace, an observation, or a score.

• Hobby - Free. 50k units per month, 30 days of data access, 2 users, 1 annotation queue, 2 alerts, and 1,000 requests per minute of ingestion throughput.
• Core - $29/mo. 100k units, 90 days of data access, unlimited users, 3 annotation queues, 20 alerts, and 4,000 requests per minute.
• Pro - $199/mo. 100k units, 3 years of data access, 50 alerts, 20,000 requests per minute, SOC 2 Type II and ISO 27001 reports, and a HIPAA-ready region.
• Teams add-on - $300/mo on top of Pro. Enterprise SSO, SSO enforcement, fine-grained RBAC, and a dedicated Slack or Teams channel.
• Enterprise - $2,499/mo. Audit logs, SCIM, custom rate limits, uptime and support SLAs, and a dedicated support engineer.
• Overage - $8 per additional 100k units on every paid tier, lower with volume commitments.

The included allowance stops moving above Core. Pro and Enterprise both include the same 100k units, and every unit past that costs the same $8 per hundred thousand no matter which tier you sit on. What the higher tiers buy is retention, ingestion throughput, alert count, and access controls, which is a reasonable thing to sell and worth knowing before anyone budgets an upgrade as a way to cover growth.

Self-hosting removes the meter and replaces it with infrastructure. The MIT core carries the full feature set rather than a limited community build, so this is a real option. What you take on is Postgres, ClickHouse, and the application containers, plus whoever gets paged when ingestion backs up.

How to Compare Competitors to Langfuse

Nearly every tool here traces, scores, and versions prompts. What differs is how many of those jobs run in one system, and what it costs you when they don't.

• Trace to dataset - Production failures are the only test cases that reflect what your users actually send. Whether a trace becomes a dataset row with a filter and a click, or with an export script somebody maintains, decides how often the regression suite reflects reality.
• Offline evals against online evals - Scoring a curated set before deploy catches known regressions. Scoring live production spans catches the failure that only appears against real inputs. Platforms differ sharply here, and the second one is the harder capability to add later.
• Prompts as a deployable artifact - A prompt change that requires a code change and a deploy is a prompt change most teams batch and delay. Versioning, release labels, and instant publish turn it into something anyone can ship on a Tuesday.
• Routing in scope or out - Running one provider makes this irrelevant. Running several means the model that served a request and the score that request earned either live together or get correlated by hand at 2am. Failover, caching, and hard spend limits sit in this same layer.
• Where the instrumentation sits - A proxy receives HTTP requests, so it reports tokens, latency, and cost per call and never sees the reasoning between two calls. SDK and OpenTelemetry instrumentation runs inside the application, so it captures tool arguments and retrieved context. This sets the ceiling on everything above it.
• What the license actually buys - Teams reach for open source because prompts and completions cannot leave a boundary, which is a deployment question rather than a licensing one. Several platforms satisfy the residency requirement through enterprise deployment without publishing any source, and several publish source while gating the compliance features that make self-hosting worthwhile.

Count how many of those your current setup handles in one system and how many it handles across two or three. The gap is the thing you are shopping for.

10 Best Langfuse Alternatives

1. Respan

Respan is the only platform here that runs gateway, observability, monitoring, and evals as one system, which means the model that served a request and the score that request earned are attached to each other by default rather than by a join somebody writes. Route, observe, and evaluate every LLM call. Instead of reading logs after the fact, teams use Respan to run observability in production, know when production shifts, and act before it spreads.

Every LLM call, tool run, retrieval, and agent turn becomes a span in one nested trace, each carrying its own input, output, latency, and cost. Click any score and land on the trace behind it.

• Turn failures into test cases - Pull requests from logs by filter and sampling rate into a dataset, so every case is one your users actually sent.
• Score quality, not vibes - LLM judges, deterministic code checks, and human review compose into one evaluator, and the same evaluator deploys on live production spans so regressions surface in real time.
• Prove the fix worked - Experiments run a prompt version, a model, or a dataset through your evaluators at scale, with side-by-side score distributions and a click into the full trace behind any row.
• Ship prompts without shipping code - Versioned templates deploy instantly and the application picks up the new version on publish, with no redeploy to change a prompt.
• Stay up when providers fail - One endpoint reaches 1,000+ models with automatic failover, retries, and load balancing, and switching models is a one-word change.
• Stop runaway spend - Budgets and rate limits per key, per customer, or org-wide, blocking requests rather than only warning.
• Audit your own agents - Red team campaigns probe for prompt injection, system-prompt leakage, and goal hijacking against the same connected agent you already trace.

For example, Retell AI runs over a million hourly LLM calls through Respan and scaled from 5M to 500M+ monthly API calls, with CTO Zexia Zhang crediting the debugging layer with resolving production issues 10x faster.

Coverage: Tracing, online and offline evals, datasets, experiments, human review, prompt management, gateway, red teaming, and cost attribution on one platform.

Pricing: Free covers 100k logs, 1k scores, 5 datasets, 2 evaluators, 5 prompts, and 7-day retention, with unlimited seats. Team is $199/mo billed yearly and lifts datasets, evaluators, and prompts to unlimited with 10k scores, 30-day retention, 5 members at $15 each beyond that, and a 99.9% uptime SLA.

2. LangSmith

LangSmith covers tracing, datasets, evaluation scoring, annotation queues, and a prompt hub, which is close to the same surface area as Langfuse. What it adds for teams on LangGraph is the development environment: visualize the graph, set breakpoints, modify state mid-run, and resume from a checkpoint.

Depth concentrates inside one ecosystem. LangSmith traces any framework through a traceable wrapper and added OpenTelemetry support in 2026, but the trace detail outside LangChain and LangGraph is noticeably thinner, which makes adopting it a bet on a framework as much as on a platform. Built-in evaluation metrics are limited enough that LLM-as-judge scoring is mostly custom work, and there is no routing layer, so provider failover and spend control stay elsewhere.

Because seats and traces meter separately, the bill tracks team size independently of usage, which discourages exactly the cross-functional access that makes annotation queues valuable in the first place. Also, self-hosting is Enterprise only.

Coverage: Tracing, datasets, evals, annotation, prompt hub. No gateway.

Pricing: Free Developer tier with 5k base traces per month. Plus at $39 per seat per month plus $0.50 per 1k base traces, with extended-retention traces at $2.50 per 1k.

3. Braintrust

Evaluation is the organizing principle at Braintrust, and the loop it closes tightest is the one that runs through CI. Scoring functions, comparison reports, statistical significance testing, and regression detection are all first-class, GitHub Actions and GitLab CI integration puts pass or fail status in a pull request comment, and a failing gate blocks the merge rather than filing a ticket.

It also ships a proxy that captures traffic with no code changes, which puts more of the loop in one place than most of this list manages. What the proxy does not do is route: there is no failover, no load balancing, and no model-level spend control, so the gateway job remains a separate purchase for teams running several providers.

Tracing exists to feed the eval workflow, so it is less developed than in platforms built for production debugging, and teams whose actual problem is finding what broke overnight tend to find the product aimed somewhere else. Self-hosting is Enterprise only and the platform is closed source. Eval volume can also grow with the size of the test suite rather than with traffic, so the tier escalation might arrive earlier than what your team is planning for.

Coverage: Evals, datasets, experiments, tracing, prompt playground, logging proxy. No routing or failover.

Pricing: Free tier with 1 GB of processed data, unlimited users, and 10k eval runs monthly. Pro at $249/mo scaling with usage. Enterprise custom and undisclosed.

4. Arize

Arize built a classical ML observability product and extended it into LLM workloads, which shows in both directions. Embedding drift detection and clustering carry over from the ML side and surface patterns in outputs that aggregate metrics hide, and agent runs render as graph visualizations with latency and error tracking across 20+ framework integrations.

Instrumentation goes through OpenInference, a set of OpenTelemetry semantic conventions for LLM spans that Arize maintains and other backends can read. Instrumenting once and moving later stays cheap because of that, which is worth weighing even if you end up somewhere else.

Evaluation is the shallower part of the product, since the metrics layer was adapted from model monitoring rather than built for LLM output quality. Custom evaluators are supported, though built-in research-backed scoring for faithfulness and hallucination is not, and prompt versioning is limited enough that the ship-the-fix step happens outside the platform.

Coverage: Tracing, online evals on spans, experiments, drift and embedding analysis. Limited prompt versioning, no gateway.

Pricing: Free tier capped at one user and 25k trace spans. Paid plans from around $50/mo, with Enterprise custom. Phoenix, the open-source tracing library under Elastic License 2.0, is free and self-hostable.

5. Laminar

Storage is the problem Laminar set out to solve. Agents re-send the whole conversation every turn, so it stores each unique message once and reconstructs the trace on read, which the vendor reports as roughly 20x less storage on average and up to 50x on long runs.

Signals is the more interesting capability. A plain-language prompt runs against every trace, produces structured events when it matches, and clusters those events, so ten thousand agent runs collapse into the handful of behaviors your agent actually has.

Prompt management is the gap, and Laminar says so directly: it is a debugger and observability platform, not a prompt registry, so teams moving off Langfuse keep prompts somewhere else and the loop stays split across two systems. Laminar also doesn't offer an LLM gateway.

Coverage: Tracing, code-first evals, Signals with clustering, agent debugger, SQL access. No prompt management, no gateway.

Pricing: Free covers 1 GB with no overage, $5 in Signals credits, 7-day retention, one project, one seat. Starter $30/mo for 3 GB then $2/GB with $15 in credits and 30-day retention. Pro $150/mo for 10 GB then $1.50/GB with $50 in credits and 6-month retention. Enterprise custom with on-premise. Apache 2.0 and free to self-host via Helm.

6. Confident AI

Confident AI inverts the usual arrangement by treating evaluation as the product and tracing as the runtime layer that feeds it. Metrics come from DeepEval, the open-source framework the same team maintains, covering 30+ single-turn and 15+ multi-turn scorers, custom G-Eval criteria defined in natural language, and deterministic code-based checks. .

With Confident AI, production traces auto-curate into evaluation datasets on rules, online evals run continuously on live traffic including multi-turn agents, signals surface new topics and frustrated users without anyone writing a query, and prompt versioning supports pre-commit evals and Git-style branching on the higher tiers.

Three things to plan around: The free tier caps at 5 test runs per week and 1 GB-month of trace spans, with additional spans dropped rather than queued, so an overrun loses data instead of generating a bill. Evaluation also consumes LLM tokens charged on top of the subscription at roughly $0.05 per million input and $0.40 per million output, and red teaming and AI governance are separate modules above Enterprise rather than included features.

Coverage: Evals, online evals, datasets, tracing, annotation, prompt management, signals. Red teaming as a paid module, no gateway.

Pricing: Free at $0 with 2 seats, 1 project, 5 test runs weekly, 1 GB-month of spans. Starter $200/mo with unlimited seats, 5 projects, 5 GB-months, then $1 per GB-month. Team $2,000/mo with unlimited projects and 75 GB-months, adding SOC 2, SSO, and custom RBAC.

7. Helicone

Helicone is in maintenance mode. Mintlify acquired it on 3 March 2026, and the team defines ongoing work as security updates, bug fixes, performance fixes, and new model support, with feature development ended and help offered to customers migrating. That makes it a poor destination for a migration and a defensible place to stay for a while if you are already there.

The half of the loop it covers is the half most of this list skips. Helicone is a gateway first: change a base URL and request logging, caching, rate limiting, retries, and cost breakdowns per user and provider arrive without touching application code. For teams whose Langfuse gap is routing rather than evaluation, that is the relevant capability.

What it does not do is score. There is no evaluation layer, no dataset curation, and no experiment comparison, so a Helicone deployment covers routing and logging and leaves the entire quality half of the loop to another tool. Our roundup of Helicone alternatives covers where existing deployments can go.

Coverage: Gateway, request logging, caching, cost tracking. No evals, no datasets, no experiments.

Pricing: Hobby free with 10,000 requests per month and one seat. Pro $79/mo with unlimited seats, alerts, and reports. Team $799/mo adding SOC 2 and HIPAA. Enterprise custom with on-prem.

8. Galileo

Galileo is an evaluation platform aimed at teams where quality and compliance drive the buying decision. More than twenty vendor-maintained evaluators cover hallucination detection, context adherence, and completeness without any scorer configuration, and Luna-2 small language models score inline so checks don't route through a heavyweight judge on every request. Note that Cisco did acquire Galileo in 2026, so the roadmap may have changed as a result.

However, runtime guardrails sit behind the Enterprise tier, which is the detail worth checking early, since they're the reason most teams look at Galileo in the first place. The free tier caps at 5,000 traces per month, so evaluating the capability at any real volume means a sales conversation. There is also no self-hosting on any tier, which rules it out where prompts and completions can't leave your infrastructure.

The audit workflows produce the reporting a risk function asks for, and that orientation shapes the rest of the product. Prompt iteration happens outside the platform, with no versioning or A/B testing built in, so the path from a failing score to a shipped fix runs through other tools.

Coverage: Vendor-managed evaluators, runtime guardrails on Enterprise, audit reporting. No prompt management.

Pricing: Free at 5,000 traces per month. Pro at $150/mo including 50,000 traces with usage-based overages. Enterprise is custom and required for both guardrails and any deployment inside your own environment.

9. Weights & Biases Weave

Eligibility is the first thing to check with Weights & Biases. Pro at $60/mo is restricted to organizations with fewer than 50 employees, stated as a requirement rather than a guideline, so growing past that headcount means an Enterprise conversation regardless of how little you use. The self-hosted free tier prohibits corporate use entirely, which removes the option most likely to appeal to teams with data residency concerns.

For teams already tracking experiments there, Weave extends the existing console into LLM tracing and evaluation, and the path of least friction is real. Dashboards and interactive tables make comparing runs and inspecting predictions faster than any alternative here, artifact lineage tracks datasets and models as versioned objects, and the eval framework with scorers and comparisons is mature enough to carry the offline half of the loop.

The trace interface carries over from experiment tracking rather than being built for agent runs, which shows up most during long executions where live viewing is weak. Prompt management is thin and there is no gateway, so the ship-the-fix step happens outside. Weave data ingestion overage runs $0.10 per MB, roughly $100 per GB, which is the number to model before committing anything agent-shaped.

Coverage: Experiment tracking, artifact lineage, LLM tracing, evals with scorers. Thin prompt management, no gateway.

Pricing: Free gives 5 model seats, 5 GB of storage, and 1 GB of Weave ingestion monthly. Pro from $60/mo with 100 GB of storage and 1.5 GB of Weave ingestion, additional storage at $0.03/GB. Enterprise custom, covering HIPAA, SSO, and private hosting.

10. MLflow

MLflow belongs on this list because so many teams already run it, and because recent versions added GenAI tracing, evaluation, prompt management, and an AI Gateway alongside the experiment tracking and model registry it has always had.

That breadth comes with a caveat familiar to anyone who has operated it. The open-source server is a component rather than a product: authentication, access control, and high availability are yours to build, artifact storage is a separate concern you configure and pay for elsewhere, and the interface slows noticeably when comparing hundreds of runs.

The GenAI features are also newer and thinner than in platforms built for inference workloads first. As with self-hosting Langfuse, free describes the license rather than the total, and the two decisions have the same shape: you are choosing to own an operational surface in exchange for owning the data.

Coverage: Experiment tracking, model registry, GenAI tracing, evals, prompt management, AI Gateway with routing and fallback. Depth depends on your own instrumentation.

Pricing: Free and open source. The real cost is the server, the backing database, the artifact store, and the engineer keeping all three alive.

Frequently Asked Questions

Langfuse vs LangSmith: which should you use?

LangSmith fits teams whose stack is LangChain or LangGraph and will still be in two years, since trace depth and the LangGraph development environment are both strongest there. Langfuse fits teams that want framework independence, an MIT-licensed core, and self-hosting without an enterprise contract. On coverage the two are close, since both trace, both run datasets and evaluators, and both version prompts, and neither includes a gateway. Cost structures differ more: LangSmith meters seats and traces separately so the bill tracks team size, while Langfuse meters units against an allowance that stops growing above the $29 tier. For teams that would rather not tie observability to a framework choice or to headcount, Respan vs Langfuse covers the option that adds routing to the same platform.

What is the best Langfuse alternative?

Respan, for most teams running agents in production, because it closes more of the loop in one system than anything else here. A bad score links to the trace that produced it, that trace becomes a dataset, an experiment proves the fix against real data, the new prompt version ships without a deploy, and the same evaluator keeps scoring live traffic afterward. The gateway that routed the request sits on the same platform, so the model, the cost, and the score are one record. Teams whose only bottleneck is regression gating in CI will find Braintrust closer to that specific workflow, and teams committed to LangGraph will get more from LangSmith.

What is the best open-source Langfuse alternative?

Laminar is the closest match on license terms, at Apache 2.0 with every feature on the self-hosted image and a one-command Helm chart, though it has no prompt management. Phoenix, the open-source library from Arize, is available under Elastic License 2.0, and Helicone is Apache 2.0 but currently in maintenance mode.

Worth separating first is which requirement you actually have. Teams usually reach for open source because prompts and completions cannot leave a boundary, or because a security review is coming and someone needs to answer for where the data sits. Respan handles that through compliance posture rather than through a license: SOC 2, HIPAA with a BAA, GDPR, and ISO 27001, with PII masking and the ability to omit log payloads entirely so sensitive fields never land in the platform. For most teams that clears the same review an open-source deployment would, without taking on a database cluster to operate.

Is Langfuse still open source after the ClickHouse acquisition?

Yes. The core remains MIT-licensed with no usage limits for commercial use, the self-hosting deployment guides are still published and maintained, and Langfuse has stated that its commitment to open source and self-hosting continues under ClickHouse. Release activity supports that, with v4 shipping in August 2026 and the repository still updating weekly. The open question is not the license but whether a database company's roadmap priorities match yours over the several years an instrumentation choice tends to last.

Picking the One That Fits

Count the systems your current setup touches between a bad output and a shipped fix. If the answer is one, you do not need this list. If it is three or four, the tax is the correlation work between them, and it gets paid during every incident rather than once at purchase.

Respan runs tracing, evaluation on live production traffic, prompt management, and the AI gateway that served the request on one platform. Start for free or book a demo.