Claude API Tutorial: Get Started with Anthropic's API (2025)

1. What is the Claude API?

The Claude API (by Anthropic) lets you integrate Claude's language models directly into your own applications. Instead of using the Claude.ai chat interface, you call the API from your code and get Claude's responses programmatically.

2. Get your API key (5 steps)

You need an API key to authenticate every request. Here's how to generate one.

3. Your first API call

Anthropic provides official SDKs for Python and Node.js. Install one and make your first call in under 5 minutes.

import anthropic

client = anthropic.Anthropic(api_key="YOUR_API_KEY")  # or use ANTHROPIC_API_KEY env var

message = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explain the difference between a list and a tuple in Python."}
    ]
)

print(message.content[0].text)

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });

const message = await client.messages.create({
  model: "claude-3-5-sonnet-20241022",
  max_tokens: 1024,
  messages: [
    { role: "user", content: "Explain the difference between a list and a tuple in Python." }
  ]
});

console.log(message.content[0].text);

4. System prompts — how to set Claude's role

A system prompt is a set of instructions that frames Claude's behavior before the user's first message. It defines Claude's role, persona, output format, and constraints.

message = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    system="You are a senior Python engineer. Be concise. Always include type hints in code examples. Never explain obvious things.",
    messages=[
        {"role": "user", "content": "Write a function to parse CSV files safely."}
    ]
)

5. Multi-turn conversations

The Claude API is stateless — it does not remember previous calls. To build a conversation, you pass the full message history on every request. Append each new message and response to the list before calling the API again.

messages = []

# Turn 1
messages.append({"role": "user", "content": "I'm building a REST API with FastAPI."})
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=messages
)
messages.append({"role": "assistant", "content": response.content[0].text})

# Turn 2 — Claude remembers the FastAPI context
messages.append({"role": "user", "content": "How should I handle authentication?"})
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=messages
)
print(response.content[0].text)

6. Streaming responses

Instead of waiting for the full response, streaming lets you display Claude's output token by token — just like the Claude.ai chat UI. This improves perceived latency for end users.

with client.messages.stream(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Write a 3-paragraph essay about the impact of AI on software development."}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

7. Vision — send images to Claude

Claude can analyze images. You encode the image as base64 and pass it in the content array alongside your text message.

import base64

with open("screenshot.png", "rb") as f:
    image_data = base64.standard_b64encode(f.read()).decode("utf-8")

message = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/png",
                        "data": image_data,
                    }
                },
                {
                    "type": "text",
                    "text": "Describe what's happening in this screenshot."
                }
            ]
        }
    ]
)
print(message.content[0].text)

8. Tool use (function calling)

Tool use lets you define functions (tools) that Claude can decide to call. You pass a list of tool definitions with your request. When Claude determines a tool is needed, it returns a tool_use block with the function name and arguments — your code then executes the function and returns the result.

tools = [
    {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "City name"},
                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
            },
            "required": ["city"]
        }
    }
]

message = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    tools=tools,
    messages=[{"role": "user", "content": "What's the weather in Tokyo?"}]
)

# Claude will respond with a tool_use block
if message.stop_reason == "tool_use":
    tool_call = message.content[1]
    print(f"Claude wants to call: {tool_call.name}")
    print(f"With args: {tool_call.input}")

9. Pricing and token counting

The Claude API charges per token. A token is roughly 4 characters in English. "Hello world" is 2 tokens. You pay separately for input tokens (your messages + system prompt) and output tokens (Claude's response).

token_count = client.beta.messages.count_tokens(
    model="claude-3-5-sonnet-20241022",
    messages=[{"role": "user", "content": "How many tokens is this?"}]
)
print(token_count.input_tokens)

FAQ