Claude API OpenTelemetry: trace your agents in your own monitoring

Since October 14, 2026, the Claude API can send OpenTelemetry traces of your Messages API requests and Managed Agents sessions to your own monitoring. It is in public beta.¹,² You add a destination in the Claude Console, and every request, model call, tool use and MCP call shows up as a span, with timing, status and tokens. If your product has an AI feature or an agent built on Claude, you can now see where a run failed or got slow, next to the rest of your app.

What shipped

Until now, your traces showed a Claude API call as one span: that it happened and how long it took. You did not see that the agent ran three model requests, a web search and an MCP tool, or which of them failed.

Now there are two ways to get that detail, and they fit together:²

• API tracing. An admin adds a destination in the Claude Console. The API itself then sends spans for each request, each model run inside it, each server tool and MCP tool it runs, and each Managed Agents turn. No code changes, and it works for any client.
• SDK tracing. You register a tracer provider in your app, and the Claude SDK adds client spans: each request as your app saw it, and the tools your own code runs through the tool runner.

With both, a request's SDK span and API spans sit in one trace, under your own spans.² The spans use the OpenTelemetry GenAI semantic conventions, so platforms that understand those conventions recognize them without extra setup.²

Which Claude telemetry you need

"Claude" and "OpenTelemetry" now mean three different setups, and search results mix them up. Pick by what you are watching:²,⁴

The Claude Code side changed this week too. Its traces now use the same GenAI conventions, which we cover in Claude Code OpenTelemetry: what v2.1.300 changed.

What a trace shows you

Here is the shape of one Managed Agents chat request, simplified from Anthropic's example. Your app receives a message, sends it to a session, and the agent works through a turn:²

POST /chat                                   your app
├─ anthropic.sessions.events.send            Claude SDK
│  └─ anthropic.session.turn                 Claude API
│     ├─ anthropic.model_request
│     ├─ anthropic.tool_use  bash
│     ├─ anthropic.session.turn              another thread
│     └─ anthropic.model_request             stop: requires_action
├─ anthropic.custom_tool_use  list_issues    your code
└─ anthropic.sessions.events.send            Claude SDK
   └─ anthropic.session.turn                 Claude API

Read top to bottom: the first turn made model requests, ran bash, handed part of the work to another thread, then stopped because the model asked for list_issues, a tool your own code runs. Your code ran it, sent the result back, and a second turn started. If anything in that chain failed or was slow, it is the span that is red or long.

For a session with several threads, group spans by gen_ai.conversation.id to read one thread as a transcript, or by anthropic.session.id for the whole session.² For a plain Messages API request, the shape is the same idea: an anthropic.messages.create span with a span for each model request and each tool the API ran.²

This is what agent monitoring needs: the whole run, not just the final answer. We wrote about why in AI agent monitoring: how to watch agents in production.

Metadata only or full content

Every destination has a content mode, and it is the one real decision in the setup:²

• Metadata only (the default): IDs, timing, status, token counts, and names you chose, such as your agent and tool names and your MCP server names. No prompts, no answers.
• Full content: everything above, plus the system prompt, the messages, the model's output, and tool arguments and results.

Full content is what lets you read why a run went wrong. Metadata only tells you that it went wrong, where, and how long it took. The cost of Full content is that your users' prompts now live in your monitoring tool, under its access and retention rules, so check those first.²

A practical start: Metadata only everywhere, and Full content on a staging workspace, where you debug. Destinations are scoped by workspace, so that split is two destinations.³ Each span holds up to 0.75 MB of content by default; longer prompts are shortened and marked anthropic.content.truncated.²

The token-counting trap

If you build a cost chart on these traces, it is easy to get wrong, because the same tokens appear on more than one span of a request.²

Anthropic's rules, in short:²

• When a request has both an SDK span and an API span (both are named anthropic.messages.create), sum the API one. Tell them apart by kind: the SDK span is CLIENT, the API span is SERVER.
• For API spans of a Messages API request, sum either the anthropic.messages.create spans or their anthropic.model_request spans, never both.
• For a Managed Agents session, sum anthropic.model_request and anthropic.session.outcome_evaluation.
• Do not add the cache attributes to gen_ai.usage.input_tokens. It already includes tokens read from and written to the cache.
• Spans can arrive twice when a delivery is retried, so count each one once by trace ID and span ID.

And treat the chart as an estimate. Delivery is best effort, so a span can be lost, and a caller can leave spans out. For exact usage per API key, Anthropic points to its Usage API.² More on where token spend goes in LLM observability and cost.

How to set it up

You need the admin role in your Claude Console organization, and a monitoring tool that accepts OTLP over HTTP with protobuf, at an HTTPS URL on port 443.³ If your tool is one of Anthropic's twelve listed partners, pick it as the Provider and the Console asks for its key.² Otherwise use Custom.

This is how we set it up with Fixter, which takes standard OTLP over HTTP:³,⁵

1. In the Console, open the OpenTelemetry settings page and click Add destination.
2. Fill in the fields like this. Do not add /v1/traces to the URL; the API adds it.

Provider               Custom
Name                   Fixter
OTLP endpoint URL      https://ingest.fixter.dev
Request headers        Authorization: Bearer <your Fixter API key>
Content mode           Metadata only
Workspaces             All

3. Save, then click Test in the destination's More actions menu. An anthropic.test span should arrive.
4. Send a request from the playground, your app or a Managed Agents session in a covered workspace. Within about a minute the Delivery column shows Healthy.
5. In your monitoring, filter on service.name = claude-platform.

If Delivery shows Failing, hover over it. A 401 or 403 is a wrong header, a 404 a wrong path.³ The API disables a destination that redirects, resolves to a private IP, or fails for 24 hours.³

To get the API spans nested under your own app's spans, also set up SDK tracing and call the SDK inside one of your spans. The SDK passes the W3C traceparent header along, and the API attaches its spans to it.³ If you connect your own MCP server through the MCP connector, the API passes the trace on to it too, so your server's spans join the same trace.³

What it is not

• Not a billing record. Best effort, at least once. Use the Usage API for exact numbers.²
• Not Claude Code. Your team's Claude Code sessions need Claude Code's own telemetry setup.⁴
• Not zero data retention for agents. The Messages API stays eligible with Full content on, but Managed Agents is not eligible for zero data retention.²
• Still beta. Up to 10 destinations per organization, and the details can change.³

Traces of your agent are most useful next to everything else your app does: the request that triggered the run, the database call after it, the error a user saw. Fixter is monitoring for teams that build with coding agents: you send your app's logs and traces, and now your Claude traces, over standard OpenTelemetry. Fixter finds the issues and bugs in your system and tells you what broke and why, and you pull them into Claude Code over MCP to fix. See how monitoring works in Fixter.

Frequently asked questions

Does the Claude API support OpenTelemetry?

Yes, in public beta since October 14, 2026. The Claude API can export a span for each Messages API request, model call and tool use, and for each turn of a Managed Agents session, to any observability platform that accepts OTLP over HTTP. An admin adds a destination in the Claude Console, or you set up tracing in the Claude SDK.

How do I send Claude Managed Agents traces to my observability tool?

In the Claude Console, open the OpenTelemetry settings page and add a destination: choose your provider or Custom, enter your platform's OTLP/HTTP endpoint URL and its authentication header, pick a content mode and the workspaces to cover, then click Test. Spans arrive with service.name set to claude-platform. You need the admin role in the organization.

Does the Claude API send my prompts to my observability platform?

Only if you choose Full content. The default, Metadata only, sends IDs, timing, status, token counts and names you chose, such as tool and agent names. Full content adds the prompts and responses. Organizations with a HIPAA, FERPA or K-12 restriction with Anthropic only get metadata from the API, whatever the setting.

Can I use OpenTelemetry traces to count my Claude API spend?

Carefully. Token counts appear on several spans of the same request, so adding them all counts the same tokens twice. Sum only one level, as Anthropic's docs describe. And delivery is best effort, so a span can be lost. For an exact per-key count, Anthropic points to its Usage API.

Is this the same as Claude Code's OpenTelemetry?

No. This export covers apps that call the Claude API and Managed Agents sessions. Claude Code and the Claude Agent SDK have their own telemetry setup, through environment variables such as CLAUDE_CODE_ENABLE_TELEMETRY, and Cowork has its own too.

Which observability tools work with Claude API traces?

Any platform that accepts OTLP over HTTP with protobuf at an HTTPS URL. Anthropic lists twelve partners with their own setup pages, including Grafana Cloud, Honeycomb, Sentry, Datadog, Langfuse and PostHog, and the Custom provider covers the rest. Fixter accepts it as a Custom destination.