Both of these tools changed ownership status or pricing structure in the last twelve months, which is why the comparison is worth redoing now rather than relying on a 2024 blog post. ClickHouse acquired Langfuse on January 16, 2026, alongside a $400M Series D, and committed publicly to keeping the MIT license and the self-hosting path intact. LangChain, which builds LangSmith, raised a $125M Series B in October 2025 at a $1.25B valuation and has revised LangSmith's per-trace rates at least once since. If you evaluated either tool eighteen months ago, your notes on pricing and governance are stale.
The more important thing that has not changed: neither tool stops a single API call. Both are recording systems. They attach cost to a trace after the model provider has already returned a response and already started your invoice. For a team running agents, where one user request can fan out into forty model calls, the gap between "we can see the spend" and "we can cap the spend" is the entire problem. This comparison covers what each tool actually does, what it costs, and where the enforcement layer has to live instead.
What LangSmith does
LangSmith is LangChain's managed platform for tracing, evaluation, prompt management, and agent monitoring. It is closed source. Its strongest property is that if your application is already built on LangChain or LangGraph, tracing turns on with environment variables (LANGSMITH_TRACING, LANGSMITH_API_KEY) and no code changes. Every chain step, tool call, and retriever hit shows up as a nested run with inputs, outputs, latency, and token counts. Outside the LangChain ecosystem you can use the @traceable decorator or push OpenTelemetry spans to its OTel endpoint, which works but is not the zero-setup path.
The evaluation side is the real differentiator. LangSmith datasets, LLM-as-judge evaluators, and pairwise experiment comparison are mature, and the annotation queue for routing traces to human reviewers is genuinely well built. If your bottleneck is "we cannot tell whether the new prompt is better," LangSmith is a strong answer.
Pricing, as of August 2026: Developer is free with 5,000 traces per month and a single seat. Plus is $39 per seat per month with 10,000 base traces included. Enterprise is custom-quoted and is the only tier that permits self-hosting or a hybrid VPC data plane. Beyond the included allowance, you pay per 1,000 traces, at a lower rate for base traces (14-day retention) and a higher rate for extended traces (400-day retention). Those per-trace rates have moved more than once during 2026 and public secondary sources disagree on the current numbers, so check current pricing at langchain.com/pricing before you model anything. One billing behavior worth knowing regardless of rate: a trace that receives feedback is automatically promoted to extended retention and billed at the higher rate.
Key limitations. Self-hosting sits behind an Enterprise contract, so a mid-size team with a data residency requirement has no self-serve path. Seat charges stack on top of usage charges, which penalizes wide read access across a team. And because the product is closed source, your traces live in a store you cannot query directly.
What Langfuse does
Langfuse covers the same surface: tracing, prompt management, evaluations, datasets, and cost tracking. Its architecture is OpenTelemetry-native, so instrumentation is framework-agnostic by default. Vercel AI SDK, LiteLLM, raw OpenAI or Anthropic SDK calls, LlamaIndex, and LangChain all report through the same pipeline without a preferred-partner path.
The core repository is MIT licensed and self-hosting is a first-class, self-serve option with no license key and no usage cap. That is the single biggest structural difference from LangSmith. The caveat is operational, not legal: since v3, a production self-host is not one container. It expects PostgreSQL for transactional data, ClickHouse for the analytical store, Redis or Valkey for queueing, and S3-compatible blob storage for large payloads. Docker Compose gets you a demo. A real deployment is four stateful services you now own, and that engineering time is the actual price of the $0 license. Note also that an ee/ directory in the repo holds commercially licensed features that require a paid license key even on a self-hosted install, so "MIT core" is not the same as "every feature is free."
Cloud pricing, as of August 2026: Hobby is free with 50,000 units per month. Core is $29 per month, Pro is $199 per month, and Enterprise is $2,499 per month. Overage runs roughly $8 per 100,000 units on a graduated scale that steps down at higher volumes. All paid tiers include unlimited users, so there is no seat tax.
The billing unit is where naive price comparisons break. LangSmith bills per trace, meaning one root run counts once no matter how many nested spans it contains. Langfuse bills per unit, where units are the individual events ingested: observations, generations, scores. For a shallow RAG call the two are close. For a LangGraph agent that takes 40 steps per user request, one LangSmith trace maps to roughly 40-plus Langfuse units. Before you trust anyone's cost table, including this one, pull your own average span-per-trace ratio from a week of production traffic and multiply.
On ownership: the ClickHouse acquisition removed the "will this small company survive" objection and replaced it with a different question, which is whether an analytics database vendor keeps prioritizing the OSS distribution over its own cloud. The public commitment is that the MIT license, the roadmap, and self-hosting all continue unchanged. Treat that as credible and re-verify in a year.
Comparison table
| Dimension | LangSmith | Langfuse | noburn.dev |
|---|---|---|---|
| Primary function | Tracing + evaluation | Tracing + evaluation | Pre-flight cost enforcement |
| License | Closed source | MIT core, ee/ under commercial license | Closed source, managed |
| Self-hosting | Enterprise plan only | Self-serve, free, you run Postgres + ClickHouse + Redis + S3 | Managed only |
| Billing unit | Per trace (root run) | Per unit (each observation, generation, score) | Per request |
| Free tier | 5,000 traces/mo, 1 seat | 50,000 units/mo | 50,000 requests/mo, 1 project |
| Entry paid plan | Plus, $39/seat/mo, 10k traces | Core, $29/mo | Early Bird, $9/mo, 500k req, 3 projects |
| Higher tier | Enterprise, custom | Pro $199/mo, Enterprise $2,499/mo | Pro, $49/mo, 5M req, unlimited projects |
| Seat charges | Yes, per seat | No, unlimited users | No |
| When cost is known | After the response returns | After the response returns | Before the call fires |
| Blocks over-budget calls | No | No | Yes, request is rejected pre-flight |
| Per-end-user budgets | No | No | Yes |
| Passthrough billing to customers | No | No | Yes, via Stripe |
| Best framework fit | LangChain, LangGraph | Any, OTel-native | OpenAI, Anthropic, LiteLLM, LangChain, LangGraph, Vercel AI SDK |
LangSmith and Langfuse pricing verified against public sources in August 2026. Per-trace overage rates in particular change; confirm on each vendor's pricing page.
The enforcement gap
Every row above about tracing is a real difference, and none of it addresses the failure mode that actually pages people. Both tools compute cost from the usage block in the provider's response. That block does not exist until the provider has finished generating, which means it does not exist until you have already been charged. Observability is, by construction, a record of money that is gone.
The consequences are specific. A budget alert in either tool fires on a threshold crossing, and between the crossing and a human reading the alert, spend continues at whatever rate caused the crossing. An agent stuck in a tool-call loop can burn four figures inside that window. Neither tool has a mechanism to reject request number 4,001 from a user whose plan covers 4,000.
The multi-tenant case is worse. If you sell an AI feature to end customers, your unit economics are per customer, but both tools aggregate by project and trace. You can build the attribution yourself with metadata tags and a nightly rollup job, and plenty of teams do, but the output is still a report. There is no path from that report back to a rejected request without writing your own gate: a counter, a store with acceptable read latency on the hot path, a token estimator that runs before the call, and a fallback for when the counter store is down. That is a small distributed system, and it is the thing teams keep discovering they have to build after picking an observability vendor.
The distinction is not that observability is unnecessary. You want traces for debugging, and you want evaluations for shipping prompt changes. The distinction is that a system which reads your spend and a system which controls your spend are different components, and buying the first does not get you the second.
FAQ
Is Langfuse a drop-in replacement for LangSmith? For tracing, prompt management, and basic evaluation, largely yes, and the OTel-native design usually makes migration easier than expected if you are not deeply tied to LangChain callbacks. The gap is on the evaluation side, where LangSmith's experiment comparison and annotation queues are more mature. Run both in parallel for two weeks against real traffic before committing.
Which is cheaper at scale? It depends entirely on your span-per-trace ratio, because LangSmith bills per root trace and Langfuse bills per ingested observation. Shallow single-call workloads tend to favor Langfuse cloud; very deep agent traces narrow or reverse the gap. Self-hosted Langfuse removes per-event cost entirely and replaces it with the cost of operating ClickHouse, Postgres, Redis, and blob storage.
Did the ClickHouse acquisition change Langfuse's licensing? No. ClickHouse announced the acquisition on January 16, 2026, and stated that the MIT license, self-hosting, and the existing roadmap all continue. The practical change is more resourcing behind performance and self-hosting documentation, since ClickHouse was already the analytical store underneath Langfuse v3.
Can I self-host LangSmith? Only on an Enterprise contract. LangSmith offers managed cloud, a hybrid deployment where the data plane runs in your VPC, and a fully self-hosted install, but the latter two require a sales conversation. If self-serve self-hosting is a hard requirement, that decides the comparison on its own.
Do either of these stop a runaway agent? No. Both record cost after the provider responds and can alert on thresholds after they are crossed. Stopping a request requires estimating its cost before it is sent and rejecting it, which is a separate enforcement layer.
Where noburn fits in this stack
LangSmith and Langfuse tell you what a request cost once the provider has already billed you for it. noburn.dev estimates the token cost of a request client-side before the call fires and blocks it when the user or project is over budget, so a looping agent or an over-quota customer gets a rejection instead of an invoice line. It integrates with OpenAI, Anthropic, LiteLLM, LangChain, LangGraph, and the Vercel AI SDK, which means it drops in alongside whichever of these two observability tools you pick rather than replacing it. For multi-tenant SaaS, per-user metering enforces a separate spending limit for each end customer, and Stripe passthrough billing turns that same metered usage into a charge on the customer's card. Keep your traces where you want them and put the budget gate in front of the call. The free tier covers 50,000 requests per month. Documentation and SDKs are at noburn.dev/docs.