Anthropic SDK | Respan Docs

The Anthropic SDK is the official client for Anthropic’s Claude models, supporting messages, streaming, and tool use. Respan gives you full observability over every Claude call, streamed response, and tool invocation — and gateway routing through the Anthropic-compatible Respan endpoint.

Set up Respan

Create an account at platform.respan.ai and grab an API key. For gateway, also add credits or a provider key.

Run npx @respan/cli setup to set up with your coding agent.

Example projects

Tracing

Gateway

Setup

Install packages

$ pip install respan-ai respan-instrumentation-anthropic anthropic

Set environment variables

$ export ANTHROPIC_API_KEY="YOUR_ANTHROPIC_API_KEY"
$ export RESPAN_API_KEY="YOUR_RESPAN_API_KEY"

ANTHROPIC_API_KEY is used for Claude requests. RESPAN_API_KEY is used to export traces to Respan.

Initialize and run

1 from anthropic import Anthropic
2 from respan import Respan
3 from respan_instrumentation_anthropic import AnthropicInstrumentor
4 
5 respan = Respan(instrumentations=[AnthropicInstrumentor()])
6 
7 client = Anthropic()
8 
9 message = client.messages.create(
10     model="claude-sonnet-4-5-20250929",
11     max_tokens=1024,
12     messages=[{"role": "user", "content": "Say hello in three languages."}],
13 )
14 print(message.content[0].text)
15 respan.flush()

View your trace

Open the Traces page to see your auto-instrumented LLM spans with messages, tokens, and tool calls.

Configuration

Parameter	Type	Default	Description
`api_key`	`str \| None`	`None`	Falls back to `RESPAN_API_KEY` env var.
`base_url`	`str \| None`	`None`	Falls back to `RESPAN_BASE_URL` env var.
`instrumentations`	`list`	`[]`	Plugin instrumentations to activate (e.g. `AnthropicInstrumentor()`).
`customer_identifier`	`str \| None`	`None`	Default customer identifier for all spans.
`metadata`	`dict \| None`	`None`	Default metadata attached to all spans.
`environment`	`str \| None`	`None`	Environment tag (e.g. `"production"`).

Attributes

In Respan()

Set defaults at initialization — these apply to all spans.

1 from respan import Respan
2 from respan_instrumentation_anthropic import AnthropicInstrumentor
3 
4 respan = Respan(
5     instrumentations=[AnthropicInstrumentor()],
6     customer_identifier="user_123",
7     metadata={"service": "chat-api", "version": "1.0.0"},
8 )

With propagate_attributes

Override per-request using a context scope.

1 from anthropic import Anthropic
2 from respan import Respan, propagate_attributes
3 from respan_instrumentation_anthropic import AnthropicInstrumentor
4 
5 respan = Respan(instrumentations=[AnthropicInstrumentor()])
6 client = Anthropic()
7 
8 def handle_request(user_id: str, question: str):
9     with propagate_attributes(
10         customer_identifier=user_id,
11         thread_identifier="conv_abc_123",
12         metadata={"plan": "pro"},
13     ):
14         message = client.messages.create(
15             model="claude-sonnet-4-5-20250929",
16             max_tokens=1024,
17             messages=[{"role": "user", "content": question}],
18         )
19         print(message.content[0].text)

Attribute	Type	Description
`customer_identifier`	`str`	Identifies the end user in Respan analytics.
`thread_identifier`	`str`	Groups related messages into a conversation.
`metadata`	`dict`	Custom key-value pairs. Merged with default metadata.

Decorators (optional)

Decorators are not required. All Anthropic calls are auto-traced by the instrumentor. Use @workflow and @task to add structure when you want to group related calls into a named workflow with nested tasks.

1 from anthropic import Anthropic
2 from respan import Respan, workflow, task
3 from respan_instrumentation_anthropic import AnthropicInstrumentor
4 
5 respan = Respan(instrumentations=[AnthropicInstrumentor()])
6 client = Anthropic()
7 
8 @task(name="generate_outline")
9 def outline(topic: str) -> str:
10     message = client.messages.create(
11         model="claude-sonnet-4-5-20250929",
12         max_tokens=1024,
13         messages=[{"role": "user", "content": f"Create a brief outline about: {topic}"}],
14     )
15     return message.content[0].text
16 
17 @workflow(name="content_pipeline")
18 def pipeline(topic: str):
19     plan = outline(topic)
20     message = client.messages.create(
21         model="claude-sonnet-4-5-20250929",
22         max_tokens=2048,
23         messages=[{"role": "user", "content": f"Write content from this outline: {plan}"}],
24     )
25     print(message.content[0].text)
26 
27 pipeline("Benefits of API gateways")
28 respan.flush()

Examples

Streaming

Stream Claude responses with real-time text deltas.

1 with client.messages.stream(
2     model="claude-sonnet-4-5-20250929",
3     max_tokens=1024,
4     messages=[{"role": "user", "content": "Write a haiku about Python."}],
5 ) as stream:
6     for text in stream.text_stream:
7         print(text, end="", flush=True)

Tool calls

Tool calls are automatically captured as spans with inputs, outputs, and timing.

1 tools = [
2     {
3         "name": "get_weather",
4         "description": "Get the weather for a city.",
5         "input_schema": {
6             "type": "object",
7             "properties": {"city": {"type": "string"}},
8             "required": ["city"],
9         },
10     }
11 ]
12 
13 message = client.messages.create(
14     model="claude-sonnet-4-5-20250929",
15     max_tokens=1024,
16     tools=tools,
17     messages=[{"role": "user", "content": "What's the weather in Paris?"}],
18 )