Introduction

Claude's API is a powerful, flexible platform for building AI-powered applications. Whether you're creating a chatbot, a code assistant, or an automated research tool, understanding the API's core areas is essential. This guide covers the five main pillars of the Claude API: model capabilities, tools, tool infrastructure, context management, and files/assets. We'll also explore feature availability, practical code examples, and best practices to help you ship faster and smarter.

Understanding Feature Availability

Before diving into code, it's important to know the lifecycle of Claude API features. Features are classified into four stages:

• Beta: Preview features for gathering feedback. May change significantly. Not guaranteed for production. Often requires sign-up or a waitlist.
• Generally Available (GA): Stable, fully supported, and recommended for production use. Covered by standard API versioning.
• Deprecated: Still functional but no longer recommended. A migration path is provided.
• Retired: No longer available.

Platform labels include: Claude API (Anthropic first-party), Claude Platform on AWS, Bedrock (AWS-operated), Vertex AI (Google-operated), and Microsoft Foundry (Anthropic-operated on Azure). Always check the documentation for the specific platform you're using.

1. Model Capabilities: Steering Claude's Output

Model capabilities control how Claude reasons and formats responses. Key features include:

• Context Windows: Up to 1 million tokens for processing large documents, code bases, or conversations.
• Extended Thinking: Use the thinking parameter to let Claude reason step-by-step before answering. This is especially useful for complex math, logic, or multi-step tasks.
• Adaptive Thinking: Let Claude dynamically 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 responses in a specific JSON schema. Perfect for building reliable data pipelines.
• Citations: Ground Claude's responses in source documents with detailed references.
• Streaming: Receive responses token-by-token for real-time user experiences.
• Batch Processing: Send large volumes of requests asynchronously at 50% lower cost.

Example: Using Extended Thinking with Structured Output

import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-opus-4-20250514",
    max_tokens=1024,
    thinking={"type": "enabled", "budget_tokens": 2048},
    messages=[
        {"role": "user", "content": "Solve this step by step: If a train leaves Station A at 60 mph and another leaves Station B at 80 mph, 200 miles apart, when do they meet?"}
    ]
)
print(response.content[0].text)

2. Tools: Let Claude Take Action

Tools allow Claude to interact with the outside world—fetching web pages, running code, or calling your own APIs. The API supports:

• Web Search Tool: Let Claude search the internet for up-to-date information.
• Web Fetch Tool: Fetch and read the content of a specific URL.
• Code Execution Tool: Run Python or JavaScript code in a sandboxed environment.
• Computer Use Tool: Control a virtual desktop (useful for automation).
• Memory Tool: Store and retrieve information across conversations.
• Bash Tool: Execute shell commands.
• Text Editor Tool: Read, write, and edit files.
• Advisor Tool: A meta-tool that helps Claude decide which tool to use.

Example: Building a Tool-Using Agent

import anthropic
client = anthropic.Anthropic()
Define a simple calculator tool
tools = [
    {
        "name": "calculator",
        "description": "Perform basic arithmetic operations",
        "input_schema": {
            "type": "object",
            "properties": {
                "operation": {"type": "string", "enum": ["add", "subtract", "multiply", "divide"]},
                "a": {"type": "number"},
                "b": {"type": "number"}
            },
            "required": ["operation", "a", "b"]
        }
    }
]
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=[
        {"role": "user", "content": "What is 1234 * 5678?"}
    ]
)
Handle the tool call
if response.stop_reason == "tool_use":
    tool_call = response.content[-1]
    if tool_call.name == "calculator":
        result = tool_call.input["a"] * tool_call.input["b"]
        print(f"Result: {result}")

3. Tool Infrastructure: Orchestration at Scale

When you have many tools, you need infrastructure to manage them. Claude's API provides:

• Tool Runner (SDK): Automatically handles tool calls and returns results.
• Parallel Tool Use: Let Claude call multiple tools simultaneously.
• Strict Tool Use: Force Claude to use a specific tool.
• Tool Use with Prompt Caching: Cache tool definitions to reduce latency and cost.
• Fine-grained Tool Streaming: Stream tool calls and results independently.
• Programmatic Tool Calling: Bypass Claude's decision-making and call tools directly.
• Tool Combinations: Chain tools together (e.g., search the web, then summarize).

4. Context Management: Keep Long Sessions Efficient

Long conversations can become expensive and slow. Claude's context management features help:

• Context Windows: Up to 1M tokens. Use the max_tokens parameter to control output length.
• Compaction: Summarize or compress older parts of the conversation to save tokens.
• Context Editing: Remove or modify specific messages in the conversation history.
• Prompt Caching: Cache system prompts or tool definitions to reduce costs by up to 90%.
• Token Counting: Estimate token usage before making a request.

Example: Using 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 that answers questions about the Python programming language.",
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[
        {"role": "user", "content": "What are Python decorators?"}
    ]
)
print(response.content[0].text)

5. Files and Assets: Working with Documents

Claude can process a variety of file types:

• PDF Support: Extract text and tables from PDFs.
• Images and Vision: Analyze images, diagrams, and screenshots.
• Files API: Upload and reference documents in conversations.

Example: Analyzing a PDF

import anthropic
client = anthropic.Anthropic()
Upload a PDF file
with open("report.pdf", "rb") as f:
    pdf_data = f.read()
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.b64encode(pdf_data).decode("utf-8")
                    }
                },
                {
                    "type": "text",
                    "text": "Summarize the key findings from this report."
                }
            ]
        }
    ]
)
print(response.content[0].text)

Best Practices for Building with Claude

• Start with model capabilities and tools—they cover 80% of use cases.
• Use structured outputs when you need reliable, parseable responses.
• Leverage prompt caching for system prompts and tool definitions to reduce costs.
• Use streaming for real-time user experiences.
• Batch process non-urgent requests to save 50% on API costs.
• Monitor token usage with the token counting endpoint.
• Handle tool calls gracefully—always check stop_reason and provide fallback logic.

Key Takeaways

• The Claude API is organized into five areas: model capabilities, tools, tool infrastructure, context management, and files/assets.
• Extended thinking and structured outputs give you fine-grained control over Claude's reasoning and response format.
• Tools let Claude interact with the web, execute code, and use your own APIs—build agents that take real action.
• Prompt caching and batch processing can significantly reduce costs and latency.
• Always check feature availability (Beta vs. GA) before building production applications.

Ready to build? Start with the Quickstart and experiment with the code examples above. Happy building!