Introduction

So you want to build with Claude. Whether you're integrating a chatbot, automating a workflow, or experimenting with agentic AI, the Claude API is your gateway. This guide will take you from zero to your first successful API call, then help you choose the right development path for your project.

By the end, you'll understand:

• How to get and secure your API key
• How to install and use the official Python SDK
• The difference between the Messages API (direct control) and Managed Agents (autonomous infrastructure)
• How to pick the right Claude model for your use case

Let's get started.

Prerequisites

Before you begin, make sure you have:

• A Claude Platform account
• Python 3.8+ installed on your machine
• Basic familiarity with the command line

Step 1: Get Your API Key

• Log in to the Claude Platform Console.
• Navigate to API Keys in the left sidebar.
• Click Create API Key.
• Give your key a descriptive name (e.g., "My Dev Key").
• Copy the key immediately — you won't be able to see it again.

Security tip: Never hardcode your API key in source code. Use environment variables or a secrets manager.

export ANTHROPIC_API_KEY="sk-ant-..."

Step 2: Install the SDK

Claude provides official SDKs for Python, TypeScript, Go, Java, Ruby, PHP, and C#. For this guide, we'll use Python.

pip install anthropic

That's it. One package, zero dependencies to worry about.

Step 3: Make Your First API Call

Create a new file called hello_claude.py and paste the following:

import anthropic
client = anthropic.Anthropic()
message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, Claude"}
    ]
)
print(message.content[0].text)

Run it:

python hello_claude.py

If everything is configured correctly, you'll see Claude's friendly greeting printed to your terminal. Congratulations — you've just made your first API call!

Understanding the Code

• client = anthropic.Anthropic() — Initializes the client. It automatically reads the ANTHROPIC_API_KEY environment variable.
• model="claude-opus-4-7" — Specifies which Claude model to use. Opus is the most capable.
• max_tokens=1024 — Limits the response length.
• messages — An array of conversation turns. Each message has a role ("user" or "assistant") and content.

Step 4: Choose Your Developer Surface

Claude offers two primary ways to build. Your choice depends on how much control you need versus how much infrastructure you want to manage.

Option A: Messages API (Direct Control)

The Messages API gives you full control over every aspect of the conversation. You construct each turn, manage conversation state, and write your own tool loop.

Best for:

• Custom chat applications
• Workflows with complex business logic
• When you need fine-grained control over prompts and tool calls

Example — multi-turn conversation:

import anthropic
client = anthropic.Anthropic()
First turn
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "What is the capital of France?"}
    ]
)
print(response.content[0].text)
Second turn (passing history)
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "What is the capital of France?"},
        {"role": "assistant", "content": "The capital of France is Paris."},
        {"role": "user", "content": "What is its most famous landmark?"}
    ]
)
print(response.content[0].text)

Option B: Managed Agents (Autonomous Infrastructure)

Managed Agents provide fully managed agent infrastructure. You define the agent's behavior, and Claude handles state management, event history, and tool execution in persistent sessions.

Best for:

• Autonomous task completion (e.g., research, data processing)
• Long-running workflows
• When you want to skip building your own agent loop

Example — creating a managed agent:

import anthropic
client = anthropic.Anthropic()
Define your agent
agent = client.agents.create(
    name="Research Assistant",
    model="claude-sonnet-4-6",
    instructions="You are a helpful research assistant. Use web search to find accurate, up-to-date information.",
    tools=[{"type": "web_search"}]
)
Start a session
session = agent.sessions.create()
Send a message
response = session.send("What are the latest developments in quantum computing?")
print(response.content[0].text)

Step 5: Pick the Right Model

Claude offers three models optimized for different trade-offs:

Rule of thumb: Start with Sonnet for most use cases. Switch to Opus when you need deeper reasoning. Use Haiku when speed and cost are your primary constraints.

Next Steps: Building for Production

Once you've made your first call, here's what to explore next:

• Extended Thinking — Enable Claude to "think" before responding for complex reasoning tasks.
• Vision — Pass images to Claude for analysis.
• Tool Use — Let Claude call external APIs and functions.
• Structured Outputs — Get responses in JSON or other structured formats.
• Prompt Caching — Reduce latency and cost by reusing common prefixes.
• Streaming — Get responses token-by-token for a better user experience.

Troubleshooting Common Issues

Conclusion

You now have everything you need to start building with the Claude API. The path from here is yours to choose: dive deep into the Messages API for full control, or leverage Managed Agents for autonomous workflows. Either way, Claude's SDKs make it painless to get from idea to production.

Key Takeaways

• Get your API key from the Claude Platform console and store it securely as an environment variable.
• Install the SDK with pip install anthropic — the Python SDK is the most popular, but official SDKs exist for 7+ languages.
• Choose your developer surface wisely: Messages API for direct control, Managed Agents for autonomous, stateful workflows.
• Pick the right model: Opus for deep reasoning, Sonnet for balanced production use, Haiku for speed and cost efficiency.
• Explore advanced features like extended thinking, vision, tool use, and streaming as you move toward production.