You shipped an AI feature. It works in the demo. Then a user pastes something weird, the model does something you've never seen, and your only record is... a log line that says 200 OK. You have no idea what prompt actually went in, what came back, what it cost, or whether last week's "small improvement" quietly made things worse.
That gap — between "the API returned something" and "I understand what my AI is doing" — is exactly what Langfuse fills. It's the open-source layer that traces every LLM call, keeps your prompts, and lets you grade outputs, so your AI feature becomes something you can actually observe and improve instead of pray over.
What it is: an open-source (MIT-licensed) platform that brings observability, prompt management, and evaluations into one place. It captures a full trace of each request — every model call, tool call, and retrieval step, with inputs, outputs, latency, and token cost — and layers evals (programmatic checks and LLM-as-judge scoring) and experiments on top so you can measure whether a change helped.
What it does#
Three jobs, one connected workflow:
- Tracing / observability. Wrap your LLM calls and Langfuse records the whole chain: prompts, completions, tool calls, retrieved context, latency, and cost per call. When something goes wrong in production, you can open the exact trace and see what happened instead of reconstructing it from log fragments.
- Prompt management. Store and version your prompts outside your code, so tweaking a system prompt doesn't require a deploy — and so you can see which prompt version produced which output.
- Evals & experiments. Grade outputs with programmatic rules or an LLM-as-judge, run a new prompt or model against a saved dataset, and compare versions. This is the piece that turns "I think it got better" into a number — and it pairs directly with shadow-testing a cheaper model on real traffic: Langfuse is a natural place to log and grade those paired runs.
It's framework-agnostic (works with the OpenAI SDK, LangChain, LlamaIndex, and plain HTTP), so it sits under whatever stack you already have.
Who it's for#
Founders and small teams who've shipped an AI feature and outgrown eyeballing responses in the terminal. It's especially worth it if:
- You're debugging AI behavior in production and "what actually happened on that request" is a question you can't currently answer.
- You're about to change a prompt or swap a model and want proof it's an improvement, not a regression.
- You care about cost visibility — Langfuse's per-call token accounting is how you find the one expensive call path quietly eating your margin.
How to start#
Two paths, both free to begin:
- Cloud: sign up at langfuse.com (no credit card), drop in your SDK keys, wrap your model calls, and traces start showing up. Fastest way to see value in an afternoon.
- Self-host: the core is MIT-licensed, so you can run it yourself with Docker Compose. Point your SDK at your own instance instead of the cloud endpoint. No license fee, and your trace data never leaves your infrastructure.
What it costs (July 2026)#
- Hobby — free. 50,000 units/month, 30-day retention, 2 seats, no credit card. This tier is genuinely usable, not a teaser.
- Core — $29/mo. 100,000 units, 90-day retention, unlimited users (there's no per-seat charge at any paid tier).
- Pro — $199/mo. Same core features; you're mostly paying for compliance — SOC2/ISO 27001 reports, 3-year retention, higher rate limits.
- Enterprise — $2,499/mo. Unlimited users, enterprise controls.
- Overage: $8 per additional 100,000 units across paid tiers.
Self-hosting the MIT core has no license fee — you pay only for the infrastructure you run it on.
The catch#
Self-hosting is not a single lightweight container. Langfuse's backend wants PostgreSQL, ClickHouse, Redis, and S3-compatible storage — that's a real amount of operational surface for a solo founder to babysit, and it's the honest tradeoff behind "free forever on your own infra." For most small teams, the free Cloud tier is the saner starting point; reach for self-hosting when data residency or volume actually demands it.
One more thing worth knowing: ClickHouse acquired Langfuse in January 2026. So far the product has kept its MIT license and added no new pricing gates — a good sign — but it's the kind of ownership change worth keeping half an eye on if you're betting your observability stack on it.
The takeaway#
If you're shipping AI features and can't answer "what did my model actually do on that request, and did my last change make it better?", Langfuse is the fastest way to close that gap — free to start, open-source if you want to own it, and built around the exact loop (trace → evaluate → improve) that separates an AI feature you can operate from one you just hope keeps working.
