cd /news/ai-tools/langsmith-vs-langfuse-in-2026-pricin… Β· home β€Ί topics β€Ί ai-tools β€Ί article
[ARTICLE Β· art-172675] src=evalshift.dev β†— pub= topic=ai-tools verified=true sentiment=Β· neutral

LangSmith vs Langfuse in 2026: pricing, self-hosting and evals

Langfuse costs about $65 a month versus about $408 on LangSmith Plus for a five-person team running 50,000 agent requests with ten spans each, according to a November 18, 2026 comparison of the two LLM observability platforms checked against both vendors' pricing pages and docs. LangSmith Plus is priced at $39 per seat a month plus $5 per 1,000 traces beyond the first 10,000, while Langfuse Core costs $29 a month for unlimited users plus $8 per 100,000 units, where every trace, span and score counts as a unit. The comparison recommends Langfuse for teams needing free self-hosting, more than 180 days of history or many users, and LangSmith for LangChain or LangGraph builders wanting ready-made agent trajectory evaluators.

recommendation

Model your observability bill on spans per request, not requests: at ten spans each, Langfuse Core came to about $65 versus about $408 on LangSmith Plus for five users and 50,000 monthly agent requests.

more in playbook: Controlling LLM cost
by read22 min views1 publishedNov 19, 2026
LangSmith vs Langfuse in 2026: pricing, self-hosting and evals
Image: Evalshift (auto-discovered)

← all posts

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.

── more in #ai-tools 4 stories Β· sorted by recency
── more on @langsmith 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain β€” perfect for shipping the agent you just read about.

$git push zahid main
β†’ Live at https://your-agent.zahid.host βœ“
Get free account β†’ Pricing
from €0/mo Β· no card required
LIVE [news/langsmith-vs-langfus…] indexed:0 read:22min 2026-11-19 Β· β€”