Langfuse Pricing in 2026: What a Unit Really Costs

Most teams read "Langfuse is free up to 50,000 units a month" and quietly assume that means 50,000 requests. It does not. On a real multi-step agent, that free tier can run out before you cross a few thousand user requests, and the paid bill climbs from there for the same reason. The number that sets your Langfuse's pricing page bill is not how many times users hit your app. It is how many things Langfuse counts inside each of those hits.

This teardown does the arithmetic the pricing page skips: what a "unit" actually is, the full 2026 plan ladder, three worked 30-day bills, how the meter compares to LangSmith and Helicone, and when self-hosting is genuinely cheaper.

What a "unit" actually is in Langfuse pricing

Langfuse bills on units, and a unit is a single trace, observation, or score that you send it. That definition is the whole game. One user request creates exactly one trace, but that trace wraps every step inside it as a separate observation: each LLM call, each retrieval, each rerank, each embedding, each tool call. Attach an automated eval and that is a score, which is another unit.

So the unit count for one request is roughly:

> 1 trace + (number of steps you log as observations) + (number of scores you attach)

A dead-simple chatbot that makes one model call per turn is about 2 units per request. A retrieval pipeline is 5 or 6. A 15-step agent with a couple of evals is comfortably 20 or more. The free 50,000 units is generous for the chatbot and gone almost immediately for the agent, even though both might serve the same number of users. This is the single most misread line in LLM-observability pricing, and it shows up in threads like a widely-upvoted r/LLMDevs thread on why these tools feel expensive.

Langfuse pricing in 2026: the full plan ladder

Here is the current Langfuse Cloud pricing, pulled from Langfuse's pricing page in July 2026. Every paid plan includes the same 100,000 units; the plans differ on data retention, users, and support, not on the meter.

Beyond the included units, every paid plan charges the same graduated overage, and it gets cheaper as you scale:

Two things worth flagging. First, Langfuse does not charge per seat: Core and up include unlimited users, which is unusual in this category. Second, the jump from Core ($29) to Pro ($199) buys retention (90 days to 3 years) and features, not more units. If you are cost-driven and do not need long retention, Core is where most teams should sit.

Three real 30-day Langfuse bills

Numbers make the unit trap concrete. Each bill below states its assumption for units per request, then runs the 2026 rates. Your mileage varies with how deeply you instrument, which is exactly the point.

The side-project chatbot: still basically free

A support chatbot doing one model call per turn logs 1 trace plus 1 observation, so about 2 units per request.

• 40,000 requests per month = 80,000 units
• That blows past Hobby's 50,000, so you land on Core at $29
• 80,000 units is under Core's 100,000, so no overage

Bill: $29/month. Stay under roughly 25,000 requests and you are still free on Hobby.

The RAG SaaS: the 6x surprise

A retrieval app logs 1 trace plus an embedding, a retrieval, a rerank, and a generation (4 observations), plus 1 eval score. That is 6 units per request.

• 100,000 requests per month = 600,000 units
• Core includes 100,000, leaving 500,000 of overage
• 500,000 units at $8 per 100,000 = $40

Bill: $29 + $40 = $69/month. The team that budgeted "100k requests, Core covers it" is off by 6x, because their meter is counting 600k units, not 100k requests.

The multi-step agent: where it bites

A 15-step agent logging 1 trace plus roughly 17 observations plus 2 scores is about 20 units per request.

• 50,000 agent runs per month = 1,000,000 units
• Core includes 100,000, leaving 900,000 of overage
• 900,000 units at $8 per 100,000 = $72

Bill: $29 + $72 = $101/month. Same 50,000 "runs" as a small chatbot, but a $101 bill instead of $29, purely because each run is 20 units instead of 2. Double the agent to 100,000 runs (2M units) and the overage crosses into the $7 tier: 900,000 at $8 ($72) plus 1,000,000 at $7 ($70) is $142, for a $171/month bill. Trace depth, not user count, is the dial.

Langfuse vs LangSmith vs Helicone: three tools, three meters

The reason cross-tool price comparisons feel impossible is that no two of these products count the same thing. Here is what each one actually meters, with 2026 numbers from LangSmith and Helicone.

The practical read:

• Langfuse counts the deepest. Every observation is a unit, so deep agents accumulate fastest here. Great detail, but the meter runs hot on multi-step workloads.
• LangSmith counts per base trace, so trace depth matters less to the base count, but it charges per seat ($39) and adds LCU/LSU compute and storage units on top, plus a fee for extended 180-day retention.
• Helicone counts requests. For a proxy-style, one-log-per-call setup, that is the simplest meter to predict, but you get less step-level tree detail than Langfuse.

There is no universally cheapest tool. A simple high-volume app often pays least on request or base-trace metering; a deep agent you want fully traced will cost the most on unit metering but give you the richest debugging tree. Match the meter to your workload before you match the price.

Should you self-host Langfuse to save money?

Langfuse's strongest cost lever is that the core product is open source under an MIT license, and you can self-host it for free with no unit limits at all. The paid self-host tier (Enterprise, custom priced) only adds project-level RBAC, audit logs, a support SLA, and a commercial ClickHouse arrangement.

That "unlimited units for free" sounds like it should win every time. It does not, because you now run ClickHouse, Postgres, and the ingestion stack yourself. The honest crossover:

• Stay on Cloud while your bill is small relative to engineering time. As one commenter in that r/LLMDevs thread put it, the annual Cloud cost lands around 1% of an engineer's salary at moderate scale, and self-hosting to save that is a bad trade when it eats real ops hours.
• Self-host once unit volume runs into the millions per month, where Cloud overage ($6 to $8 per 100k) compounds into thousands of dollars and the fixed cost of a small ClickHouse cluster clearly wins. This is also the move if data residency or retention rules make Cloud a non-starter.

If you are still sizing your underlying model spend before you even worry about observability, that starts one layer down with your OpenAI API bill and Claude API pricing; observability is usually a single-digit percentage on top of those.

The bottom line

Langfuse pricing is clean once you translate it. Free means 50,000 units, not 50,000 requests. Paid means $29 for 100,000 units and $8 per 100,000 after, with unlimited users the whole way. The only variable that surprises people is trace depth: instrument a deep agent fully and you are buying 20 units per request, so budget on units, not on user count.

Math check: estimate your units per request (1 trace + your steps + your scores), multiply by monthly requests, subtract the 100,000 Core includes, and price the rest at $8 per 100,000. If that number is climbing past a few hundred dollars a month, price out self-hosting; below that, Core at $29 is one of the better deals in the category.