Two teams can run the same agent on the same traffic and open invoices that differ by more than double. The tools don’t count the same thing, and the gap can flip in the other direction. Prices and features below were checked on the vendors’ own pages on 10 November 2026.
Sergey Iakovlev, Lead ML Engineer at Canva, didn’t start with a purchase order. He started on his own machine. Because Langfuse is open source, he could run it locally and prove it worked before legal and procurement got involved. Then the system grew: by Langfuse’s published account, Canva’s AI support now handles 80% of user interactions across more than 250 million monthly users. At that size, he says, “We don’t have capacity for all the maintenance.” So the team moved off self-hosting and onto Langfuse Cloud. They paid to hand the work back.
That is half of the Langfuse-versus-LangSmith decision. The other half is arithmetic: the same 50,000 agent runs cost $101 a month on one tool and $239 on the other, and the gap flips at about 59 units per run.
What you’ll get
- What changed in 2026 for both tools, from their own pages
- Three adopter cases, with who published each one
- A worked cost model you can rerun, including the point where the cheaper tool changes
- A 24-hour checklist and an honest list of where this analysis is weak
The short version, by situation
| If this is you | Lean towards |
|---|---|
| Building on LangChain or LangGraph, want one vendor for traces, evals and deployment | LangSmith |
| Mixed stack (Java, raw clients), want OpenTelemetry and no framework tie-in | Langfuse |
| Many non-engineer reviewers, small budget | Langfuse (no per-seat fees) |
| Free self-hosting, and someone owns the pager | Langfuse |
| Deep agents with 60+ spans per run, cost-sensitive | Price both with your real counts (see the arithmetic below) |
| Need autonomous failure-finding built in | LangSmith, and watch Engine’s meter |
| Under about 5,000 runs a month, solo | LangSmith’s free tier goes further (5,000 runs versus 2,500 at 20 units on Langfuse’s 50,000 free units) |
Switching later is survivable. Both accept OpenTelemetry, and Langfuse publishes a migration guide for leaving LangSmith. Old trace history is the slow part.
What changed this year
Two events matter more than any feature list.
On 16 January 2026, ClickHouse acquired Langfuse. Langfuse’s announcement says it stays open source and self-hostable, with no planned licensing changes. Ten months on, Langfuse’s site shows 37,000 GitHub stars, and on 4 November it launched an AI Gateway, a feature rivals still listed as missing a week ago.
LangSmith has gone the other way, from a tracing tool toward a full agent platform. Its pricing page now lists Deployment, Fleet (no-code agents), Sandboxes, an LLM Gateway, and an autonomous failure-finder called Engine alongside observability and evals. Almost all of it is metered in LangChain Standard Units, at $1 each. That detail comes back in the bill.
“Pricing pages compare plans. Your bill compares architectures.”
Side by side, from the vendors’ own pages
| Langfuse Cloud | LangSmith | |
|---|---|---|
| Free tier | Hobby: 50k units, 30 days of data, 2 users | Developer: 5k base traces, 1 seat |
| First paid plan | Core $29/mo: 100k units, 90 days, unlimited users | Plus $39 per seat/mo: 10k base traces, seats added one by one |
| Scale plan | Pro $199/mo: 3 years of data, SOC 2 and ISO 27001 reports, unlimited annotation queues | Enterprise, custom: self-hosted or hybrid, custom SSO and RBAC, support SLA |
| SSO | On Pro, it needs the $300/mo Teams add-on | Google and GitHub sign-in on Plus; custom SSO on Enterprise |
| What’s metered | Units: traces + observations + scores | Traces, with extended retention billed on top |
| Self-hosting | Free, MIT core | Enterprise only |
| Licence | MIT core; some enterprise features behind a key | Proprietary platform, MIT SDKs |
Sources: Langfuse pricing, LangSmith pricing, Langfuse billing docs. Pricing pages in this category move several times a year, so confirm before you commit.
Four adopters, and who is telling each story
Canva chose Langfuse and later changed how it ran it. Langfuse’s case study describes a four-person ML team running a multi-agent support system across Java and Python. They scored outputs on 15 to 20 metrics offline and online, had QA staff review 20 to 100 production cases a week, and let a marketing manager in Japan build an LLM-as-judge for formal business tone without engineering help. They also chose Langfuse partly because it is framework-agnostic and speaks OpenTelemetry, which mattered for the Java side. The part most comparison posts skip: self-hosting got them to proof of value, then maintenance pushed them to Cloud. Note the source: Langfuse wrote this.
Klarna built on LangGraph and LangSmith. LangChain’s case study describes an assistant serving 85 million active users, credits trace visibility and test-driven development, and reports average resolution time down 80%. Its comparison page adds a 70% automation rate. The seller published these figures, and secondary coverage (Twig) says Klarna later walked back the “replaced 700 agents” framing in 2025, a reminder that case-study headlines age.
Podium chose LangSmith for evals. The same comparison page credits it with a 98.6% F1 score and a 90% cut in engineering intervention. Same caveat: the seller published it, and I found no independent audit.
Rakuten used LangSmith to stop guessing. The same page quotes the team saying they needed something more structured than shipping and seeing what happened, and tracks accuracy rising from 70% to 80% through pairwise evaluations. Same caveat.
What the four have in common: nobody in these stories picked on a feature grid. Canva picked on openness and fit with its stack. The LangSmith adopters picked on evals and on a framework they already used.
“Free to self-host is not free to run.”
The arithmetic (this closes the loop)
Langfuse bills units: one unit is a trace, an observation (a span, event or generation inside it) or a score. LangSmith bills a trace, which its pricing FAQ defines as one execution of your application. A 15-step agent can be one LangSmith trace and about 20 Langfuse units.
“A trace is a sentence. A unit is every word.”
Inputs. 50,000 agent runs a month. 20 units per run (one trace, about 17 observations, two scores). Langfuse Core: $29, 100k units included, $8 per 100k up to 1M units, then $7 per 100k up to 10M. LangSmith Plus: $39 per seat, 10,000 base traces included. LangSmith’s overage rate: LangChain’s page prices usage in LSUs at $1 each, but the per-trace rate sits behind a calculator I couldn’t read as plain text. Four trackers that read the pricing page (ZenML, Wavect, Cekura, Usagepricing) all give 0.005 LSU per base trace, which is $5 per 1,000. Older rates still circulate, including in LangChain’s own billing docs, which still show a base charge of 0.05¢ per trace and point to the pricing page. Go to the pricing page and confirm under Settings > Billing.
Langfuse. 50,000 × 20 = 1,000,000 units. 1,000,000 − 100,000 included = 900,000 billed. 900,000 ÷ 100,000 = 9 blocks × $8 = $72. $72 + $29 = $101.
LangSmith, one seat. 50,000 − 10,000 included = 40,000 billable traces. 40,000 ÷ 1,000 = 40 × $5 = $200. $200 + $39 = $239.
Per 1,000 runs. Langfuse: $101 ÷ 50 = $2.02. LangSmith: $239 ÷ 50 = $4.78.
Where it flips. One LangSmith trace costs $0.005. One Langfuse unit costs $8 ÷ 100,000 = $0.00008. Divide: 0.005 ÷ 0.00008 = 62.5. So once a run emits more than roughly 62 units, each run costs more on Langfuse than on LangSmith, before fixed fees and volume discounts. Including both, at 50,000 runs and one seat, the exact crossover is 59 units per run: $29 + $72 + $7 per 100k beyond 1,000,000 units reaches $239 at 2,971,429 units, and 2,971,429 ÷ 50,000 ≈ 59.4.
Chart: monthly cost at 50,000 runs, one seat. Langfuse Core rises from $41 to $381 as units per run grow from 5 to 100; LangSmith Plus stays flat at $239; they cross at about 59 units per run.
| Units per run | Langfuse Core | LangSmith Plus (1 seat) |
|---|---|---|
| 5 | $41 | $239 |
| 10 | $61 | $239 |
| 20 | $101 | $239 |
| 50 | $206 | $239 |
| 100 | $381 | $239 |
Bars are Langfuse Core; the flat line is LangSmith. My arithmetic is based on the inputs above; LangSmith counts one trace per run in every row.
“Count what your agent does, not what your user asks.”
The cost ranking depends on how deeply your agent is instrumented, not on which vendor’s sticker looks smaller. A chatty multi-agent system with 100 spans per run is cheaper on LangSmith. A tight RAG pipeline is cheaper on Langfuse.
Three things that move the bill
Retention. LangSmith’s base traces live 14 days; extended traces live 180 days and cost extra. Upgrading all 50,000 traces at 0.0025 LSU ($2.50 per 1,000) adds $125, so $239 + $125 = $364. Langfuse Core keeps 90 days inside the $101. If you need more than 90 days, Pro gives three years: $199 + $72 = $271. Competitor LangWatch reports that running an online evaluator on a trace also upgrades it to extended retention. I couldn’t confirm that on LangChain’s pages, so test it on your own account.
Seats. Langfuse’s paid plans don’t charge per user. LangSmith does: five seats is 5 × $39 = $195, so $195 + $200 = $395 against Langfuse’s unchanged $101.
Add-ons. LangSmith’s pricing page says Engine runs on a six-hour schedule and that one run can use roughly 7 to 45 LSUs, so $7 to $45 each. I’m deliberately not multiplying that into a monthly figure: the page doesn’t say whether Engine is on by default for your organisation, or how much work each run finds. Admins can switch it off. Look at Settings > Billing in your first week and see what it actually consumed.
| Scenario: 50,000 runs at 20 units | Langfuse | LangSmith |
|---|---|---|
| Baseline: one seat, short retention | $101 (Core, 90 days) | $239 (14 days) |
| Five users | $101 | $395 |
| Need six months or more of history | $271 (Pro, 3 years) | $364 (180 days) |
| Five users and long history | $271 | $520 |
Evals and prompts: closer than the marketing suggests
Both platforms trace, run LLM-as-a-judge, keep human annotation queues, and version prompts. The vendors disagree on the gaps: LangChain says Langfuse’s online deterministic evals are roadmap-only and its annotation queues lack routing, while Langfuse’s Canva case shows custom deterministic scoring running offline. Treat both as rival claims and test the two or three features you’d build around in a trial.
Self-hosting, honestly
Langfuse self-hosting is free and documented for Docker Compose, Kubernetes, and Terraform on AWS, GCP, and Azure. The licence is $0. The cost is the stack: one practitioner write-up calls running ClickHouse at production scale real ops work. LangSmith self-hosting is an Enterprise-tier option you negotiate. If your data can’t leave your network and you have no platform team, neither path is cheap. The difference is whether you pay in engineer time or in a contract. And the contract isn’t only a cost: LangSmith’s Enterprise tier lists hybrid hosting (LangChain runs the control plane, your VPC holds the data), a support SLA, and access to deployed engineers, which is exactly what a team without a platform function may want to buy.
“Pick the tool your framework already speaks.”
Do this in the next 24 hours
- Pull a week of traces and count observations per run. Use the median, not a guess.
- Multiply by monthly runs and rerun the arithmetic above. Check whether you land under or over 59 units.
- Write down how many people will log in and how long you must keep traces.
- Name who owns uptime if you self-host. No name, no self-hosting.
- Send spans to both tools for two weeks and see which one the team actually opens.
Where this breaks down
- The 20 units per run is an example. Your agent might be 5 or 100, and the whole ranking moves with it.
- LangChain’s page doesn’t print the per-trace rate as plain text; $5 per 1,000 comes from four trackers reading that page plus the $1 LSU definition, and LangChain’s own docs still show an older rate. Both vendors reprice often: Flexprice tracks several LangSmith trace-rate changes in a year, and PricingSaaS logged Langfuse cutting Pro retention from unlimited to three years in April. Verify in your billing console.
- All adopter results come from vendor-published pages. I haven’t run either tool in production for this piece.
- Engine’s cost is known only as a published per-run estimate ($7 to $45). I haven’t seen a real bill, so I haven’t modelled one.
- Price isn’t quality. Neither invoice tells you which evals will catch your failures.
The takeaway
Cost comparisons between these two tools are unit comparisons in disguise. Fix the number of runs, count what each tool actually bills for, and price your retention and your headcount. Whichever way the numbers fall, two lessons survive the vendor pages: free infrastructure still has an owner (Canva), and a headline result is still the seller’s (Klarna).
Your turn: what’s the median number of observations in one run of your agent? Put it in the comments and say which side of 59 you landed on.
Sources (checked 10 November 2026)
- Langfuse pricing · Billable units · Joining ClickHouse · AI Gateway changelog · Canva case study · Migrating from LangSmith
- LangSmith pricing · LangChain billing docs · Klarna case study · LangChain vs Langfuse page
- Third-party: ZenML on LangSmith pricing · Wavect on trace retention · Cekura · Usagepricing · Flexprice · PricingSaaS · Twig on Klarna · LangWatch comparison · Beton teardown
Disclosure: I have no commercial relationship with Langfuse, LangChain, ClickHouse, or LangWatch. LangWatch sells a competing product, so its comparison is used only for claims flagged above.