Langfuse vs LangSmith: In-Depth Comparison (2026)

We may earn a commission if you buy through our links, at no extra cost to you.

Langfuse and LangSmith are the two names that come up in every "which LLM observability tool?" thread — and they're genuinely different products, not two flavors of the same thing. Langfuse is the open-source (MIT), framework-agnostic platform: trace, evaluate, and manage prompts for any runtime, self-hosted or on their cloud. LangSmith is LangChain's managed platform: deepest-in-class tracing and evaluation for LangChain/LangGraph apps, closed source, per-seat pricing. We signed up for both, instrumented the same test app (a small RAG agent) with each, ran evaluations on both, and timed the onboarding. Here's the honest, head-to-head result — no vendor talking points.

Side-by-side spec comparison

Pricing changes often — check both official pricing pages before budgeting.

Pricing compared

Let's use real starting prices. Langfuse Cloud: Hobby is free (50k units/month, 2 users, 30-day retention); Core is $29/month (100k units included, 90-day retention, unlimited users, overage ~$8/100k units on a graduated scale that drops with volume); Pro is $199/month (3-year retention, SOC2/ISO reports, HIPAA BAA); Enterprise is $2,499/month. Self-hosting the MIT-licensed stack is free. LangSmith: Developer is free (5k base traces/month, 1 seat, 14-day retention); Plus is $39/seat/month (10k base traces included, then per-trace overages at roughly $0.50/1k base traces and ~$4.50/1k extended traces); Enterprise is custom and is the only tier with self-hosting. Note the billing wrinkle: LangSmith distinguishes "base" traces (short, simple) from "extended" traces (multi-turn, tool-heavy — i.e., agents), and extended traces bill roughly 9x the base rate.

Now a usage scenario: a 5-person team logging 100k traces/month, with agents averaging ~10 spans per trace.

• Langfuse: Core at $29/month covers 100k units; at 10 spans/trace that's 1M units, so add 900k × ~$8/100k ≈ $72 → ~$101/month, unlimited users.
• LangSmith: Plus at 5 × $39 = $195/month covers 10k base traces; the remaining ~90k base traces × ~$0.50/1k ≈ $45 → ~$240/month. If those are agent-style extended traces, the overage math gets ugly fast — several hundred dollars more.

The takeaway: Langfuse is cheaper in nearly every scenario, and the gap widens with team size (seats) and agent complexity (extended traces). LangSmith's premium is only justifiable if you're deep enough in LangChain that the native DX pays for itself. And one more time, because both vendors move prices: pricing changes often — check the official sites before you budget.

One more scenario — self-hosted: Langfuse self-hosted costs $0 in license fees, just infrastructure (roughly $200–800/month at serious volume for ClickHouse, Redis, and blob storage, plus the engineering time to operate them). LangSmith has no equivalent — self-hosting requires Enterprise on a custom quote, typically a five-figure annual commitment. The break-even we see in practice: below ~50M units/month, managed wins; above ~100M units/month, self-hosted Langfuse wins on pure cost, but only with real ClickHouse operational muscle. Teams that migrate to self-hosting to save $500/month and then burn two engineer-weeks tuning ClickHouse have not saved anything.

Tracing & observability

This is where both tools shine, in different ways. LangSmith's trace view is built around nested runs: every chain step, tool call, and retriever hit renders as a collapsible tree with inputs, outputs, latency, and token counts per node. For LangGraph agents, the trajectory view — watching the agent bounce between tools and reasoning steps — is the best we've used anywhere. Filtering by project, tagging runs, and comparing a failing run against a passing one all felt fast and well thought through.

Langfuse's trace view is built around the same tree concept but adds sessions (grouping traces by user conversation) and user-level analytics — useful when your question is "which users are having bad experiences?" rather than "what did this one call do?" The span-level detail (exact prompt sent, response, token counts, model name, cost) is equivalent. Where Langfuse pulls ahead for non-LangChain teams is instrumentation flexibility: first-class OpenTelemetry GenAI support means spans from your existing OTel pipeline land natively, and the OpenAI drop-in wrapper traced our test app with barely any code changes.

Verdict on tracing: LangSmith wins for LangChain/LangGraph agent trajectories; Langfuse wins for framework-agnostic setups and session-level analytics. Both are excellent at the core job — if tracing alone decided it, you'd be happy with either.

One more observability difference worth knowing: alerting. Langfuse ships alerting on any observation or score metric, with separate warning and alert thresholds, no-data handling, and delivery to Slack, webhooks, or GitHub Actions — available on both cloud and self-hosted. LangSmith offers rules-based alerting that covers the basics well. In our testing, Langfuse's alerting felt more flexible for production on-call setups. Neither tool offers hard spending caps, though — both will happily bill you for a runaway agent loop, so configure alerts before you need them.

Evaluations & testing

Here's where the comparison gets interesting, because both tools take evaluation seriously — they just emphasize different parts. LangSmith's eval story is the most mature we've tested: build datasets from production traces (or upload your own), run LLM-as-judge evaluators or code-based checks, compare experiments pairwise with statistical summaries, and route ambiguous traces to human reviewers through a genuinely well-designed annotation queue. If your bottleneck is "we can't tell whether the new prompt is better," LangSmith is a strong, complete answer.

Langfuse covers the same surface — datasets, experiments, LLM-as-judge and code-based evaluators, scores attached to traces, online evaluators running on production traffic, and annotation queues (unlimited on Pro) — and adds things LangSmith doesn't emphasize, like user-session-level analysis of eval results. In our testing, LangSmith's eval UX felt about half a step ahead in polish (the pairwise experiment comparison in particular), while Langfuse's open-source nature meant we could see exactly how scores were computed and extend the pipeline. For teams that want evals gating deployments automatically rather than dashboards to review, it's also worth looking at Braintrust, which is purpose-built for CI/CD-gated evaluation.

Verdict on evals: LangSmith by a nose on maturity and annotation workflow; Langfuse on openness, online evals, and cost. Most teams would be productive with either.

The annotation-queue comparison deserves a closer look, since it's where LangSmith most clearly leads. In LangSmith, routing ambiguous traces to human reviewers — with queues, reviewer assignment, and agreement tracking — felt like a finished product built for teams where domain experts label outputs daily. Langfuse's annotation queues (unlimited on Pro) cover the same workflow and we had no functional complaints, but the reviewer UX is less refined. If your quality process depends on non-engineers doing high-volume labeling, that polish matters; if engineers do occasional spot-checks, it doesn't.

Developer experience

We timed onboarding for both, starting from a fresh account with our small RAG test app. LangSmith, on a LangChain app: set two environment variables, run the app, traces appear — under two minutes, genuinely zero code changes. On a non-LangChain app (raw OpenAI SDK): install the SDK, wrap functions with @traceable, configure the project — about fifteen minutes, still pleasant. The docs are thorough, though the pricing docs took longer to parse than the SDK docs. Langfuse: sign up for Hobby (no card), grab the API keys, use the OpenAI drop-in wrapper or the Python SDK — first trace in the dashboard in under ten minutes. Self-hosting via Docker Compose took about twenty minutes on a fresh VM, most of it waiting for ClickHouse to initialize.

SDK quality is high on both sides (Python and TypeScript first-class), and both have solid docs. The DX difference that actually matters long-term isn't onboarding speed — it's billing transparency. Langfuse's usage dashboard shows units consumed in near-real time; LangSmith's base-vs-extended trace distinction meant we had to read the pricing docs twice to model our own bill. For a developer tool, that friction counts.

On docs and community: both are strong, but the flavor differs. LangSmith's docs assume LangChain knowledge and its community produces abundant walkthroughs; Langfuse's docs are more standalone-friendly, and being open source means obscure questions get answered in GitHub issues with code references. We found answers faster in Langfuse's repo; we found more step-by-step tutorials for LangSmith.

The honest downsides

Neither tool is perfect, and the marketing pages won't tell you this. Langfuse's units-based billing punishes deep instrumentation — the more spans you emit per trace, the faster the meter runs, which creates a perverse incentive to instrument less precisely when you want more visibility. Its self-hosted story is genuinely free, but operating ClickHouse, Redis, and blob storage in production is real operational work, and teams routinely underestimate it. LangSmith's downsides are structural: per-seat pricing means the bill grows with headcount even if usage doesn't, the base-vs-extended trace distinction makes bills hard to predict, and you're betting your observability layer on a closed-source platform whose roadmap you don't control. Neither downside is a dealbreaker — but go in with eyes open.

Verdict on DX: LangSmith wins the first ten minutes if you're on LangChain; Langfuse wins on billing clarity and framework freedom. Docs and SDKs are a draw.

Final verdict: which should you choose?

There is no single winner — there's a right tool per situation. Here's how we'd decide:

Our personal take after testing both: if we were starting a new agent project today outside the LangChain ecosystem, we'd pick Langfuse — the combination of self-hosting, sane billing, and complete features is hard to argue with. If we were already deep in LangGraph with a team doing heavy prompt evaluation, we'd pay LangSmith's premium without much complaint. The most common mistake we see is choosing on brand familiarity instead of architecture: decide based on where your traces actually come from and what your evaluators need to prove, not on which logo you've seen more often. And if neither fits — per-seat pricing too rich, or you want something lighter — see all LangSmith alternatives or all Langfuse alternatives, or zoom out to our 10 best LLM observability tools guide for the full category.

Try Langfuse →   Try LangSmith →

Looking for more developer tooling? Browse our AI coding tools category.