> ## Documentation Index
> Fetch the complete documentation index at: https://docs.honeycomb.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Send Claude Platform Traces to Honeycomb

> Export OpenTelemetry traces from Claude Managed Agents and the Claude API to Honeycomb.

Beta

The Claude Platform can export OpenTelemetry traces of your organization's activity directly to Honeycomb.
You don't need a collector or code changes: an admin adds Honeycomb as a telemetry destination in the Claude Console at [platform.claude.com](https://platform.claude.com), and traces for Claude Managed Agents and Claude API requests start arriving in Honeycomb.

If your application uses the Claude API and OpenTelemetry, then propagate your trace context to the Claude API.
Claude's spans appear inside your application's traces.

These traces follow the [OpenTelemetry GenAI semantic conventions](https://opentelemetry.io/docs/specs/semconv/gen-ai/), so Managed Agents conversations appear in the [Agent Timeline](https://docs.honeycomb.io/investigate/observe/agent-timeline.md) and model calls get [LLM cost estimates](https://docs.honeycomb.io/investigate/observe/llm-cost.md) without any remapping.
For the gaps, refer to [Limitations](#limitations).

> [!NOTE]
>
> This page covers telemetry from the Claude Platform: Claude Managed Agents and the Claude API.
> To send telemetry from other Anthropic sources:
>
> * **Claude Code:** Refer to [Remapping existing telemetry](https://docs.honeycomb.io/send-data/use-cases/agents.md#remapping-existing-telemetry).
> * **Anthropic usage and cost reports:** Refer to [Monitor Anthropic Usage & Cost](https://docs.honeycomb.io/send-data/use-cases/anthropic-usage-monitoring.md).

## Before you begin

Make sure that you have:

* The Admin role in your organization at [platform.claude.com](https://platform.claude.com), which Anthropic calls the Claude Console.
  This is the organization that owns your Claude API keys, and it's separate from any Claude Team or Enterprise organization you use at claude.ai.
* A Honeycomb [Ingest API key](https://docs.honeycomb.io/configure/environments/manage-api-keys.md#create-api-key) for the environment that should receive your Claude traces.
  The key needs permission to create datasets.

## Add Honeycomb as a destination

**1. Open OpenTelemetry settings**

At [platform.claude.com](https://platform.claude.com), open your settings and select **OpenTelemetry** in the left navigation.
If a workspace is selected, select the **X** on the workspace filter to clear it.

**2. Select Add destination**

Select **Add destination**.

> [!TIP]
>
> If you don't see **Add destination**:
>
> * Confirm that the page isn't filtered to a workspace. The button appears only when no workspace is selected.
> * Confirm that you have the Admin role in your organization at [platform.claude.com](https://platform.claude.com).

**3. Choose Honeycomb**

In **Provider**, select **Honeycomb**.
Optionally, change the **Name** of the destination, such as `Honeycomb production`.

**4. Check the region**

**Region** is **US**, and the endpoint under **OTLP details** is `https://api.honeycomb.io`.

> [!NOTE]
>
> If your Honeycomb team is in the EU, you can't select EU when you add the destination. Either:
>
> * Add the destination with the **Honeycomb** provider, then edit the destination and change **OTLP endpoint URL** to `https://api.eu1.honeycomb.io`.
> * Add the destination with the **Custom** provider instead. Set **OTLP endpoint URL** to `https://api.eu1.honeycomb.io`, and under **Request headers**, add `x-honeycomb-team` with your Ingest API key as the value.

**5. Add your API key**

In **Ingest API key**, paste your Honeycomb Ingest API key.
Use a key with permission to create datasets.

**6. Leave Dataset empty**

Leave **Dataset** empty.
Honeycomb names the dataset after the service, `claude-platform`.

**7. Choose a content mode**

Select how much content Claude includes in each span:

* **Metadata only:** Spans carry identifiers, timing, status, and token counts, but never prompt or tool content.
* **Full content:** Spans also carry message and tool content, including system instructions, prompts, and model responses.

> [!WARNING]
>
> With **Full content**, prompts and responses are stored in Honeycomb and visible to anyone with access to the environment, or to the `claude-platform` dataset if your team uses dataset restrictions.
> Choose **Full content** only if your organization permits storing that data in Honeycomb.

**8. Choose where it applies**

In **Workspaces**, choose which Claude Platform workspaces will send data to Honeycomb.

**9. Save the destination**

Select **Add destination**.

![Claude Console - Add destination dialog with the Honeycomb provider selected](https://mintcdn.com/honeycomb/SRr8iUrEdfF32j6-/_assets/images/claude-platform/add-destination-honeycomb.png?fit=max\&auto=format\&n=SRr8iUrEdfF32j6-\&q=85\&s=a4e210b0d98c3c14f6763004a174ab57)

## Send traces through your own collector

To route Claude traces through your own OpenTelemetry Collector or [Refinery](https://docs.honeycomb.io/manage-data-volume/sample/honeycomb-refinery) before they reach Honeycomb, add a destination with the **Custom** provider instead of **Honeycomb**.

**1. Open OpenTelemetry settings**

Open the **OpenTelemetry** settings page, as described in [Add Honeycomb as a destination](#add-honeycomb-as-a-destination).

**2. Select Add destination**

Select **Add destination**.

**3. Choose Custom**

In **Provider**, select **Custom**.

**4. Enter your collector's endpoint**

In **OTLP endpoint URL**, enter your collector's OTLP/HTTP base URL.
Don't include `/v1/traces`, because Claude Platform appends it to the URL.

The endpoint must:

* Use HTTPS on port 443.
* Have a certificate from a publicly trusted certificate authority.

**5. Add authentication headers**

Under **Request headers**, add any authentication headers that your collector needs.

**6. Save the destination**

Complete the remaining fields, and then select **Add destination**.

**7. Export from your collector to Honeycomb**

Claude Platform sends OTLP/HTTP with protobuf encoding, so make sure your collector accepts it.
Then configure your collector to export to Honeycomb:

* **OpenTelemetry Collector:** Refer to [Send Data with the OpenTelemetry Collector](https://docs.honeycomb.io/send-data/opentelemetry/collector).
* **Refinery:** Refer to [Set Up Honeycomb Refinery](https://docs.honeycomb.io/manage-data-volume/sample/honeycomb-refinery/set-up.md).

## Verify your data

To generate traces, run an agent from the [Claude Console agent quickstart](https://platform.claude.com/workspaces/default/agent-quickstart/), send a message in the [Claude Console playground](https://platform.claude.com/workspaces/default/playground), or send a request to the Claude API.

Within about a minute, the **Delivery** column on the Claude Console's OpenTelemetry settings page should display **Healthy**.

![Claude Console - OpenTelemetry destinations list with the Honeycomb destination's Delivery column showing Healthy](https://mintcdn.com/honeycomb/SRr8iUrEdfF32j6-/_assets/images/claude-platform/healthy-destination.png?fit=max\&auto=format\&n=SRr8iUrEdfF32j6-\&q=85\&s=9f12b2d7695cee1b88488490e264313f)

Then, in Honeycomb, open the [Agent Timeline](https://docs.honeycomb.io/investigate/observe/agent-timeline.md) to explore Managed Agents conversations.
Messages API requests have no conversation ID, so they don't appear as conversations; find them as traces instead.

To find a trace:

1. Open the environment that matches your API key.
2. Select **Query**, and choose the `claude-platform` dataset.
3. Select **Run Query**.
   The graph shows a count of Claude Platform spans.
4. Select any point on the graph, and in the menu that appears, select **View trace**.

You can also ask [Canvas](https://docs.honeycomb.io/investigate/canvas) to show you some traces from the `claude-platform` dataset.

## What Claude Platform sends

Claude Platform sends traces only, with no metrics or logs.
It doesn't sample: every span is sent, unless your application's trace context [says to drop the trace](#connect-claude-traces-to-your-application).

Unless you [pass in your own trace context](#connect-claude-traces-to-your-application), each request to the Claude API starts a new trace.
In Managed Agents, the trace for a request contains the agent turns it starts, and each turn contains its model calls and tool calls.

One Managed Agents conversation can span several traces.
To see a whole conversation in one place, open it in the [Agent Timeline](https://docs.honeycomb.io/investigate/observe/agent-timeline.md), or filter on `gen_ai.conversation.id`.
The conversation ID is on each turn, model call, and tool call span.

### Key attributes

| Attribute | Description |
| - | - |
| `gen_ai.provider.name` | Always `anthropic` |
| `gen_ai.operation.name` | `chat` for model calls, `invoke_agent` for agent turns, or `execute_tool` for tool calls. Some spans, such as API request spans, have none. |
| `gen_ai.conversation.id` | Groups Managed Agents spans, across traces, into a conversation. Messages API requests don't have it. |
| `gen_ai.agent.id`, `gen_ai.agent.name` | The agent that ran the turn. Present only on agent turns (`invoke_agent`), not on model calls or tool calls. |
| `gen_ai.request.model`, `gen_ai.response.model` | Requested and actual model |
| `gen_ai.usage.input_tokens`, `gen_ai.usage.output_tokens` | Token counts |
| `gen_ai.usage.cache_read.input_tokens`, `gen_ai.usage.cache_write.input_tokens` | Prompt cache token counts |
| `gen_ai.input.messages`, `gen_ai.output.messages`, `gen_ai.system_instructions` | Turn message content (**Full content** mode only) |
| `gen_ai.tool.call.arguments` | Tool input, in the standard GenAI field (**Full content** mode only) |
| `anthropic.tool_result.content` | Tool output (**Full content** mode only). The GenAI semantic conventions put tool output in `gen_ai.tool.call.result`, but Claude Platform uses this Anthropic field instead. |

Honeycomb adds [estimated LLM cost fields](https://docs.honeycomb.io/investigate/observe/llm-cost.md) at ingest to spans with a `gen_ai.operation.name` of `chat`.
Each model call has exactly one `chat` span, so you can sum estimated cost across all spans without counting a call twice.

### Limitations

As of October 14, 2026, Claude Platform doesn't populate all the fields that the [Agent Timeline](https://docs.honeycomb.io/investigate/observe/agent-timeline.md) uses, so some details don't appear there.

Honeycomb's conversation cost totals include only `chat` spans.
To use Anthropic's spans as a source of token counts instead, sum only the spans named `anthropic.model_request`, `anthropic.compaction`, and `anthropic.session.outcome_evaluation`.

> [!NOTE]
>
> OpenTelemetry export is in beta on the Claude Platform, and Anthropic may change field names at any time.
> Full compatibility with Honeycomb's GenAI features isn't guaranteed.

## Connect Claude traces to your application

When your application calls the Claude API, it can send its trace context in a W3C `traceparent` header.
Claude's request span then becomes a child of your application's span, and everything the request starts nests under it.
In Honeycomb, you see one trace: your request handler, the agent turns and model calls it triggered, and the custom tools your code ran in between.

![Honeycomb trace view - an application's POST request span containing claude-platform spans for session and agent calls, with the application's own tool call span between them](https://mintcdn.com/honeycomb/SRr8iUrEdfF32j6-/_assets/images/claude-platform/connected-trace.png?fit=max\&auto=format\&n=SRr8iUrEdfF32j6-\&q=85\&s=1a04cf39596fdba1d77432450317ab7a)

Make sure OpenTelemetry propagation is enabled in your application.
The preferred way to propagate trace context is to instrument the HTTP library that calls Claude, such as `httpx` for the Claude Python SDK.
Its OpenTelemetry instrumentation creates a client span for each request and adds the `traceparent` header for you.

To have your coding agent set this up, give it a prompt like this one:

```text theme={}
Make sure this application propagates W3C trace context to the Claude API. Find where it calls Claude (the Anthropic SDK or an HTTP client). If OpenTelemetry instrumentation exists for that SDK or HTTP library, enable it so each request gets a client span and a traceparent header. Otherwise, inject the active trace context into the request headers. Then check one request in Honeycomb: Claude's spans should appear under the application's span in the same trace.
```

If no instrumentation is available for your HTTP library, inject the trace context into the request headers yourself.
For example, with the OpenTelemetry API and the Claude Python SDK:

```python theme={}
from opentelemetry.propagate import inject

# Copy the active span's trace context into the request headers.
headers = {}
inject(headers)

client.beta.sessions.events.send(
    session.id,
    events=[
        {
            "type": "user.message",
            "content": [{"type": "text", "text": "Summarize the open issues"}],
        },
    ],
    extra_headers=headers,
)
```

The same `extra_headers` argument works for Messages API calls, such as `client.messages.create`.

Claude Platform respects the sampled flag in `traceparent`.
Claude's spans follow your application's head sampling decision, so a trace is either complete or absent.

Honeycomb assembles traces across all datasets in an environment, so send your application's telemetry to the same environment as your Claude Platform destination.

## Troubleshooting

**You don't see Add destination:**

* Confirm that the page isn't filtered to a workspace. The button appears only when no workspace is selected.
* Confirm that you have the Admin role in your organization at [platform.claude.com](https://platform.claude.com).

**No `claude-platform` dataset appears:**

* Check the **Delivery** column on the Claude Console's OpenTelemetry settings page. If it displays **Failing**, hover over it to see the last error:
  * `HTTP error (status 401)` or `HTTP error (status 403)` usually means the API key is wrong.
  * `HTTP error (status 404)` usually means the endpoint URL has the wrong path. With a [Custom provider](#send-traces-through-your-own-collector), don't include `/v1/traces`.
  * `TLS failure` means a certificate problem with the endpoint.
* If it displays **Disabled**, hover over it to see why. Claude Platform disables a destination that redirects, resolves to a non-public IP address, or fails every delivery for 24 hours. Fix the cause, then select **Enable** from the destination's **More actions** menu. Spans produced while the destination was disabled are not delivered later.
* Confirm that the destination's endpoint matches your Honeycomb team's region: `https://api.honeycomb.io` for US or `https://api.eu1.honeycomb.io` for EU. To check it, edit the destination and look at **OTLP endpoint URL**.
* Confirm that the Ingest API key belongs to the environment you're checking, and that the key can create datasets.
* Confirm that the destination's **Workspaces** setting includes the workspace where your agent runs.

**Spans have no prompt or response content:**
The destination uses **Metadata only** mode. Edit the destination and select **Full content**.

**Claude spans don't appear in your application's traces:**

* Confirm that your application sends a `traceparent` header on its Claude API requests, and that the header's sampled flag is "keep" (if the `traceparent` ends in `-00`, it means "drop").
* Confirm that your application and your Claude Platform destination send to the same Honeycomb environment.

**Claude traces have no root span:**
Your application is propagating its trace context to the Claude API, but your application's spans aren't reaching this Honeycomb environment.
They might be going to a different environment, or not to Honeycomb at all.
Send your application's telemetry to the same environment as your Claude Platform destination.