Introduction

Building applications with Claude starts with the API. Whether you're creating a simple chatbot, a code assistant, or a complex autonomous agent, the Claude API gives you direct access to the most capable models in the industry. This guide walks you through everything you need to go from zero to your first production-ready integration.

By the end of this article, you'll know how to:

• Get your API key and set up your environment
• Install the official SDK (Python, TypeScript, and more)
• Make your first API call
• Understand the two main development surfaces: Messages API and Managed Agents
• Choose the right model for your use case

Let's dive in.

Prerequisites

Before you start, make sure you have:

• A Claude API account (sign up for free)
• Python 3.7+ installed (or Node.js 18+ for TypeScript)
• Basic familiarity with REST APIs and JSON

Step 1: Get Your API Key

• Log in to the Anthropic Console.
• Navigate to API Keys in the left sidebar.
• Click Create Key and give it a name (e.g., "My First App").
• Copy the key immediately — you won't be able to see it again.

Security tip: Never hardcode your API key in client-side code or commit it to version control. Use environment variables instead.

Step 2: Install the SDK

Anthropic provides official SDKs for multiple languages. Here's how to install the most popular ones:

Python

pip install anthropic

TypeScript / JavaScript

npm install @anthropic-ai/sdk

Other languages

Anthropic also supports Go, Java, Ruby, PHP, C#, and direct cURL calls. The setup pattern is similar across all SDKs.

Step 3: Make 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 (reads ANTHROPIC_API_KEY from environment)
client = anthropic.Anthropic()
Send a message
message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, Claude!"}
    ]
)
Print the response
print(message.content[0].text)

TypeScript Example

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

What's happening here?

• The client object handles authentication and HTTP requests automatically.
• model specifies which Claude model to use (see model selection below).
• max_tokens limits the length of the response.
• messages is an array of conversation turns. Each turn has a role ("user" or "assistant") and content.

Step 4: Understand the Two Development Surfaces

Claude's API offers two distinct ways to build, depending on how much control you need vs. how much infrastructure you want to offload.

Messages API (Direct Model Access)

With the Messages API, you have full control over every aspect of the conversation:

• You construct every turn manually.
• You manage conversation state (history, context window).
• You write your own tool loop (if using function calling).

Best for: Custom applications, fine-grained control, complex workflows. Quickstart: Messages API Reference

Managed Agents (Fully Managed Infrastructure)

With Managed Agents, Anthropic handles the heavy lifting:

• Deploy autonomous agents in stateful sessions.
• Persistent event history is managed for you.
• Built-in tool execution and error handling.

Best for: Rapid prototyping, production agents, teams that want to focus on logic rather than infrastructure. Quickstart: Managed Agents Reference

Step 5: Choose the Right Model

Claude offers three tiers of models, each optimized for different workloads:

Recommendation: Start with Sonnet for general use. Switch to Opus when you need deeper reasoning, and use Haiku for cost-sensitive or real-time scenarios.

Step 6: Explore Advanced Features

Once you've made your first call, you can layer on more powerful capabilities:

• Extended Thinking – Let Claude reason step-by-step before responding.
• Vision – Send images alongside text for analysis.
• Tool Use – Give Claude access to external functions (APIs, databases, etc.).
• Web Search – Enable real-time web search within conversations.
• Code Execution – Let Claude run code in a sandboxed environment.
• Structured Outputs – Get responses in JSON or other structured formats.
• Prompt Caching – Reduce latency and cost for repeated system prompts.
• Streaming – Receive tokens as they're generated for a real-time experience.

Each of these features has its own dedicated documentation and code samples in the Anthropic Cookbook.

Step 7: Evaluate and Ship

Before going to production, consider these best practices:

• Prompt engineering – Iterate on your prompts using the Workbench for rapid testing.
• Run evals – Create test suites to measure accuracy and safety.
• Batch testing – Use the batch API to test at scale.
• Safety & guardrails – Implement content filters and rate limiting.
• Cost optimization – Monitor token usage and choose the smallest model that meets your needs.
• Rate limits & errors – Handle 429 (rate limit) and 500 (server error) responses gracefully with retries.

Next Steps

Now that you've made your first API call, here's what to explore next:

• Interactive courses – Master Claude through guided tutorials.
• Cookbook – Browse code samples and patterns for common use cases.
• Quickstarts – Deploy starter apps for chatbots, code assistants, and more.
• Claude Code – Try the agentic coding assistant in your terminal.

Key Takeaways

• Get your API key from the Anthropic Console and store it securely as an environment variable.
• Install the SDK for your language (Python, TypeScript, etc.) and make your first call in under 5 minutes.
• Choose your development surface: Messages API for full control, Managed Agents for autonomous, stateful deployments.
• Pick the right model: Opus for deep reasoning, Sonnet for balanced performance, Haiku for speed and cost savings.
• Explore advanced features like tool use, vision, and streaming to build truly powerful applications.