---
title: Usa OpenTelemetry con la Claude API
url: https://platform.claude.com/docs/es/manage-claude/opentelemetry/api
description: Agrega un destino en la Claude Console para enviar trazas de OpenTelemetry de tus solicitudes a la Messages API y de tus sesiones de Managed Agents a tu plataforma de observabilidad.
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). Solo para funciones que por sí mismas cumplen los requisitos de ZDR, como la Messages API. Claude Managed Agents no cumple los requisitos de ZDR.
supportedPlatforms:
Claude API: beta
Claude Platform on AWS: beta
rows:
- label: Compatible con
value: Messages API, Claude Managed Agents
details:
- Tras la entrega, los datos quedan en poder del servicio que elegiste, fuera de Anthropic, bajo los controles de retención y acceso de ese servicio.
---
Con OpenTelemetry, la Claude API puede emitir un *span* (intervalo) por cada solicitud al modelo y por cada uso de herramienta que ejecuta. Puedes ver estos spans en tu plataforma de observabilidad sin cambiar tu código.
La API emite spans para tus solicitudes a la Messages API y tus sesiones de Managed Agents. Para recibirlos, agrega un *destino* en la Claude Console. Un destino le indica a la API el endpoint OTLP de tu plataforma de observabilidad y cómo autenticarse con él.
## Qué necesitas
* **El rol de administrador** en una organización de la Claude Console, para agregar y cambiar destinos. Con el rol de desarrollador, puedes verlos. Si tu organización está en Claude Platform on AWS, inicia sesión en la Console a través de la AWS Console, como se describe en [Iniciar sesión](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#signing-in).
* **Un endpoint OTLP/HTTP** que acepte codificación protobuf en una URL HTTPS en el puerto 443. Si ejecutas tu propio [OpenTelemetry Collector](https://opentelemetry.io/docs/collector/), su receptor OTLP/HTTP escucha en el puerto 4318 de forma predeterminada. Configura el receptor para que acepte HTTPS en el puerto 443, o coloca un balanceador de carga o un proxy inverso delante del Collector.
* **Credenciales para el endpoint**, como una clave de API.
## 1. Agrega un destino
Cuando agregas un destino de telemetría, Anthropic enviará trazas de la actividad de Claude Platform en tu organización al endpoint OTLP/HTTP del proveedor externo que especifiques, de acuerdo con los términos de tu proveedor y los controles de acceso. Tras la entrega, los datos quedan en poder del servicio que elegiste, fuera de Anthropic, bajo los controles de retención y acceso de ese servicio.
1. En la Console, abre la [página de configuración de OpenTelemetry](https://platform.claude.com/settings/telemetry-destinations) de tu organización y haz clic en **Add destination**.
2. Configura el destino:
| Campo | Qué ingresar |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Provider** | Tu plataforma de observabilidad, o **Custom** si no aparece en la lista. Si eliges una plataforma de la lista, la Console te pide sus datos, como una clave de API, en lugar de **OTLP endpoint URL**, **Request headers** y **OTLP traces endpoint URL**. |
| **Name** | Opcional. Por ejemplo, "Plataforma de observabilidad de Acme". |
| **OTLP endpoint URL** | La URL HTTPS base del endpoint OTLP/HTTP de tu plataforma de observabilidad, con un nombre de host, no una dirección IP. Puede tener un prefijo de ruta, por ejemplo `https://gateway.example.com/otlp`. No agregues `/v1/traces`, porque la API lo agrega. Si estableces una **OTLP traces endpoint URL**, la API usa esa URL en su lugar. |
| **Request headers** | Los encabezados que la API envía con cada solicitud, por ejemplo el encabezado de clave de API de tu plataforma de observabilidad. Coloca las credenciales solo en los valores de los encabezados. Después de guardar, la Console no vuelve a mostrar los valores. |
| **Content mode** | **Metadata only** o **Full content**. Consulta [en qué se diferencian los modos de contenido](https://platform.claude.com/docs/es/manage-claude/opentelemetry#choose-a-content-mode). |
| **Workspaces** | Los espacios de trabajo cuyos spans recibe el destino: **All**, **Selected** o **All except**. Consulta [Elige los espacios de trabajo de un destino](https://platform.claude.com/docs/es/manage-claude/opentelemetry/api#choose-workspaces-for-a-destination). |
| **OTLP traces endpoint URL** | Opcional, en **Advanced settings**. La URL completa del endpoint de trazas de tu plataforma de observabilidad, por ejemplo `https://gateway.example.com/custom/traces`. Establécela cuando la plataforma reciba trazas en una URL distinta de la OTLP endpoint URL más `/v1/traces`. Debe tener el mismo host que la OTLP endpoint URL. |
| **Maximum content size in MB** | Opcional, en **Advanced settings** cuando el modo de contenido es **Full content**. La cantidad máxima de contenido que la API envía en cada span. La Console la completa según el **Provider** que elijas. Cámbiala para que se ajuste a lo que acepta tu plataforma de observabilidad. Déjalo vacío para enviar tanto como la API permita. Consulta [Límites de contenido](https://platform.claude.com/docs/es/manage-claude/opentelemetry#content-limits). |
3. Haz clic en **Add destination** para guardar.
4. Haz clic en **Test** en el menú **More actions** del destino. Verás un mensaje que indica que el span de prueba se entregó a tu colector, o cómo falló la entrega (consulta [Errores de entrega](https://platform.claude.com/docs/es/manage-claude/opentelemetry/api#delivery-errors)).
5. Comprueba que el span `anthropic.test` haya llegado a tu plataforma de observabilidad.
### Admin API y CLI
También puedes agregar un destino con la [Admin API](https://platform.claude.com/docs/es/manage-claude/admin-api) en lugar de la Console. Inicia sesión en la CLI como administrador, o usa una [clave de Admin API](https://platform.claude.com/docs/es/manage-claude/admin-api-keys) en `ANTHROPIC_API_KEY`. En Claude Platform on AWS, envía las solicitudes a `https://aws-external-anthropic.{region}.api.aws` en su lugar, firmadas con tus credenciales de AWS como en [Realizar solicitudes](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws#making-requests). Allí, tu [política de IAM](https://platform.claude.com/docs/es/api/claude-platform-on-aws-iam-actions) decide quién puede administrar destinos. Una solicitud solo puede incluir los espacios de trabajo de tu cuenta de AWS en esa región.
```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
```
Una solicitud de creación acepta la configuración de la Console excepto **Provider**, así que ingresa tú mismo la URL del endpoint y los encabezados de tu plataforma de observabilidad. Establece `traces.max_content_bytes` (csharp, go: `Traces.MaxContentBytes`; java, php: `traces.maxContentBytes`), en bytes, para ajustarlo a lo que acepta tu plataforma de observabilidad (consulta [Límites de contenido](https://platform.claude.com/docs/es/manage-claude/opentelemetry#content-limits)). Para listar, cambiar o eliminar destinos, o para agregar o quitar un espacio de trabajo, usa los demás métodos de la API de destinos de telemetría.
## 2. Elige los espacios de trabajo de un destino
Un destino recibe los spans de los espacios de trabajo que abarca. Elígelos cuando agregues el destino. En **Workspaces**, selecciona una de las siguientes opciones:
* **All:** Todos los espacios de trabajo de la organización, incluido el [Default Workspace](https://platform.claude.com/docs/es/manage-claude/workspaces#how-workspaces-work) y los espacios de trabajo que se creen más adelante.
* **Selected:** Solo los espacios de trabajo que selecciones.
* **All except:** Como **All**, pero sin los espacios de trabajo que selecciones.
Para **Selected** o **All except**, selecciona los espacios de trabajo en el cuadro de búsqueda que aparece debajo de las opciones. Para cambiar más adelante los espacios de trabajo de un destino, abre su menú **More actions** en la [página de configuración de OpenTelemetry](https://platform.claude.com/settings/telemetry-destinations) mientras el filtro **Workspace** muestra **All**. Haz clic en **Edit** y luego elige otra opción de **Workspaces** o cambia los espacios de trabajo en el cuadro de búsqueda.
Si tienes el rol de desarrollador en la organización y el rol de Workspace Admin en un espacio de trabajo, puedes agregar ese espacio de trabajo a un destino **Selected** o quitarlo de él. Configura el filtro **Workspace** en ese espacio de trabajo y, luego, abre el menú **More actions** del destino. En Claude Platform on AWS, la Console no tiene el rol de Workspace Admin. Allí, es tu [política de IAM](https://platform.claude.com/docs/es/api/claude-platform-on-aws-iam-actions) la que decide quién puede agregar un espacio de trabajo a un destino o quitarlo de él.
La API envía los spans a cada destino habilitado que cubra el [espacio de trabajo en el que se ejecuta la solicitud o la sesión](https://platform.claude.com/docs/es/manage-claude/workspaces#api-keys-and-resource-scoping).
## 3. Comprueba que llegan los spans
1. En la Console, selecciona un espacio de trabajo que el destino cubra y envía una solicitud a la Messages API en el [playground](https://platform.claude.com/playground). También puedes enviar una solicitud a la Messages API desde tu aplicación o iniciar una sesión de Managed Agents en ese espacio de trabajo. Para iniciar una sesión, puedes seguir los pasos de [Primeros pasos con Claude Managed Agents](https://platform.claude.com/docs/es/managed-agents/quickstart).
2. En la Console, en la [página de configuración de OpenTelemetry](https://platform.claude.com/settings/telemetry-destinations), comprueba que la columna **Delivery** del destino muestre **Healthy**. Esto puede tardar alrededor de un minuto.
3. En tu plataforma de observabilidad, filtra por `service.name` = `claude-platform` para encontrar los spans de la solicitud.
Si la columna muestra **Failing**, mantén el puntero sobre ella para ver el último error. Para encontrar la causa probable, consulta [Errores de entrega](https://platform.claude.com/docs/es/manage-claude/opentelemetry/api#delivery-errors).
## 4. Conecta los spans de la API con tus propias trazas
De forma predeterminada, los spans de la API de una solicitud a la Messages API o de una sesión de Managed Agents están en sus propias trazas. Conéctalos con las trazas de tu aplicación para que queden anidados bajo tus propios spans.
La API lee el contexto de traza de cada solicitud desde el [encabezado `traceparent`](https://www.w3.org/TR/trace-context/) de W3C. Si el indicador de muestreo del encabezado está desactivado, la API no emite el span de la solicitud ni los spans que dependen de él. Claude Platform on AWS aún no admite este encabezado. Los spans de las solicitudes que le envías siempre inician sus propias trazas, incluso cuando el indicador de muestreo está desactivado.
Para conectar los spans de la API, [configura el trazado del SDK](https://platform.claude.com/docs/es/manage-claude/opentelemetry/sdk) en tu aplicación y llama al SDK desde dentro de uno de tus propios spans. Tu span contiene entonces el span del SDK, que a su vez contiene el span de la API. Envía todos estos spans a la misma plataforma de observabilidad para que pueda mostrarlos como una sola traza. Consulta las trazas de ejemplo de [una solicitud a la Messages API](https://platform.claude.com/docs/es/manage-claude/opentelemetry#a-messages-api-request) y de [una sesión de Managed Agents](https://platform.claude.com/docs/es/manage-claude/opentelemetry#a-managed-agents-session).
El siguiente ejemplo envía un mensaje de usuario a una sesión dentro de tu propio span:
```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;
// Agrega esta fuente a tu proveedor de trazas (tracer provider), junto a com.anthropic.sdk.csharp.
var source = new ActivitySource("MyService");
using (source.StartActivity("summarize_issues"))
{
// parameters contiene un evento user.message.
await client.Beta.Sessions.Events.Send(session.ID, parameters);
}
```
```go Go
// Pasa el contexto que contiene tu span.
ctx, span := otel.Tracer("my-service").Start(ctx, "summarize_issues")
defer span.End()
// params contiene un evento user.message.
_, 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 contiene un evento user.message.
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
```
El SDK escribe el encabezado `traceparent` con el propagador de tu aplicación, y el indicador de muestreo que contiene sigue a tu muestreador. Si tu aplicación usa un propagador distinto del contexto de traza de W3C, como B3, agrega también el propagador de contexto de traza de W3C.
Copia el contexto de traza del span actual en los encabezados de la solicitud, por ejemplo cuando creas una sesión de Managed Agents o envías un mensaje de usuario:
```bash cURL
# TRACEPARENT es el traceparent del span activo en tu propio servicio,
# por ejemplo 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",
}
# Copia el contexto de traza del span activo en los encabezados de la solicitud.
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"
};
// Copia el contexto de traza del span activo en los encabezados de la solicitud.
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 establece el encabezado content-type.
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");
// Copia el contexto de traza del span activo en los encabezados de la solicitud.
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")
// Copia el contexto de traza del span activo en los encabezados de la solicitud.
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"}]
}
]
}
"""));
// Copia el contexto de traza del span activo en los encabezados de la solicitud.
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',
];
// Copia el contexto de traza del span activo en los encabezados de la solicitud.
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"
}
# Copia el contexto de traza del span activo en los encabezados de la solicitud.
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
)
```
La Messages API también transmite la traza a tu servidor MCP cuando lo conectas con el [conector MCP](https://platform.claude.com/docs/es/agents-and-tools/mcp-connector), para que pueda colocar sus propios spans bajo los spans de la API. Cada solicitud y notificación que la API envía a tu servidor MCP tiene un `traceparent` de W3C en `params._meta`. En una solicitud `tools/call`, este hace referencia al span [`anthropic.mcp_tool_use`](https://platform.claude.com/docs/es/api/opentelemetry/spans#anthropic-tool-use-anthropic-mcp-tool-use-and-anthropic-custom-tool-use) de ese uso de herramientas. En los demás mensajes, hace referencia al span [`anthropic.messages.create`](https://platform.claude.com/docs/es/api/opentelemetry/spans#anthropic-messages-create). Para una solicitud que la API no rastrea, como una cuyo encabezado `traceparent` tiene el indicador de muestreo desactivado, la API no envía ningún `traceparent`.
## Próximos pasos
Obtén observabilidad de tu cliente.
Sigue una solicitud desde tu cliente hasta la Claude API.
## Entrega y estado
Las siguientes reglas se aplican a los spans que la API envía a tus destinos.
* **Al menos una vez:** Un destino puede recibir el mismo span más de una vez. Para eliminar duplicados, usa el ID de traza y el ID de span.
* **Mejor esfuerzo:** Un span puede perderse antes de la entrega. La API no puede volver a enviar un span perdido.
* **Compresión:** La API comprime con gzip la primera solicitud de cada entrega y establece el encabezado `Content-Encoding: gzip`. Si tu endpoint responde a esa solicitud con una respuesta `400` o `415`, la API vuelve a enviar de inmediato los mismos spans sin compresión.
* **Reintentos:** La API vuelve a intentar una entrega más tarde, un número limitado de veces, después de un tiempo de espera agotado, un fallo de conexión, TLS o DNS, o una respuesta `408`, `429` o `5xx`. No reintenta otros fallos.
* **Tiempos de espera:** Para cada solicitud, tu endpoint debe completar el handshake TLS en 5 segundos y enviar los encabezados de respuesta en 5 segundos. Cada entrega agota su tiempo de espera después de 10 segundos en total, incluido el reenvío sin compresión.
* **User agent:** Cada solicitud tiene el encabezado `User-Agent: Claude-Platform`.
La columna **Delivery** muestra el estado de cada destino. El estado puede tener hasta un minuto de retraso.
| Estado de entrega | Significado |
| ----------------- | ------------------------------------------------------------------------------------- |
| **Healthy** | La última entrega se realizó correctamente. |
| **Failing** | La última entrega falló. Para ver el error, mantén el puntero sobre **Failing**. |
| **No data** | La API aún no ha intentado ninguna entrega. |
| **Disabled** | El destino no recibe spans. Para ver el motivo, mantén el puntero sobre **Disabled**. |
La API deshabilita un destino cuando:
* El endpoint envía una redirección `3xx`.
* El nombre de host del endpoint se resuelve en una dirección IP que no es pública.
* Todas las entregas fallan durante 24 horas.
La API no envía spans a un destino deshabilitado. Para reanudar la exportación, corrige la causa. Luego, con el filtro **Workspace** de la [página de configuración de OpenTelemetry](https://platform.claude.com/settings/telemetry-destinations) mostrando **All**, haz clic en **Enable** en el menú **More actions** del destino. La exportación se reanuda en aproximadamente un minuto.
Para cambiar un destino, abre su menú **More actions** mientras el filtro **Workspace** muestra **All**. Luego haz clic en **Edit**, **Disable**, **Enable** o **Delete**. Si cambias el host de la **OTLP endpoint URL**, vuelve a ingresar los valores de los encabezados. Si el destino tiene una **OTLP traces endpoint URL**, asígnale el mismo host nuevo o déjala vacía.
## Límites
| Límite | Valor |
| ------------------------------------------------------------- | ---------------- |
| Destinos por organización, incluidos los deshabilitados | 10 |
| Espacios de trabajo que seleccionas para un destino | 1,000 |
| Encabezados de solicitud por destino | 20 |
| Longitud del nombre de un encabezado | 128 bytes |
| Longitud del valor de un encabezado | 4,096 bytes |
| Longitud de todos los nombres y valores de encabezados juntos | 16,384 bytes |
| Longitud de una URL de endpoint | 2,048 caracteres |
## Solución de problemas
| Problema | Qué revisar |
| ----------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| No hay spans de la API | El espacio de trabajo necesita un destino habilitado que lo cubra. Consulta [Elige los espacios de trabajo de un destino](https://platform.claude.com/docs/es/manage-claude/opentelemetry/api#choose-workspaces-for-a-destination). Después de que un destino comienza a cubrir un espacio de trabajo, los spans de ese espacio de trabajo pueden tardar hasta un minuto en llegar. |
| La columna **Delivery** muestra **Failing** | Mantén el puntero sobre ella para ver el último error. Para encontrar la causa probable, consulta [Errores de entrega](https://platform.claude.com/docs/es/manage-claude/opentelemetry/api#delivery-errors). |
| La columna **Delivery** muestra **Disabled** | Mantén el puntero sobre ella para ver por qué. Para conocer los motivos, consulta [cuándo la API deshabilita un destino](https://platform.claude.com/docs/es/manage-claude/opentelemetry/api#delivery-and-health). |
| Los spans no tienen prompts ni respuestas, pero el destino está configurado en **Full content** | Tu organización podría tener una restricción de manejo de datos de HIPAA, FERPA o K-12 con Anthropic. Consulta [Modos de contenido](https://platform.claude.com/docs/es/manage-claude/opentelemetry#choose-a-content-mode). |
### Errores de entrega
Cuando una entrega falla, la columna **Delivery** muestra **Failing**. Mantén el puntero sobre este estado para ver el error y, a continuación, busca la causa probable:
| Error | Causa probable |
| ------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| HTTP error (status 401) o HTTP error (status 403) | Un encabezado de autenticación incorrecto |
| HTTP error (status 404) | Una ruta incorrecta en la **OTLP endpoint URL** o en la **OTLP traces endpoint URL** |
| DNS resolution failure | El nombre de host del endpoint no se resuelve |
| TLS failure | Un problema de TLS, por ejemplo con el certificado del endpoint |
| Timeout | El endpoint no respondió a tiempo. Consulta [los tiempos de espera de entrega](https://platform.claude.com/docs/es/manage-claude/opentelemetry/api#delivery-and-health) |
| Connection failure | La API no pudo conectarse al endpoint |