---
title: OpenTelemetry mit der Claude API verwenden
url: https://platform.claude.com/docs/de/manage-claude/opentelemetry/api
description: Füge in der Claude Console ein Ziel hinzu, um OpenTelemetry-Traces deiner Messages-API-Anfragen und Managed-Agents-Sessions an deine Observability-Plattform zu senden.
featureMetadata:
topic:
title: OpenTelemetry
url: https://platform.claude.com/docs/en/manage-claude/opentelemetry
status: beta
zdr:
eligibility: eligible
note: Excludes [Covered Models](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements). Nur für Funktionen, die selbst für ZDR infrage kommen, wie etwa die Messages-API. Claude Managed Agents kommt für ZDR nicht infrage.
supportedPlatforms:
Claude API: beta
Claude Platform on AWS: beta
rows:
- label: Funktioniert mit
value: Messages API, Claude Managed Agents
details:
- Nach der Zustellung werden die Daten von dem von dir gewählten Dienst außerhalb von Anthropic gespeichert, gemäß den Aufbewahrungs- und Zugriffskontrollen dieses Dienstes.
---
Mit OpenTelemetry kann die Claude API für jede Modellanfrage und jede Tool-Nutzung, die sie ausführt, einen *span* (Span) ausgeben. Du kannst diese Spans in deiner Observability-Plattform ansehen, ohne deinen Code zu ändern.
Die API erzeugt Spans für deine Messages-API-Anfragen und Managed-Agents-Sessions. Um sie zu empfangen, füge in der Claude Console ein *destination* (Ziel) hinzu. Ein Ziel teilt der API den OTLP-Endpunkt deiner Observability-Plattform mit und wie sie sich dort authentifiziert.
## Was du brauchst
* **Die Admin-Rolle** in einer Claude Console-Organisation, um Ziele hinzuzufügen und zu ändern. Mit der Entwickler-Rolle kannst du sie ansehen. Wenn deine Organisation Claude Platform on AWS nutzt, melde dich über die AWS Console bei der Console an, wie unter [Anmelden](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#signing-in) beschrieben.
* **Ein OTLP/HTTP-Endpunkt**, der Protobuf-Kodierung unter einer HTTPS-URL auf Port 443 akzeptiert. Wenn du deinen eigenen [OpenTelemetry Collector](https://opentelemetry.io/docs/collector/) betreibst, lauscht dessen OTLP/HTTP-Receiver standardmäßig auf Port 4318. Konfiguriere den Receiver so, dass er HTTPS auf Port 443 akzeptiert, oder setze einen Load Balancer oder Reverse Proxy vor den Collector.
* **Anmeldedaten für den Endpunkt**, etwa einen API-Key.
## 1. Ein Ziel hinzufügen
Wenn du ein Telemetrie-Ziel hinzufügst, sendet Anthropic Traces der Claude-Platform-Aktivität in deiner Organisation an den von dir angegebenen OTLP/HTTP-Endpunkt des Drittanbieters, in Übereinstimmung mit den Bedingungen und Zugriffskontrollen deines Anbieters. Nach der Zustellung werden die Daten von dem von dir gewählten Dienst außerhalb von Anthropic gespeichert, gemäß den Aufbewahrungs- und Zugriffskontrollen dieses Dienstes.
1. Öffne in der Console die [OpenTelemetry-Einstellungsseite](https://platform.claude.com/settings/telemetry-destinations) deiner Organisation und klicke auf **Add destination**.
2. Konfiguriere das Ziel:
| Feld | Was du eingibst |
| ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Provider** | Deine Observability-Plattform oder **Custom**, wenn sie nicht aufgeführt ist. Wenn du eine aufgeführte Plattform auswählst, fragt die Console anstelle von **OTLP endpoint URL**, **Request headers** und **OTLP traces endpoint URL** nach deren Details, etwa einem API-Key. |
| **Name** | Optional. Zum Beispiel „Acmes Observability-Plattform". |
| **OTLP endpoint URL** | Die Basis-HTTPS-URL des OTLP/HTTP-Endpunkts deiner Observability-Plattform, mit einem Hostnamen, nicht einer IP-Adresse. Sie kann ein Pfadpräfix haben, zum Beispiel `https://gateway.example.com/otlp`. Füge nicht `/v1/traces` hinzu, da die API es hinzufügt. Wenn du eine **OTLP traces endpoint URL** festlegst, verwendet die API stattdessen diese URL. |
| **Request headers** | Die Header, die die API mit jeder Anfrage sendet, zum Beispiel den API-Key-Header deiner Observability-Plattform. Lege Anmeldedaten nur in Header-Werten ab. Nach dem Speichern zeigt die Console die Werte nicht mehr an. |
| **Content mode** | **Metadata only** oder **Full content**. Siehe [wie sich die Content-Modi unterscheiden](https://platform.claude.com/docs/de/manage-claude/opentelemetry#choose-a-content-mode). |
| **Workspaces** | Die Workspaces, deren Spans das Ziel empfängt: **All**, **Selected** oder **All except**. Siehe [Workspaces für ein Ziel wählen](https://platform.claude.com/docs/de/manage-claude/opentelemetry/api#choose-workspaces-for-a-destination). |
| **OTLP traces endpoint URL** | Optional, unter **Advanced settings**. Die vollständige URL des Traces-Endpunkts deiner Observability-Plattform, zum Beispiel `https://gateway.example.com/custom/traces`. Lege sie fest, wenn die Plattform Traces unter einer anderen URL als der OTLP endpoint URL plus `/v1/traces` empfängt. Sie muss denselben Host wie die OTLP endpoint URL haben. |
| **Maximum content size in MB** | Optional, unter **Advanced settings**, wenn der Content-Modus **Full content** ist. Die maximale Menge an Inhalt, die die API in jedem Span sendet. Die Console füllt das Feld je nach gewähltem **Provider** aus. Passe den Wert an das an, was deine Observability-Plattform akzeptiert. Lass das Feld leer, um so viel zu senden, wie die API zulässt. Siehe [Inhaltsgrenzen](https://platform.claude.com/docs/de/manage-claude/opentelemetry#content-limits). |
3. Klicke zum Speichern auf **Add destination**.
4. Klicke im Menü **More actions** des Ziels auf **Test**. Eine Meldung zeigt an, ob der Test-Span an deinen Collector zugestellt wurde oder warum die Zustellung fehlgeschlagen ist (siehe [Zustellungsfehler](https://platform.claude.com/docs/de/manage-claude/opentelemetry/api#delivery-errors)).
5. Prüfe, ob der Span `anthropic.test` in deiner Observability-Plattform angekommen ist.
### Admin API und CLI
Du kannst ein Ziel auch über die [Admin API](https://platform.claude.com/docs/de/manage-claude/admin-api) statt über die Console hinzufügen. Melde dich in der CLI als Admin an oder verwende einen [Admin-API-Key](https://platform.claude.com/docs/de/manage-claude/admin-api-keys) in `ANTHROPIC_API_KEY`. Sende die Anfragen bei Claude Platform on AWS stattdessen an `https://aws-external-anthropic.{region}.api.aws`, signiert mit deinen AWS-Zugangsdaten wie unter [Anfragen stellen](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#making-requests). Dort legt deine [IAM-Richtlinie](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions) fest, wer Ziele verwalten kann. Eine Anfrage kann nur die Workspaces deines AWS-Kontos in dieser Region enthalten.
```bash CLI
# Sign in once as an admin, which opens a browser. Leave ANTHROPIC_API_KEY unset, because it overrides the profile.
ant auth login --profile admin --scope "org:admin"
ant --profile admin beta:organization:telemetry-destinations create \
--endpoint-url https://gateway.example.com/otlp \
--headers '{authorization: "Bearer YOUR_OBSERVABILITY_API_KEY"}' \
--traces.content-mode metadata_only \
--workspaces.type all
```
```bash cURL
curl --fail-with-body -sS "https://api.anthropic.com/v1/organizations/telemetry_destinations" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: telemetry-destinations-2026-08-11" \
-H "content-type: application/json" \
-d '{
"endpoint_url": "https://gateway.example.com/otlp",
"headers": {"authorization": "Bearer YOUR_OBSERVABILITY_API_KEY"},
"traces": {"content_mode": "metadata_only"},
"workspaces": {"type": "all"}
}'
```
```python Python
client = anthropic.Anthropic()
destination = client.beta.organization.telemetry_destinations.create(
endpoint_url="https://gateway.example.com/otlp",
headers={"authorization": "Bearer YOUR_OBSERVABILITY_API_KEY"},
traces={"content_mode": "metadata_only"},
workspaces={"type": "all"},
)
print(destination.id)
```
```typescript TypeScript
const client = new Anthropic();
const destination = await client.beta.organization.telemetryDestinations.create({
endpoint_url: "https://gateway.example.com/otlp",
headers: { authorization: "Bearer YOUR_OBSERVABILITY_API_KEY" },
traces: { content_mode: "metadata_only" },
workspaces: { type: "all" }
});
console.log(destination.id);
```
```csharp C#
using Anthropic.Models.Beta.Organization.TelemetryDestinations;
AnthropicClient client = new();
var destination = await client.Beta.Organization.TelemetryDestinations.Create(
new()
{
EndpointUrl = "https://gateway.example.com/otlp",
Headers = new Dictionary
{
["authorization"] = "Bearer YOUR_OBSERVABILITY_API_KEY",
},
Traces = new() { ContentMode = BetaTelemetryDestinationContentMode.MetadataOnly },
Workspaces = new BetaTelemetryDestinationWorkspacesAllParams(),
}
);
Console.WriteLine(destination.ID);
```
```go Go
client := anthropic.NewClient()
destination, err := client.Beta.Organization.TelemetryDestinations.New(
context.Background(),
anthropic.BetaOrganizationTelemetryDestinationNewParams{
EndpointURL: "https://gateway.example.com/otlp",
Headers: map[string]string{
"authorization": "Bearer YOUR_OBSERVABILITY_API_KEY",
},
Traces: anthropic.BetaTelemetryDestinationTracesParams{
ContentMode: anthropic.BetaTelemetryDestinationContentModeMetadataOnly,
},
Workspaces: anthropic.BetaTelemetryDestinationWorkspacesParamsUnion{
OfAll: &anthropic.BetaTelemetryDestinationWorkspacesAllParams{},
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(destination.ID)
```
```java Java
import com.anthropic.core.JsonValue;
import com.anthropic.models.beta.organization.telemetrydestinations.BetaTelemetryDestinationContentMode;
import com.anthropic.models.beta.organization.telemetrydestinations.BetaTelemetryDestinationTracesParams;
import com.anthropic.models.beta.organization.telemetrydestinations.BetaTelemetryDestinationWorkspacesAllParams;
import com.anthropic.models.beta.organization.telemetrydestinations.TelemetryDestinationCreateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = TelemetryDestinationCreateParams.builder()
.endpointUrl("https://gateway.example.com/otlp")
.headers(TelemetryDestinationCreateParams.Headers.builder()
.putAdditionalProperty("authorization", JsonValue.from("Bearer YOUR_OBSERVABILITY_API_KEY"))
.build())
.traces(BetaTelemetryDestinationTracesParams.builder()
.contentMode(BetaTelemetryDestinationContentMode.METADATA_ONLY)
.build())
.workspaces(BetaTelemetryDestinationWorkspacesAllParams.builder().build())
.build();
var destination = client.beta().organization().telemetryDestinations().create(params);
IO.println(destination.id());
}
```
```php PHP
$client = new Client();
$destination = $client->beta->organization->telemetryDestinations->create(
endpointURL: 'https://gateway.example.com/otlp',
headers: ['authorization' => 'Bearer YOUR_OBSERVABILITY_API_KEY'],
traces: ['contentMode' => 'metadata_only'],
workspaces: ['type' => 'all'],
);
echo "{$destination->id}\n";
```
```ruby Ruby
client = Anthropic::Client.new
destination = client.beta.organization.telemetry_destinations.create(
endpoint_url: "https://gateway.example.com/otlp",
headers: {authorization: "Bearer YOUR_OBSERVABILITY_API_KEY"},
traces: {content_mode: :metadata_only},
workspaces: {type: :all}
)
puts destination.id
```
Eine create-Anfrage übernimmt die Einstellungen der Console außer **Provider**, gib also die Endpunkt-URL und die Header deiner Observability-Plattform selbst ein. Setze `traces.max_content_bytes` (csharp, go: `Traces.MaxContentBytes`; java, php: `traces.maxContentBytes`) in Bytes, damit es zu dem passt, was deine Observability-Plattform akzeptiert (siehe [Inhaltsgrenzen](https://platform.claude.com/docs/de/manage-claude/opentelemetry#content-limits)). Um Ziele aufzulisten, zu ändern oder zu löschen oder einen einzelnen Workspace hinzuzufügen oder zu entfernen, verwende die anderen Methoden der API für Telemetrie-Ziele.
## 2. Workspaces für ein Ziel wählen
Ein Ziel empfängt die Spans der Workspaces, die es abdeckt. Wähle sie aus, wenn du das Ziel hinzufügst. Wähle für **Workspaces** eine der folgenden Optionen:
* **All:** Jeder Workspace in der Organisation, einschließlich des [Default Workspace](https://platform.claude.com/docs/de/manage-claude/workspaces#how-workspaces-work) und später erstellter Workspaces.
* **Selected:** Nur die Workspaces, die du auswählst.
* **All except:** Wie **All**, aber ohne die Workspaces, die du auswählst.
Wähle bei **Selected** oder **All except** die Workspaces im Suchfeld aus, das unter den Optionen erscheint. Um die Workspaces eines Ziels später zu ändern, öffne sein Menü **More actions** auf der [OpenTelemetry-Einstellungsseite](https://platform.claude.com/settings/telemetry-destinations), während der Filter **Workspace** **All** anzeigt. Klicke auf **Edit** und wähle dann eine andere **Workspaces**-Option oder ändere die Workspaces im Suchfeld.
Wenn du die Entwickler-Rolle in der Organisation und die Workspace Admin-Rolle in einem Workspace hast, kannst du diesen Workspace zu einem **Selected**-Ziel hinzufügen oder ihn daraus entfernen. Stelle den Filter **Workspace** auf diesen Workspace ein und öffne dann das Menü **More actions** des Ziels. Bei Claude Platform on AWS gibt es in der Console keine Workspace Admin-Rolle. Dort entscheidet deine [IAM-Richtlinie](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions), wer einen Workspace einem Ziel hinzufügen oder daraus entfernen kann.
Die API sendet Spans an jedes aktivierte Ziel, das den [Workspace, in dem die Anfrage oder Session ausgeführt wird](https://platform.claude.com/docs/de/manage-claude/workspaces#api-keys-and-resource-scoping), abdeckt.
## 3. Prüfen, ob Spans ankommen
1. Wähle in der Console einen Workspace aus, den das Ziel abdeckt, und sende eine Messages-API-Anfrage im [Playground](https://platform.claude.com/playground). Du kannst auch eine Messages-API-Anfrage aus deiner Anwendung senden oder eine Managed-Agents-Session in diesem Workspace starten. Um eine Session zu starten, kannst du den Schritten in [Erste Schritte mit Claude Managed Agents](https://platform.claude.com/docs/de/managed-agents/quickstart) folgen.
2. Prüfe in der Console auf der [OpenTelemetry-Einstellungsseite](https://platform.claude.com/settings/telemetry-destinations), ob die Spalte **Delivery** des Ziels **Healthy** anzeigt. Das kann etwa eine Minute dauern.
3. Filtere in deiner Observability-Plattform nach `service.name` = `claude-platform`, um die Spans der Anfrage zu finden.
Wenn die Spalte **Failing** anzeigt, halte den Mauszeiger darüber, um den letzten Fehler zu sehen. Die wahrscheinliche Ursache findest du unter [Zustellungsfehler](https://platform.claude.com/docs/de/manage-claude/opentelemetry/api#delivery-errors).
## 4. API-Spans mit deinen eigenen Traces verbinden
Standardmäßig befinden sich die API-Spans einer Messages-API-Anfrage oder einer Managed-Agents-Session in eigenen Traces. Verbinde sie mit den Traces deiner Anwendung, sodass sie unter deinen eigenen Spans verschachtelt werden.
Die API liest den Trace-Kontext jeder Anfrage aus dem W3C-[`traceparent`-Header](https://www.w3.org/TR/trace-context/). Wenn das Sampled-Flag im Header aus ist, erzeugt die API weder den Span der Anfrage noch die Spans darunter. Claude Platform on AWS unterstützt diesen Header noch nicht. Die Spans für Anfragen, die du dorthin sendest, starten immer eigene Traces, auch wenn das Sampled-Flag aus ist.
Um die API-Spans zu verbinden, [richte SDK-Tracing ein](https://platform.claude.com/docs/de/manage-claude/opentelemetry/sdk) in deiner Anwendung und rufe das SDK innerhalb eines deiner eigenen Spans auf. Dein Span enthält dann den SDK-Span, der wiederum den API-Span enthält. Sende all diese Spans an dieselbe Observability-Plattform, damit diese sie als einen Trace anzeigen kann. Siehe die Beispiel-Traces [einer Messages-API-Anfrage](https://platform.claude.com/docs/de/manage-claude/opentelemetry#a-messages-api-request) und [einer Managed-Agents-Session](https://platform.claude.com/docs/de/manage-claude/opentelemetry#a-managed-agents-session).
Das folgende Beispiel sendet eine Benutzernachricht an eine Session innerhalb deines eigenen Spans:
```python Python
from opentelemetry import trace
tracer = trace.get_tracer("my-service")
with tracer.start_as_current_span("summarize_issues"):
client.beta.sessions.events.send(
session.id,
events=[
{
"type": "user.message",
"content": [{"type": "text", "text": "Summarize the open issues"}],
},
],
)
```
```typescript TypeScript
import { trace } from "@opentelemetry/api";
const tracer = trace.getTracer("my-service");
await tracer.startActiveSpan("summarize_issues", async (span) => {
try {
await client.beta.sessions.events.send(session.id, {
events: [
{
type: "user.message",
content: [{ type: "text", text: "Summarize the open issues" }]
}
]
});
} finally {
span.end();
}
});
```
```csharp C#
using System.Diagnostics;
// Füge diese Quelle deinem Tracer-Provider hinzu, neben com.anthropic.sdk.csharp.
var source = new ActivitySource("MyService");
using (source.StartActivity("summarize_issues"))
{
// parameters enthält ein user.message-Event.
await client.Beta.Sessions.Events.Send(session.ID, parameters);
}
```
```go Go
// Übergib den Kontext, der deinen Span enthält.
ctx, span := otel.Tracer("my-service").Start(ctx, "summarize_issues")
defer span.End()
// params enthält ein user.message-Event.
_, err := client.Beta.Sessions.Events.Send(ctx, session.ID, params)
```
```java Java
Tracer tracer = GlobalOpenTelemetry.getTracer("my-service");
Span span = tracer.spanBuilder("summarize_issues").startSpan();
try (Scope scope = span.makeCurrent()) {
// params enthält ein user.message-Event.
client.beta().sessions().events().send(session.id(), params);
} finally {
span.end();
}
```
```php PHP
use OpenTelemetry\API\Globals;
$tracer = Globals::tracerProvider()->getTracer('my-service');
$span = $tracer->spanBuilder('summarize_issues')->startSpan();
$scope = $span->activate();
try {
$client->beta->sessions->events->send(
$session->id,
events: [
[
'type' => 'user.message',
'content' => [
['type' => 'text', 'text' => 'Summarize the open issues'],
],
],
],
);
} finally {
$scope->detach();
$span->end();
}
```
```ruby Ruby
tracer = OpenTelemetry.tracer_provider.tracer("my-service")
tracer.in_span("summarize_issues") do
client.beta.sessions.events.send_(
session.id,
events: [
{
type: "user.message",
content: [{type: "text", text: "Summarize the open issues"}]
}
]
)
end
```
Das SDK schreibt den `traceparent`-Header mit dem Propagator deiner Anwendung, und das Sampled-Flag darin folgt deinem Sampler. Wenn deine Anwendung einen anderen Propagator als W3C Trace Context verwendet, etwa B3, füge zusätzlich den W3C-Trace-Context-Propagator hinzu.
Kopiere den Trace-Kontext des aktuellen Spans in die Anfrage-Header, zum Beispiel wenn du eine Managed-Agents-Session erstellst oder eine Benutzernachricht sendest:
```bash cURL
# TRACEPARENT ist der traceparent des aktiven Spans in deinem eigenen Service,
# zum Beispiel 00---01.
curl -fsSL "https://api.anthropic.com/v1/sessions/$SESSION_ID/events" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-H "traceparent: $TRACEPARENT" \
-d '{
"events": [
{
"type": "user.message",
"content": [{"type": "text", "text": "Summarize the open issues"}]
}
]
}'
```
```python Python
import os
import httpx2
from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
headers = {
"x-api-key": os.environ["ANTHROPIC_API_KEY"],
"anthropic-version": "2023-06-01",
"anthropic-beta": "managed-agents-2026-04-01",
"content-type": "application/json",
}
# Kopiere den Trace-Kontext des aktiven Spans in die Request-Header.
TraceContextTextMapPropagator().inject(headers)
httpx2.post(
f"https://api.anthropic.com/v1/sessions/{os.environ['SESSION_ID']}/events",
headers=headers,
json={
"events": [
{
"type": "user.message",
"content": [{"type": "text", "text": "Summarize the open issues"}],
},
],
},
)
```
```typescript TypeScript
import { context, defaultTextMapSetter } from "@opentelemetry/api";
import { W3CTraceContextPropagator } from "@opentelemetry/core";
const headers: Record = {
"x-api-key": process.env.ANTHROPIC_API_KEY!,
"anthropic-version": "2023-06-01",
"anthropic-beta": "managed-agents-2026-04-01",
"content-type": "application/json"
};
// Kopiere den Trace-Kontext des aktiven Spans in die Request-Header.
new W3CTraceContextPropagator().inject(context.active(), headers, defaultTextMapSetter);
await fetch(`https://api.anthropic.com/v1/sessions/${process.env.SESSION_ID}/events`, {
method: "POST",
headers,
body: JSON.stringify({
events: [
{
type: "user.message",
content: [{ type: "text", text: "Summarize the open issues" }]
}
]
})
});
```
```csharp C#
using System.Diagnostics;
using System.Net.Http.Json;
using OpenTelemetry;
using OpenTelemetry.Context.Propagation;
using var httpClient = new HttpClient();
using var request = new HttpRequestMessage(
HttpMethod.Post,
$"https://api.anthropic.com/v1/sessions/{Environment.GetEnvironmentVariable("SESSION_ID")}/events")
{
// JsonContent setzt den Content-Type-Header.
Content = JsonContent.Create(new
{
events = new[]
{
new
{
type = "user.message",
content = new[] { new { type = "text", text = "Summarize the open issues" } },
},
},
}),
};
request.Headers.Add("x-api-key", Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY"));
request.Headers.Add("anthropic-version", "2023-06-01");
request.Headers.Add("anthropic-beta", "managed-agents-2026-04-01");
// Kopiere den Trace-Kontext des aktiven Spans in die Request-Header.
new TraceContextPropagator().Inject(
new PropagationContext(Activity.Current?.Context ?? default, Baggage.Current),
request,
(carrier, key, value) => carrier.Headers.Add(key, value));
await httpClient.SendAsync(request);
```
```go Go
import (
"context"
"net/http"
"os"
"strings"
"go.opentelemetry.io/otel/propagation"
)
func sendMessage(ctx context.Context) error {
body := strings.NewReader(`{
"events": [
{
"type": "user.message",
"content": [{"type": "text", "text": "Summarize the open issues"}]
}
]
}`)
req, err := http.NewRequestWithContext(ctx, http.MethodPost,
"https://api.anthropic.com/v1/sessions/"+os.Getenv("SESSION_ID")+"/events", body)
if err != nil {
return err
}
req.Header.Set("x-api-key", os.Getenv("ANTHROPIC_API_KEY"))
req.Header.Set("anthropic-version", "2023-06-01")
req.Header.Set("anthropic-beta", "managed-agents-2026-04-01")
req.Header.Set("content-type", "application/json")
// Kopiere den Trace-Kontext des aktiven Spans in die Request-Header.
propagation.TraceContext{}.Inject(ctx, propagation.HeaderCarrier(req.Header))
resp, err := http.DefaultClient.Do(req)
if err != nil {
return err
}
return resp.Body.Close()
}
```
```java Java
import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator;
import io.opentelemetry.context.Context;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
void main() throws Exception {
var request = HttpRequest.newBuilder(URI.create(
"https://api.anthropic.com/v1/sessions/" + System.getenv("SESSION_ID") + "/events"))
.header("x-api-key", System.getenv("ANTHROPIC_API_KEY"))
.header("anthropic-version", "2023-06-01")
.header("anthropic-beta", "managed-agents-2026-04-01")
.header("content-type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString("""
{
"events": [
{
"type": "user.message",
"content": [{"type": "text", "text": "Summarize the open issues"}]
}
]
}
"""));
// Kopiere den Trace-Kontext des aktiven Spans in die Request-Header.
W3CTraceContextPropagator.getInstance()
.inject(Context.current(), request, HttpRequest.Builder::header);
HttpClient.newHttpClient().send(request.build(), HttpResponse.BodyHandlers.ofString());
}
```
```php PHP
use OpenTelemetry\API\Trace\Propagation\TraceContextPropagator;
$headers = [
'x-api-key' => getenv('ANTHROPIC_API_KEY'),
'anthropic-version' => '2023-06-01',
'anthropic-beta' => 'managed-agents-2026-04-01',
'content-type' => 'application/json',
];
// Kopiere den Trace-Kontext des aktiven Spans in die Request-Header.
TraceContextPropagator::getInstance()->inject($headers);
$ch = curl_init('https://api.anthropic.com/v1/sessions/' . getenv('SESSION_ID') . '/events');
curl_setopt_array($ch, [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array_map(
static fn ($name, $value) => "$name: $value",
array_keys($headers),
$headers,
),
CURLOPT_POSTFIELDS => json_encode([
'events' => [
[
'type' => 'user.message',
'content' => [
['type' => 'text', 'text' => 'Summarize the open issues'],
],
],
],
]),
]);
curl_exec($ch);
```
```ruby Ruby
require "json"
require "net/http"
require "opentelemetry"
headers = {
"x-api-key" => ENV.fetch("ANTHROPIC_API_KEY"),
"anthropic-version" => "2023-06-01",
"anthropic-beta" => "managed-agents-2026-04-01",
"content-type" => "application/json"
}
# Kopiere den Trace-Kontext des aktiven Spans in die Request-Header.
OpenTelemetry::Trace::Propagation::TraceContext.text_map_propagator.inject(headers)
Net::HTTP.post(
URI("https://api.anthropic.com/v1/sessions/#{ENV.fetch("SESSION_ID")}/events"),
{
events: [
{
type: "user.message",
content: [{type: "text", text: "Summarize the open issues"}]
}
]
}.to_json,
headers
)
```
Die Messages API gibt den Trace auch an deinen MCP-Server weiter, wenn du ihn mit dem [MCP-Connector](https://platform.claude.com/docs/de/agents-and-tools/mcp-connector) verbindest, sodass er seine eigenen Spans unter die API-Spans setzen kann. Jede Anfrage und Benachrichtigung, die die API an deinen MCP-Server sendet, enthält einen W3C-`traceparent` in `params._meta`. In einer `tools/call`-Anfrage verweist er auf den [`anthropic.mcp_tool_use`](https://platform.claude.com/docs/de/api/opentelemetry/spans#anthropic-tool-use-anthropic-mcp-tool-use-and-anthropic-custom-tool-use)-Span dieser Tool-Nutzung. In den anderen Nachrichten verweist er auf den [`anthropic.messages.create`](https://platform.claude.com/docs/de/api/opentelemetry/spans#anthropic-messages-create)-Span. Für eine Anfrage, die die API nicht tracet, etwa eine, deren `traceparent`-Header das Sampled-Flag deaktiviert hat, sendet die API keinen `traceparent`.
## Nächste Schritte
Erhalte Observability für deinen Client.
Verfolge eine Anfrage von deinem Client bis in die Claude API.
## Zustellung und Status
Die folgenden Regeln gelten für die Spans, die die API an deine Ziele sendet.
* **Mindestens einmal:** Ein Ziel kann denselben Span mehr als einmal erhalten. Um Duplikate zu entfernen, verwende die Trace-ID und die Span-ID.
* **Best Effort:** Ein Span kann vor der Zustellung verloren gehen. Die API kann einen verlorenen Span nicht erneut senden.
* **Komprimierung:** Die API komprimiert die erste Anfrage jeder Zustellung mit gzip und setzt den Header `Content-Encoding: gzip`. Wenn dein Endpunkt diese Anfrage mit einer `400`- oder `415`-Antwort beantwortet, sendet die API dieselben Spans sofort erneut ohne Komprimierung.
* **Wiederholungen:** Nach einem Timeout, einem Verbindungs-, TLS- oder DNS-Fehler oder einer `408`-, `429`- oder `5xx`-Antwort versucht die API die Zustellung später erneut, eine begrenzte Anzahl von Malen. Bei anderen Fehlern wiederholt sie die Zustellung nicht.
* **Timeouts:** Für jede Anfrage muss dein Endpunkt den TLS-Handshake innerhalb von 5 Sekunden abschließen und die Antwort-Header innerhalb von 5 Sekunden senden. Jede Zustellung läuft nach insgesamt 10 Sekunden ab, einschließlich des erneuten Sendens ohne Komprimierung.
* **User Agent:** Jede Anfrage hat den Header `User-Agent: Claude-Platform`.
Die Spalte **Delivery** zeigt den Zustand jedes Ziels. Der Zustand kann bis zu einer Minute verzögert sein.
| Zustellungszustand | Bedeutung |
| ------------------ | -------------------------------------------------------------------------------------------------------- |
| **Healthy** | Die letzte Zustellung war erfolgreich. |
| **Failing** | Die letzte Zustellung ist fehlgeschlagen. Um den Fehler zu sehen, halte den Mauszeiger über **Failing**. |
| **No data** | Die API hat noch keine Zustellung versucht. |
| **Disabled** | Das Ziel empfängt keine Spans. Um den Grund zu sehen, halte den Mauszeiger über **Disabled**. |
Die API deaktiviert ein Ziel, wenn:
* Der Endpunkt eine `3xx`-Weiterleitung sendet.
* Der Hostname des Endpunkts zu einer IP-Adresse aufgelöst wird, die nicht öffentlich ist.
* Alle Zustellungen 24 Stunden lang fehlschlagen.
Die API sendet keine Spans an ein deaktiviertes Ziel. Um den Export fortzusetzen, behebe die Ursache. Klicke dann, während der Filter **Workspace** auf der [OpenTelemetry-Einstellungsseite](https://platform.claude.com/settings/telemetry-destinations) **All** anzeigt, im Menü **More actions** des Ziels auf **Enable**. Der Export startet innerhalb von etwa einer Minute erneut.
Um ein Ziel zu ändern, öffne sein Menü **More actions**, während der Filter **Workspace** **All** anzeigt. Klicke dann auf **Edit**, **Disable**, **Enable** oder **Delete**. Wenn du den Host der **OTLP endpoint URL** änderst, gib die Header-Werte erneut ein. Wenn das Ziel eine **OTLP traces endpoint URL** hat, gib ihr denselben neuen Host oder leere sie.
## Limits
| Limit | Wert |
| ---------------------------------------------------- | ------------- |
| Ziele pro Organisation, einschließlich deaktivierter | 10 |
| Workspaces, die du für ein Ziel auswählst | 1.000 |
| Request-Header pro Ziel | 20 |
| Länge eines Header-Namens | 128 Bytes |
| Länge eines Header-Werts | 4.096 Bytes |
| Länge aller Header-Namen und -Werte zusammen | 16.384 Bytes |
| Länge einer Endpunkt-URL | 2.048 Zeichen |
## Fehlerbehebung
| Problem | Was zu prüfen ist |
| -------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Keine API-Spans | Der Workspace benötigt ein aktiviertes Ziel, das ihn abdeckt. Siehe [Workspaces für ein Ziel wählen](https://platform.claude.com/docs/de/manage-claude/opentelemetry/api#choose-workspaces-for-a-destination). Nachdem ein Ziel begonnen hat, einen Workspace abzudecken, kann es bis zu einer Minute dauern, bis Spans aus diesem Workspace ankommen. |
| Die Spalte **Delivery** zeigt **Failing** | Halte den Mauszeiger darüber, um den letzten Fehler zu sehen. Die wahrscheinliche Ursache findest du unter [Zustellungsfehler](https://platform.claude.com/docs/de/manage-claude/opentelemetry/api#delivery-errors). |
| Die Spalte **Delivery** zeigt **Disabled** | Halte den Mauszeiger darüber, um den Grund zu sehen. Die Gründe findest du unter [wann die API ein Ziel deaktiviert](https://platform.claude.com/docs/de/manage-claude/opentelemetry/api#delivery-and-health). |
| Spans enthalten keine Prompts oder Antworten, obwohl das Ziel auf **Full content** eingestellt ist | Deine Organisation hat möglicherweise mit Anthropic eine HIPAA-, FERPA- oder K-12-Einschränkung für den Datenumgang. Siehe [Content-Modi](https://platform.claude.com/docs/de/manage-claude/opentelemetry#choose-a-content-mode). |
### Zustellungsfehler
Wenn eine Zustellung fehlschlägt, zeigt die Spalte **Delivery** **Failing** an. Halte den Mauszeiger darüber, um den Fehler zu sehen, und finde dann die wahrscheinliche Ursache:
| Fehler | Wahrscheinliche Ursache |
| ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| HTTP error (status 401) oder HTTP error (status 403) | Ein falscher Authentifizierungs-Header |
| HTTP error (status 404) | Ein falscher Pfad in der **OTLP endpoint URL** oder der **OTLP traces endpoint URL** |
| DNS resolution failure | Der Hostname des Endpunkts lässt sich nicht auflösen |
| TLS failure | Ein TLS-Problem, zum Beispiel mit dem Zertifikat des Endpunkts |
| Timeout | Der Endpunkt hat nicht rechtzeitig geantwortet. Siehe [die Zustellungs-Timeouts](https://platform.claude.com/docs/de/manage-claude/opentelemetry/api#delivery-and-health) |
| Connection failure | Die API konnte keine Verbindung zum Endpunkt herstellen |