Introduction

Claude isn't just a chat interface—it's a powerful AI engine you can integrate directly into your own applications. Whether you're building a customer support bot, a code assistant, or a creative writing tool, the Claude API gives you programmatic access to the same models that power claude.ai.

This guide will take you from zero to your first working API call, then show you how to choose the right development surface for your project. By the end, you'll understand the core concepts, see working code examples, and know exactly what to do next.

What You'll Need

Before you start, make sure you have:

• A Claude API account (sign up is free)
• An API key from the API Keys section of your console
• Python 3.7+ installed on your machine (or Node.js if you prefer TypeScript)
• Basic familiarity with the command line and JSON

Step 1: Get Your API Key

• Log in to the Anthropic Console.
• Navigate to Settings > API Keys.
• Click Create Key, give it a name (e.g., "My First App"), and copy the key.
• Store it securely—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.

Step 2: Install the SDK

Anthropic provides official client SDKs for Python, TypeScript, Go, Java, Ruby, PHP, and C#. We'll use Python for this guide.

pip install anthropic

For TypeScript/Node.js:

npm install @anthropic-ai/sdk

Step 3: Make Your First API Call

Create a file called hello_claude.py and add the following code:

import anthropic
client = anthropic.Anthropic(
    api_key="YOUR_API_KEY_HERE"  # Replace with your actual key
)
message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, Claude!"}
    ]
)
print(message.content[0].text)

Run it:

python hello_claude.py

You should see a friendly greeting from Claude. Congratulations—you've just made your first API call!

Understanding the Code

• client.messages.create() is the core method for sending messages to Claude.
• model specifies which Claude model to use (we'll cover model selection shortly).
• max_tokens controls the maximum length of Claude's response.
• messages is an array of conversation turns. Each turn has a role ("user" or "assistant") and content.
• The response contains an array of content blocks; the first one is usually the text reply.

Step 4: Choose Your Development Surface

Claude offers two primary ways to build: Messages API (direct model access) and Managed Agents (fully managed agent infrastructure). Your choice depends on your use case.

Messages API (Direct Access)

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

• Custom chat interfaces
• Fine-grained control over conversation flow
• Integrating Claude into existing backend systems
• Building with tools, extended thinking, or structured outputs

Example: Multi-turn conversation

import anthropic
client = anthropic.Anthropic()
def chat_with_claude(user_input, history=[]):
    history.append({"role": "user", "content": user_input})
    
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        messages=history
    )
    
    assistant_reply = response.content[0].text
    history.append({"role": "assistant", "content": assistant_reply})
    return assistant_reply, history
Example usage
history = []
reply1, history = chat_with_claude("What is the capital of France?", history)
print(reply1)  # "The capital of France is Paris."
reply2, history = chat_with_claude("What is its most famous landmark?", history)
print(reply2)  # "The most famous landmark is the Eiffel Tower."

Managed Agents (Fully Managed Infrastructure)

Managed Agents handle the heavy lifting—conversation state, session management, and event history are all persisted for you. This is ideal for:

• Rapid prototyping and deployment
• Applications where you don't want to manage state
• Autonomous agents that need to run over extended periods

Example: Creating a Managed Agent

import anthropic
client = anthropic.Anthropic()
Create an agent
agent = client.agents.create(
    name="CustomerSupportBot",
    model="claude-sonnet-4-6",
    instructions="You are a helpful customer support agent for a SaaS company.",
    tools=[
        {
            "type": "function",
            "function": {
                "name": "get_order_status",
                "description": "Get the status of a customer order",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "order_id": {"type": "string"}
                    },
                    "required": ["order_id"]
                }
            }
        }
    ]
)
Start a session
session = client.agents.sessions.create(agent_id=agent.id)
Send a message
response = client.agents.sessions.message(
    agent_id=agent.id,
    session_id=session.id,
    message="Hi, I'd like to check on my order #12345"
)
print(response.content[0].text)

Step 5: Choose the Right Model

Claude offers three model tiers, each optimized for different workloads:

Recommendation: Start with Sonnet 4.6 for most use cases. It's fast enough for interactive applications and smart enough for complex tasks. Upgrade to Opus when you need deeper reasoning; switch to Haiku when you need maximum throughput.

Step 6: Explore Advanced Features

Once you're comfortable with the basics, Claude's API offers several powerful capabilities:

Extended Thinking

Claude can "think" through complex problems before responding, producing better results for math, logic, and multi-step reasoning.

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    thinking={"type": "enabled", "budget_tokens": 1024},
    messages=[{"role": "user", "content": "Solve this: 47 * 89 + 123"}]
)

Vision

Claude can analyze images, diagrams, and documents. Just include an image URL or base64-encoded data in your message.

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What's in this image?"},
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/png",
                        "data": "base64_encoded_string_here"
                    }
                }
            ]
        }
    ]
)

Tool Use (Function Calling)

Give Claude access to external tools like databases, APIs, or calculators. Claude will decide when to call them.

Structured Outputs

Request responses in a specific JSON schema—perfect for extracting structured data.

Prompt Caching

Reduce latency and cost by caching repeated system prompts or context.

Streaming

Get responses token-by-token for a real-time experience.

Step 7: Evaluate and Ship

Before going to production, consider these best practices:

• Prompt engineering: Iterate on your prompts using the Workbench to test variations.
• Run evaluations: Use the Evaluation tools to measure performance on your specific tasks.
• Batch testing: Test your app with multiple inputs before deploying.
• Safety & guardrails: Implement content filtering and rate limiting.
• Cost optimization: Use prompt caching and choose the right model for each task.

Next Steps

Now that you've made your first API call and understand the landscape, here's where to go next:

• Interactive courses: Anthropic's learning hub offers hands-on tutorials.
• Cookbook: Browse code samples and patterns for common use cases.
• Quickstarts: Deploy starter apps for customer support, code review, and more.
• Claude Code: Try the agentic coding assistant right in your terminal.

Key Takeaways

• Start with the Messages API for full control, or Managed Agents for hands-off state management.
• Sonnet 4.6 is the best starting point for most production workloads; switch to Opus or Haiku based on your needs.
• Always store your API key securely using environment variables or a secrets manager.
• Use the Workbench to iterate on prompts before writing production code.
• Explore advanced features like extended thinking, vision, and tool use to unlock Claude's full potential.