Introduction

Claude isn't just a chat interface—it's a powerful API that you can integrate into your own applications, workflows, and tools. Whether you're building a custom chatbot, automating document analysis, or creating an autonomous coding assistant, the Claude API gives you direct access to the same models that power Claude.ai.

This guide will take you from zero to your first production-ready API call. You'll learn:

• How to get your API key and set up your environment
• The two main ways to interact with Claude: Messages API and Managed Agents
• How to choose the right model for your use case
• The full developer journey from building to shipping

By the end, you'll have a working Python script that talks to Claude and a clear understanding of where to go next.

Getting Started

1. Get Your API Key

Before you can make any API calls, you need an API key. Head to the Anthropic Console and create a new key. Keep it secret—anyone with this key can use your account.

2. Choose a Model

Claude comes in three flavors. Pick the one that matches your needs:

For most production use cases, Sonnet is the sweet spot. Use Opus when you need the highest quality reasoning, and Haiku when speed is critical.

3. Install the SDK

Anthropic provides official SDKs for Python, TypeScript, Go, Java, Ruby, PHP, and C#. Here's how to install the Python one:

pip install anthropic

Making Your First API Call

Let's write a simple script that sends a message to Claude and prints the response.

Python Example

import anthropic
Initialize the client with your API key
client = anthropic.Anthropic(
    api_key="your-api-key-here"
)
Send a message
message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, Claude! What can you help me with today?"}
    ]
)
Print the response
print(message.content[0].text)

TypeScript Example

import Anthropic from '@anthropic-ai/sdk';
const client = new Anthropic({
  apiKey: 'your-api-key-here',
});
async function main() {
  const message = await client.messages.create({
    model: 'claude-sonnet-4-6',
    max_tokens: 1024,
    messages: [{ role: 'user', content: 'Hello, Claude!' }],
  });
console.log(message.content[0].text);
}
main();

That's it! You've just made your first API call. But there's much more you can do.

Two Developer Surfaces

Claude's platform offers two main ways to build:

Messages API (Direct Model Access)

With the Messages API, you have full control. You construct every turn of the conversation, manage conversation state yourself, and write your own tool loop. This is ideal for:

• Custom chatbots with specific conversation flows
• Applications where you need to control every detail
• Integrating Claude into existing systems

Key features:

• Extended thinking (for complex reasoning)
• Vision (analyze images)
• Tool use (let Claude call your functions)
• Web search and code execution
• Structured outputs (JSON mode)
• Prompt caching (reduce costs for repeated prompts)
• Streaming (get responses token by token)

Managed Agents (Fully Managed Infrastructure)

Managed Agents let you deploy and manage autonomous agents without worrying about infrastructure. You define the agent's behavior, and Claude handles conversation state, event history, and tool execution.

Best for:

• Long-running autonomous tasks
• Applications where you don't want to manage state
• Multi-step workflows that require persistence

Both surfaces are available through the same API endpoint, but Managed Agents add a layer of abstraction that simplifies development.

The Developer Journey

Anthropic has mapped out a clear path from idea to production:

Phase 1: Get Started

• Get your API key
• Choose a model
• Install an SDK
• Try the Workbench (a web-based playground for testing prompts)

Phase 2: Build

• Use the Messages API for direct control
• Enable advanced features like extended thinking, vision, and tool use
• Implement streaming for better user experience
• Use prompt caching to optimize costs

Phase 3: Evaluate & Ship

• Follow prompting best practices
• Run evaluations to measure performance
• Use batch testing for regression checks
• Implement safety and guardrails
• Understand rate limits and error handling
• Optimize costs

Phase 4: Operate

• Use workspaces and admin controls
• Manage API keys securely
• Monitor usage and costs
• Plan model migrations as new versions are released

Advanced Features to Explore

Once you have the basics down, dive into these powerful capabilities:

Extended Thinking

For complex tasks that require step-by-step reasoning, enable extended thinking. Claude will show its internal reasoning process before giving the final answer.

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    thinking={"type": "enabled", "budget_tokens": 2048},
    messages=[{"role": "user", "content": "Solve this complex math problem..."}]
)

Tool Use

Let Claude call your own functions. Define tools as JSON schemas, and Claude will decide when to use them.

tools = [
    {
        "name": "get_weather",
        "description": "Get the current weather for a city",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {"type": "string"}
            },
            "required": ["location"]
        }
    }
]
message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}]
)

Vision

Claude can analyze images. Pass image data directly in the messages array.

import base64
with open("diagram.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode()
message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe this diagram"},
                {"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": image_data}}
            ]
        }
    ]
)

Resources to Keep Learning

Anthropic provides a wealth of resources to deepen your knowledge:

• Courses: Interactive courses to master Claude
• Cookbook: Code samples and patterns for common use cases
• Quickstarts: Deployable starter apps you can clone and modify
• What's New: Latest features and updates
• Claude Code: An agentic coding assistant that runs in your terminal

Key Takeaways

• Get your API key from the Anthropic Console and keep it secure—it's your gateway to all Claude API features.
• Choose the right model: Opus for deep reasoning, Sonnet for balanced production use, Haiku for speed.
• Two developer surfaces: Messages API for full control, Managed Agents for hands-off infrastructure.
• Follow the developer journey: Start with the Quickstart, build with advanced features, evaluate rigorously, then operate at scale.
• Explore advanced features like extended thinking, tool use, and vision to unlock Claude's full potential in your applications.