Introduction

So you want to build something with Claude. Whether you're creating a smart chatbot, an automated content generator, or a code assistant, the Claude API is your gateway. This guide will take you from zero to your first working API call, explain the two main ways to interact with Claude, and point you to the next steps for production.

By the end of this article, you'll have a running Claude integration and a clear understanding of which developer surface fits your project.

Prerequisites

Before you start, make sure you have:

• A Claude API account (you'll need to sign up and add a payment method)
• Basic familiarity with the command line
• Python 3.8+ or Node.js 18+ installed on your machine

Step 1: Get Your API Key

Your API key is your passport to Claude. Here's how to get one:

• Log in to the Anthropic Console.
• Navigate to API Keys in the left sidebar.
• Click Create Key.
• Give your key a descriptive name (e.g., "My First App").
• Copy the key and store it securely. You won't be able to see it again.

Security tip: Never hardcode your API key in your source code. Use environment variables instead.

Step 2: Choose Your Model

Claude comes in three flavors, each optimized for different workloads:

For your first call, Sonnet is a great all-rounder. You can always switch later.

Step 3: Install the SDK

Anthropic provides official SDKs for multiple languages. Here's how to install them:

Python

pip install anthropic

TypeScript / JavaScript

npm install @anthropic-ai/sdk

Step 4: Make Your First API Call

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

Python Example

Create a file called hello_claude.py:

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

Run it:

python hello_claude.py

You should see something like:

Hello! How can I help you today?

TypeScript Example

Create a file called hello_claude.ts:

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();

Run it with:

npx ts-node hello_claude.ts

Step 5: Understand the Two Developer Surfaces

Claude's API offers two distinct ways to build. Choosing the right one depends on how much control you need.

Messages API (Direct Model Access)

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

• Custom chatbots with specific conversation flows
• Applications where you need to inject system prompts
• Scenarios where you want to handle tool calls yourself

When to use it: You want maximum flexibility and are comfortable managing state.

Managed Agents (Autonomous Infrastructure)

With Managed Agents, Anthropic handles the heavy lifting. You define your agent's instructions and tools, and Claude runs autonomously in stateful sessions with persistent event history. This is perfect for:

• Customer support bots that need to remember past interactions
• Research assistants that perform multi-step tasks
• Any workflow where you want to "set and forget" the agent loop

When to use it: You want to deploy quickly without building your own agent infrastructure.

Step 6: Explore Advanced Features

Once you've made your first call, you can level up with these capabilities:

Extended Thinking

Claude can show its reasoning process before giving a final answer. Enable it with the thinking parameter:

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    thinking={"type": "enabled", "budget_tokens": 1024},
    messages=[{"role": "user", "content": "Solve this math problem step by step..."}]
)

Vision

Claude can analyze images. Pass image data in the content array:

import base64
with open("chart.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": "What does this chart show?"},
            {"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": image_data}}
        ]
    }]
)

Tool Use

Give Claude the ability to call external functions:

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?"}]
)

Streaming

For real-time applications, stream responses token by token:

stream = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Tell me a story"}],
    stream=True
)
for chunk in stream:
    if chunk.type == "content_block_delta":
        print(chunk.delta.text, end="")

Step 7: Plan for Production

Before you ship, consider these essentials:

• Rate limits & errors: Handle 429 (rate limit) and 500 (server error) responses gracefully with retries.
• Cost optimization: Use Haiku for simple tasks, Sonnet for most work, and Opus only when you need deep reasoning.
• Prompt caching: Cache common system prompts to reduce latency and cost.
• Safety & guardrails: Use Claude's content filtering and your own validation to catch harmful outputs.
• Monitoring: Set up usage monitoring in the Anthropic Console to track costs and performance.

Next Steps

You've made your first API call and explored the key concepts. Here's where to go from here:

• Interactive courses: Check out Anthropic's official courses for hands-on learning.
• Cookbook: Browse code samples and patterns for common use cases.
• Quickstarts: Deploy starter apps to see full-stack examples.
• Claude Code: Try the agentic coding assistant in your terminal for a different way to work with Claude.

Key Takeaways

• Get your API key from the Anthropic Console and store it securely as an environment variable.
• Choose your model based on your needs: Haiku for speed, Sonnet for balance, Opus for deep reasoning.
• Two developer surfaces exist: the Messages API for full control, and Managed Agents for autonomous, stateful workflows.
• Advanced features like Extended Thinking, Vision, Tool Use, and Streaming unlock powerful capabilities with minimal code.
• Plan for production by handling errors, optimizing costs, caching prompts, and monitoring usage.