Start where it’s automatic. For supported providers and frameworks, install an instrumentor package, call .instrument(), and every call is traced — no per-call code changes. You can start from the Arize AX UI — when you create a new tracing project, the setup wizard walks you through choosing your integration and gives you the code to copy:

New Tracing Project setup wizard in Arize AX

Or follow the steps below.

Set Up with Skills or Code

By Arize Skills
By Code

Three steps to instrument with your AI coding agent:Install skill

npx skills add Arize-ai/arize-skills --skill "arize-instrumentation" --yes

Set up authentication

export ARIZE_API_KEY="YOUR_API_KEY"
export ARIZE_SPACE_ID="YOUR_SPACE_ID"

Instrument your app

# Ask your AI coding agent:
"Set up Arize tracing in my application"

Works with Cursor, Claude Code, Codex, and more. The skill analyzes your stack, picks the right OpenInference package, wires it in, and tells you exactly how to verify traces are flowing:

Arize instrumentation skill analyzing a Vercel AI SDK app and proposing the right OpenInference integration

Install the OpenInference instrumentor for your provider, register a tracer provider with your Arize credentials, and call .instrument().

Install

Python
JS/TS
Go

pip install arize-otel openinference-instrumentation-openai openai

npm install @arizeai/openinference-instrumentation-openai openai @opentelemetry/sdk-trace-node @opentelemetry/exporter-trace-otlp-proto @opentelemetry/resources @opentelemetry/instrumentation

Go has no first-party OpenInference auto-instrumentor today. Install the OpenTelemetry Go SDK and instrument your LLM calls manually — see Manual instrumentation for the full pattern.

go get \
  go.opentelemetry.io/otel \
  go.opentelemetry.io/otel/sdk \
  go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp

Python
JS/TS
Go

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

tracer_provider = register(
    space_id="YOUR_SPACE_ID",        # Settings > API Keys in Arize AX
    api_key="YOUR_API_KEY",          # Settings > API Keys > + New API Key
    project_name="my-project",
)
OpenAIInstrumentor().instrument(tracer_provider=tracer_provider)

import { NodeTracerProvider, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-node";
import { registerInstrumentations } from "@opentelemetry/instrumentation";
import { resourceFromAttributes } from "@opentelemetry/resources";
import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
import OpenAI from "openai";
import { OpenAIInstrumentation } from "@arizeai/openinference-instrumentation-openai";

const provider = new NodeTracerProvider({
    resource: resourceFromAttributes({
        ["openinference.project.name"]: "my-project",
    }),
    spanProcessors: [
        new SimpleSpanProcessor(
            new OTLPTraceExporter({
                url: "https://otlp.arize.com/v1/traces",
                headers: {
                    'arize-space-id': 'YOUR_SPACE_ID',
                    'arize-api-key': 'YOUR_API_KEY',
                },
            }),
        ),
    ],
});

const instrumentation = new OpenAIInstrumentation();
instrumentation.manuallyInstrument(OpenAI);
registerInstrumentations({ instrumentations: [instrumentation] });
provider.register();

Set up the TracerProvider directly and create spans with OpenInference attributes by hand around each LLM call. The full snippet is on the Manual instrumentation page; the minimal init looks like:

exporter, err := otlptracehttp.New(ctx,
    otlptracehttp.WithEndpoint("otlp.arize.com"),
    otlptracehttp.WithHeaders(map[string]string{
        "arize-space-id": os.Getenv("ARIZE_SPACE_ID"),
        "arize-api-key":  os.Getenv("ARIZE_API_KEY"),
    }),
)
if err != nil { log.Fatalf("exporter: %v", err) }

res, err := resource.New(ctx, resource.WithAttributes(
    attribute.String("openinference.project.name", "my-project"),
))
if err != nil { log.Fatalf("resource: %v", err) }

tp := sdktrace.NewTracerProvider(
    sdktrace.WithBatcher(exporter),
    sdktrace.WithResource(res),
)
otel.SetTracerProvider(tp)
// Use a fresh background context for shutdown — a request-scoped ctx
// may already be cancelled and would drop in-flight spans.
defer tp.Shutdown(context.Background())

Run your app

Every OpenAI call is now traced automatically:

Python
JS/TS
Go

import openai
client = openai.OpenAI()
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "What is observability?"}],
)

const client = new OpenAI();
const response = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "What is observability?" }],
});

Wrap each LLM call in a span and set the OpenInference attribute keys as raw strings:

tracer := otel.Tracer("my-app")

ctx, span := tracer.Start(ctx, "openai.chat_completion")
defer span.End()
span.SetAttributes(
    attribute.String("openinference.span.kind", "LLM"),
    attribute.String("llm.model_name", "gpt-4o"),
    attribute.String("input.value", "What is observability?"),
)

resp, err := client.CreateChatCompletion(ctx, /* ... */)
if err != nil {
    span.RecordError(err)
    span.SetStatus(codes.Error, err.Error())
}
span.SetAttributes(attribute.String("output.value", resp.Choices[0].Message.Content))

This example uses OpenAI, but the same pattern works for any provider — install the instrumentor, call .instrument(), and go.

For some frameworks (CrewAI, LangChain, AutoGen, LlamaIndex), .instrument() must run before importing the library — they patch methods at runtime, so objects created earlier will not emit spans. See each integration page for specifics.

Supported Integrations

Arize has 30+ native integrations across LLM providers, Python and TypeScript agent frameworks, and Java. The most common ones:

OpenAI

Anthropic

LangChain

LangGraph

LlamaIndex

CrewAI

Mastra

Vercel AI SDK

See all 30+ integrations (LLM providers, agent frameworks, Python, TypeScript, Java)

For a primer on the underlying OpenTelemetry concepts these integrations build on, see OTel primitives.

Learn More

What auto captures — auto-instrumentors set OpenInference semantic conventions automatically: model name, messages, token counts, inputs, outputs.
Group traces into conversations — add session.id and user.id to follow multi-turn interactions. See Set up sessions.
Enrich traces with custom data — attach metadata, tags, and custom attributes to auto-instrumented spans. See Customize your traces.
Control what’s captured — hide sensitive inputs, suppress tracing for specific calls, or truncate images with TraceConfig. See Mask and redact data.
Augment what auto didn’t capture — add manual spans for anything auto-instrumentation missed. See Manual instrumentation or Combine auto + manual.

Next step

For custom logic that auto-instrumentors can’t capture, add manual spans:

How to Use Arize AX

Quickstart

Instrument

Observe

Evaluate

Improve

Machine Learning

Settings

Security

Auto-Instrumentation

Set Up with Skills or Code

Supported Integrations

OpenAI

Anthropic

LangChain

LangGraph

LlamaIndex

CrewAI

Mastra

Vercel AI SDK

See all 30+ integrations (LLM providers, agent frameworks, Python, TypeScript, Java)

Learn More

Next step

Next: Manual Instrumentation

How to Use Arize AX

Quickstart

Instrument

Observe

Evaluate

Improve

Machine Learning

Settings

Security

Documentation Index

​Set Up with Skills or Code

​Supported Integrations

OpenAI

Anthropic

LangChain

LangGraph

LlamaIndex

CrewAI

Mastra

Vercel AI SDK

See all 30+ integrations (LLM providers, agent frameworks, Python, TypeScript, Java)

​Learn More

​Next step

Next: Manual Instrumentation

Set Up with Skills or Code

Supported Integrations

Learn More

Next step