Claude Agent SDK Pricing: Anthropic Agent API Cost Explained

Anthropic bills agents the same way it bills everything else: per input token and per output token on the Messages API, at $5 in / $25 out per 1M tokens for Claude Opus 5, $2 / $10 for Claude Sonnet 5 and $1 / $5 for Claude Haiku 4.5. Tool definitions, tool results and the assistant's tool calls are all ordinary tokens. The Claude Agent SDK, which wraps the Claude Code harness as a library, adds no licence fee; it makes the same API calls with prompt caching applied to its stable prefix.

On a 12-step agent run with a 4,000-token system prompt and tool set, 1,500-token tool results and 300 output tokens per step (166,800 input tokens, 3,600 output tokens in total), the uncached cost is:

Sonnet 4.6 costs 50% more than Sonnet 5 for the same tier; do not start a new agent on it. Prices are from our catalogue as of 2026-09-11; live rows are on the models page and the Claude pricing page.

A Claude agent turn is client.messages.create with tools=[...]. Claude replies with stop_reason: "tool_use" and one or more tool_use blocks; you execute them, append a user message of tool_result blocks, and call again. The request renders as tools, then system, then messages, and all of it is billed on every call.

For the Sonnet 5 12-step trace: 166,800 input tokens × $2 ÷ 1,000,000 = $0.3336, plus 3,600 output tokens × $10 ÷ 1,000,000 = $0.036, total $0.3696. Input is 90% of the bill, and almost all of it is context sent one step earlier. Doubling every assistant turn to 600 tokens adds only $0.036.

Two Anthropic-specific details change the numbers. Adaptive thinking is on by default on Opus 5 and Sonnet 5 and bills as output, so set output_config.effort to low or medium on worker agents. Server-side tools such as web search bill their fetched content as input on top of any per-use charge listed on the vendor page.

Anthropic's prompt caching charges roughly 10% of the list input rate for cache reads and roughly 125% for the initial cache write. These are approximate multipliers rather than catalogue rows, but in an agent loop most of each request is a prefix you already sent, so the saving is large.

Mark the end of the stable prefix with cache_control: {"type": "ephemeral"}: the last tool definition (tools render first) and the system prompt, and optionally the most recent tool result so the conversation itself is cached step to step. The default cache lifetime is five minutes, extendable with ttl: "1h" for agents that wait on slow tools.

import anthropic

client = anthropic.Anthropic()
tools = [{
    "name": "search_orders",
    "description": "Find orders by customer email",
    "input_schema": {"type": "object", "properties": {"email": {"type": "string"}},
                     "required": ["email"], "additionalProperties": False},
    "strict": True,
    "cache_control": {"type": "ephemeral"},  # cache the tools prefix
}]
response = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=2000,
    output_config={"effort": "medium"},
    system=[{"type": "text", "text": SYSTEM_PROMPT,
             "cache_control": {"type": "ephemeral"}}],
    tools=tools,
    messages=history,
)
u = response.usage
# Sonnet 5: uncached in $2, cache write ~$2.50, cache read ~$0.20, out $10 per 1M
cost = (u.input_tokens * 2 + u.cache_creation_input_tokens * 2.5
        + u.cache_read_input_tokens * 0.2 + u.output_tokens * 10) / 1_000_000

On the 12-step Sonnet 5 trace the cached total is roughly $0.12 against $0.37 uncached, and on a 30-step run roughly $0.40 against $1.90. If cache_read_input_tokens is zero on step two, something in your prefix is changing between calls. See the prompt caching cost comparison for the per-provider rules.

Per run, Opus 5 costs 2.5× Sonnet 5 and 5× Haiku 4.5 at the same step count. The question is whether the dearer model finishes in fewer steps or fails less often, because both change cost per successful task more than the per-token rate does.

The cheapest model that still does this reliably: Haiku 4.5 at $0.185 per 12-step run (about $0.06 cached) for well-specified tool work with strict schemas: enrichment, lookups, classify-and-act loops, subagents that read files and report back. It follows strict: true schemas well; note it lacks the effort parameter and uses budget_tokens for extended thinking.

When to pay for Sonnet 5: as the default for anything a person reviews afterwards. At $0.37 per run uncached it is the price-performance anchor of the range, with 1M context, adaptive thinking and effort control.

When to pay for Opus 5: as the planner in a multi-agent setup, for long-horizon coding where a wrong plan wastes dozens of steps, and where one failure costs more than the $0.55 premium per run. Opus 5 also supports mid-conversation system messages, which steer a running agent without breaking the cached prefix. The lowest cost per finished task in practice is Opus 5 planning, Sonnet 5 or Haiku 4.5 executing, all sharing one cached tool prefix. The cheapest LLM for AI agents guide ranks these against other vendors.

The Message Batches API processes requests asynchronously within 24 hours at roughly 50% of list; batch rows exist in our catalogue for the Anthropic models at that discount. It cannot drive a live loop, where each step depends on the previous result, but it suits the fan-out half of agent work: scoring 5,000 tickets, or running the same 5-step agent over a backlog overnight.

from anthropic.types.message_create_params import MessageCreateParamsNonStreaming
from anthropic.types.messages.batch_create_params import Request

batch = client.messages.batches.create(requests=[
    Request(custom_id=f"ticket-{t.id}",
            params=MessageCreateParamsNonStreaming(
                model="claude-haiku-4-5", max_tokens=1000,
                system=SYSTEM_PROMPT, tools=tools,
                messages=[{"role": "user", "content": t.text}]))
    for t in tickets
])
# Haiku 4.5 batch: ~$0.50 in / ~$2.50 out per 1M instead of $1 / $5

Batch and caching stack: a 5-step Haiku 4.5 agent over 10,000 items costs $455 at list and about $228 in a batch. See LLM batch API pricing for the other vendors' tiers.

Claude Code is included in Claude Pro ($20/month) and Claude Max (from $100/month); used any other way it bills at API rates. The subscription buys a usage allowance rather than a token meter, so the comparison is: how many agent runs would the same money buy on the API?

If a person is driving Claude Code interactively for coding, the subscription almost always wins: interactive sessions are long, context-heavy and cached, and the allowance absorbs them. Pro suits a developer running a handful of sessions a day; Max suits someone who lives in it. Our is Claude Code worth it review has the usage profiles.

The API wins when the agent runs unattended, in parallel, or inside a product. Allowances are per person and rate-limited, so they cannot back a service running 500 agent jobs an hour, and they do not cover the Claude Agent SDK in production. Under roughly 50 Sonnet-class runs a month for one person, buy Pro; above a few hundred unattended runs, use the API with caching and Haiku 4.5 for routine steps.

Four controls, applied together:

• max_tokens per call: 1,000 to 4,000 for tool-calling turns. This bounds a single turn, not the loop.
• A hard step cap: break after N tool_use responses. Fifteen is generous for most task types.
• Stop conditions: end on stop_reason == "end_turn", on two identical consecutive tool calls, or on a finish tool the agent must call to declare completion.
• A per-run USD budget computed from response.usage after every call, using the arithmetic in the snippet above. Abort past your ceiling and log the total per task to track cost per successful task.

At Sonnet 5 rates a $0.50 per-run budget permits about 14 uncached reference steps or roughly 35 cached. Opus 5 and Sonnet 5 also support an advisory task_budget (beta); treat it as a complement to a hard client-side cap. The AI cost calculator turns a monthly run count into a budget line.

What it costs: $0.18 to $0.92 per 12-step run across the Claude range before caching, roughly $0.06 to $0.31 after. Who should pay API rates: teams running agents unattended, in parallel, or in a product. Who should not: an individual developer using Claude Code interactively, for whom Pro at $20 or Max from $100 is cheaper than any realistic API bill. Cheapest way to get the result: Sonnet 5 as default, Haiku 4.5 for schema-bound worker steps, Opus 5 only as planner, cache_control on tools and system, batches for fan-out. The OpenAI Agents SDK cost and Gemini agent API cost guides cover the other vendors.