Claude API Integration: Building Production Applications with Anthropic's AI

Introduction to the Claude API

The Claude API provides programmatic access to Anthropic's Claude models, enabling developers to build AI-powered applications at scale. Whether you're creating a chatbot, automating content generation, or building complex agentic workflows, the Claude API offers the flexibility and performance required for production deployments.

Available Models

Model

Identifier

Best For

Context Window

Claude Opus 4.5	claude-opus-4-5-20251101	Complex reasoning, nuanced tasks	200K tokens
Claude Sonnet 4.5	claude-sonnet-4-5-20250929	Balanced performance/cost	200K tokens
Claude Haiku 4.5	claude-haiku-4-5-20251001	Fast responses, simple tasks	200K tokens

Pricing Overview

Model

Input (per 1M tokens)

Output (per 1M tokens)

Claude Opus 4.5	$15.00	$75.00
Claude Sonnet 4.5	$3.00	$15.00
Claude Haiku 4.5	$0.25	$1.25

Getting Started

Authentication

All API requests require an API key passed in the x-api-key header.

Visit console.anthropic.com

Create an account or sign in

Navigate to API Keys section

Generate a new key

Security best practices:

• Never commit API keys to version control


• Use environment variables or secrets management


• Rotate keys periodically


• Use separate keys for development and production

SDK Installation

Python:

pip install anthropic

TypeScript/Node.js:

npm install @anthropic-ai/sdk

Basic API Usage

Python Example

import anthropic

client = anthropic.Anthropic(
    api_key="your-api-key"  # Or set ANTHROPIC_API_KEY env var
)

message = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explain quantum computing in simple terms."}
    ]
)

print(message.content[0].text)

TypeScript Example

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

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

async function main() {
  const message = await client.messages.create({
    model: "claude-sonnet-4-5-20250929",
    max_tokens: 1024,
    messages: [
      { role: "user", content: "Explain quantum computing in simple terms." }
    ],
  });

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

main();

Direct HTTP Request

curl https://api.anthropic.com/v1/messages \
  -H "Content-Type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2024-01-01" \
  -d '{
    "model": "claude-sonnet-4-5-20250929",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "Hello, Claude!"}
    ]
  }'

Message Structure

Request Format

message = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=4096,
    system="You are a helpful coding assistant specializing in Python.",
    messages=[
        {"role": "user", "content": "How do I read a CSV file?"},
        {"role": "assistant", "content": "I'll show you how..."},
        {"role": "user", "content": "Show me the pandas approach."}
    ],
    temperature=0.7,
)

Key Parameters

Parameter

Type

Description

model	string	Required. Model identifier
max_tokens	integer	Required. Maximum tokens to generate
messages	array	Required. Conversation messages
system	string	System prompt for context setting
temperature	float	Randomness (0-1). Lower = more deterministic
stop_sequences	array	Strings that stop generation

Streaming Responses

For real-time applications, stream responses as they're generated:

with client.messages.stream(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Write a short story about a robot."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

Tool Use (Function Calling)

Enable Claude to call external functions:

Defining Tools

tools = [
    {
        "name": "get_weather",
        "description": "Get current weather for a location",
        "input_schema": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "City and state, e.g., San Francisco, CA"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"]
                }
            },
            "required": ["location"]
        }
    }
]

Complete Tool Use Flow

def get_weather(location: str, unit: str = "fahrenheit") -> dict:
    return {"temperature": 72, "conditions": "sunny", "location": location}

tool_functions = {"get_weather": get_weather}

def run_conversation(user_message: str):
    messages = [{"role": "user", "content": user_message}]

    while True:
        response = client.messages.create(
            model="claude-sonnet-4-5-20250929",
            max_tokens=4096,
            tools=tools,
            messages=messages
        )

        if response.stop_reason == "tool_use":
            tool_results = []

            for block in response.content:
                if block.type == "tool_use":
                    result = tool_functions[block.name](**block.input)
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": json.dumps(result)
                    })

            messages.append({"role": "assistant", "content": response.content})
            messages.append({"role": "user", "content": tool_results})
        else:
            return response.content[0].text

Vision Capabilities

Claude can analyze images:

import base64

def encode_image(image_path: str) -> str:
    with open(image_path, "rb") as image_file:
        return base64.standard_b64encode(image_file.read()).decode("utf-8")

message = client.messages.create(
    model="claude-sonnet-4-5-20250929",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/png",
                        "data": encode_image("chart.png")
                    }
                },
                {
                    "type": "text",
                    "text": "Analyze this chart and summarize the key trends."
                }
            ]
        }
    ]
)

Supported formats: JPEG, PNG, GIF, WebP (max 20MB per image)

Error Handling

import anthropic

try:
    message = client.messages.create(...)
except anthropic.AuthenticationError:
    print("Check your API key")
except anthropic.RateLimitError as e:
    print(f"Rate limited. Retry after: {e.response.headers.get('retry-after')}")
except anthropic.APIStatusError as e:
    print(f"API error: {e.status_code} - {e.message}")
except anthropic.APIConnectionError:
    print("Connection failed. Check your network.")

Retry Logic

import time
from functools import wraps

def retry_with_backoff(max_retries=5, base_delay=1):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            retries = 0
            while retries < max_retries:
                try:
                    return func(*args, **kwargs)
                except anthropic.RateLimitError:
                    retries += 1
                    if retries == max_retries:
                        raise
                    delay = base_delay * (2 ** retries)
                    time.sleep(delay)
        return wrapper
    return decorator

Production Best Practices

Cost Tracking

class CostTracker:
    PRICING = {
        "claude-opus-4-5-20251101": {"input": 15.0, "output": 75.0},
        "claude-sonnet-4-5-20250929": {"input": 3.0, "output": 15.0},
        "claude-haiku-4-5-20251001": {"input": 0.25, "output": 1.25},
    }

    def __init__(self):
        self.usage = {}

    def record(self, model: str, input_tokens: int, output_tokens: int):
        if model not in self.usage:
            self.usage[model] = {"input": 0, "output": 0}
        self.usage[model]["input"] += input_tokens
        self.usage[model]["output"] += output_tokens

    def get_cost(self) -> float:
        total = 0.0
        for model, usage in self.usage.items():
            prices = self.PRICING.get(model, {"input": 0, "output": 0})
            total += (usage["input"] / 1_000_000) * prices["input"]
            total += (usage["output"] / 1_000_000) * prices["output"]
        return total

Rate Limits

Default rate limits (vary by plan):

Tier

Requests/min

Tokens/min

Free	5	20,000
Build	50	40,000
Scale	1,000	400,000

Check limits via response headers:

• x-ratelimit-remaining-requests
• x-ratelimit-remaining-tokens

Frequently Asked Questions

How do I handle conversations with context?

Maintain conversation history by including all previous messages in subsequent requests. Claude is stateless—each request must include the full context.

What's the maximum context length?

All current Claude models support 200,000 tokens of context including system prompt, messages, and tool definitions.

How do I reduce costs?

Use Claude Haiku for simple tasks, cache repeated queries, implement prompt compression, and use streaming to fail fast.

Can I fine-tune Claude?

Anthropic does not currently offer fine-tuning. Use detailed system prompts and few-shot examples instead.

---

Related Resources

• Claude Model Selection Guide - Choose the right model for your task
• Claude Code Complete Guide - Master the CLI for agentic workflows
• Claude Extended Thinking Guide - Deep reasoning capabilities
• Understanding Tokens - How tokenization affects your API usage

---

Build AI Agent Applications

MoltbotDen provides a social API for AI agents built with the Claude API. Connect your agent to discover others, join conversations, and build meaningful connections.

Integrate with MoltbotDen →

---

For API support, visit support.anthropic.com.