Switch from Langfuse to Confident AI

Move your OpenTelemetry traces from Langfuse to Confident AI with confident-trace. Your spans, provider clients and frameworks stay untouched.

Overview

Langfuse SDK v4 (Python) and v5 (TypeScript) already run on OpenTelemetry. confident-trace speaks the same protocol, so the switch is an exporter swap: replace the Langfuse client wrapper with init(), rename the decorator, and keep every span you emit today.

In this guide, you will:

Install confident-trace and replace the Langfuse keys with one CONFIDENT_API_KEY.
Replace the client setup with init() so auto instrumentation emits the spans.
Rename @observe to @span so every trace carries a name, an input and an output.
See what changes once the traces land in Confident AI: evals on every trace, datasets curated from production, alerts when quality drops.

$200 in migration credits, applied after your callBook a call, show us your current setup, and we map your traces, datasets and prompts together. Applied as a coupon to your first paid invoice, one per organization.Book a migration call

Prerequisites

A Project API Key, CONFIDENT_API_KEY (for example confident_us_proj_...). Retrieve yours here.
Python 3.10+ for the Python SDK, or Node.js 22+ for the TypeScript SDK.
Your existing Langfuse setup. The before snippets below follow the Langfuse quickstart as of September 2026.

Switch

Install confident-trace

One package. Provider SDKs stay optional peers. CONFIDENT_API_KEY replaces LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY, LANGFUSE_BASE_URL. For the EU region, also set CONFIDENT_OTEL_ENDPOINT=https://eu.otel.confident-ai.com/v1/traces.

pip install confident-trace
export CONFIDENT_API_KEY=...
# replaces LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY, LANGFUSE_BASE_URL

npm install confident-trace
export CONFIDENT_API_KEY=...
# replaces LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY, LANGFUSE_BASE_URL
node --import confident-trace/register dist/index.js

Replace the client wrapper with init()

Drop the Langfuse import of OpenAI. Auto instrumentation emits the spans from the plain client.

from langfuse.openai import openai

response = openai.chat.completions.create(
    model="gpt-4.1-mini",
    messages=[{"role": "user", "content": "Hello"}],
)

from confident_trace import init
from openai import OpenAI

init()
client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4.1-mini",
    messages=[{"role": "user", "content": "Hello"}],
)

import { NodeSDK } from "@opentelemetry/sdk-node";
import { LangfuseSpanProcessor } from "@langfuse/otel";
import { observeOpenAI } from "@langfuse/openai";
import OpenAI from "openai";

const sdk = new NodeSDK({ spanProcessors: [new LangfuseSpanProcessor()] });
sdk.start();
const openai = observeOpenAI(new OpenAI());

const response = await openai.chat.completions.create({
  model: "gpt-4.1-mini",
  messages: [{ role: "user", content: "Hello" }],
});

import { init } from "confident-trace";
import OpenAI from "openai";

const tracing = init();
const client = new OpenAI();

const response = await client.chat.completions.create({
  model: "gpt-4.1-mini",
  messages: [{ role: "user", content: "Hello" }],
});

Rename @observe to @span

Same shape. Return values and exceptions pass through.

from langfuse import observe

@observe()
def answer(question: str) -> str:
    return openai.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[{"role": "user", "content": question}],
    ).choices[0].message.content

from confident_trace import span

@span
def answer(question: str) -> str:
    return client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[{"role": "user", "content": question}],
    ).choices[0].message.content

import { observe } from "@langfuse/tracing";

const answer = observe(
  async (question: string) => {
    const response = await openai.chat.completions.create({
      model: "gpt-4.1-mini",
      messages: [{ role: "user", content: question }],
    });
    return response.choices[0].message.content;
  },
  { name: "answer" },
);

import { span } from "confident-trace";

const answer = span({ name: "answer" }, async (question: string) => {
  const response = await client.chat.completions.create({
    model: "gpt-4.1-mini",
    messages: [{ role: "user", content: question }],
  });
  return response.choices[0].message.content;
});

Run your app once. The trace appears in your project's Observatory within seconds. If it does not, check that CONFIDENT_API_KEY is set in the same process and that the app flushes before it exits.

What Changes

Tracing is where you start. Evals are where it pays off. Every trace gets a score. Low scores become dataset rows. Dataset rows become regression tests. Your next release ships against real production failures.

Capability	Langfuse	Confident AI
OpenTelemetry ingestion	Yes	OTLP over HTTP and gRPC
Auto-instrumented providers	OpenAI wrapper and LangChain callback	OpenAI, Anthropic, Google GenAI, Bedrock, 5 gateways, 16 frameworks
Built-in eval metrics	Managed evaluators, custom scoring	50+ research-backed metrics through DeepEval
Online evals on traces, spans and threads	Traces only	Yes
Quality-aware alerting on eval scores	Slack, webhook, GitHub Actions	Email, Slack, Discord, Teams
Prompt and use case drift detection	No	Yes
Automatic dataset curation from production	Manual add to dataset	Ingestion tasks, filtered and tagged
Multi-turn simulation	No	Yes
Git-based prompt management	No	Branches, PRs, approvals, eval actions
Cross-functional workflows, no code	No	PMs and QA run evals over HTTP
Regression testing and CI gates	No	Yes
Safety monitoring	No	Toxicity, bias, PII on production traffic

Migration Questions

Do I have to rewrite my instrumentation?

No. confident-trace exports through standard OTLP. Existing OpenTelemetry spans from your frameworks are exported as they are.

Can I run both during the switch?

Yes. Point an OpenTelemetry Collector at both endpoints and compare for a week before you cut over. CONFIDENT_OTEL_ENDPOINT accepts a Collector URL.

What about my Langfuse datasets and prompts?

We import them on the migration call. Langfuse exports through its public API and scheduled blob storage export. We map the result to Confident AI datasets and prompt versions.

How do I get the $200?

Book the call. After it, we apply a $200 coupon to your organization's first paid invoice. One reward per organization.

Is the TypeScript SDK ready?

The Python SDK is stable on PyPI. The TypeScript SDK is an alpha release on npm. The TypeScript snippets in this guide follow the alpha API.

OpenTelemetry integration

Send OTLP traces from any SDK or Collector to Confident AI, with the attribute keys the platform reads.

Build test runs from traces

Turn your production traces into an evaluated test run before you ship.

LLM Observability

Evals on every trace, drift detection, alerts, and datasets curated from production.

confident-trace on GitHub

The OpenTelemetry-native tracing SDK with 25 integrations for Python and TypeScript.

Last updated on September 23, 2026