Switch from Arize to Confident AI

Move your traces from Arize Phoenix or Arize AX to Confident AI with confident-trace. Your OpenTelemetry spans and OpenInference instrumentors stay untouched.

Overview

Phoenix (open source) and Arize AX both sit on OpenTelemetry through OpenInference instrumentors. confident-trace exports through the same provider, so the switch is one call: replace register() with init(), add one decorator to your entry point, and keep the OpenInference spans you emit today. The steps below show Phoenix first and Arize AX second where they differ.

In this guide, you will:

Install confident-trace and replace the Arize keys with one CONFIDENT_API_KEY.
Replace the client setup with init() so auto instrumentation emits the spans.
Add @span to your entry point 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 Arize setup. The before snippets below follow the Arize quickstart as of September 2026.

Switch

Install confident-trace

One package. Provider SDKs stay optional peers. CONFIDENT_API_KEY replaces PHOENIX_COLLECTOR_ENDPOINT, PHOENIX_API_KEY, PHOENIX_PROJECT_NAME (Phoenix) or ARIZE_SPACE_ID, ARIZE_API_KEY, ARIZE_PROJECT_NAME (Arize AX). 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 PHOENIX_COLLECTOR_ENDPOINT, PHOENIX_API_KEY, PHOENIX_PROJECT_NAME (Phoenix) or ARIZE_SPACE_ID, ARIZE_API_KEY, ARIZE_PROJECT_NAME (Arize AX)

npm install confident-trace
export CONFIDENT_API_KEY=...
# replaces PHOENIX_COLLECTOR_ENDPOINT, PHOENIX_API_KEY, PHOENIX_PROJECT_NAME (Phoenix) or ARIZE_SPACE_ID, ARIZE_API_KEY, ARIZE_PROJECT_NAME (Arize AX)
node --import confident-trace/register dist/index.js

Replace register() with init()

Drop the tracer provider and the manual instrumentor call. Auto instrumentation emits the spans. Existing OpenInference spans export through the shared provider.

from phoenix.otel import register
from openai import OpenAI

tracer_provider = register(
    project_name="my-app",
    auto_instrument=True,
)
client = OpenAI()

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

import os
from arize.otel import register
from openinference.instrumentation.openai import OpenAIInstrumentor
from openai import OpenAI

tracer_provider = register(
    space_id=os.environ["ARIZE_SPACE_ID"],
    api_key=os.environ["ARIZE_API_KEY"],
    project_name=os.environ["ARIZE_PROJECT_NAME"],
)
OpenAIInstrumentor().instrument(tracer_provider=tracer_provider)
client = OpenAI()

response = client.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 { register, registerInstrumentations } from "@arizeai/phoenix-otel";
import { OpenAIInstrumentation } from "@arizeai/openinference-instrumentation-openai";
import OpenAI from "openai";

register({ projectName: "my-app" });
const instrumentation = new OpenAIInstrumentation();
instrumentation.manuallyInstrument(OpenAI);
registerInstrumentations({ instrumentations: [instrumentation] });
const client = new OpenAI();

const response = await client.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" }],
});

Add @span to your entry point

Phoenix and Arize AX have no decorator in their quickstarts. One decorator gives the trace a name, an input and an output. Existing OpenInference spans still export.

After (confident-trace)

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

After (confident-trace)

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	Phoenix (open source)	Arize AX	Confident AI
OpenTelemetry ingestion	Yes	Yes	OTLP over HTTP and gRPC
Auto-instrumented providers	OpenInference instrumentors	OpenInference instrumentors	OpenAI, Anthropic, Google GenAI, Bedrock, 5 gateways, 16 frameworks
Built-in eval metrics	phoenix.evals, custom evaluators	Custom evaluators	50+ research-backed metrics through DeepEval
Online evals on traces, spans and threads	You run and schedule the job	Yes	Yes
Quality-aware alerting on eval scores	No	Slack, PagerDuty, OpsGenie	Email, Slack, Discord, Teams
Prompt and use case drift detection	No	Limited	Yes
Automatic dataset curation from production	Manual, or by script	Manual	Ingestion tasks, filtered and tagged
Multi-turn simulation	No	No	Yes
Git-based prompt management	No	No	Branches, PRs, approvals, eval actions
Cross-functional workflows, no code	No	No	PMs and QA run evals over HTTP
Regression testing and CI gates	No	No	Yes
Safety monitoring	No	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.

I am on Phoenix Cloud, not self-hosted. Which snippet do I use?

The Phoenix snippet. The register() call is the same. Only the endpoint and the API key change.

What about my Phoenix datasets and prompts?

Datasets export as CSV. Prompts export through the Phoenix CLI. Bring them to the migration call and we map them.

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