Claude’s API is designed to be both powerful and modular. Whether you’re building a simple chatbot or a complex agent that browses the web and runs code, understanding the five core areas of the API surface will help you get the most out of Claude. This guide covers each area with practical code examples and best practices.

1. Model Capabilities: Steering Claude’s Reasoning and Outputs

Model capabilities let you control how Claude thinks and what it returns. Key features include:

• Extended Thinking – Claude can reason step-by-step before responding. Use the thinking parameter to enable it.
• Adaptive Thinking – Let Claude decide when and how much to think. Recommended for Opus 4.7. Use the effort parameter to control depth.
• Structured Outputs – Force Claude to return JSON or follow a specific schema.
• Citations – Ground responses in source documents with exact sentence references.
• Streaming – Receive tokens as they’re generated for lower latency.
• Batch Processing – Send large volumes of requests asynchronously at 50% lower cost.

Example: Enabling Extended Thinking with Structured Output

import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    thinking={"type": "enabled", "budget_tokens": 2048},
    messages=[
        {"role": "user", "content": "Solve this step by step: 23 * 47"}
    ]
)
print(response.content[0].text)

Batch Processing for Cost Savings

Batch API calls cost 50% less than standard calls. Here’s how to submit a batch:

import anthropic
client = anthropic.Anthropic()
batch = client.batches.create(
    requests=[
        {
            "custom_id": "req-001",
            "params": {
                "model": "claude-sonnet-4-20250514",
                "max_tokens": 1024,
                "messages": [{"role": "user", "content": "Summarize this article."}]
            }
        },
        {
            "custom_id": "req-002",
            "params": {
                "model": "claude-sonnet-4-20250514",
                "max_tokens": 1024,
                "messages": [{"role": "user", "content": "Translate to French."}]
            }
        }
    ]
)
print(f"Batch submitted: {batch.id}")

2. Tools: Let Claude Take Actions

Tools extend Claude’s capabilities beyond text generation. Claude can call functions, browse the web, execute code, and even control a computer.

Built-in Tools

• Web Search Tool – Search the internet in real time.
• Web Fetch Tool – Retrieve content from a specific URL.
• Code Execution Tool – Run Python or JavaScript in a sandbox.
• Computer Use Tool – Control a virtual desktop environment.
• Memory Tool – Store and recall information across sessions.
• Bash Tool – Execute shell commands.
• Text Editor Tool – Read, write, and edit files.

Example: Using the Web Search Tool

import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=[
        {
            "type": "web_search",
            "name": "web_search",
            "description": "Search the web for current information."
        }
    ],
    messages=[
        {"role": "user", "content": "What is the latest news on AI regulation?"}
    ]
)
print(response.content[0].text)

Parallel Tool Use

Claude can call multiple tools in a single turn. This is useful for gathering data from multiple sources simultaneously.

tools = [
    {
        "type": "web_search",
        "name": "web_search",
        "description": "Search the web."
    },
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string"}
                },
                "required": ["city"]
            }
        }
    }
]
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=[
        {"role": "user", "content": "What's the weather in Paris and any recent news?"}
    ]
)

3. Tool Infrastructure: Discovery and Orchestration at Scale

When you have many tools, managing them becomes critical. Claude’s tool infrastructure includes:

• Tool Runner (SDK) – Automatically invoke tool calls.
• Strict Tool Use – Force Claude to use a specific tool.
• Fine-grained Tool Streaming – Stream tool calls and results.
• Tool Search – Dynamically select the best tool for a task.
• MCP (Model Context Protocol) – Connect to remote MCP servers for standardized tool access.

Example: Using Tool Runner

from anthropic import Anthropic
from anthropic.types import ToolUseBlock
client = Anthropic()
def get_weather(city: str) -> str:
    return f"The weather in {city} is sunny, 22°C."
tools = [
    {
        "name": "get_weather",
        "description": "Get weather for a city.",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string"}
            },
            "required": ["city"]
        }
    }
]
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}]
)
Tool Runner automatically handles the call
for block in response.content:
    if isinstance(block, ToolUseBlock):
        if block.name == "get_weather":
            result = get_weather(**block.input)
            print(result)

4. Context Management: Keeping Long Sessions Efficient

Claude supports up to 1M tokens of context. To keep long-running sessions efficient, use:

• Context Windows – Manage large documents and conversations.
• Compaction – Summarize or prune old context to stay within limits.
• Prompt Caching – Cache repeated system prompts or large documents to reduce cost and latency.
• Token Counting – Estimate token usage before sending a request.

Example: Prompt Caching

import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "You are a helpful assistant with knowledge of the entire codebase.",
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[
        {"role": "user", "content": "Explain the authentication flow."}
    ]
)
print(f"Cache created: {response.cache_creation_input_tokens} tokens cached")

5. Files and Assets: Managing Documents and Data

Claude can process PDFs, images, and other files. Use the Files API to upload and reference documents.

PDF Support

import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "document",
                    "source": {
                        "type": "base64",
                        "media_type": "application/pdf",
                        "data": "<base64_encoded_pdf>"
                    }
                },
                {
                    "type": "text",
                    "text": "Summarize this document."
                }
            ]
        }
    ]
)
print(response.content[0].text)

Images and Vision

Claude can analyze images. Pass them as base64 or via URL.

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/jpeg",
                        "data": "<base64_encoded_image>"
                    }
                },
                {
                    "type": "text",
                    "text": "Describe this image in detail."
                }
            ]
        }
    ]
)

Best Practices for Production

• Start with model capabilities and tools – These are the building blocks for most applications.
• Use batch processing for high-volume tasks – Save 50% on API costs.
• Leverage prompt caching – Cache large system prompts or reference documents to reduce latency and cost.
• Monitor token usage – Use the token counting endpoint to estimate costs before sending requests.
• Handle tool calls gracefully – Implement proper error handling and retries for tool invocations.

Key Takeaways

• Claude’s API is organized into five areas: model capabilities, tools, tool infrastructure, context management, and files.
• Extended thinking, structured outputs, and citations give you fine-grained control over Claude’s responses.
• Built-in tools like web search, code execution, and computer use let Claude take real-world actions.
• Batch processing cuts costs by 50%, and prompt caching reduces latency for repeated contexts.
• Always check the feature availability table (GA vs. Beta) before using a feature in production.