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 — don't hardcode keys. anthropic.AsyncAnthropic() for asyncio. Auto-retries 429/5xx (max_retries=2).
export ANTHROPIC_API_KEY="sk-ant-..."
Get a key from console.anthropic.com. Same messages.create surface on AnthropicBedrock, AnthropicVertex & Foundry client classes (partner pricing).

2First message & blocksmessages.create

resp = client.messages.create( model="claude-opus-5", max_tokens=16000, messages=[{"role":"user", "content":"Capital of France?"}])★
The one call you use everywhere. messages is a list of {"role","content"}; 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 — don't assume content[0].text.
resp.stop_reason · resp.usage.input_tokens / .output_tokens★
stop_reason: end_turn, max_tokens, tool_use, pause_turn, refusal. usage reports billed tokens.
# don't lowball max_tokens — hitting the cap truncates mid-thoughttip
Model max output is 128K (Opus/Sonnet 5) / 64K (Haiku 4.5). 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. Adaptive thinking on by default. 128K max output.
"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. "claude-opus-4-8" is the prior Opus ($5/$25).
m = client.models.retrieve("claude-opus-5"); m.max_input_tokens [x for x in client.models.list() if x.capabilities["thinking"]...]
Query live capabilities (context window, vision, thinking, effort, structured outputs) instead of hardcoding. ⚠️ Model IDs are complete — never append a date suffix.

4System, turns & paramsshape the request

client.messages.create(..., 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. (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 — 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.)
for event in stream: if event.type == "content_block_delta": ...
Iterate raw events (message_start, content_block_delta incl. input_json_delta for streaming tool args) for fine-grained handling.

6Thinking & effortreasoning depth

client.messages.create(..., thinking={"type":"adaptive", "display":"summarized"}, output_config={"effort":"high"}, messages=[...])★
Adaptive thinking lets Claude decide when/how much to reason (on by default on Opus 5). display:"summarized" streams a readable summary.
output_config={"effort": "low"|"medium"|"high"|"xhigh"|"max"}★
Effort (default high) trades thoroughness for token spend. xhigh for coding/agentic; low for simple/high-volume routes.
# 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. Echo thinking blocks back unchanged when continuing on the same model.

7Prompt cachingup to ~90% off

client.messages.create(..., cache_control={"type":"ephemeral"}, system=large_document, messages=[...])★
Auto-caches the last cacheable block. Reuse a big system prompt/context: 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. Zero across identical-prefix requests means a silent invalidator: datetime.now() in the prompt, unsorted json.dumps, or a varying tool set.
# caching is a PREFIX match — put volatile content lastgotcha
Any byte change in the prefix invalidates everything after it. Put 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.
for r in client.messages.batches.results(batch.id): ... # when ended
Poll batches.retrieve(id).processing_status 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 — wrong tokenizer). Multiply by the input rate to estimate cost.

9Context managementlong agent runs

# 1M-token window on Opus/Sonnet 5; 200K on Haiku 4.5★
Long context lets you inline whole codebases/docs. Watch cost: every token in the window is billed each turn — pair with prompt caching.
m.capabilities["context_management"]["compact_20260112"]["supported"]2026
Context compaction summarizes earlier turns automatically so a long agent loop stays under the window — a model capability you can check via the Models API and enable per the docs.
# context editing: auto-clear stale tool_results to reclaim tokens
Context editing drops old tool results/turns mid-run so a tool-heavy agent doesn't blow the budget. Pairs with the memory tool (card 11) to persist what matters. Confirm the current beta header in the docs.

10Tool use & Tool Runnerfunction calling

tools = [{"name":"get_weather", "description":"...", "input_schema":{"type":"object", "properties":{...}, "required":[...]}}] resp = client.messages.create(..., tools=tools)★
Define tools with JSON Schema. When stop_reason == "tool_use", run your function and send a tool_result back 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 (beta) drives the whole call→execute→loop cycle — you just write the tool functions. for message in runner: to iterate.
{"name":"...", ..., "strict": True} # schema-valid arguments
strict: true (needs additionalProperties: false + required) guarantees tool inputs validate. Always json.loads tool inputs.
# parallel tool_use blocks -> return ALL tool_results in ONE user msggotcha
Splitting parallel results trains Claude to stop making parallel calls. Return a failed tool as tool_result with is_error: true. The Python runner won't auto-resume pause_turn — handle it.

11Anthropic client toolsmemory · bash · editor

tools=[{"type":"memory_20250818", "name":"memory"}]★memory
The memory tool lets Claude store/recall info across turns in files you control. Anthropic defines the schema; your app executes the ops (return a tool_result). Subclass BetaAbstractMemoryTool to plug it into the Tool Runner.
# Anthropic-schema client tools (you run them, Claude is trained on them): # bash · text_editor · computer use · browser use★
bash (persistent shell), text editor (view/edit files), computer use (screenshot + mouse/keyboard), browser use. Add the tool by its dated type — the string is model-specific, so copy it from the Tool reference.
# these are CLIENT tools — your code executes them, in YOUR sandboxnote
Unlike server tools (card 12), Anthropic only supplies the schema — you implement the shell/editor/desktop and return results. Sandbox computer/bash use carefully.

12Server toolsAnthropic-hosted

tools=[{"type":"web_search_20260209", "name":"web_search", "max_uses":5}]★
Web search runs on Anthropic's side — results (with citations) come back as content blocks in the same response, no client loop. allowed_domains/blocked_domains to scope. web_fetch_20260209 retrieves a page/PDF.
tools=[{"type":"code_execution_20260120", "name":"code_execution"}]★
Code execution: Claude writes & runs Python/bash in a sandbox (data analysis, generating .xlsx/charts). Feed inputs via container_upload (file_id); reuse the sandbox with container=<id>. Also advisor & tool search tools.
# server-tool errors return HTTP 200, not an exceptiongotcha
A failed server tool returns a result block whose content is an error object — branch on it. A long server-tool turn can end with stop_reason: "pause_turn"; re-send to continue.

13MCP connector & Skillsconnect & extend

client.messages.create(..., mcp_servers=[ {"type":"url", "url":"https://mcp.example.com", "name":"docs"}])★MCP
The MCP connector lets Claude use a remote MCP server's tools straight from a Messages request — no separate MCP client. (Beta — confirm the current beta header.)
from anthropic.lib.tools.mcp import mcp_tool # local MCP -> Tool Runner
For local MCP servers, convert their tools/prompts/resources with the SDK helpers (mcp_tool/async_mcp_tool, mcp_message) and pass them to the Tool Runner. Needs pip install anthropic[mcp].
client.skills # Agent Skills — packaged instructions + code, run via code execution
Skills (out of beta) bundle instructions/scripts Claude loads on demand — e.g. produce .docx/.pptx/.xlsx through the code-execution sandbox.

14Files, documents & citationsFiles API

up = client.files.upload(file=("report.pdf", open("report.pdf","rb"), "application/pdf")) up.id # reference by file_id across many requests★files
The Files API (out of beta) uploads a PDF/image/data file once (up to 500 MB) and references it by file_id — no re-upload per call. files.list/retrieve_metadata/delete/download.
{"type":"document", "source":{"type":"file", "file_id": up.id}, "citations":{"enabled": True}}★
Put a document block (from a file_id, base64, or url) in the user content. With citations.enabled, replies carry cited spans pointing back to the source — grounded, verifiable answers.
{"type":"image", "source":{"type":"file", "file_id": img.id}}
Vision takes images the same way (or inline base64/url). ⚠️ Only files created by code execution/Skills can be downloaded back; user uploads can't.

15Structured output & visiontyped JSON

from pydantic import BaseModel class Person(BaseModel): name: str; age: int msg = client.messages.parse(model="claude-opus-5", max_tokens=1024, messages=[...], output_format=Person) msg.parsed_output # a validated Person★
messages.parse() validates the response against your schema and returns typed data via parsed_output. Pass a Pydantic model as output_format.
output_config={"format":{"type":"json_schema", "schema":{...}}}★
Raw form on messages.create — guarantees the first block is JSON matching your schema (additionalProperties:false + required). Combine with strict tools for validated tool args too.
# the old top-level output_format on create() is deprecated -> output_config
On create() use output_config.format; output_format= is the parse() convenience. Don't mix them up.

16Errors & robustnesshandle failure

try: ... except anthropic.RateLimitError as e: 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 SDK auto-retries 429/5xx/network with backoff (max_retries=2)
Bump anthropic.Anthropic(max_retries=5) or set per-request timeout. Honor retry-after on rate limits.
# stop_reason == "refusal" -> Claude declined; don't retry blindly
Handle refusal and pause_turn explicitly. Log usage for cost/observability.

17The Claude ecosystembeyond the API

# Claude Code — agentic coding in the terminal/IDE★
Anthropic's coding agent; also embeddable as the Claude Agent SDK (claude-agent-sdk / @anthropic-ai/claude-agent-sdk) — Claude Code as a library with built-in file/bash/search tools.
# Managed Agents — Anthropic runs the loop + hosts the tool sandbox
Server-hosted, stateful agents with a per-session workspace, Skills & MCP — no loop code to own. Use when you want Anthropic to run and host the agent.
# prefer the official SDK over OpenAI-compat shims for Claude
Use the Anthropic SDK (or raw HTTP to /v1/messages) to get thinking, tools, caching, files & structured output right. MCP connects external tools/data.

Claude API cheat sheet

Outline

Setup & core

Cost, context & tools

Files, output & ecosystem

Setup & Core Requests

Cost & Context

Tools

Files, Output & Ecosystem

Worth memorizing