Anthropic

The SDK wraps an Anthropic or AsyncAnthropic client in place and instruments the messages surface:

client.messages.create(...), non-streaming and stream=True
client.messages.stream(...), the context-manager helper
the async equivalents on AsyncAnthropic

Anthropic is the provider with the richest cache reporting, so it is the one where the cache-specific metrics matter most.

Install

pip install 'lago-agent-sdk[anthropic]'

npm install lago-agent-sdk @anthropic-ai/sdk

Wrap and call

from anthropic import Anthropic
from lago_agent_sdk import LagoSDK

sdk = LagoSDK(
    api_key="<YOUR_LAGO_API_KEY>",
    default_subscription_id="sub_acme",
)
client = sdk.wrap(Anthropic(api_key="<YOUR_ANTHROPIC_API_KEY>"))

resp = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=200,
    messages=[{"role": "user", "content": "Hello"}],
)
sdk.flush()

import Anthropic from "@anthropic-ai/sdk";
import { LagoSDK } from "lago-agent-sdk";

const sdk = new LagoSDK({
  apiKey: process.env.LAGO_API_KEY!,
  defaultSubscriptionId: "sub_acme",
});
const client = sdk.wrap(new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY! }));

await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 200,
  messages: [{ role: "user", content: "Hello" }],
});
await sdk.flush();

Streaming

Both streaming styles are instrumented. Usage is captured from the final message_delta event, which is where Anthropic reports the completed token counts.

# Style 1: stream=True on create()
stream = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=200,
    messages=[{"role": "user", "content": "Hello"}],
    stream=True,
)
for event in stream:
    ...

# Style 2: the context-manager helper
with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=200,
    messages=[{"role": "user", "content": "Hello"}],
) as stream:
    for text in stream.text_stream:
        ...

// Style 1: stream: true on create()
const stream = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 200,
  messages: [{ role: "user", content: "Hello" }],
  stream: true,
});
for await (const event of stream) {
  // ...
}

// Style 2: the stream() helper
const s = client.messages.stream({
  model: "claude-sonnet-4-6",
  max_tokens: 200,
  messages: [{ role: "user", content: "Hello" }],
});
await s.finalMessage();

Async

Wrap AsyncAnthropic the same way. The SDK detects the async client and instruments create and stream with async wrappers.

Python

from anthropic import AsyncAnthropic

client = sdk.wrap(AsyncAnthropic(api_key="..."))

resp = await client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=200,
    messages=[{"role": "user", "content": "Hello"}],
)

Per-call override

client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=200,
    messages=[{"role": "user", "content": "Hello"}],
    extra_lago={
        "subscription": "sub_acme",
        "dimensions": {"feature": "summarize"},
        "mode": "price",     # optional
        "markup": 1.5,       # optional
    },
)

await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 200,
  messages: [{ role: "user", content: "Hello" }],
  lago: {
    subscription: "sub_acme",
    dimensions: { feature: "summarize" },
    mode: "price",   // optional
    markup: 1.5,     // optional
  },
} as any);

The wrapper strips extra_lago / lago before forwarding, so Anthropic’s strict request validation never sees it.

What gets captured

Canonical field	Anthropic source
`input`	`usage.input_tokens`
`output`	`usage.output_tokens`
`cache_read`	`usage.cache_read_input_tokens`
`cache_write`	`usage.cache_creation_input_tokens`
`cache_write_5m`	`usage.cache_creation.ephemeral_5m_input_tokens`
`cache_write_1h`	`usage.cache_creation.ephemeral_1h_input_tokens`
`tool_calls`	count of `content[]` blocks with `type == "tool_use"`

Reasoning tokens are not exposed. Anthropic folds extended-thinking tokens into output_tokens. Billing on llm_output_tokens already captures thinking. llm_reasoning_tokens stays at zero and no event is emitted for it.

Anthropic’s cache tokens are additive, not a subset. input_tokens counts only the tokens that were not served from cache or written to it. Your true prompt total is llm_input_tokens + llm_cached_input_tokens + llm_cache_creation_tokens.A real cached response makes this unmistakable: input_tokens: 13 alongside cache_read_input_tokens: 2803. Billing llm_input_tokens alone would charge that call for 13 tokens instead of 2,816.This is the opposite of OpenAI, Gemini and Mistral, where the cached tokens are already inside the prompt count. See Bill in tokens for a setup that keeps the two rules apart.

Cache writes are the interesting part. Anthropic prices cache creation above normal input and cache reads well below it, and the SDK gives you all three counts separately. That lets you mirror Anthropic’s own rate structure directly: charge llm_cache_creation_tokens at a premium, llm_cached_input_tokens at a discount, and llm_input_tokens at the standard rate — each on its own count, no subtraction needed.The 5-minute and 1-hour TTL splits are reported separately because Anthropic prices them differently.

Unrecognized usage fields (service_tier, inference_geo, server_tool_use) land in CanonicalUsage.extras so provider drift is visible instead of silently dropped.

Pricing

In price mode, native Anthropic clients are priced from OpenRouter’s public model list, per token, refreshed hourly on the background thread.

Claude models accessed through Bedrock are priced from AWS’s bulk price list instead, which currently omits the newest Claude models. If you need dollar-cost billing for Claude and you are on Bedrock, see the Bedrock page.

What is and isn’t instrumented

wrap() patches exactly two methods — messages.create and messages.stream — on both the sync Anthropic and async AsyncAnthropic clients. Everything else on the client passes through unmetered, and each of these is billable:

Surface	Why it is missed
`messages.parse`	Issues its own request rather than calling `create`, so the patch never sees it
`messages.batches.create`	A separate resource, not patched
`client.beta.messages.create`	`beta.messages` is a distinct object from `client.messages`
`client.completions.create`	The legacy Text Completions API

messages.parse is the easy one to miss. It looks like a create variant and returns the same usage, but it is not instrumented — a workload built on structured outputs would bill nothing.

If you use any of these, build a CanonicalUsage yourself and pass it to sdk.emit().

Introduction

Get started

Events & Usage Components

Pricing & Subscriptions

Invoicing

Payments & Cash Collection

AI Agents and MCP

Data & Analytics

Resources

Install

Wrap and call

Streaming

Async

Per-call override

What gets captured

Pricing

What is and isn’t instrumented

Next steps

Configuration reference

Charges with filters

​Install

​Wrap and call

​Streaming

​Async

​Per-call override

​What gets captured

​Pricing

​What is and isn’t instrumented

​Next steps

Configuration reference

Charges with filters

Install

Wrap and call

Streaming

Async

Per-call override

What gets captured

Pricing

What is and isn’t instrumented

Next steps