{"slug": "langsmith-vs-langfuse-in-2026-pricing-self-hosting-and-evals", "title": "LangSmith vs Langfuse in 2026: pricing, self-hosting and evals", "summary": "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.", "body_md": "[← all posts](https://www.evalshift.dev/blog)\n\n# LangSmith vs Langfuse in 2026: pricing, self-hosting and evals\n\nLangSmith vs Langfuse on pricing with worked examples, free vs Enterprise self-hosting, agent evals, judges and CI, checked against both vendors' docs.\n\nLangSmith 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.\n\nThey 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.\n\nLangfuse is MIT-licensed outside its `ee` folders and self-hosts for free with no usage limits.\nLangSmith is proprietary, and self-hosting it is an Enterprise add-on. Neither documents a statistical test on the difference between two experiments.\n\nThis 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.\n\nA 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.\n\n## LangSmith vs Langfuse at a glance\n\n|  | Langfuse | LangSmith | \n|---|---|---|\n| Company | Langfuse, [acquired by ClickHouse ↗](https://langfuse.com/blog/joining-clickhouse) in January 2026 | LangChain; [$300M Series C ↗](https://www.langchain.com/blog/series-c) at a $3B valuation, November 13, 2026 | \n| License | MIT, except the `ee` folders | Proprietary; SDKs, openevals and agentevals MIT | \n| Free cloud plan | Hobby: 50k units a month, 30 days of data, 2 users | Developer: 1 seat, 5k traces a month, 14 days | \n| First paid plan | Core: $29 a month, unlimited users | Plus: $39 per seat a month | \n| What is metered | Units: traces, observations and scores | Seats, and traces | \n| History | 30 days (Hobby), 90 days (Core), 3 years (Pro and Enterprise) | 14 days base, 180 days extended | \n| Self-hosting | Free on every plan; Enterprise license adds features | Enterprise add-on with a license key | \n| SDKs | Python, TypeScript; other languages through OpenTelemetry | Python, TypeScript, Go, Java | \n| OpenTelemetry | SDKs built on it; ingests OTLP | Ingests OTLP | \n| Offline evals | `run_experiment()` on a hosted or local dataset, or prompt experiments in the UI | `evaluate()` , or pytest, Vitest and Jest tests | \n| Ready-made agent evaluators | Write your own | agentevals trajectory match and judge | \n| CI | Official [`experiment-action` ↗](https://langfuse.com/docs/evaluation/experiments/experiments-ci-cd) with a fail-on-regression gate and a PR comment | Your own workflow running the test suite | \n| Agent deployment | No | LangSmith Agent Server | \n\nSources: [Langfuse pricing ↗](https://langfuse.com/pricing),\n[Langfuse self-hosted pricing ↗](https://langfuse.com/pricing-self-host),\n[LangSmith pricing ↗](https://www.langchain.com/pricing),\n[LangSmith usage and billing ↗](https://docs.langchain.com/langsmith/usage-and-billing).\n\n## Pricing: traces and seats against units\n\n### LangSmith\n\n|  | Developer | Plus | Enterprise | \n|---|---|---|---|\n| Price | Free | $39 per seat a month | Custom | \n| Seats | 1 | Unlimited | Custom | \n| Included traces | 5k a month | 10k a month | Custom | \n| Hosting | Cloud | Cloud | Cloud, BYOC or self-hosted | \n\nBeyond 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.\n\nA trace is one request end to end, however many model and tool calls it contains. Two details move the bill:\n\n- +**Evaluators extend retention by default.** A new online evaluator or automation rule upgrades\nthe traces it matches to extended retention unless you opt out. Scoring a trace therefore adds\n$2.50 per 1,000, though there is no per-score charge.\n- +**180 days is the ceiling on the cloud.** Since September 14, 2026, LangSmith Cloud keeps\ntraces for at most 180 days. Self-hosted and BYOC installs default to 400 days.\n\n### Langfuse\n\n|  | Hobby | Core | Pro | Enterprise | \n|---|---|---|---|---|\n| Price | Free | $29 a month | $199 a month | $2,499 a month | \n| Users | 2 | Unlimited | Unlimited | Unlimited | \n| Included units | 50k a month | 100k a month | 100k a month | 100k a month | \n| Data access | 30 days | 90 days | 3 years | 3 years | \n| Annotation queues | 1 | 3 | Unlimited | Unlimited | \n\nA unit is one [billable data point ↗](https://langfuse.com/docs/administration/billable-units): a\ntrace, an observation inside it, or a score. Observations are the spans: each model call, tool\ncall, retrieval or custom step you record. An agent request with ten observations and one\nevaluator score is 12 units. Units that Langfuse creates count too: an LLM-as-a-judge evaluator\nstores a trace of its own execution, so each judged request adds a few more.\n\nBeyond 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.\n\nLangfuse'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.\n\n### What the same team pays on each\n\nThe 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.\n\n**50,000 agent requests a month, ten observations each**\n\n- +**LangSmith Plus:** $195 for five seats, plus 40,000 traces beyond the included 10,000 at $5 per\n1,000, which is $200. Extended retention on the 5,000 scored traces adds $12.50. About**$408 a\nmonth** .\n- +**Langfuse Core:** 50,000 requests at 11 units each, plus 5,000 scores, is 555,000 units. The\n455,000 above the allowance cost $36.40. About**$65 a month** , with 90 days of data. On Pro,\nwith three years, about $235.\n\n**1,000,000 agent requests a month, ten observations each**\n\n- +**LangSmith Plus:** $195 for seats, plus 990,000 traces at $5 per 1,000, which is $4,950.\nExtended retention on the 100,000 scored traces adds $250:**$5,395 a month** . Keeping every\ntrace for 180 days adds another $2,250.\n- +**Langfuse Core:** 11.1 million units. $72 for the units up to 1M, $630 for the next 9M and\n$71.50 for the last 1.1M: about**$803 a month** . On Pro, about $973.\n\n**50,000 requests a month from a deep agent, 150 observations each**\n\n- +**LangSmith Plus:** the same $408 as the first case, because LangSmith bills the trace, not\nwhat is inside it.\n- +**Langfuse Core:** 7.55 million units. $72 up to 1M and $458.85 for the rest: about**$560 a\nmonth** .\n\nThe 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.\n\nHeadcount 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.\n\nTwo 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.\n\n## Self-hosting: free against Enterprise\n\nThis is the largest difference between the two, and the main reason teams compare them.\n\n|  | Langfuse | LangSmith | \n|---|---|---|\n| Who can self-host | Anyone, free | [Enterprise plan add-on ↗](https://docs.langchain.com/langsmith/self-hosted) , with a license key | \n| License | [MIT ↗](https://github.com/langfuse/langfuse/blob/main/LICENSE) , except the`ee` folders | Proprietary | \n| Free self-hosted version includes | All core features, Enterprise SSO, organization-level roles, no usage limits | No free version | \n| Paid license adds | Project-level roles, data retention rules, audit logs, SCIM, server-side data masking, protected prompt labels | Everything is licensed | \n| 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 | \n| Install paths | Docker Compose for one VM; Helm, and Terraform for AWS, Azure and GCP, for production | Helm or Terraform on Kubernetes | \n| Commercial option | Enterprise license, priced on top of a ClickHouse Cloud, BYOC or Private plan | [BYOC ↗](https://docs.langchain.com/langsmith/byoc) on Enterprise, operated by LangChain | \n\nSources: [Langfuse self-hosting ↗](https://langfuse.com/self-hosting),\n[Langfuse self-hosted pricing ↗](https://langfuse.com/pricing-self-host).\n\nWhat 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.\n\nThe 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.\n\nLangfuse's repository is also active: v4.82.0 shipped on November 17, 2026, and the project has about 37,600 GitHub stars.\n\n## Evaluation\n\nAn offline experiment looks much the same in both: a dataset, a function under test and a list of evaluators.\n\nLangfuse:\n\n``` python\nfrom langfuse import Evaluation, get_client\n\nfrom app import reply  # your function that calls the model\n\nlangfuse = get_client()\n\ndef correct(*, output, expected_output, **kwargs):\n    return Evaluation(name=\"correct\", value=float(output == expected_output[\"answer\"]))\n\ndataset = langfuse.get_dataset(\"order-questions\")\nresult = dataset.run_experiment(\n    name=\"Support replies\",\n    task=lambda *, item, **kwargs: reply(item.input[\"question\"]),\n    evaluators=[correct],\n)\nprint(result.format())\n```\n\nLangSmith:\n\n``` python\nfrom langsmith import Client\n\nfrom app import reply  # your function that calls the model\n\nclient = Client()\n\ndef correct(outputs: dict, reference_outputs: dict) -> bool:\n    return outputs[\"answer\"] == reference_outputs[\"answer\"]\n\nclient.evaluate(\n    lambda inputs: {\"answer\": reply(inputs[\"question\"])},\n    data=\"Order questions\",\n    evaluators=[correct],\n    num_repetitions=3,\n)\n```\n\nLangfuse's runner also takes a local list instead of a hosted dataset, and runs prompt experiments\nfrom the UI without code. LangSmith can run a dataset as [pytest ↗](https://docs.langchain.com/langsmith/pytest),\nVitest or Jest tests, where each test syncs to a dataset example.\n\nWhere they differ:\n\n|  | Langfuse | LangSmith | \n|---|---|---|\n| Judge evaluators | [LLM-as-a-judge ↗](https://langfuse.com/docs/evaluation/evaluation-methods/llm-as-a-judge) on observations or experiments; decision-model evaluators for typed questions | LLM-as-judge evaluators, offline and online | \n| 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 | \n| 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 | \n| Agent trajectories | Code you write in an experiment script | [agentevals ↗](https://docs.langchain.com/langsmith/trajectory-evals) : strict, unordered, subset and superset match, or a judge | \n| Pairwise | Not in its evaluation docs | [Pairwise evaluators ↗](https://docs.langchain.com/langsmith/evaluate-pairwise) , human or automated | \n| Checking a judge against humans | [Score analytics ↗](https://langfuse.com/docs/evaluation/scores/score-analytics) : Cohen's kappa, F1 and correlation between two scores | [Align Evaluator ↗](https://docs.langchain.com/langsmith/improve-judge-evaluator-feedback) : label, test the judge, iterate | \n| Human review | Annotation queues with assigned users, limited by plan | Annotation queues with rubrics; automation rules route runs into them | \n| Datasets | Versioned; experiments can pin a version | Versioned; rules add matching traces | \n| Prompts | Prompt management with labels, playground | Prompt Hub, playground | \n\n### Agents: what the judge can see\n\nThe 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.\n\nLangfuse'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.\n\nLangSmith 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.\n\nThe trajectory matchers are MIT-licensed functions, so you can call agentevals from a Langfuse\nexperiment too. [Evaluating agent tool calls](https://www.evalshift.dev/blog/evaluating-agent-tool-calls) covers what those\nchecks catch.\n\n### Checking the judge\n\nBoth now give you a way to measure an LLM judge against human labels, which is the step most teams\nskip. LangSmith's Align Evaluator is a workflow: label examples, run the judge on them, revise the\nprompt. Langfuse's score analytics compares any two scores on the same objects, such as a judge\nscore and a human annotation, and reports Cohen's kappa, F1 and agreement for categorical scores,\nor Pearson and Spearman correlation for numeric ones. [When to trust an LLM\njudge](https://www.evalshift.dev/blog/when-to-trust-an-llm-judge) explains what agreement level to ask for.\n\n### Comparing two experiments\n\nBoth let you pick a baseline and see what moved.\n[Langfuse ↗](https://langfuse.com/docs/evaluation/experiments/compare-experiments) shows aggregate\nscores, then each item side by side against the baseline, with filters such as \"similarity below\n0.2\" to list the items that got worse.\n[LangSmith ↗](https://docs.langchain.com/langsmith/compare-experiment-results) colors each example red\nor green against the baseline for each feedback key and counts how many did better or worse.\n\nThat is where both stop. I searched both vendors' documentation for a confidence interval, a\np-value or a significance test on an experiment comparison and found none; in Langfuse's case\nthe only match was a feature request in its GitHub discussions. LangSmith runs each example several times with\n`num_repetitions` and shows the standard deviation across repetitions, which tells you how noisy\none example is but not whether two experiments differ.\n\nIt matters because experiment scores are noisy. On 200 cases, a pass rate of 86% has a 95%\nconfidence interval of roughly 80.5% to 90.1%, so a three-point drop between two experiments can\nbe nothing. [How many eval cases do you need](https://www.evalshift.dev/blog/how-many-eval-cases-do-you-need) has the\narithmetic.\n\n## CI\n\nThis is the one area where Langfuse ships more than LangSmith.\n\n**Langfuse** has an official GitHub Action,\n[`langfuse/experiment-action` ↗](https://github.com/langfuse/experiment-action). It runs your\nexperiment scripts against a dataset, optionally pinned to a version, and posts or updates one\npull request comment with the status of each script, run-level scores, item-level scores and a\nlink to the comparison view. A script that raises `RegressionError` fails the job:\n\n``` python\nfrom langfuse import RegressionError, RunnerContext\n\nTHRESHOLD = 0.95\n\n# answer_support_question, exact_match and avg_accuracy are defined elsewhere in the script\n\ndef experiment(context: RunnerContext):\n    result = context.run_experiment(\n        name=\"PR gate: support agent\",\n        task=answer_support_question,\n        evaluators=[exact_match],\n        run_evaluators=[avg_accuracy],\n    )\n    accuracy = next(\n        (e.value for e in result.run_evaluations if e.name == \"avg_accuracy\"), 0.0\n    )\n    if accuracy < THRESHOLD:\n        raise RegressionError(\n            result=result, metric=\"avg_accuracy\", value=accuracy, threshold=THRESHOLD\n        )\n    return result\n```\n\nThe 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.\n\n**LangSmith** has no official eval action. The documented path is to run the pytest, Vitest or\nJest suite in your own workflow, where a failed assertion fails the job. That is a direct gate with\nnothing posted on the pull request unless you add it.\n\nEither way, the gate policy is yours to design. [LLM regression testing in\nCI](https://www.evalshift.dev/blog/llm-regression-testing-in-ci) covers what to block on.\n\n## Getting your data out\n\nOn LangSmith's cloud, traces past their retention window are deleted, so export matters more there.\n\n- +**Langfuse:** the public API and UI export on every plan.[Scheduled\nexport ↗](https://langfuse.com/docs/api-and-data-platform/features/export-to-blob-storage) to S3,\nGCS or Azure Blob Storage, in Parquet, CSV, JSON or JSONL, needs the Teams add-on on Pro or\nEnterprise, and is available when self-hosted.\n- +**LangSmith:** runs through the API or CLI, datasets as CSV or JSONL.[Bulk\nexport ↗](https://docs.langchain.com/langsmith/data-export) to S3-compatible storage, as Parquet,\nis Enterprise only for organizations that signed up after August 3, 2026. Earlier customers keep\nit on Plus until February 1, 2027.\n\nMoving 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.\n\n## What each vendor says about the other\n\nBoth publish a comparison page:\n[Langfuse's ↗](https://langfuse.com/compare/langsmith), with LangSmith facts checked in October 2026,\nand [LangChain's ↗](https://www.langchain.com/resources/langsmith-vs-langfuse), from April 2026. I\nchecked their claims against the other side's docs.\n\n| Claim | What the docs say in November 2026 | \n|---|---|\n| 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 | \n| Langfuse: LangSmith Cloud caps retention at 180 days | Correct, per LangChain's own docs | \n| Langfuse: LangSmith bulk export is Enterprise only | Correct for organizations that signed up after August 3, 2026 | \n| Langfuse: LangSmith has Python and JS/TS SDKs | LangChain also documents Go and Java SDKs | \n| LangChain: online deterministic evals are on Langfuse's roadmap | [Code evaluators ↗](https://langfuse.com/docs/evaluation/evaluation-methods/code-evaluators) run online on every cloud plan, and self-hosted with a dispatcher configured | \n| LangChain: Langfuse has no alerting | [Alerts ↗](https://langfuse.com/docs/observability/features/alerts) on cost and quality metrics, to Slack, PagerDuty, GitHub Actions or webhooks, on every plan and self-hosted v4 | \n| 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 | \n| 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 | \n| LangChain: self-hosted Langfuse lacks high availability | True of the Docker Compose setup only; the Helm and Terraform paths are the production ones | \n\nBoth 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.\n\n## What both leave to you\n\nLangSmith 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?\n\nBoth 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.\n\nThat is the job [EvalShift](https://www.evalshift.dev/docs) does. It runs your captured production cases through both\nmodels, scores tool selection, arguments and trace rules on both sides, and tests each per-example\ndifference for significance: a paired t-test or Wilcoxon, an effect size with a confidence\ninterval, and a false-discovery-rate correction across the run. A\n[migration policy](https://www.evalshift.dev/docs/migration-policy) turns that into a verdict that passes or fails the pull\nrequest.\n\nIn [one published run](https://www.evalshift.dev/blog/cheaper-faster-and-still-a-fail), the candidate model was 58.8%\ncheaper and 75.2% faster with no failed calls, and the verdict was still FAIL: it picked a\ndifferent tool on 25% of comparisons against a 10% limit. A dashboard of cost, latency and errors\nshowed a clean win.\n\nIt runs alongside whichever platform you choose. What it does not do: trace production, monitor\nlive traffic or manage prompts. The CLI and SDK are free and open source;\n[Pro](https://www.evalshift.dev/pricing), the hosted gate with run history and baselines, is $199 a month.\n[EvalShift vs Langfuse](https://www.evalshift.dev/compare/evalshift-vs-langfuse) and [EvalShift vs\nLangSmith](https://www.evalshift.dev/compare/evalshift-vs-langsmith) go dimension by dimension.\n\n## How to choose\n\n| If you | Look at | \n|---|---|\n| Must keep traces in your infrastructure without an Enterprise contract | Langfuse | \n| Want an open-source platform you could fork or audit | Langfuse | \n| Have many reviewers, product managers and domain experts who need access | Langfuse | \n| Want more than 180 days of history on a hosted plan | Langfuse Pro | \n| Want an eval gate that comments on the pull request out of the box | Langfuse | \n| Build on LangChain or LangGraph | LangSmith | \n| Want trajectory evaluators and pairwise evaluation ready-made | LangSmith | \n| Run deep agents with about 100 or more spans per request, on a small team | LangSmith, after pricing both | \n| Want to deploy agents on the same platform | LangSmith | \n| Write in Go or Java | LangSmith | \n\nIf neither fits, [LangSmith alternatives](https://www.evalshift.dev/blog/langsmith-alternatives) covers Braintrust,\nArize Phoenix, Opik, Laminar and MLflow, and [Braintrust vs LangSmith](https://www.evalshift.dev/blog/braintrust-vs-langsmith)\ncompares the other common pairing.\n\n## FAQ\n\n**Is Langfuse or LangSmith better?** Neither is better overall. Langfuse is the better fit for\nteams that must self-host without an Enterprise contract, want long history, or have many users.\nLangSmith is the better fit for teams on LangChain or LangGraph and for agent evals, with\ntrajectory matchers, pairwise and thread-level evaluators and an agent runtime.\n\n**Which is cheaper, Langfuse or LangSmith?** Usually Langfuse at November 2026 list prices. Five\npeople sending 50,000 agent requests a month with ten observations each pay about $65 on Langfuse\nCore and about $408 on LangSmith Plus. Langfuse bills every observation and LangSmith bills the\ntrace, so an agent emitting more than about 60 to 110 units per request, depending on how many\nLangSmith seats you would pay for, can cost more on Langfuse.\n\n**How much does Langfuse cost?** Hobby is free with 50,000 units a month, 30 days of data and 2\nusers. Core is $29 a month and Pro $199 a month, each with 100,000 units and unlimited users, then\n$8 per 100,000 units up to 1 million and less above that. Enterprise is $2,499 a month.\nSelf-hosting the open-source version is free.\n\n**How much does LangSmith cost?** The Developer plan is free with one seat and 5,000 traces a\nmonth. Plus is $39 per seat a month with 10,000 traces included, then $5 per 1,000 traces kept for\n14 days and a further $2.50 per 1,000 to keep them 180 days. Enterprise is custom.\n\n**Is Langfuse open source and free to self-host?** Yes. Langfuse is MIT-licensed except its `ee`\nfolders, and the self-hosted version includes all core features, enterprise SSO and\norganization-level roles with no usage limits. A paid license adds project-level roles, data\nretention rules, audit logs, SCIM and server-side data masking.\n\n**Can you self-host LangSmith?** Only on an Enterprise plan. Self-hosted LangSmith is an Enterprise\nadd-on that needs a license key and runs on Kubernetes with Helm or Terraform, backed by Postgres,\nRedis, blob storage and ClickHouse or SmithDB. LangChain also offers BYOC, where it operates the\ndata plane in your cloud account.\n\n**Is LangSmith or Langfuse better for evals?** For agent evals, LangSmith ships more ready-made:\ntrajectory matchers, pairwise evaluators and thread-level evaluators that can read tool calls and\nresults. Langfuse has LLM judges, code evaluators, experiments, judge agreement metrics and an\nofficial CI action with a pull request comment. Neither documents a significance test on an\nexperiment comparison.", "url": "https://wpnews.pro/news/langsmith-vs-langfuse-in-2026-pricing-self-hosting-and-evals", "canonical_source": "https://www.evalshift.dev/blog/langsmith-vs-langfuse", "published_at": "2026-11-19 16:46:15.493760+00:00", "updated_at": "2026-11-19 16:46:18.008575+00:00", "lang": "en", "topics": ["ai-tools", "mlops", "ai-agents", "large-language-models", "developer-tools"], "entities": ["LangSmith", "Langfuse", "LangChain", "ClickHouse", "LangGraph", "EvalShift"], "also_reported_by": [], "takeaway": "For five users and 50,000 agent requests at ten spans each, LangSmith Plus costs about $408 a month versus about $65 on Langfuse Core, because Langfuse meters every span and score as a unit while LangSmith meters seats plus traces.", "recommendation": {"advice": "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.", "playbook": "llm-cost", "playbook_url": "https://wpnews.pro/playbooks/llm-cost"}, "alternates": {"html": "https://wpnews.pro/news/langsmith-vs-langfuse-in-2026-pricing-self-hosting-and-evals", "markdown": "https://wpnews.pro/news/langsmith-vs-langfuse-in-2026-pricing-self-hosting-and-evals.md", "text": "https://wpnews.pro/news/langsmith-vs-langfuse-in-2026-pricing-self-hosting-and-evals.txt", "jsonld": "https://wpnews.pro/news/langsmith-vs-langfuse-in-2026-pricing-self-hosting-and-evals.jsonld"}}