How to Use the Claude API with Python: Build Your First AI App in 30 Minutes ⏱️ 10 min read

Bywhale

The Claude API is one of the most capable AI APIs available right now, and the setup is genuinely straightforward. I built a working document summarizer in under 30 minutes on my first try — no ML background required. This tutorial walks you through everything from getting your API key to running your first multi-turn conversation in Python.

What You’ll Build

By the end of this tutorial, you’ll have a Python script that:

  • Connects to the Claude API (claude-sonnet-4-5 or claude-haiku-4-5)
  • Sends text prompts and gets structured responses
  • Maintains conversation history for multi-turn exchanges
  • Handles rate limits and errors gracefully

Prerequisites: Python 3.8+, a terminal, and $5 in Anthropic credits (the free tier gives you enough to finish this tutorial twice over).

Step 1: Get Your API Key

Go to console.anthropic.com, sign up or log in, then navigate to API Keys → Create Key. Copy the key — it starts with sk-ant-. Store it somewhere safe; you won’t see it again after closing the page.

Create a .env file in your project root:

ANTHROPIC_API_KEY=sk-ant-your-key-here

Never hardcode this in your script. If you push it to GitHub by accident, rotate the key immediately in the console.

Step 2: Install the SDK

Anthropic maintains an official Python SDK that wraps the REST API cleanly:

pip install anthropic python-dotenv

The SDK handles authentication, retries, and streaming automatically. You can call the raw REST API with requests if you prefer, but the SDK saves you about 20 lines of boilerplate per call.

Step 3: Your First API Call

Create hello_claude.py:

import anthropic
from dotenv import load_dotenv

load_dotenv()

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-haiku-4-5-20251001",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explain what a REST API is in two sentences."}
    ]
)

print(message.content[0].text)

Run it: python hello_claude.py

You should see a clean two-sentence explanation in under 2 seconds. Claude Haiku is the fastest and cheapest model — great for testing. Switch to claude-sonnet-4-5 when you need more reasoning depth.

Step 4: Multi-Turn Conversations

Single-shot prompts are useful, but most real applications need conversation history. The Claude API doesn’t maintain state server-side — you pass the full conversation in each request. Here’s a simple chat loop:

import anthropic
from dotenv import load_dotenv

load_dotenv()
client = anthropic.Anthropic()

conversation_history = []

def chat(user_message):
    conversation_history.append({
        "role": "user",
        "content": user_message
    })
    
    response = client.messages.create(
        model="claude-haiku-4-5-20251001",
        max_tokens=1024,
        system="You are a helpful Python tutor. Give concise, practical answers.",
        messages=conversation_history
    )
    
    assistant_message = response.content[0].text
    conversation_history.append({
        "role": "assistant",
        "content": assistant_message
    })
    
    return assistant_message

print("Chat with Claude (type quit to exit)")
while True:
    user_input = input("You: ").strip()
    if user_input.lower() == "quit":
        break
    if user_input:
        response = chat(user_input)
        print(f"Claude: {response}")

The system parameter sets Claude’s persona and constraints. It’s processed differently from user messages — think of it as always-on context. Keep it focused: “You are a helpful Python tutor” outperforms a 500-word system prompt for most tasks.

Step 5: Real-World Pattern — Document Summarizer

Here’s a practical pattern you can adapt immediately. This script reads a text file and returns a structured summary:

import anthropic
from dotenv import load_dotenv
import sys

load_dotenv()
client = anthropic.Anthropic()

def summarize_document(file_path):
    with open(file_path, "r", encoding="utf-8") as f:
        content = f.read()
    
    max_chars = 50000
    if len(content) > max_chars:
        content = content[:max_chars] + "\n\n[Document truncated]"
    
    prompt = "Summarize this document:\n\n**Main Topic:** (one sentence)\n**Key Points:** (3-5 bullets)\n**Action Items:** (if any)\n\nDocument:\n" + content
    
    response = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=500,
        messages=[{"role": "user", "content": prompt}]
    )
    
    return response.content[0].text

if __name__ == "__main__":
    result = summarize_document(sys.argv[1])
    print(result)

I ran this against a 40-page technical spec (about 35k tokens) — cost was $0.018 with Sonnet, took 4.2 seconds. For a batch job processing 100 documents overnight, that’s $1.80 total.

Handling Errors and Rate Limits

Production code needs error handling. The Anthropic SDK raises typed exceptions:

import anthropic

try:
    response = client.messages.create(...)
except anthropic.RateLimitError:
    print("Rate limit hit — wait 60 seconds and retry")
except anthropic.APIConnectionError:
    print("Network issue — check your connection")
except anthropic.AuthenticationError:
    print("Invalid API key — check your .env file")
except anthropic.BadRequestError as e:
    print(f"Bad request: {e.message}")

For production workloads, add exponential backoff on RateLimitError. The free tier allows 5 requests/minute; paid tiers scale to thousands. Check your current limits at console.anthropic.com/settings/limits.

Cost Breakdown (March 2026 Pricing)

  • Claude Haiku 4.5: $0.80/M input tokens, $4/M output tokens — use for high-volume, speed-sensitive tasks
  • Claude Sonnet 4.5: $3/M input, $15/M output — best quality/cost balance for most apps
  • Claude Opus 4: $15/M input, $75/M output — for complex reasoning tasks where quality matters most

A typical chat message is 200–500 tokens. At Haiku pricing, you can handle 2,000+ exchanges for $1. Start with Haiku for development, benchmark quality against Sonnet, and only upgrade if you see quality gaps that matter for your use case.

Next Steps

You now have a working foundation. From here, the most useful directions:

  • Tool use (function calling): Let Claude call your Python functions — build agents that search the web, query databases, or send emails
  • Streaming responses: Use client.messages.stream() for real-time output in chat UIs
  • Vision: Pass images alongside text for document parsing, screenshot analysis, or product photo descriptions

The Anthropic docs at docs.anthropic.com are genuinely good — the cookbook section has copy-paste examples for most patterns. Start there before building anything custom. More often than not, your use case is already solved. Now go build something.

Similar Posts