Introduction

Claude, Anthropic's powerful AI assistant, is not just accessible through the chat interface at claude.ai. As a developer, you can integrate Claude directly into your own applications, workflows, and services using the Claude API. Whether you're building a customer support chatbot, a content generation tool, or an intelligent code assistant, the Claude API gives you programmatic access to Claude's capabilities.

This guide will take you from zero to your first successful API call in under 10 minutes. We'll cover account setup, API key generation, and making requests using cURL, Python, and TypeScript. By the end, you'll have a working integration and understand the foundational patterns you'll use in every Claude application.

Prerequisites

Before you start, you'll need two things:

• An Anthropic Console account – Sign up at console.anthropic.com. The free tier includes $5 in credits to get started.
• An API key – You'll generate this inside the Console after signing up.

Note: The Claude API is a paid service, but the free credits are more than enough to complete this tutorial and experiment further.

Step 1: Create Your Anthropic Console Account

• Navigate to console.anthropic.com.
• Click Sign Up and follow the registration process (email + password, or use Google/GitHub OAuth).
• Once logged in, you'll land on the Console dashboard. This is your command center for managing API keys, viewing usage, and accessing documentation.

Step 2: Generate Your API Key

• In the Console, click on your profile icon (top-right corner) and select API Keys from the dropdown.
• Click Create API Key.
• Give your key a descriptive name (e.g., "Development", "My App").
• Copy the generated key immediately – you won't be able to see it again after closing the dialog.

Security Best Practice: Store your API key in an environment variable (e.g., ANTHROPIC_API_KEY) or a secrets manager. Never hardcode it in your source code or commit it to version control.

Step 3: Make Your First API Call

Now for the exciting part – let's talk to Claude! We'll use the Messages API, which is the primary interface for all Claude interactions.

Option A: Using cURL (Quick Test)

Open your terminal and run:

curl https://api.anthropic.com/v1/messages \
  --header "x-api-key: $ANTHROPIC_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "Hello, Claude! What is the capital of France?"}
    ]
  }'

Explanation:

• x-api-key: Your secret API key.
• anthropic-version: The API version (always include this).
• model: Which Claude model to use. claude-sonnet-4-20250514 is the latest Sonnet model – great balance of speed and intelligence.
• max_tokens: Maximum words/tokens in Claude's response.
• messages: An array of message objects. Each has a role (user or assistant) and content.

You should receive a JSON response with Claude's answer.

Option B: Using Python (Recommended for Developers)

First, install the Anthropic Python SDK:

pip install anthropic

Then create a file first_call.py:

import os
from anthropic import Anthropic
Initialize the client
client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
Send a message
message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, Claude! What is the capital of France?"}
    ]
)
Print the response
print(message.content[0].text)

Run it:

python first_call.py

Expected output:

The capital of France is Paris.

Option C: Using TypeScript/JavaScript

Install the SDK:

npm install @anthropic-ai/sdk

Create first_call.ts:

import Anthropic from '@anthropic-ai/sdk';
const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});
async function main() {
  const message = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 1024,
    messages: [
      { role: 'user', content: 'Hello, Claude! What is the capital of France?' }
    ],
  });
console.log(message.content[0].text);
}
main();

Run with:

npx ts-node first_call.ts

Understanding the Response

The API returns a structured JSON object. Here's what you'll see:

{
  "id": "msg_01ABC123...",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "The capital of France is Paris."
    }
  ],
  "model": "claude-sonnet-4-20250514",
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 14,
    "output_tokens": 7
  }
}

Key fields:

• content: An array of content blocks. Most responses contain a single text block.
• stop_reason: Why Claude stopped generating. "end_turn" means it finished naturally.
• usage: Token counts for billing and optimization.

Next Steps: Core Patterns to Master

You've made your first API call – congratulations! Now it's time to build on that foundation. Here are the essential patterns you'll use in every Claude integration:

1. Multi-turn Conversations

Claude can maintain context across multiple messages. Simply add more messages to the array:

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

2. System Prompts

Set Claude's behavior and persona using a system prompt:

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="You are a helpful travel guide. Answer concisely and always include a fun fact.",
    messages=[
        {"role": "user", "content": "Tell me about Paris."}
    ]
)

3. Handling Stop Reasons

Check stop_reason to understand why Claude stopped:

• "end_turn": Claude finished naturally.
• "max_tokens": The response was cut off – increase max_tokens or continue the conversation.
• "stop_sequence": Claude hit a custom stop sequence you defined.

4. Streaming Responses

For real-time applications, stream the response token by token:

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

Exploring Further

Once you're comfortable with the basics, dive into Claude's more advanced capabilities:

• Models overview: Compare Claude models (Haiku, Sonnet, Opus) by speed, cost, and capability.
• Tools (Function Calling): Give Claude the ability to call external APIs, query databases, or perform actions.
• Structured Outputs: Get Claude to return JSON, YAML, or other structured formats reliably.
• Prompt Caching: Reduce costs and latency for repeated system prompts or large contexts.
• Vision: Send images to Claude for analysis and description.

Key Takeaways

• Getting started is fast: You can make your first Claude API call in under 5 minutes with just an account and an API key.
• The Messages API is the core: All Claude interactions use the same messages.create pattern – master this, and you can build anything.
• Use environment variables for security: Never hardcode your API key. Use os.environ.get("ANTHROPIC_API_KEY") or similar.
• Start with Sonnet: claude-sonnet-4-20250514 offers the best balance of intelligence, speed, and cost for most use cases.
• Explore the ecosystem: Claude supports streaming, multi-turn conversations, system prompts, tools, vision, and more – all accessible through the same API.

Now go build something amazing with Claude! For complete reference, check the Anthropic API Documentation.