OpenAI

Overview

Confident AI lets you trace and evaluate OpenAI calls, whether standalone or used as a component within a larger application.

With confident-trace, Confident AI's OpenTelemetry-native tracing SDK, you keep the official OpenAI client exactly as it is — call init() once and every Chat Completions or Responses call shows up in the Observatory as an LLM span with its messages, token usage and cost, latency, and errors.

Auto-Instrument

1. Install Dependencies

   Run the following command to install confident-trace alongside the OpenAI SDK:

   PythonTypeScript

   pip install confident-trace openai

2. Set Your API Keys

   Get your Confident AI Project API key and set it as an environment variable, along with your OpenAI key:

   export CONFIDENT_API_KEY="<your-confident-project-key>"
   export OPENAI_API_KEY="<your-openai-key>"

3. Instrument OpenAI

   Call init() once before making model calls. It detects the installed OpenAI SDK and instruments it for you — keep importing your client from openai as usual, no wrapper needed.

   PythonTypeScript

   from confident_trace import init, shutdown
   from openai import OpenAI
   
   init()
   client = OpenAI()
   
   try:
       response = client.responses.create(
           model="gpt-4.1-mini",
           input="Explain OpenTelemetry in one sentence.",
       )
       print(response.output_text)
   finally:
       shutdown()

4. Run OpenAI

   Run your script to send the trace to Confident AI:

   PythonTypeScript

   python main.py

   Done ✅. Open the Observatory in your Confident AI project and you'll find a trace with an LLM span inside it.

What Gets Captured

Each supported model call becomes an LLM span. If there's already an active span (for example one you created with span), the call nests under it; a call with no parent starts a new trace of its own.

• Model and response details — requested model, response ID, timing, status, and token usage.
• Messages — input/output messages, finish reasons, and tool-call data returned by the model.
• Streaming output — recorded as your app consumes the stream, without reading ahead of it.

Captured content follows the content policy. Size limits are disabled by default, but you can configure a limit or redact content before export.

Chat Completions, Streaming, and Async

The quickstart used the Responses API, but every supported call is traced the same way. These examples continue after init() and client setup from the quickstart, and before shutdown().

completion = client.chat.completions.create(
    model="gpt-4.1-mini",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is the weather in France?"},
    ],
)
print(completion.choices[0].message.content)

const completion = await client.chat.completions.create({
  model: "gpt-4.1-mini",
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "What is the weather in France?" },
  ],
});
console.log(completion.choices[0].message.content);

with client.responses.create(
    model="gpt-4.1-mini", input="Write a short poem.", stream=True
) as stream:
    for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)

const stream = await client.responses.create({
  model: "gpt-4.1-mini", input: "Write a short poem.", stream: true,
});
try {
  for await (const event of stream) {
    if (event.type === "response.output_text.delta") {
      process.stdout.write(event.delta);
    }
  }
} finally {
  stream.controller.abort();
}

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

async def generate_response(input: str) -> str:
    response = await async_client.responses.create(
        model="gpt-4.1-mini",
        instructions="You are a helpful assistant.",
        input=input,
    )
    return response.output_text

print(asyncio.run(generate_response("What is the weather in France?")))

Set Trace Span Properties

Use a trace context to add properties you know before the call starts. It creates no extra span; the trace started by client.responses.create() inherits the tags, metadata, user ID, and customer ID.

from confident_trace import init, trace_context
from openai import OpenAI

init()

client = OpenAI()

with trace_context(
    tags=["support"],
    metadata={"release": "2026-09"},
    user_id="user-42",
    customer_id="customer-7",
):
    response = client.responses.create(
        model="gpt-4.1-mini",
        input="Explain OpenTelemetry in one sentence.",
    )

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

init();

const client = new OpenAI();

const response = await traceContext(
  {
    tags: ["support"],
    metadata: { release: "2026-09" },
    userId: "user-42",
    customerId: "customer-7",
  },
  () => client.responses.create({
    model: "gpt-4.1-mini",
    input: "Explain OpenTelemetry in one sentence.",
  }),
);

See users and customers to set an optional display name alongside each ID, and trace context for every supported trace property and update behavior.

Instrumenting Multi-Turn

You do not need turn() when one OpenAI entry-point call is already one conversational turn—the integration creates that turn's trace automatically. Use turn() when you want to define the boundary yourself, such as grouping two sequential OpenAI calls into one turn. Reuse the same thread ID on later turns to group them into one conversation.

from confident_trace import init, turn

init()

with turn("support-turn", thread_id="chat-42"):
    context = client.responses.create(model="gpt-4.1-mini", input="Find the relevant account details.")
    answer = client.responses.create(model="gpt-4.1-mini", input=f"Summarize these details: {context.output_text}")

import { init, turn } from "confident-trace";

init();

const answer = await turn({ name: "support-turn", threadId: "chat-42" }, async () => {
  const context = await client.responses.create({ model: "gpt-4.1-mini", input: "Find the relevant account details." });
  return client.responses.create({ model: "gpt-4.1-mini", input: `Summarize these details: ${context.output_text}` });
});

See threads for thread I/O, turn IDs, and user IDs.

Troubleshooting

For general setup issues, see troubleshooting.

Disable OpenAI Instrumentation

Pass init() a list of integration identifiers to opt in to only those integrations. The identifier for OpenAI is "openai" in Python and TypeScript; omit it to disable this integration. An empty list disables all automatic instrumentation:

from confident_trace import init
init(instrumentations=())
# Use ("openai",) to opt in; omit "openai" to disable it.

import { init } from "confident-trace";
init({ instrumentations: [] });
// Use ["openai"] to opt in; omit "openai" to disable it.

This turns off Confident AI's automatic instrumentation; calls made after initialization are not instrumented by this integration.

Next Steps

Last updated on September 23, 2026