If you are new to AI tools, here is the fastest way to get going: start with Langfuse Cloud, connect an existing AI app, and look at one recorded request. This guide explains how to get started with Langfuse without assuming you know observability, tracing, or software deployment. The verdict: Langfuse is a strong, flexible option if you want to understand what your AI app does and where it may be going wrong.
How This Guide Was Built
This guide is desk research, not a hands-on test: I checked the official Langfuse documentation, vendor pricing pages, the ClickHouse announcement, and community reports for context. I verified plans, prices, the free tier, sign-up and first-trace steps, and the self-hosting licence; no account, SDK, trace, or dashboard was tested. Last verified: September 2026.
The distinction matters: setup instructions below reflect what Langfuse documents, not a walkthrough performed on a live project. Community reports can help reveal questions to investigate, but they are not a substitute for checking current documentation, pricing, and your own requirements. Product interfaces and plan terms can change, so use the linked vendor pages before making a purchase or choosing a data region.
What Langfuse does and when to use it
Langfuse is an open-source platform for LLM observability and evaluation: it records traces, helps rate quality, manages prompts, and supports cost tracking, so teams can inspect what a model did rather than guess. It is useful for debugging chatbots, evaluating outputs, and monitoring retrieval workflows, as well as organizing experiments.
An LLM, or large language model, is software that generates or interprets text. Observability means collecting enough information about an application to understand its behavior. Langfuse organizes that information into a few beginner-friendly concepts:
- A trace is the full journey of one request through an AI application. For example, a single question sent to a chatbot can be represented as one trace.
- Observations are the steps recorded inside a trace, such as spans, generations, and events. A span is a recorded operation; a generation is a model response; an event records something that happened.
- Scores are quality ratings attached to traces. They can help you compare outputs or flag a response that needs review.
- Sessions group related traces into a multi-turn conversation, rather than leaving each user message isolated.
- Datasets and experiments let you replay a fixed set of inputs and inspect the results. That can help you compare changes against the same examples.
- Prompt management stores prompt versions so you can update and manage prompts without redeploying code, according to the prompt management documentation.
These concepts are useful for everyday questions, not just engineering investigations. You might want to see what your chatbot said and how much a request cost, identify whether a newer prompt version made answers worse, inspect the retrieval step in a retrieval-augmented generation (RAG) app, or track usage across models. RAG is a method that searches for relevant information and supplies it to a model alongside a user’s question.
Langfuse also documents LLM-as-a-judge evaluations, in which a model rates another model’s output, along with custom dashboards, alerts on metrics, model usage and cost tracking, and annotation queues for human review. These tools can help a team spot patterns, but a rating is not proof that an answer is correct; define what good means for your use case and check important results with people. See our AI evaluation tools comparison for a broader view of evaluation products.
Langfuse scores 8.4/10 in ToolBrain’s review. That makes it worth considering if you want an open-source option with cloud and self-hosting paths, but it does not mean every feature is needed for a beginner. For a fuller assessment, read our Langfuse review.
There are two useful pieces of 2026 context. Langfuse’s changelog says v4 shipped on August 17, 2026, under the title “Langfuse v4: Faster at Scale,” and the site’s announcement describes it as real-time and up to 165× faster; those are vendor claims, not measurements made for this guide (v4 changelog). Langfuse also announced that it joined ClickHouse in January 2026; ClickHouse’s announcement says the acquisition was accompanied by a $400 million Series D (Langfuse announcement, ClickHouse announcement).
How do I get started with Langfuse?
The fastest way to get started with Langfuse, according to the official getting-started guide, is to sign up for the free Hobby plan at cloud.langfuse.com, create a project, copy its public and secret API keys, install the relevant package, and send a request from an existing app so it appears as a trace.
-
Choose Cloud for your first project. Sign up at cloud.langfuse.com. Langfuse lists Hobby at $0 per month, with no credit card required, 50,000 units per month, 30 days of data access, and two users on its pricing page. A unit is one trace, one observation, or one score; Langfuse defines the total as traces plus observations plus scores in its billable units documentation.
-
Select the right data region. Langfuse lists Cloud endpoints for the EU at
https://cloud.langfuse.com, the US athttps://us.cloud.langfuse.com, Japan athttps://jp.cloud.langfuse.com, and HIPAA athttps://hipaa.cloud.langfuse.comin its getting-started documentation. Pick a region based on your organization’s requirements, and ask your privacy or security lead if you are unsure. -
Create a project. A project is the workspace where your app’s traces, scores, and other Langfuse data are organized. After signing up, create a project for one application or environment so you can keep its records separate from unrelated work. The documented onboarding flow then lets you generate API keys for that project (Langfuse getting-started guide).
-
Create and store the API keys. Generate a public key, which starts with
pk-lf-, and a secret key, which starts withsk-lf-. Langfuse documents the environment variablesLANGFUSE_PUBLIC_KEY,LANGFUSE_SECRET_KEY, andLANGFUSE_BASE_URLfor configuration (getting-started guide). An environment variable is a setting provided to a program when it runs. Keep the secret key out of shared code, screenshots, and public repositories.For a Unix-like shell, a setup can look like this:
export LANGFUSE_PUBLIC_KEY="pk-lf-your-project-key" export LANGFUSE_SECRET_KEY="sk-lf-your-project-secret" export LANGFUSE_BASE_URL="https://cloud.langfuse.com"Replace the example values with your project’s keys and the endpoint for your chosen region. For ongoing use, store secrets in your deployment’s secure configuration rather than relying on a personal terminal session.
-
Install the library for your app’s language. For Python, Langfuse documents
pip install langfuseand an OpenAI-compatible import path:from langfuse.openai import openai. The documentation describes this as a drop-in replacement for the OpenAI client that records calls in the background (getting-started guide). A drop-in replacement is a component intended to work in place of another with little change to how you call it. For JavaScript or TypeScript, the documented packages are@langfuse/openaiand@opentelemetry/sdk-node, installed withnpm install. -
Connect one existing request. The simplest first check is usually to instrument one request your application already makes, rather than redesigning the whole app. In Python, swap the existing OpenAI import to the Langfuse import documented above, then run the part of your app that sends a request. In JavaScript or TypeScript, follow the package setup in Langfuse’s getting-started guide. The exact application code depends on your project, so keep the first change small.
-
Open the project and look for the trace. Return to the Langfuse project and inspect the recorded request. A trace is the request’s overall journey; observations show the steps inside it, and scores can later record quality judgments (observability overview). Begin by checking that a request appears and that its steps make sense. Then use the recorded detail to ask a specific question, such as where a response took a wrong turn.
If your app already sends OpenTelemetry spans, you may not need to add the same instrumentation again. OpenTelemetry is a standard for collecting and exporting information about how software runs; Langfuse documents an endpoint that lets an existing setup send that information to Langfuse (getting-started guide). For teams working with agentic coding tools, Langfuse also documents the shortcut npx skills add langfuse/skills --skill "langfuse".
Langfuse vs alternatives: which should you pick?
Langfuse is a strong open-source choice if you want both a free cloud starting point and a self-hosting option; Comet Opik, Braintrust, and LangSmith offer different documented plans or deployment paths, so compare the specific needs that matter to you. The LLM observability comparison gives more context.
The table summarizes the listed plans and documented options. “Self-hostable” means the vendor documents running the software in infrastructure you control; it does not mean setup or maintenance is automatic. For Langfuse, Hobby, Core, and Pro are Cloud plans, while the open-source edition is a separate self-hosting path. Each vendor cell links to its source page.
| Option | Price (2026) | Free tier | Self-hostable | Best for |
|---|---|---|---|---|
| Langfuse Hobby | $0/month — Langfuse pricing | 50,000 units/month, 30 days data access, 2 users, no credit card | No | Trying LLM tracing with zero setup cost |
| Langfuse Core | $29/month — Langfuse pricing | 100,000 units/month included | No | Small teams that need unlimited users and 90-day data access |
| Langfuse Pro | $199/month — Langfuse pricing | 100,000 units/month included | No | Production apps needing 3-year retention, high rate limits, SOC 2 / ISO 27001 and a HIPAA BAA |
| Langfuse self-hosted (open source) | $0, MIT licence — self-host pricing | Unlimited units, no metering | Yes (Docker Compose, VM, Kubernetes/Helm, Terraform) | Data-control requirements, or heavy volume where metering would be expensive |
| Comet Opik | Open source $0; Free Cloud $0; Pro Cloud $19/month — Comet pricing | Free Cloud: up to 10 team members, 25,000 spans/month, 60-day retention | Yes (the hosted codebase is the same OSS codebase) | Teams that want an open-source observability stack and already use Comet |
| Braintrust | Starter $0/month; Pro $249/month — Braintrust pricing | Starter: 1 GB processed data, 10,000 scores, 14-day retention, unlimited users, no credit card | Enterprise only (on-prem or hosted) | Teams that want evaluation-forward tooling with model credits included |
| LangSmith | Trace pricing, retention and limits are documented on LangSmith usage and billing | A free account is documented (no credit card required) — LangSmith observability docs | Yes (cloud, hybrid or self-hosted deployment options documented) | Teams already building on LangChain or LangGraph |
A MIT licence is a permissive open-source licence that allows broad use of the software, subject to its licence terms. Langfuse says its self-hosted open-source edition includes core platform features and APIs, unlimited units, and deployment documentation; it lists Docker Compose, a single virtual machine, Kubernetes with Helm, and Terraform templates for AWS, Azure, and Google Cloud (self-hosting options, deployment documentation). A virtual machine is a computer hosted in software rather than a separate physical machine; Kubernetes is software for managing containerized applications, and Helm helps install applications on Kubernetes.
Langfuse’s Cloud prices also differ in data access and support. The pricing page lists 90 days of data access on Core and three years on Pro, plus Pro features including data retention management, unlimited annotation queues, high rate limits, SOC 2 and ISO 27001 reports, a BAA available for HIPAA, and prioritized in-app support (Langfuse pricing). A BAA, or business associate agreement, is a contract used in certain healthcare contexts. Check the plan details against your own compliance needs rather than treating a listed feature as a complete compliance solution.
For paid Langfuse Cloud plans, the first 100,000 units are included; the pricing page lists graduated rates above that level of $8 per 100,000 units from 100,000 to 1 million, $7 from 1 million to 10 million, $6.50 from 10 million to 50 million, and $6 above 50 million (Langfuse pricing). The same page lists discounts for early-stage startups, research and students, non-profits, and open-source projects. Hobby’s listed 50,000-unit allowance is clear, but the cited pricing information does not specify what happens when a Hobby project exceeds it.
For a beginner, the choice is often practical: use Langfuse Cloud if you want a hosted start without running infrastructure, and investigate the self-hosted edition if controlling where data runs is important. Langfuse says the instrumentation code is the same for Cloud and self-hosting, but the self-hosted route still requires someone to deploy and maintain the service (getting-started guide). If you are comparing more products, see our Arize AI Phoenix review and our Braintrust review.
3 pro tips for beginners
Three beginner tips make Langfuse easier to approach: start with Cloud to avoid operating infrastructure, use the documented OpenAI-compatible import if it fits your app, and group related turns into sessions so a conversation is easier to follow. These suggestions follow the Langfuse getting-started guide and observability overview.
- Start with one question, not every dashboard. Before sending data, write down what you hope to learn: for instance, whether answers are relevant, which step of a RAG app is failing, or how usage differs between prompt versions. A focused question makes it easier to decide which traces and observations are useful. Once that first investigation works, add more information.
- Keep conversations connected. If your app supports multiple messages in a conversation, use a session ID so the related traces can be grouped. Langfuse defines sessions as a way to group multi-turn conversations (observability overview). Without grouping, it can be harder to see whether a response makes sense in the context of what the user said earlier.
- Treat a score as a question to investigate. A score can help you identify outputs that deserve a closer look, but it only measures the criteria you chose. Try a small set of representative inputs, define what counts as a good answer, and review surprising results. For other evaluation options and workflows, browse the AI evaluation tools comparison.
Common mistakes and how to avoid them
Common beginner mistakes include exposing secret keys, collecting traces without a clear purpose, and misunderstanding what unit usage counts; Langfuse’s observability overview presents traces, observations, scores, and prompts as connected parts of understanding an application, not simply a log viewer.
- Putting a secret key directly in app code. Code is often copied, shared, and checked into version control. Keep
LANGFUSE_SECRET_KEYin environment configuration or an appropriate secrets manager, and avoid pasting it into issue trackers or screenshots. Langfuse documents environment variables for its keys in the getting-started guide. - Confusing a trace with a single model response. One trace is the overall journey of a request; it can contain multiple observations. If a RAG app searches for documents, assembles context, and then asks a model to respond, inspect the recorded steps rather than judging the final text alone (observability overview).
- Assuming units mean only model calls. Langfuse defines billable units as the count of traces plus observations plus scores, so a complex trace with multiple recorded steps and ratings can contribute more than one unit (billable units documentation). Estimate your likely recording pattern and compare it with the plan before choosing a paid tier.
- Treating Hobby’s limit as a known billing transition. Langfuse lists the Hobby allowance, but the available pricing details cited here do not explain what happens after it is reached. Do not assume an automatic upgrade, a particular overage charge, or a service behavior; check the current pricing page or ask Langfuse before relying on a specific outcome.
- Keeping traces but not using them to improve anything. A record is most useful when it helps you make a decision. Attach scores to outputs you want to assess, compare a stable dataset when changing prompts, and use human review for ambiguous cases. Langfuse documents datasets and experiments for replaying fixed inputs and annotation queues for human review (observability overview, evaluation overview).
FAQ
These three beginner questions summarize what Langfuse documents about cost, self-hosting, and what a first trace means. The answers are based on the pricing page, getting-started guide, and self-hosting documentation; check those primary sources before committing to a plan or deployment.
Is Langfuse free for beginners?
Yes, Langfuse lists a Cloud Hobby plan at $0 per month with no credit card required, 50,000 units per month, 30 days of data access, and two users (Langfuse pricing). The open-source self-hosted edition is also listed as free with unlimited units, but you must operate the infrastructure yourself (self-host pricing).
Should I use Langfuse Cloud or self-host it?
Choose Langfuse Cloud if you want a hosted service and do not want to run infrastructure; choose self-hosting if your team needs to operate the platform in its own environment. Langfuse documents both options and says the instrumentation code is the same for each (getting-started guide). Self-hosted deployment still needs setup and maintenance.
What is the first thing I should look for in Langfuse?
Start by checking that one request from your application appears as a trace, then inspect the observations that record its steps. A trace represents the request’s full journey, while observations represent work inside it, such as spans, generations, and events (Langfuse observability overview). This confirms the basic connection before you add evaluations or dashboards.
Where to go next
After this guide, useful next steps are to read our Langfuse review, compare options in the AI evaluation tools comparison, and learn how the ToolBrain pipeline works. Return to the setup steps when you are ready to connect an app and inspect its first trace.
If you are still choosing a tool, use the comparison links in this guide to check whether self-hosting, evaluation workflows, or a particular ecosystem matters most to you. If you have already chosen Langfuse, keep the first project small: connect one application, inspect a representative request, and decide what you want to measure next. That gives you a practical starting point without needing to adopt every feature at once.
📖 Related Reads
- ToolBrain — tool reviews, LLM comparisons, and AI workflow guides
- NiteAgent — AI agent development, frameworks, and production patterns
Cross-links automatically generated from None.
Back to all posts