LangSmith vs Langfuse on pricing with worked examples, free vs Enterprise self-hosting, agent evals, judges and CI, checked against both vendors' docs.
LangSmith and Langfuse both trace an LLM application, run evals on datasets and on live traffic, manage prompts and send outputs to human reviewers. Choose Langfuse if you need to self-host without an Enterprise contract, want more than 180 days of history, or have many people who need access. Choose LangSmith if you build on LangChain or LangGraph, want ready-made agent trajectory evaluators, or run deep agents where hundreds of spans per request would make Langfuse's per-span meter the more expensive one.
They bill on different meters. As of November 2026, LangSmith Plus is $39 per seat a month plus $5 per 1,000 traces beyond the first 10,000. Langfuse Core is $29 a month for any number of users, plus $8 per 100,000 units beyond the first 100,000, where every trace, every span inside it and every score is one unit. For five people and 50,000 agent requests a month with ten spans each, that is about $408 on LangSmith Plus and about $65 on Langfuse Core.
Langfuse is MIT-licensed outside its ee folders and self-hosts for free with no usage limits.
LangSmith is proprietary, and self-hosting it is an Enterprise add-on. Neither documents a statistical test on the difference between two experiments.
This post compares them on pricing with worked examples, self-hosting, evals, CI and getting your data out, then checks each vendor's comparison page against the other vendor's docs.
A disclosure: I build EvalShift. It replaces neither platform, and it appears only in the section on what both leave to you. Every claim here comes from the vendors' own pricing pages, docs and announcements, read on November 18, 2026.
LangSmith vs Langfuse at a glance #
| Langfuse | LangSmith | |
|---|---|---|
| Company | Langfuse, acquired by ClickHouse β in January 2026 | LangChain; $300M Series C β at a $3B valuation, November 13, 2026 |
| License | MIT, except the ee folders |
Proprietary; SDKs, openevals and agentevals MIT |
| Free cloud plan | Hobby: 50k units a month, 30 days of data, 2 users | Developer: 1 seat, 5k traces a month, 14 days |
| First paid plan | Core: $29 a month, unlimited users | Plus: $39 per seat a month |
| What is metered | Units: traces, observations and scores | Seats, and traces |
| History | 30 days (Hobby), 90 days (Core), 3 years (Pro and Enterprise) | 14 days base, 180 days extended |
| Self-hosting | Free on every plan; Enterprise license adds features | Enterprise add-on with a license key |
| SDKs | Python, TypeScript; other languages through OpenTelemetry | Python, TypeScript, Go, Java |
| OpenTelemetry | SDKs built on it; ingests OTLP | Ingests OTLP |
| Offline evals | run_experiment() on a hosted or local dataset, or prompt experiments in the UI |
evaluate() , or pytest, Vitest and Jest tests |
| Ready-made agent evaluators | Write your own | agentevals trajectory match and judge |
| CI | Official experiment-action β with a fail-on-regression gate and a PR comment |
Your own workflow running the test suite |
| Agent deployment | No | LangSmith Agent Server |
Sources: Langfuse pricing β, Langfuse self-hosted pricing β, LangSmith pricing β, LangSmith usage and billing β.
Pricing: traces and seats against units #
LangSmith
| Developer | Plus | Enterprise | |
|---|---|---|---|
| Price | Free | $39 per seat a month | Custom |
| Seats | 1 | Unlimited | Custom |
| Included traces | 5k a month | 10k a month | Custom |
| Hosting | Cloud | Cloud | Cloud, BYOC or self-hosted |
Beyond the included traces, LangSmith charges $5 per 1,000 base traces, kept for 14 days. Upgrading a trace to extended retention, 180 days, costs a further $2.50 per 1,000. The pricing page quotes these in LangChain Standard Units (LSUs), where one LSU is one dollar.
A trace is one request end to end, however many model and tool calls it contains. Two details move the bill:
- +Evaluators extend retention by default. A new online evaluator or automation rule upgrades the traces it matches to extended retention unless you opt out. Scoring a trace therefore adds $2.50 per 1,000, though there is no per-score charge.
- +180 days is the ceiling on the cloud. Since September 14, 2026, LangSmith Cloud keeps traces for at most 180 days. Self-hosted and BYOC installs default to 400 days.
Langfuse
| Hobby | Core | Pro | Enterprise | |
|---|---|---|---|---|
| Price | Free | $29 a month | $199 a month | $2,499 a month |
| Users | 2 | Unlimited | Unlimited | Unlimited |
| Included units | 50k a month | 100k a month | 100k a month | 100k a month |
| Data access | 30 days | 90 days | 3 years | 3 years |
| Annotation queues | 1 | 3 | Unlimited | Unlimited |
A unit is one billable data point β: a trace, an observation inside it, or a score. Observations are the spans: each model call, tool call, retrieval or custom step you record. An agent request with ten observations and one evaluator score is 12 units. Units that Langfuse creates count too: an LLM-as-a-judge evaluator stores a trace of its own execution, so each judged request adds a few more.
Beyond the included 100k, units are billed in graduated tiers: $8 per 100k up to 1M, $7 per 100k up to 10M, $6.50 per 100k up to 50M, and $6 per 100k above that. Enterprise SSO, project-level roles and scheduled export are a $300-a-month Teams add-on on Pro, and included in Enterprise.
Langfuse's plan limit is on data access, not storage. Older data stays stored and becomes visible again if you upgrade; deleting data after a set period is a separate, opt-in feature on Pro and Enterprise.
What the same team pays on each
The two cannot be put on one unit, so a comparison needs assumptions. Mine: five people, and one evaluator scoring 10% of requests. The judge model's own token cost is extra on both, and the Langfuse figures leave out the judge's execution traces, which add about $1 in the first case and about $13 in the second.
50,000 agent requests a month, ten observations each
- +LangSmith Plus: $195 for five seats, plus 40,000 traces beyond the included 10,000 at $5 per 1,000, which is $200. Extended retention on the 5,000 scored traces adds $12.50. About**$408 a month** .
- +Langfuse Core: 50,000 requests at 11 units each, plus 5,000 scores, is 555,000 units. The 455,000 above the allowance cost $36.40. About**$65 a month** , with 90 days of data. On Pro, with three years, about $235.
1,000,000 agent requests a month, ten observations each
- +LangSmith Plus: $195 for seats, plus 990,000 traces at $5 per 1,000, which is $4,950. Extended retention on the 100,000 scored traces adds $250:$5,395 a month . Keeping every trace for 180 days adds another $2,250.
- +Langfuse Core: 11.1 million units. $72 for the units up to 1M, $630 for the next 9M and $71.50 for the last 1.1M: about**$803 a month** . On Pro, about $973.
50,000 requests a month from a deep agent, 150 observations each
- +LangSmith Plus: the same $408 as the first case, because LangSmith bills the trace, not what is inside it.
- +Langfuse Core: 7.55 million units. $72 up to 1M and $458.85 for the rest: about**$560 a month** .
The third case is where the meters cross. At the margin, a LangSmith trace costs $0.005 and a Langfuse unit costs $0.00007 to $0.00008, so an extra request is cheaper on Langfuse until it carries roughly 60 to 70 units. Seat fees move the point where whole bills cross: for one person at 50,000 requests a month it is about 63 units per request, and for the five-person team about 108. Most chat and RAG requests carry far fewer. A coding or research agent that makes a hundred tool calls per task can carry more.
Headcount pulls the other way: twenty more people cost $780 a month on LangSmith and nothing on Langfuse Core. In the deep-agent case, a team of 25 pays about $1,188 on LangSmith Plus and the same $560 on Langfuse.
Two cautions. A team sending a million traces a month to either vendor would negotiate, and neither publishes an Enterprise usage rate. And the comparison leaves out what LangSmith's bill covers that Langfuse does not sell, such as the agent runtime.
Self-hosting: free against Enterprise #
This is the largest difference between the two, and the main reason teams compare them.
| Langfuse | LangSmith | |
|---|---|---|
| Who can self-host | Anyone, free | Enterprise plan add-on β , with a license key |
| License | MIT β , except theee folders |
Proprietary |
| Free self-hosted version includes | All core features, Enterprise SSO, organization-level roles, no usage limits | No free version |
| Paid license adds | Project-level roles, data retention rules, audit logs, SCIM, server-side data masking, protected prompt labels | Everything is licensed |
| Services you run | Web and worker containers, Postgres, ClickHouse, Redis or Valkey, S3-compatible blob storage | Kubernetes services, Postgres, Redis or Valkey, blob storage, and ClickHouse or, from version 0.17, SmithDB |
| Install paths | Docker Compose for one VM; Helm, and Terraform for AWS, Azure and GCP, for production | Helm or Terraform on Kubernetes |
| Commercial option | Enterprise license, priced on top of a ClickHouse Cloud, BYOC or Private plan | BYOC β on Enterprise, operated by LangChain |
Sources: Langfuse self-hosting β, Langfuse self-hosted pricing β.
What the table does not show is that the operational work is similar. Both run a trace store next to Postgres, a Redis-compatible cache and object storage. Langfuse's trace store is ClickHouse. LangSmith's was ClickHouse too; from version 0.17 a new install can use SmithDB, LangChain's own trace store, instead. Langfuse says plainly that its Docker Compose setup has no high availability, scaling or backups, so production means Kubernetes or the cloud Terraform modules, which is where LangSmith starts. On Langfuse, budget for operating ClickHouse; it is the part most teams have not run before.
The difference is the license. A Langfuse install can go into production this afternoon without talking to anyone. A self-hosted LangSmith install needs a signed Enterprise contract first. Since the acquisition, Langfuse's own Enterprise self-hosted license is priced on top of a ClickHouse commercial plan, so a team that needs audit logs or SCIM on its own infrastructure is buying from ClickHouse.
Langfuse's repository is also active: v4.82.0 shipped on November 17, 2026, and the project has about 37,600 GitHub stars.
Evaluation #
An offline experiment looks much the same in both: a dataset, a function under test and a list of evaluators.
Langfuse:
from langfuse import Evaluation, get_client
from app import reply # your function that calls the model
langfuse = get_client()
def correct(*, output, expected_output, **kwargs):
return Evaluation(name="correct", value=float(output == expected_output["answer"]))
dataset = langfuse.get_dataset("order-questions")
result = dataset.run_experiment(
name="Support replies",
task=lambda *, item, **kwargs: reply(item.input["question"]),
evaluators=[correct],
)
print(result.format())
LangSmith:
from langsmith import Client
from app import reply # your function that calls the model
client = Client()
def correct(outputs: dict, reference_outputs: dict) -> bool:
return outputs["answer"] == reference_outputs["answer"]
client.evaluate(
lambda inputs: {"answer": reply(inputs["question"])},
data="Order questions",
evaluators=[correct],
num_repetitions=3,
)
Langfuse's runner also takes a local list instead of a hosted dataset, and runs prompt experiments from the UI without code. LangSmith can run a dataset as pytest β, Vitest or Jest tests, where each test syncs to a dataset example.
Where they differ:
| Langfuse | LangSmith | |
|---|---|---|
| Judge evaluators | LLM-as-a-judge β on observations or experiments; decision-model evaluators for typed questions | LLM-as-judge evaluators, offline and online |
| Code evaluators | Python or TypeScript, written in the UI, run online and on experiments; self-hosted needs a code evaluator dispatcher | Python or JavaScript, offline and online; on whole threads as advanced code evaluators, in beta |
| What an online evaluator sees | One observation, for judges and code evaluators alike; trace-level evaluators are deprecated | A run, or a whole thread; tool calls and results only with the trajectory input |
| Agent trajectories | Code you write in an experiment script | agentevals β : strict, unordered, subset and superset match, or a judge |
| Pairwise | Not in its evaluation docs | Pairwise evaluators β , human or automated |
| Checking a judge against humans | Score analytics β : Cohen's kappa, F1 and correlation between two scores | Align Evaluator β : label, test the judge, iterate |
| Human review | Annotation queues with assigned users, limited by plan | Annotation queues with rubrics; automation rules route runs into them |
| Datasets | Versioned; experiments can pin a version | Versioned; rules add matching traces |
| Prompts | Prompt management with labels, playground | Prompt Hub, playground |
Agents: what the judge can see
The row that matters most for agent teams is the third one. A Langfuse observation-level judge reads the input, output, metadata and tool calls of the observation it matches. It does not load sibling or child observations. To judge a whole agent run, you target the root observation, and the judge sees only what your application wrote onto that root. If the final answer is on the root but the tool calls are on children, the judge never sees the tool calls.
Langfuse's online code evaluators have the same limit: they see the tool calls recorded on the matched observation, not on its children. A check across a whole agent run goes in your experiment script.
LangSmith ships trajectory matchers, and its thread-level evaluators can read the conversation's trajectory, including the tool calls and tool results recorded on child runs. You have to choose that input: the default sends only the messages on root runs. The trajectory input is not available everywhere either: on the cloud it works in the GCP US, EU and APAC and AWS US regions, and a self-hosted install needs version 0.17 or later with queries switched to SmithDB. If you want to check on day one that an agent called the right tools in the right order, LangSmith has that ready.
The trajectory matchers are MIT-licensed functions, so you can call agentevals from a Langfuse experiment too. Evaluating agent tool calls covers what those checks catch.
Checking the judge
Both now give you a way to measure an LLM judge against human labels, which is the step most teams skip. LangSmith's Align Evaluator is a workflow: label examples, run the judge on them, revise the prompt. Langfuse's score analytics compares any two scores on the same objects, such as a judge score and a human annotation, and reports Cohen's kappa, F1 and agreement for categorical scores, or Pearson and Spearman correlation for numeric ones. When to trust an LLM judge explains what agreement level to ask for.
Comparing two experiments
Both let you pick a baseline and see what moved. Langfuse β shows aggregate scores, then each item side by side against the baseline, with filters such as "similarity below 0.2" to list the items that got worse. LangSmith β colors each example red or green against the baseline for each feedback key and counts how many did better or worse.
That is where both stop. I searched both vendors' documentation for a confidence interval, a
p-value or a significance test on an experiment comparison and found none; in Langfuse's case
the only match was a feature request in its GitHub discussions. LangSmith runs each example several times with
num_repetitions and shows the standard deviation across repetitions, which tells you how noisy
one example is but not whether two experiments differ.
It matters because experiment scores are noisy. On 200 cases, a pass rate of 86% has a 95% confidence interval of roughly 80.5% to 90.1%, so a three-point drop between two experiments can be nothing. How many eval cases do you need has the arithmetic.
CI #
This is the one area where Langfuse ships more than LangSmith.
Langfuse has an official GitHub Action,
langfuse/experiment-action β. It runs your
experiment scripts against a dataset, optionally pinned to a version, and posts or updates one
pull request comment with the status of each script, run-level scores, item-level scores and a
link to the comparison view. A script that raises RegressionError fails the job:
from langfuse import RegressionError, RunnerContext
THRESHOLD = 0.95
def experiment(context: RunnerContext):
result = context.run_experiment(
name="PR gate: support agent",
task=answer_support_question,
evaluators=[exact_match],
run_evaluators=[avg_accuracy],
)
accuracy = next(
(e.value for e in result.run_evaluations if e.name == "avg_accuracy"), 0.0
)
if accuracy < THRESHOLD:
raise RegressionError(
result=result, metric="avg_accuracy", value=accuracy, threshold=THRESHOLD
)
return result
The threshold is yours to write, and Langfuse's own docs warn that an average can hide a newly failing case: a candidate that fixes two cases and breaks one has a higher score. They recommend keeping a reviewed, per-case baseline file in your repository and failing on any case that passed before and fails now. Choosing a baseline in the UI does not configure the gate.
LangSmith has no official eval action. The documented path is to run the pytest, Vitest or Jest suite in your own workflow, where a failed assertion fails the job. That is a direct gate with nothing posted on the pull request unless you add it.
Either way, the gate policy is yours to design. LLM regression testing in CI covers what to block on.
Getting your data out #
On LangSmith's cloud, traces past their retention window are deleted, so export matters more there.
- +Langfuse: the public API and UI export on every plan.Scheduled export β to S3, GCS or Azure Blob Storage, in Parquet, CSV, JSON or JSONL, needs the Teams add-on on Pro or Enterprise, and is available when self-hosted.
- +LangSmith: runs through the API or CLI, datasets as CSV or JSONL.Bulk export β to S3-compatible storage, as Parquet, is Enterprise only for organizations that signed up after August 3, 2026. Earlier customers keep it on Plus until February 1, 2027.
Moving between them is easier at the tracing layer than anywhere else. Both ingest OpenTelemetry, so an application instrumented with OTel can switch by repointing its exporter. Datasets move as files. Evaluators configured in either UI have to be rebuilt, and experiment history does not move.
What each vendor says about the other #
Both publish a comparison page: Langfuse's β, with LangSmith facts checked in October 2026, and LangChain's β, from April 2026. I checked their claims against the other side's docs.
| Claim | What the docs say in November 2026 |
|---|---|
| Langfuse: about 6x cheaper, $621 on Pro against $3,895 on LangSmith Plus for 500k traces, 10 spans, 1 score and 5 users | The arithmetic holds at list prices. It assumes 10 spans per trace; in that scenario the bills cross at roughly 110 units per request, and deeper agents reverse it |
| Langfuse: LangSmith Cloud caps retention at 180 days | Correct, per LangChain's own docs |
| Langfuse: LangSmith bulk export is Enterprise only | Correct for organizations that signed up after August 3, 2026 |
| Langfuse: LangSmith has Python and JS/TS SDKs | LangChain also documents Go and Java SDKs |
| LangChain: online deterministic evals are on Langfuse's roadmap | Code evaluators β run online on every cloud plan, and self-hosted with a dispatcher configured |
| LangChain: Langfuse has no alerting | Alerts β on cost and quality metrics, to Slack, PagerDuty, GitHub Actions or webhooks, on every plan and self-hosted v4 |
| LangChain: Langfuse annotation queues have no routing or assignment | Users can be assigned to a queue, and queues are managed through the API; rule-based routing like LangSmith's automation rules is not in the queue docs |
| LangChain: Langfuse has five fixed roles | Roles are fixed, with no custom roles, but the docs now list six, including an organization-only AI Gateway role |
| LangChain: self-hosted Langfuse lacks high availability | True of the Docker Compose setup only; the Helm and Terraform paths are the production ones |
Both pages were written by one side and both products change monthly. LangChain's page still calls the agent runtime LangSmith Deployment, which has since been renamed Agent Server. Check a claim that matters to you against the other vendor's docs, this post's claims included.
What both leave to you #
LangSmith and Langfuse answer "what is production doing?" and "how does this dataset score?" well. The question a model upgrade raises is narrower: if I swap the model under this agent, does it still call the same tools with the same arguments, and is the difference in scores real or noise?
Both show you the two experiments side by side. Neither tests the difference. Langfuse's action fails a pull request on a threshold you write; neither decides whether a change is a regression or noise.
That is the job EvalShift does. It runs your captured production cases through both models, scores tool selection, arguments and trace rules on both sides, and tests each per-example difference for significance: a paired t-test or Wilcoxon, an effect size with a confidence interval, and a false-discovery-rate correction across the run. A migration policy turns that into a verdict that passes or fails the pull request.
In one published run, the candidate model was 58.8% cheaper and 75.2% faster with no failed calls, and the verdict was still FAIL: it picked a different tool on 25% of comparisons against a 10% limit. A dashboard of cost, latency and errors showed a clean win.
It runs alongside whichever platform you choose. What it does not do: trace production, monitor live traffic or manage prompts. The CLI and SDK are free and open source; Pro, the hosted gate with run history and baselines, is $199 a month. EvalShift vs Langfuse and EvalShift vs LangSmith go dimension by dimension.
How to choose #
| If you | Look at |
|---|---|
| Must keep traces in your infrastructure without an Enterprise contract | Langfuse |
| Want an open-source platform you could fork or audit | Langfuse |
| Have many reviewers, product managers and domain experts who need access | Langfuse |
| Want more than 180 days of history on a hosted plan | Langfuse Pro |
| Want an eval gate that comments on the pull request out of the box | Langfuse |
| Build on LangChain or LangGraph | LangSmith |
| Want trajectory evaluators and pairwise evaluation ready-made | LangSmith |
| Run deep agents with about 100 or more spans per request, on a small team | LangSmith, after pricing both |
| Want to deploy agents on the same platform | LangSmith |
| Write in Go or Java | LangSmith |
If neither fits, LangSmith alternatives covers Braintrust, Arize Phoenix, Opik, Laminar and MLflow, and Braintrust vs LangSmith compares the other common pairing.
FAQ #
Is Langfuse or LangSmith better? Neither is better overall. Langfuse is the better fit for teams that must self-host without an Enterprise contract, want long history, or have many users. LangSmith is the better fit for teams on LangChain or LangGraph and for agent evals, with trajectory matchers, pairwise and thread-level evaluators and an agent runtime.
Which is cheaper, Langfuse or LangSmith? Usually Langfuse at November 2026 list prices. Five people sending 50,000 agent requests a month with ten observations each pay about $65 on Langfuse Core and about $408 on LangSmith Plus. Langfuse bills every observation and LangSmith bills the trace, so an agent emitting more than about 60 to 110 units per request, depending on how many LangSmith seats you would pay for, can cost more on Langfuse.
How much does Langfuse cost? Hobby is free with 50,000 units a month, 30 days of data and 2 users. Core is $29 a month and Pro $199 a month, each with 100,000 units and unlimited users, then $8 per 100,000 units up to 1 million and less above that. Enterprise is $2,499 a month. Self-hosting the open-source version is free.
How much does LangSmith cost? The Developer plan is free with one seat and 5,000 traces a month. Plus is $39 per seat a month with 10,000 traces included, then $5 per 1,000 traces kept for 14 days and a further $2.50 per 1,000 to keep them 180 days. Enterprise is custom.
Is Langfuse open source and free to self-host? Yes. Langfuse is MIT-licensed except its ee
folders, and the self-hosted version includes all core features, enterprise SSO and
organization-level roles with no usage limits. A paid license adds project-level roles, data
retention rules, audit logs, SCIM and server-side data masking.
Can you self-host LangSmith? Only on an Enterprise plan. Self-hosted LangSmith is an Enterprise add-on that needs a license key and runs on Kubernetes with Helm or Terraform, backed by Postgres, Redis, blob storage and ClickHouse or SmithDB. LangChain also offers BYOC, where it operates the data plane in your cloud account.
Is LangSmith or Langfuse better for evals? For agent evals, LangSmith ships more ready-made: trajectory matchers, pairwise evaluators and thread-level evaluators that can read tool calls and results. Langfuse has LLM judges, code evaluators, experiments, judge agreement metrics and an official CI action with a pull request comment. Neither documents a significance test on an experiment comparison.