OpenLLMetry vs Langfuse is mostly a false choice, because the two sit at different layers. OpenLLMetry is an Apache 2.0 instrumentation library from Traceloop that captures LLM calls, vector database queries and framework steps as OpenTelemetry spans and sends them anywhere. Langfuse is the place those spans can land: an MIT licensed platform that stores traces and adds prompt management, datasets, evaluations and cost dashboards. Use OpenLLMetry when you want vendor neutral capture or a language Langfuse has no SDK for. Use the Langfuse SDK alone when you write Python or TypeScript and Langfuse is your only backend. Many teams run both.

The real comparison people need is a different one: OpenLLMetry plus some backend versus the Langfuse SDK plus Langfuse, and Traceloop's own hosted platform versus Langfuse Cloud. This guide covers both, with pricing and docs rechecked on November 7, 2026. For the wider market, see our LLM observability tools roundup.

OpenLLMetry vs Langfuse at a glance

ItemOpenLLMetryLangfuse
What it isInstrumentation library (OpenTelemetry extensions)Observability and evaluation platform
LicenseApache 2.0MIT core; some enterprise features need a license key
Stores or shows traces?No. It exports spans to a backendYes. UI, database, APIs
LanguagesPython, Node.js and Next.js, Go, Ruby SDKsPython and JavaScript or TypeScript SDKs; other languages through OpenTelemetry
Where data goesTraceloop or any of 25+ listed backends, including LangfuseLangfuse Cloud or your own self hosted Langfuse
Evals and promptsNone in the library itselfDatasets, experiments, LLM as a judge, human annotation, prompt versioning
Owner in November 2026Traceloop, now part of ServiceNowLangfuse, now part of ClickHouse
PriceFreeSelf host free; Cloud has a free Hobby tier and paid plans from 29 dollars a month

In short, OpenLLMetry answers "how do I capture what my LLM app did?" and Langfuse answers "where do I look at it, score it and improve it?"

What OpenLLMetry actually does

OpenLLMetry is a set of OpenTelemetry instrumentations plus a thin SDK. You call Traceloop.init() once and it patches supported clients (OpenAI, Anthropic, Bedrock, Vertex AI, Mistral, Ollama and others), vector stores such as Pinecone, Qdrant and Chroma, and frameworks such as LangChain, LlamaIndex, CrewAI and LiteLLM. Each call becomes a span with model name, token usage and, by default, the prompt and completion text. The project introduction describes it as tracing "built on top of OpenTelemetry" that you can export to Traceloop or to your existing observability stack.

Because the output is standard OTLP, the same spans can go to Datadog, Grafana, Honeycomb, New Relic, Dynatrace, SigNoz, Langfuse, LangSmith, Laminar or a plain OpenTelemetry Collector. The integrations list in the Traceloop docs names each of those, and the Traceloop pricing FAQ says OpenLLMetry is Apache 2.0 licensed, free, and connects to 25 or more platforms.

The project ships often. Its GitHub releases page shows version 0.63.0 on November 5, 2026, which added a trace_content parameter to Traceloop.init() and fixed token counting for thinking tokens in the Vertex AI and Google Generative AI instrumentations. Earlier 2026 releases added LiteLLM instrumentation (0.62.0, June 28) and moved the LangChain and OpenAI Agents instrumentations toward the OpenTelemetry GenAI semantic conventions. The repository had roughly 7,500 GitHub stars when we checked.

The privacy switch matters. If prompts contain customer data, set TRACELOOP_TRACE_CONTENT=false (or pass the new trace_content option) so spans carry timings and token counts without the text itself.

What Langfuse actually does

Langfuse is a full application: a web UI, a ClickHouse backed store for traces, and APIs. On top of tracing it gives you sessions and user tracking, token and cost tracking, prompt versioning with release labels, datasets and experiments, LLM as a judge evaluators, human annotation queues, dashboards and alerts. Our Langfuse vs LangSmith comparison covers those features against the main hosted rival.

Langfuse is itself built on OpenTelemetry. Its OpenTelemetry integration docs say the Python and JavaScript SDKs are a thin layer on the official OpenTelemetry client, and that Langfuse accepts OTLP traces at /api/public/otel from any instrumentation library. The same page names OpenLLMetry, OpenLIT, Arize's OpenInference and MLflow as popular options and says OpenLLMetry and OpenLIT extend Langfuse tracing to languages such as Java and Go.

Ownership changed this year. ClickHouse announced it had acquired Langfuse on January 16, 2026, and said the core stays open source under the MIT license, self hostable at production scale, with Langfuse Cloud running as a standalone service.

How to send OpenLLMetry traces to Langfuse

Langfuse publishes an OpenLLMetry cookbook for this exact setup. The short version in Python:

import os, base64
from traceloop.sdk import Traceloop

auth = base64.b64encode(
    f"{os.environ['LANGFUSE_PUBLIC_KEY']}:{os.environ['LANGFUSE_SECRET_KEY']}".encode()
).decode()

Traceloop.init(
    api_endpoint="https://cloud.langfuse.com/api/public/otel",
    headers={
        "Authorization": f"Basic {auth}",
        "x-langfuse-ingestion-version": "4",
    },
)

Swap the endpoint for https://us.cloud.langfuse.com/api/public/otel in the US region, or your own host for a self hosted server. Four details from the Langfuse docs decide whether this works well:

  1. Send the ingestion version header. Without x-langfuse-ingestion-version: 4, spans sent straight over OpenTelemetry can take up to 10 minutes to appear.
  2. Use HTTP, not gRPC. Langfuse accepts OTLP over HTTP with JSON or protobuf. gRPC is not supported yet, so point a Collector's otlphttp exporter at Langfuse.
  3. Propagate user and session IDs to every span. Filters on userId, sessionId, tags and metadata work per observation, so set langfuse.user.id and langfuse.session.id (or user.id and session.id) on each span, for example with OpenTelemetry baggage.
  4. Self hosted servers need version 3.22.0 or later. That release introduced the OTLP endpoint. Older servers return 4xx errors.

Langfuse maps standard gen_ai.* attributes to model, usage and cost fields. Anything it does not recognize lands under metadata.attributes, where you can see it but not filter on it. Prefix custom fields with langfuse.observation.metadata. if you need to query them.

We did not run this setup first hand for this guide. The snippet follows the two vendors' published docs as of November 7, 2026.

When the Langfuse SDK alone is the better choice

If your app is Python or TypeScript and Langfuse is your only backend, the native SDK is simpler. It already sits on OpenTelemetry, so spans from other instrumented libraries in the same process can still flow into Langfuse. It also gives you helpers OpenLLMetry does not: linking a generation to a managed prompt version, attaching scores from code, and propagate_attributes() for user and session IDs without writing baggage code. Langfuse also ships native integrations for LangChain, LlamaIndex, the OpenAI SDK, the Vercel AI SDK and many agent frameworks.

The cost of that convenience is coupling. Langfuse specific attributes and helpers mean more rewrite work if you later move to another backend.

When OpenLLMetry earns its place

Pick OpenLLMetry as the capture layer in four situations:

  • You already run an APM tool. Teams on Datadog, Grafana or Dynatrace can send the same LLM spans there for latency and error alerting, and fan them out to Langfuse for prompt and eval work with one Collector.
  • You want to switch backends later. Instrumenting once with plain OpenTelemetry is the cheapest insurance against lock in. Our Datadog LLM Observability vs Langfuse guide uses exactly this approach for a two week side by side trial.
  • Your stack uses a language or framework the Langfuse SDK does not cover. Go and Ruby services, or frameworks that OpenLLMetry instruments directly, are the usual cases.
  • You are tracing agents across services. Standard OpenTelemetry context propagation stitches spans from several services into one trace. Our AI agent observability guide explains why that matters for long agent runs.

The downside is that OpenLLMetry and Langfuse do not always agree on attribute names. Langfuse's mapping table is the reference when a field such as cost or prompt version does not show up where you expect.

Traceloop vs Langfuse: the hosted platforms

Some people searching for OpenLLMetry vs Langfuse really mean Traceloop's hosted platform, which is built on OpenLLMetry and competes with Langfuse directly. Here is how the two hosted offers compared on November 7, 2026:

ItemTraceloop platformLangfuse Cloud
Free tierFree Forever: up to 50K spans a month, 24 hours of data retentionHobby: 50k units a month, 30 days of data access, 2 users
Paid entryEnterprise, priced on request, for more than 50K spansCore: 29 dollars a month with 100k units, then 8 dollars per 100k units
Higher plansEnterprise includes SOC 2 and an on premises optionPro at 199 dollars a month, Enterprise at 2,499 dollars a month
Self hostOn premises deployment on EnterpriseFree MIT self host with unlimited usage
OwnerServiceNow (Traceloop)ClickHouse (Langfuse)

Sources: Traceloop pricing and Langfuse pricing. Traceloop's pricing card lists up to 5 seats on the free plan, while its FAQ says there is no seat limit; confirm with the vendor if seats matter. A Langfuse unit is any trace, observation or score, so one LLM call with a few nested spans counts as several units.

Ownership is the bigger strategic difference. Traceloop announced on March 2, 2026 that it was joining ServiceNow, with its technology becoming part of ServiceNow's AI Control Tower. The post says OpenLLMetry will remain open source and that Traceloop will keep selling its product to existing customers, with roadmap changes announced in advance. That is reassuring for the library and less clear for small teams choosing the hosted product. Langfuse, by contrast, keeps a public self serve price list and a free self hosted path.

Which should you pick?

  • Solo developer or small team, Python or TypeScript, one backend: Langfuse SDK plus Langfuse Cloud Hobby or a self hosted server. Add OpenLLMetry later only if you need another destination. See is Langfuse free for commercial use before you self host for a client.
  • Team with an existing APM bill: OpenLLMetry as the capture layer, a Collector that fans out to your APM tool and to Langfuse.
  • Polyglot services or Go and Ruby backends: OpenLLMetry everywhere, Langfuse (or another OTLP backend) as the store.
  • Enterprise already on ServiceNow: Traceloop's platform inside AI Control Tower may be the path of least procurement; still instrument with OpenLLMetry so you can leave.
  • You want a single container to start: compare Arize Phoenix in our Langfuse vs Arize Phoenix guide; Phoenix also accepts OpenTelemetry data.

Our default recommendation: instrument with OpenTelemetry, using OpenLLMetry where it saves code, and use Langfuse as the place where traces become evals and prompt fixes. Choosing one does not rule out the other.

FAQ

Is OpenLLMetry an alternative to Langfuse?

Only partly. OpenLLMetry captures and exports traces but has no storage, UI, prompt management or evaluation features. It replaces the Langfuse SDK's capture role, not the Langfuse platform. Traceloop's hosted platform is the actual Langfuse alternative.

Can I use OpenLLMetry with Langfuse?

Yes. Point OpenLLMetry's OTLP exporter at your Langfuse host's /api/public/otel endpoint with Basic auth built from your public and secret keys, and add the x-langfuse-ingestion-version: 4 header. Langfuse documents this in its OpenLLMetry cookbook.

Is OpenLLMetry free?

Yes. OpenLLMetry is Apache 2.0 licensed and free to use with any supported backend. Traceloop's own hosted platform has a free tier of up to 50K spans a month with 24 hours of retention, and paid Enterprise plans above that.

Is Langfuse built on OpenTelemetry?

Yes. The Langfuse Python and JavaScript SDKs are a thin layer on the official OpenTelemetry client, and the server accepts OTLP over HTTP from any instrumentation library. It does not accept gRPC yet.

Does OpenLLMetry log my prompts?

By default it records prompts and completions on spans. Set TRACELOOP_TRACE_CONTENT=false, or use the trace_content option added in version 0.63.0, to keep text out and send only metadata such as timings and token counts.

Who owns OpenLLMetry and Langfuse now?

Traceloop, the company behind OpenLLMetry, announced it was joining ServiceNow on March 2, 2026. ClickHouse acquired Langfuse on January 16, 2026. Both projects say they remain open source.