Claude API Cheat Sheet

1Install, client & authanthropic SDK

pip install anthropic★
Official Python SDK. Also @anthropic-ai/sdk (TS), plus Go/Java/Ruby/C#/PHP.
import anthropic client = anthropic.Anthropic() # reads ANTHROPIC_API_KEY★
The zero-arg client resolves credentials from the environment (ANTHROPIC_API_KEY, or an ant auth login profile) — don't hardcode keys. anthropic.AsyncAnthropic() for asyncio.
export ANTHROPIC_API_KEY="sk-ant-..."
Get a key from console.anthropic.com. The SDK auto-retries 429/5xx/network errors (max_retries=2 default) with backoff.
# Bedrock / Vertex / Foundry: use the platform client class anthropic.AnthropicVertex(project_id="...", region="...")
Same messages.create surface on Amazon Bedrock, Google Vertex AI, and Microsoft Foundry via their dedicated client classes (partner pricing).

2First message & blocksmessages.create

resp = client.messages.create( model="claude-opus-5", max_tokens=16000, messages=[{"role":"user", "content":"What is the capital of France?"}])★
The one call you use everywhere. messages is a list of {"role","content"} (roles user/assistant). max_tokens is required.
for block in resp.content: if block.type == "text": print(block.text)★
resp.content is a list of content blocks (text, thinking, tool_use, ...). Check .type before reading — don't assume content[0].text.
resp.stop_reason · resp.usage.input_tokens / .output_tokens★
stop_reason: end_turn, max_tokens, tool_use, refusal, pause_turn. usage reports billed tokens.
# don't lowball max_tokens — hitting the cap truncates mid-thoughttip
Default ~16000 for non-streaming, ~64000 for streaming; use ~256 only for classification. Hitting the cap gives stop_reason: "max_tokens".

3Models & pricingpick a string

"claude-opus-5" # 1M ctx · $5 / $25 per 1M · the default★
Anthropic's flagship general model — use it unless you have a reason not to. Thinking is on by default.
"claude-sonnet-5" # 1M ctx · $2 / $10 · high-volume workhorse★
Cheaper, still very capable — good for production volume. "claude-haiku-4-5" (200K, $1/$5) for simple, speed-critical tasks.
"claude-fable-5-1" # 1M ctx · $10 / $50 · most capable
The most capable widely-released model for the hardest reasoning/agentic work — different API behavior & higher price than Opus. "claude-opus-4-8" is the prior Opus.
client.models.list() · client.models.retrieve("claude-opus-5")
Live capability lookup: max_input_tokens (context window), max_tokens, capabilities. ⚠️ Model IDs are complete — never append a date suffix.

4System, turns & paramsshape the request

client.messages.create(model=..., max_tokens=16000, system="You are a terse Python expert.", messages=[...])★
The system prompt is a top-level parameter (not a message). Set behavior/persona/format there.
messages = [ {"role":"user", "content":"My name is Alice."}, {"role":"assistant", "content":"Hi Alice!"}, {"role":"user", "content":"What's my name?"}]★
The API is stateless — send the full history each turn. First message must be user; append the model's replies as assistant.
..., temperature=1.0, stop_sequences=["\n\n"]
Standard sampling & stop controls. (Newer thinking models restrict temperature/top_p — leave them default there.)
# assistant prefill returns 400 on current modelschanged
Prefilling the last assistant turn is rejected on Opus 5 / Sonnet 5 / Fable / the 4.6+ family. Use structured outputs or a system instruction to control format instead.

5Streamingfor long output

with client.messages.stream(model="claude-opus-5", max_tokens=64000, messages=[...]) as stream: for text in stream.text_stream: print(text, end="")★
text_stream yields text deltas as they arrive — the chat-UI pattern. Stream anything with long input/output or high max_tokens to avoid HTTP timeouts.
final = stream.get_final_message() # complete Message when done★
Use the helper to get the full assembled response instead of hand-collecting events. (Async: async with client.messages.stream(...).)
for event in stream: if event.type == "content_block_delta": ...
Iterate raw events (message_start, content_block_delta, ...) when you need fine-grained handling.

6Thinking & effortreasoning depth

client.messages.create(model="claude-opus-5", max_tokens=16000, thinking={"type":"adaptive", "display":"summarized"}, output_config={"effort":"high"}, messages=[...])★
Adaptive thinking lets Claude decide when/how much to reason. On Opus 5 it's on by default. display:"summarized" streams a readable summary (default is empty thinking text).
output_config={"effort": "low"|"medium"|"high"|"xhigh"|"max"}★
Effort (inside output_config, default high) trades thoroughness for token spend. xhigh is the sweet spot for coding/agentic work; low for simple/high-volume routes.
for b in resp.content: if b.type == "thinking": print(b.thinking)
Read thinking blocks when displayed. Echo them back unchanged when continuing on the same model.
# budget_tokens is removed on current models (400 if sent)changed
The old fixed thinking-budget is gone on Opus 5 / Sonnet 5 / Fable / 4.7-4.8 — use adaptive thinking + effort. (budget_tokens lingers only on Haiku 4.5 / older models.)

7Prompt cachingup to ~90% off

client.messages.create(..., cache_control={"type":"ephemeral"}, system=large_document, messages=[...])★
Top-level cache_control auto-caches the last cacheable block. Reuse a big system prompt/context across requests: first call full price, later calls ~90% cheaper for the cached prefix.
system=[{"type":"text", "text": doc, "cache_control":{"type":"ephemeral", "ttl":"1h"}}]
Fine-grained: mark specific blocks (default TTL 5 min, or "1h"). Order is tools → system → messages; keep stable content first.
resp.usage.cache_read_input_tokens # >0 means a cache hit★
Verify hits. If it's zero across identical-prefix requests, a silent invalidator is at work: datetime.now() in the prompt, unsorted json.dumps, or a varying tool set.
# any byte change in the prefix invalidates everything after itgotcha
Caching is a prefix match. Put volatile content (timestamps, IDs, the question) after the cached prefix.

8Batches & token countingoffline & estimates

batch = client.messages.batches.create(requests=[ {"custom_id":"a", "params":{...}}, ...])★
Message Batches run asynchronously at 50% cost — ideal for bulk, non-latency-sensitive jobs.
while client.messages.batches.retrieve(batch.id).processing_status != "ended": sleep(30) for r in client.messages.batches.results(batch.id): ...
Poll to ended, then stream results. ⚠️ Results arrive in any order — key by custom_id, not position.
n = client.messages.count_tokens(model="claude-opus-5", system=system, messages=messages).input_tokens★
Count tokens before sending (don't use tiktoken — it's a different tokenizer). Multiply by the input rate to estimate cost.

9Tool usefunction calling

tools = [{"name":"get_weather", "description":"...", "input_schema":{"type":"object", "properties":{...}, "required":[...]}}] resp = client.messages.create(..., tools=tools)★
Define tools with a JSON Schema. When stop_reason == "tool_use", read the tool_use block, run your function, and send the result back as a tool_result in a new user message — loop until end_turn.
from anthropic import beta_tool @beta_tool def get_weather(city: str) -> str: return f"sunny in {city}" runner = client.beta.messages.tool_runner(model="claude-opus-5", max_tokens=16000, tools=[get_weather], messages=[...])★
The Tool Runner drives the whole call→execute→loop cycle for you — you just write the tool functions (@beta_tool). runner.until_done() for the final message.
{"name":"...", ..., "strict": True} # schema-valid arguments
strict: true (schema needs additionalProperties: false + required) guarantees tool inputs validate. Always json.loads tool inputs — never string-match.
# parallel tool_use blocks -> return ALL tool_results in ONE user msggotcha
Splitting parallel results across messages silently trains Claude to stop making parallel calls. Return a failed tool as tool_result with is_error: true.

10Structured output & visiontyped JSON & images

from pydantic import BaseModel class Person(BaseModel): name: str; age: int msg = client.messages.parse(model="claude-opus-5", max_tokens=1024, messages=[...], output_config={"format": Person})★
messages.parse() validates the response against your schema and returns typed data. (Under the hood: output_config: {format: {...}} — the old output_format is deprecated.)
{"role":"user", "content":[ {"type":"image", "source":{"type":"url", "url":"https://.../x.png"}}, {"type":"text", "text":"What's in this image?"}]}★
Vision: put image blocks (url or base64) before the text. PDFs go in as {"type":"document", ...}.
# upload once, reuse: client.files.upload(...) -> file_id
The Files API lets you upload a PDF/image once and reference it by file_id across requests.

11Server toolsAnthropic-hosted

tools=[{"type":"web_search_20260209", "name":"web_search", "max_uses":5}]★
Web search runs on Anthropic's side — results come back as content blocks in the same response, no client loop. allowed_domains/blocked_domains to scope it.
tools=[{"type":"code_execution_20260521", "name":"code_execution"}]
Code execution: Claude writes & runs Python in a sandbox (data analysis, generating .xlsx/charts via Agent Skills). Fully server-side.
# server-tool errors return HTTP 200, not an exceptiongotcha
A failed web search returns a result block whose content is an error object (e.g. {error_code: ...}) — a success content is a list. Branch on that.

12Errors & ecosystemrobustness & surfaces

try: ... except anthropic.RateLimitError as e: retry_after = e.response.headers.get("retry-after") except anthropic.APIStatusError as e: ...★
Catch typed exceptions most-specific-first (BadRequestError, AuthenticationError, NotFoundError, RateLimitError, APIStatusError, APIConnectionError) — not one broad class.
# the Anthropic platform, beyond the raw API:
Claude Code (agentic CLI/IDE coding), the Claude Agent SDK (claude-agent-sdk — Claude Code as a library), Managed Agents (server-hosted stateful agents), and MCP (connect tools/data).
# MCP connector: mcp_servers=[...] + a mcp_toolset tool (beta)
Connect external MCP servers so Claude can use their tools/resources in a request.
# prefer this SDK over OpenAI-compatible shims for Claude
Use the official Anthropic SDK (or raw HTTP to /v1/messages) — not an OpenAI-compat layer — to get thinking, tools, caching & structured output right.

Claude API cheat sheet

Outline

Setup & models

Core requests

Cost & tools

Server tools & ecosystem

Setup & Models

Core Requests

Cost & Tools

Server Tools & Ecosystem

Worth memorizing