Anthropic

Anthropic provides the Claude family of large language models. Arize AX captures every Anthropic SDK call — prompts, responses, tool calls (including server tools and the MCP connector), thinking, and token usage — via the OpenInference instrumentors for Python, JavaScript / TypeScript, and Go, so you can debug, evaluate, and monitor Claude-powered applications.

Building on Claude Managed Agents? The Claude Platform and the Claude SDK export OpenTelemetry spans for sessions natively, so you don’t need this instrumentor. Don’t run both on the same client, or each request appears twice.

Prerequisites

Python 3.10+, Node.js 18+, or Go 1.25+
For the current Messages API features on this page: openinference-instrumentation-anthropic 3.1.0 or later (Python, with anthropic 1.8.0 or later), or @arizeai/openinference-instrumentation-anthropic 1.0.0 or later (TypeScript)
An Arize AX account (sign up)
An ANTHROPIC_API_KEY from the Anthropic Console

Launch Arize AX

Sign in to your Arize AX account.
From Space Settings, copy your Space ID and API Key. You will set them as ARIZE_SPACE_ID and ARIZE_API_KEY below.

Install

pip install arize-otel openinference-instrumentation-anthropic anthropic

npm install @anthropic-ai/sdk \
  @arizeai/openinference-instrumentation-anthropic \
  @arizeai/openinference-semantic-conventions \
  @opentelemetry/api \
  @opentelemetry/context-async-hooks \
  @opentelemetry/exporter-trace-otlp-proto \
  @opentelemetry/instrumentation \
  @opentelemetry/resources \
  @opentelemetry/sdk-trace \
  @opentelemetry/semantic-conventions

go get \
  github.com/Arize-ai/arize-otel-go \
  github.com/Arize-ai/openinference/go/openinference-instrumentation-anthropic-sdk-go \
  github.com/anthropics/anthropic-sdk-go

Configure credentials

export ARIZE_SPACE_ID="<your-space-id>"
export ARIZE_API_KEY="<your-api-key>"
export ARIZE_PROJECT_NAME="anthropic-tracing-example"
export ANTHROPIC_API_KEY="<your-anthropic-api-key>"

Setup tracing

# instrumentation.py
import os

from arize.otel import register
from openinference.instrumentation.anthropic import AnthropicInstrumentor

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

AnthropicInstrumentor().instrument(tracer_provider=tracer_provider)

# Turn off the Anthropic SDK's own spans (anthropic 1.14.0 and later), so
# each request isn't traced twice. Earlier SDK versions ignore this.
os.environ.setdefault("ANTHROPIC_OPEN_TELEMETRY", "false")

print("Arize AX tracing initialized for Anthropic.")

// instrumentation.ts
import { context, trace } from "@opentelemetry/api";
import {
  AsyncLocalStorageContextManager,
} from "@opentelemetry/context-async-hooks";
import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
import { resourceFromAttributes } from "@opentelemetry/resources";
import { SimpleSpanProcessor, TracerProvider } from "@opentelemetry/sdk-trace";
import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
import {
  SEMRESATTRS_PROJECT_NAME,
} from "@arizeai/openinference-semantic-conventions";
import { registerInstrumentations } from "@opentelemetry/instrumentation";
import {
  AnthropicInstrumentation,
} from "@arizeai/openinference-instrumentation-anthropic";
import Anthropic from "@anthropic-ai/sdk";

const projectName =
  process.env.ARIZE_PROJECT_NAME ?? "anthropic-tracing-example";

export const provider = new TracerProvider({
  resource: resourceFromAttributes({
    [ATTR_SERVICE_NAME]: projectName,
    [SEMRESATTRS_PROJECT_NAME]: projectName,
  }),
  spanProcessors: [
    new SimpleSpanProcessor({
      exporter: new OTLPTraceExporter({
        url: "https://otlp.arize.com/v1/traces",
        headers: {
          "arize-space-id": process.env.ARIZE_SPACE_ID ?? "",
          "arize-api-key": process.env.ARIZE_API_KEY ?? "",
        },
      }),
    }),
  ],
});

trace.setGlobalTracerProvider(provider);
context.setGlobalContextManager(
  new AsyncLocalStorageContextManager().enable(),
);

const instrumentation = new AnthropicInstrumentation();
instrumentation.manuallyInstrument(Anthropic);

registerInstrumentations({ instrumentations: [instrumentation] });

// Turn off the Anthropic SDK's own spans (@anthropic-ai/sdk 0.134.0 and
// later), so each request isn't traced twice. Earlier SDK versions ignore this.
process.env.ANTHROPIC_OPEN_TELEMETRY ??= "false";

console.log("Arize AX tracing initialized for Anthropic.");

// main.go
//
// Go integrations live in a single file — the tracer setup, the
// instrumented middleware, and the messages call all sit inside main().
// The `Run Anthropic` step below is just `go run main.go`.
package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "time"

    arizeotel "github.com/Arize-ai/arize-otel-go"
    anthropicotel "github.com/Arize-ai/openinference/go/openinference-instrumentation-anthropic-sdk-go"
    "github.com/anthropics/anthropic-sdk-go"
    "github.com/anthropics/anthropic-sdk-go/option"
    "go.opentelemetry.io/otel"
)

func main() {
    ctx := context.Background()

    projectName := os.Getenv("ARIZE_PROJECT_NAME")
    if projectName == "" {
        projectName = "anthropic-tracing-example"
    }

    // Register reads ARIZE_SPACE_ID / ARIZE_API_KEY from the environment.
    tp, err := arizeotel.Register(ctx, arizeotel.Options{
        ProjectName: projectName,
    })
    if err != nil {
        log.Printf("register tracer: %v", err)
        return
    }
    defer func() {
        shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
        defer cancel()
        _ = tp.Shutdown(shutdownCtx)
    }()

    fmt.Println("Arize AX tracing initialized for Anthropic.")

    // The middleware wraps every /v1/messages request in an
    // LLM-kind span. The SDK reads ANTHROPIC_API_KEY from the environment.
    client := anthropic.NewClient(
        option.WithMiddleware(anthropicotel.Middleware(otel.Tracer(projectName))),
    )

    resp, err := client.Messages.New(ctx, anthropic.MessageNewParams{
        Model:     "claude-sonnet-5-5",
        MaxTokens: 256,
        Messages: []anthropic.MessageParam{
            anthropic.NewUserMessage(anthropic.NewTextBlock(
                "Why is the ocean salty? Answer in two sentences.",
            )),
        },
    })
    if err != nil {
        log.Printf("anthropic: %v", err)
        return
    }

    for _, block := range resp.Content {
        fmt.Println(block.Text)
    }
}

Anthropic SDK spans. Starting with anthropic 1.14.0 (Python) and @anthropic-ai/sdk 0.134.0 (TypeScript), the Anthropic SDK emits its own OpenTelemetry spans whenever a tracer provider is registered. With the OpenInference instrumentor also running, each request would appear twice, and its tokens and cost would be counted twice. The setup above sets ANTHROPIC_OPEN_TELEMETRY=false so that only the OpenInference spans are exported. A client created with an explicit open_telemetry (Python) or openTelemetry (TypeScript) option ignores the variable, so pass False / false there instead.

Go SDK Only /v1/messages is instrumented today. Streaming responses pass through unchanged, but output.value and token counts are not populated for streaming spans yet. tool_use content blocks in messages are not yet captured as message.tool_calls attributes — wrap your tool execution in manual TOOL spans, see Manual instrumentation.

Run Anthropic

# example.py

# Importing instrumentation first ensures tracing is set up
# before `anthropic` is imported.
from instrumentation import tracer_provider

import anthropic

# The client reads ANTHROPIC_API_KEY from the environment.
client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=256,
    messages=[
        {
            "role": "user",
            "content": "Why is the ocean salty? Answer in two sentences.",
        },
    ],
)

print(message.content[0].text)

// example.ts

// Importing instrumentation first ensures tracing is set up
// before the Anthropic client is used.
import { provider } from "./instrumentation";
import Anthropic from "@anthropic-ai/sdk";

// The client reads ANTHROPIC_API_KEY from the environment.
const client = new Anthropic();

const message = await client.messages.create({
  model: "claude-sonnet-5-5",
  max_tokens: 256,
  messages: [
    {
      role: "user",
      content: "Why is the ocean salty? Answer in two sentences.",
    },
  ],
});

const block = message.content[0];
if (block.type === "text") {
  console.log(block.text);
}

// Flush any pending spans before the process exits.
await provider.forceFlush();

# The full example lives in main.go above.
go run main.go

Expected output

Arize AX tracing initialized for Anthropic.
The ocean is salty because rivers continuously dissolve mineral salts from rocks and soil and carry them to the sea, where they accumulate over millions of years. Water leaves the ocean through evaporation but the salts remain, steadily concentrating until reaching today's roughly 3.5% salinity.

Verify in Arize AX

Open your Arize AX space and select project anthropic-tracing-example.
You should see a new trace within ~30 seconds containing an LLM span — messages.create for the Python SDK, Anthropic Messages for the Node.js SDK, or anthropic.messages.create for the Go SDK — with the prompt, response, and token usage attached. Other Python methods get spans named after the method, such as messages.stream, messages.parse, messages.count_tokens, and beta.messages.create. In Node.js, every messages.create and messages.stream call is an Anthropic Messages span, stable or beta, and token counting is an Anthropic Count Tokens span.
If no traces appear, see Troubleshooting.

Check from the skill, CLI, or SDK

Confirm spans are actually reaching your Arize AX project. Use whichever fits your workflow — the skill and CLI work for any framework; the SDK check is shown for each language.

Arize skill (agent)
AX CLI
SDK

Install the Arize Skills plugin and let your coding agent check for you:

npx skills add Arize-ai/arize-skills

Then prompt your agent:

Use the arize-trace skill to export and analyze recent traces from my project. Confirm spans are arriving, and summarize any errors or latency issues.

Export recent spans for your project — any rows mean traces are landing:

ax spans export "$ARIZE_PROJECT_NAME" --space "$ARIZE_SPACE_ID" \
  --limit 5 --stdout | jq 'length'

A non-zero count confirms spans reached Arize AX. Run ax auth login first if you have not authenticated. See the ax spans reference.

Query the project’s spans and check that at least one came back.

import os
from arize import ArizeClient

client = ArizeClient(api_key=os.environ["ARIZE_API_KEY"])
resp = client.spans.list(
    project=os.environ["ARIZE_PROJECT_NAME"],
    space=os.environ["ARIZE_SPACE_ID"],
    limit=5,
)
count = len(resp.spans)
print(
    f"{count} span(s) found" if count else "No spans yet — recheck setup"
)

// Reads ARIZE_API_KEY from the environment.
import { listSpans } from "@arizeai/ax-client";

const { data: spans } = await listSpans({
  project: process.env.ARIZE_PROJECT_NAME!,
  space: process.env.ARIZE_SPACE_ID!,
  limit: 5,
});
const count = spans.length;
console.log(
  count ? `${count} span(s) found` : "No spans yet — recheck setup",
);

client, err := arize.NewClient(
    arize.Config{APIKey: os.Getenv("ARIZE_API_KEY")},
)
if err != nil {
    log.Fatal(err)
}
resp, err := client.Spans.List(ctx, spans.ListRequest{
    Project: os.Getenv("ARIZE_PROJECT_NAME"),
    Space:   os.Getenv("ARIZE_SPACE_ID"),
    Limit:   5,
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("%d span(s) found\n", len(resp.Spans))

SDK span references: Python · TypeScript · Go.

What gets captured

The Python and TypeScript instrumentors cover the stable and beta Messages API (client.messages and client.beta.messages), streaming and non-streaming. Each LLM span records:

Messages. The system prompt as input message 0, then each message and content block in order: text, images, thinking, tool calls and tool results, documents, and compaction summaries. Other content block types are recorded as their type and JSON, with base64 data replaced by a placeholder.
Tool calls. Client tools (tool_use), server tools such as web search, web fetch, and code execution (server_tool_use), and MCP connector tools (mcp_tool_use) are all recorded as message.tool_calls on the output message. The tools available to the request, including tools added inline with tool_addition, are recorded in llm.tools.
Token usage. Prompt, completion, and total tokens, cache reads and writes, and thinking tokens as llm.token_count.completion_details.reasoning.
Provider. llm.provider is anthropic, or the cloud that hosts the model. See Trace Claude on Amazon Bedrock, Google Vertex AI, and Microsoft Foundry.
Response details in metadata. Details with no OpenInference attribute go to span metadata, alongside any metadata you set yourself:

Metadata key	What it holds
`stop_details`	Why the response stopped, such as a refusal’s category and explanation
`citations`	The sources Claude cited, from documents, search results, and web search
`cache_miss_reason`	Why a prompt cache lookup missed
`usage_iterations`	Per-iteration token usage, such as for compaction and server-side fallbacks
`server_tool_use`	Server tool request counts, when a server tool ran
`mcp_server_names`	The MCP server each MCP tool call went to
`tool_callers`	The caller of each tool call that the model didn’t make directly, such as code execution
`toolset_names`	The computer or browser toolset each tool call came from
`container_id`	The code execution container the request ran in
`context_management_applied_edits`	The context management edits the API applied
`input_transformations`	Changes the API made to the request input

messages.count_tokens (Python) and messages.countTokens (TypeScript), stable and beta, get a lightweight span with the token count response as its output.

Compaction calls report 0 for the top-level token counts, as the API does, so these spans show no cost. The tokens the compaction used are in the usage_iterations metadata.

Trace tool usage

The instrumentor traces each messages.create call automatically, including every tool call Claude requests. Server tools and MCP connector tools run on Anthropic’s side, so their calls appear on the LLM span with no extra code. Client tools run in your code, and how you trace them depends on how you run the tool loop:

TypeScript. Use client.beta.messages.toolRunner() to run the loop. The instrumentor wraps each run in a beta.messages.tool_runner CHAIN span, with an LLM span for each request and a TOOL span for each tool run, so you need no manual spans.
Python, or a loop you write yourself. Wrap the loop in a manual chain span and each tool execution in a manual tool span with the OpenTelemetry API. The auto LLM spans nest under your chain span automatically. See Combine auto and manual instrumentation for the pattern. The Python tool_runner gets LLM spans but not the chain and tool spans, so wrap it the same way.

# tools_example.py

# Importing instrumentation first ensures tracing is set up
# before `anthropic` is imported.
from instrumentation import tracer_provider

import anthropic
from opentelemetry import trace
from openinference.instrumentation import OITracer, TraceConfig

# The client reads ANTHROPIC_API_KEY from the environment.
client = anthropic.Anthropic()
tracer = OITracer(trace.get_tracer(__name__), config=TraceConfig())


# A trivial tool the model can call.
@tracer.tool
def get_weather(city: str) -> str:
    return f"It is 72°F and sunny in {city}."


tools = [
    {
        "name": "get_weather",
        "description": "Get the current weather for a city.",
        "input_schema": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
]


@tracer.chain
def weather_agent(question: str) -> str:
    messages = [{"role": "user", "content": question}]

    # First LLM call — auto-instrumented as an LLM span.
    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=256,
        tools=tools,
        messages=messages,
    )
    messages.append({"role": "assistant", "content": response.content})

    # Execute each tool call inside a manual TOOL span.
    tool_results = []
    for block in response.content:
        if block.type == "tool_use":
            result = get_weather(**block.input)
            tool_results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": result,
            })

    messages.append({"role": "user", "content": tool_results})

    # Second LLM call — Claude answers using the tool result.
    final = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=256,
        messages=messages,
    )
    answer = "".join(b.text for b in final.content if b.type == "text")
    return answer


print(weather_agent("What is the weather in San Francisco?"))

// tools_example.ts

// Importing instrumentation first ensures tracing is set up
// before the Anthropic client is used.
import { provider } from "./instrumentation";
import Anthropic from "@anthropic-ai/sdk";
import { betaTool } from "@anthropic-ai/sdk/helpers/beta/json-schema";

// The client reads ANTHROPIC_API_KEY from the environment.
const client = new Anthropic();

// A trivial tool the model can call. The tool runner calls `run` for
// each tool call, and the instrumentor traces it as a TOOL span.
const getWeather = betaTool({
  name: "get_weather",
  description: "Get the current weather for a city.",
  inputSchema: {
    type: "object",
    properties: { city: { type: "string" } },
    required: ["city"],
  },
  run: async ({ city }) => {
    await new Promise((resolve) => setTimeout(resolve, 100)); // Simulate a network call
    return `It is 72°F and sunny in ${city}.`;
  },
});

// The tool runner sends the request, runs each tool Claude calls, and
// sends the results back until Claude finishes. The instrumentor wraps
// the whole run in a CHAIN span, with an LLM span for each request.
const final = await client.beta.messages.toolRunner({
  model: "claude-sonnet-5-5",
  max_tokens: 256,
  tools: [getWeather],
  messages: [
    { role: "user", content: "What is the weather in San Francisco?" },
  ],
});

const answer = final.content
  .filter((b): b is Anthropic.Beta.BetaTextBlock => b.type === "text")
  .map((b) => b.text)
  .join("");
console.log(answer);

// Flush any pending spans before the process exits.
await provider.forceFlush();

// main.go
//
// Self-contained tool loop: tracer setup, a manual CHAIN span, and a manual
// TOOL span around the tool execution — all in one file. Run with
// `go run main.go`.
package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "os"
    "time"

    arizeotel "github.com/Arize-ai/arize-otel-go"
    anthropicotel "github.com/Arize-ai/openinference/go/openinference-instrumentation-anthropic-sdk-go"
    semconv "github.com/Arize-ai/openinference/go/openinference-semantic-conventions"
    "github.com/anthropics/anthropic-sdk-go"
    "github.com/anthropics/anthropic-sdk-go/option"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/codes"
)

// A trivial tool the model can call.
func getWeather(city string) string {
    return fmt.Sprintf("It is 72°F and sunny in %s.", city)
}

func main() {
    ctx := context.Background()

    projectName := os.Getenv("ARIZE_PROJECT_NAME")
    if projectName == "" {
        projectName = "anthropic-tracing-example"
    }

    tp, err := arizeotel.Register(ctx, arizeotel.Options{ProjectName: projectName})
    if err != nil {
        log.Printf("register tracer: %v", err)
        return
    }
    defer func() {
        shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
        defer cancel()
        _ = tp.Shutdown(shutdownCtx)
    }()

    fmt.Println("Arize AX tracing initialized for Anthropic.")

    tracer := otel.Tracer(projectName)
    client := anthropic.NewClient(
        option.WithMiddleware(anthropicotel.Middleware(tracer)),
    )

    tools := []anthropic.ToolUnionParam{
        {
            OfTool: &anthropic.ToolParam{
                Name:        "get_weather",
                Description: anthropic.String("Get the current weather for a city."),
                InputSchema: anthropic.ToolInputSchemaParam{
                    Properties: map[string]any{
                        "city": map[string]any{"type": "string"},
                    },
                    Required: []string{"city"},
                },
            },
        },
    }

    question := "What is the weather in San Francisco?"

    // Manual CHAIN span wraps the whole tool loop. Threading this ctx into the
    // client calls nests the auto LLM spans under it.
    ctx, chainSpan := tracer.Start(ctx, "weather-agent")
    chainSpan.SetAttributes(
        attribute.String(semconv.OpenInferenceSpanKind, semconv.SpanKindChain),
        attribute.String(semconv.InputValue, question),
    )

    messages := []anthropic.MessageParam{
        anthropic.NewUserMessage(anthropic.NewTextBlock(question)),
    }

    // First LLM call — auto-instrumented as an LLM span.
    resp, err := client.Messages.New(ctx, anthropic.MessageNewParams{
        Model:     "claude-sonnet-5-5",
        MaxTokens: 256,
        Tools:     tools,
        Messages:  messages,
    })
    if err != nil {
        log.Printf("anthropic: %v", err)
        return
    }
    messages = append(messages, resp.ToParam())

    // Execute each tool call inside a manual TOOL span.
    var toolResults []anthropic.ContentBlockParamUnion
    for _, block := range resp.Content {
        toolUse, ok := block.AsAny().(anthropic.ToolUseBlock)
        if !ok {
            continue
        }

        var input struct {
            City string `json:"city"`
        }
        _ = json.Unmarshal(toolUse.Input, &input)

        _, toolSpan := tracer.Start(ctx, toolUse.Name)
        toolSpan.SetAttributes(
            attribute.String(semconv.OpenInferenceSpanKind, semconv.SpanKindTool),
            attribute.String(semconv.InputValue, string(toolUse.Input)),
        )
        result := getWeather(input.City)
        toolSpan.SetAttributes(attribute.String(semconv.OutputValue, result))
        toolSpan.SetStatus(codes.Ok, "")
        toolSpan.End()

        toolResults = append(toolResults, anthropic.NewToolResultBlock(toolUse.ID, result, false))
    }
    messages = append(messages, anthropic.NewUserMessage(toolResults...))

    // Second LLM call — Claude answers using the tool result.
    final, err := client.Messages.New(ctx, anthropic.MessageNewParams{
        Model:     "claude-sonnet-5-5",
        MaxTokens: 256,
        Messages:  messages,
    })
    if err != nil {
        log.Printf("anthropic: %v", err)
        return
    }

    var answer string
    for _, block := range final.Content {
        answer += block.Text
    }
    chainSpan.SetAttributes(attribute.String(semconv.OutputValue, answer))
    chainSpan.SetStatus(codes.Ok, "")
    chainSpan.End()

    fmt.Println(answer)
}

Expected output

Arize AX tracing initialized for Anthropic.
The weather in San Francisco is currently 72°F and sunny.

The trace tree in Arize AX is a chain span with two LLM spans and one get_weather tool span under it. In Python and Go the chain span is your weather-agent span. In TypeScript it is the tool runner’s beta.messages.tool_runner span.

Go SDK The auto middleware still emits an LLM span for each Messages.New call, but it does not populate tool_use blocks as attributes on that span. The chain and tool spans are created manually with the OpenTelemetry API — threading the chain span’s ctx into each Messages.New call is what nests the auto LLM spans underneath it.

Trace Claude on Amazon Bedrock, Google Vertex AI, and Microsoft Foundry

The Python and TypeScript instrumentors also trace the Anthropic SDK’s own clients for the clouds that host Claude, with the same setup as above. llm.provider records where the model ran:

Platform	Python client	TypeScript package	`llm.provider`
Anthropic API	`Anthropic`, `AsyncAnthropic`	`@anthropic-ai/sdk`	`anthropic`
Amazon Bedrock	`AnthropicBedrock`, `AnthropicBedrockMantle`, `AnthropicAWS`	`@anthropic-ai/bedrock-sdk`	`aws`
Google Vertex AI	`AnthropicVertex`, `AnthropicGoogleCloud`	`@anthropic-ai/vertex-sdk`	`google`
Microsoft Foundry	`AnthropicFoundry`	`@anthropic-ai/foundry-sdk`	`azure`

The async versions of each Python client are traced too. If you call Claude on Bedrock through boto3 instead, use the Amazon Bedrock instrumentor.

Mask sensitive data

The Python and TypeScript instrumentors respect the TraceConfig settings in Mask and redact data. Because span metadata isn’t masked by TraceConfig, the instrumentors apply the hide settings to the response details they put there:

citations is left out when inputs, outputs, input messages, or output messages are hidden, because citation URLs and titles name the sources.
With input text or output text hidden, only each citation’s cited_text is left out.
The explanation in stop_details is left out when outputs, output messages, or output text are hidden.

Request parameters are recorded in llm.invocation_parameters, which the hide settings don’t mask. If you use the MCP connector, each server’s authorization_token in mcp_servers is recorded there. In Python, so are any extra_headers, which are also part of input.value. Keep credentials out of these parameters, or remove them with a span processor before export.

Upgrading from earlier instrumentor versions

These changes affect dashboards, monitors, and evaluators built on spans from earlier versions:

TypeScript. The system prompt is now input message 0, so the other input messages move up one index when a system prompt is set. The system prompt is no longer part of llm.invocation_parameters.
TypeScript. A streamed response’s output.value is now the rebuilt message as JSON (application/json), the same as a non-streaming response, instead of the concatenated text.
Python. Prompt, completion, and total token counts of 0 are now recorded instead of left out.
Python and TypeScript. In an assistant message that mixes server and client tools, the server tool calls are now in message.tool_calls too, so a client tool call can have a higher index than before.

Troubleshooting

No traces in Arize AX. Confirm ARIZE_SPACE_ID and ARIZE_API_KEY are set in the same shell that runs the example. Enable OpenTelemetry debug logs with export OTEL_LOG_LEVEL=debug and re-run.
Anthropic spans missing but other spans present (Python). AnthropicInstrumentor().instrument(...) must run before any import anthropic in the application. Make sure instrumentation.py is the first import in your entry point.
Each Claude call appears twice, with an anthropic.messages.create span under the LLM span. Recent Anthropic SDK versions emit their own spans. Set ANTHROPIC_OPEN_TELEMETRY=false before you create the client, as the setup above does, or pass open_telemetry=False (Python) or openTelemetry: false (TypeScript) to the client.
401 from Anthropic. Verify ANTHROPIC_API_KEY is set and has access to the model in the example. Swap claude-sonnet-5-5 for a model your key can call.
Go process exits before spans flush. arize-otel-go uses a batched span processor by default. The defer tp.Shutdown(...) block in main.go is what flushes the batch — without it, short-lived programs lose their last spans. Pass SimpleProcessor: true to arizeotel.Register if you want synchronous export instead.

OpenTelemetry

LLM Providers

Agent Frameworks

Coding Agents

Platforms

Orchestration

Vector Databases

Evaluation

Prerequisites

Launch Arize AX

Install

Configure credentials

Setup tracing

Run Anthropic

Expected output

Verify in Arize AX

Check from the skill, CLI, or SDK

What gets captured

Trace tool usage

Expected output

Trace Claude on Amazon Bedrock, Google Vertex AI, and Microsoft Foundry

Mask sensitive data

Upgrading from earlier instrumentor versions

Troubleshooting

Resources

Anthropic Documentation

OpenInference Anthropic Instrumentor (Python)

OpenInference Anthropic Instrumentor (JavaScript / TypeScript)

Anthropic Tracing Example (messages.create)

Anthropic Tracing Example (tool calling)

Anthropic Go SDK

OpenInference Anthropic Instrumentor (Go)

​Prerequisites

​Launch Arize AX

​Install

​Configure credentials

​Setup tracing

​Run Anthropic

​Expected output

​Verify in Arize AX

​Check from the skill, CLI, or SDK

​What gets captured

​Trace tool usage

​Expected output

​Trace Claude on Amazon Bedrock, Google Vertex AI, and Microsoft Foundry

​Mask sensitive data

​Upgrading from earlier instrumentor versions

​Troubleshooting

​Resources

Anthropic Documentation

OpenInference Anthropic Instrumentor (Python)

OpenInference Anthropic Instrumentor (JavaScript / TypeScript)

Anthropic Tracing Example (messages.create)

Anthropic Tracing Example (tool calling)

Anthropic Go SDK

OpenInference Anthropic Instrumentor (Go)

Prerequisites

Launch Arize AX

Install

Configure credentials

Setup tracing

Run Anthropic

Expected output

Verify in Arize AX

Check from the skill, CLI, or SDK

What gets captured

Trace tool usage

Expected output

Trace Claude on Amazon Bedrock, Google Vertex AI, and Microsoft Foundry

Mask sensitive data

Upgrading from earlier instrumentor versions

Troubleshooting

Resources