Claude API: Anthropic SDK Tutorial & Beispiele 2026

Aktualisiert: März 2026 · Lesezeit: ca. 18 Minuten

Du willst KI in deine eigene App einbauen und suchst eine Alternative zur ChatGPT-API? Dann solltest du dir die Claude API von Anthropic genauer ansehen – dem Unternehmen hinter Claude AI im Test. Während OpenAI das Ökosystem dominiert, hat sich Anthropics API still und leise zu einer der leistungsfähigsten Schnittstellen für Large Language Models entwickelt – mit einem 200K-Token-Kontextfenster, nativem PDF-Support und einem der besten Reasoning-Modelle auf dem Markt.

In diesem Tutorial zeige ich dir Schritt für Schritt, wie du die Anthropic API einrichtest, deine erste Anfrage sendest und fortgeschrittene Features wie Vision, Tool Use und Streaming nutzt. Mit echten Python-Code-Beispielen, die du sofort kopieren und einsetzen kannst.

Claude API Key erstellen: Schritt für Schritt

Bevor du eine einzige Zeile Code schreibst, brauchst du einen Claude API Key. So bekommst du ihn:

1. Account auf der Anthropic Console anlegen

Gehe auf console.anthropic.com und erstelle einen Account. Du kannst dich mit E-Mail oder über Google anmelden. Nach der Registrierung bestätigst du deine E-Mail-Adresse.^[1]

2. Billing einrichten

Navigiere zu Settings → Billing und hinterlege eine Kreditkarte. Anthropic bietet neuen Accounts ein kostenloses Startguthaben von 5 US-Dollar – damit kannst du die API ausgiebig testen, bevor echte Kosten entstehen. Du kannst außerdem ein monatliches Ausgabenlimit setzen, um Überraschungen zu vermeiden.

3. API Key generieren

Unter API Keys klickst du auf „Create Key“, vergibst einen Namen (z. B. „mein-chatbot-projekt“) und kopierst den Schlüssel sofort. Wichtig: Der Key wird nur einmal angezeigt. Speichere ihn in einer .env-Datei oder deinem Secrets-Manager.

# .env Datei
ANTHROPIC_API_KEY=sk-ant-api03-xxxxxxxxxxxxxxxxxxxxxxxx

Erste API-Anfrage: Python-Beispiel mit der Messages API

Die Claude Messages API ist der zentrale Endpunkt für alle Interaktionen. Hier ist dein erstes funktionierendes Beispiel:^[2]

SDK installieren

pip install anthropic

Minimales Python-Beispiel

import anthropic

client = anthropic.Anthropic()  # liest ANTHROPIC_API_KEY aus Umgebungsvariablen

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Erkläre mir Docker in 3 Sätzen."}
    ]
)

print(message.content[0].text)

Das war’s – sechs Zeilen produktiver Code. Der Client liest den API Key automatisch aus der Umgebungsvariable ANTHROPIC_API_KEY. Die Antwort kommt als strukturiertes Objekt zurück, wobei message.content[0].text den eigentlichen Text enthält.

Alternative: Direkt per cURL

Wenn du die API ohne SDK testen willst, geht das auch per cURL:

curl https://api.anthropic.com/v1/messages 
  -H "content-type: application/json" 
  -H "x-api-key: $ANTHROPIC_API_KEY" 
  -H "anthropic-version: 2023-06-01" 
  -d '{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "Was ist Kubernetes?"}
    ]
  }'

Claude-Modelle und Preise im Überblick

Anthropic bietet drei Modell-Klassen an, die sich in Leistung, Geschwindigkeit und Preis unterscheiden. Die Wahl des richtigen Modells hat direkten Einfluss auf deine Kosten und die Qualität der Ergebnisse.^[3]

Was bedeutet das in der Praxis? Ein typischer Chatbot-Dialog mit Sonnet (500 Input-Tokens, 300 Output-Tokens) kostet ungefähr 0,006 $ pro Nachricht. Das sind rund 166 Nachrichten pro Dollar. Mit Haiku kommst du auf über 2.000 Nachrichten pro Dollar – ideal für Anwendungen mit hohem Volumen.

API-Features im Detail erklärt

Die Anthropic API bietet weit mehr als einfache Text-Completion. Hier sind die wichtigsten Features, die du kennen solltest:

Messages API – Der Kern

Alle Interaktionen laufen über den /v1/messages-Endpunkt. Du sendest eine Liste von Nachrichten (user/assistant) und erhältst eine Antwort. Anders als bei OpenAI gibt es keine separaten Endpunkte für Chat vs. Completion – alles läuft über Messages.^[2]

System Prompts

System Prompts definieren das Verhalten von Claude für die gesamte Konversation. Sie werden als separater Parameter (nicht als Nachricht) übergeben:

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="Du bist ein hilfreicher Assistent für Python-Entwickler. "
           "Antworte immer mit Codebeispielen und erkläre knapp.",
    messages=[
        {"role": "user", "content": "Wie lese ich eine CSV-Datei ein?"}
    ]
)

Vision – Bildanalyse per API

Claude kann Bilder analysieren, beschreiben und Fragen dazu beantworten. Du übergibst Bilder entweder als Base64-kodierte Daten oder über eine URL:^[4]

import anthropic
import base64

client = anthropic.Anthropic()

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

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/png",
                        "data": image_data
                    }
                },
                {
                    "type": "text",
                    "text": "Was siehst du auf diesem Screenshot?"
                }
            ]
        }
    ]
)

print(message.content[0].text)

Tool Use (Function Calling)

Mit Tool Use kann Claude externe Funktionen aufrufen – etwa eine Datenbank abfragen, eine API ansprechen oder Berechnungen durchführen. Du definierst die verfügbaren Tools mit JSON Schema, und Claude entscheidet selbstständig, wann ein Tool-Aufruf sinnvoll ist:

tools = [
    {
        "name": "get_weather",
        "description": "Ruft das aktuelle Wetter für eine Stadt ab.",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "Name der Stadt"
                }
            },
            "required": ["city"]
        }
    }
]

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=tools,
    messages=[
        {"role": "user", "content": "Wie ist das Wetter in Berlin?"}
    ]
)

# Claude antwortet mit einem Tool-Aufruf:
# {"type": "tool_use", "name": "get_weather", "input": {"city": "Berlin"}}

Streaming

Für Echtzeit-Anwendungen wie Chatbots willst du die Antwort Token für Token streamen, statt auf die komplette Antwort zu warten:

with client.messages.stream(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Schreibe eine kurze Geschichte."}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

Die Streaming-Variante nutzt Server-Sent Events (SSE) und fühlt sich für Nutzer deutlich responsiver an – die ersten Tokens erscheinen innerhalb von Millisekunden.

Praxis: Einfachen Chatbot mit Claude bauen (Python)

Hier ist ein voll funktionsfähiger Terminal-Chatbot in 15 Zeilen – mit Konversationsverlauf, damit Claude sich an vorherige Nachrichten erinnert:

import anthropic

client = anthropic.Anthropic()
conversation = []

print("Claude Chatbot (Ctrl+C zum Beenden)n")

while True:
    user_input = input("Du: ")
    conversation.append({"role": "user", "content": user_input})

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        system="Du bist ein freundlicher, hilfreicher Assistent. Antworte auf Deutsch.",
        messages=conversation
    )

    assistant_msg = response.content[0].text
    print(f"nClaude: {assistant_msg}n")
    conversation.append({"role": "assistant", "content": assistant_msg})

Der Trick ist die conversation-Liste: Jede Nachricht (User + Assistant) wird angehängt, sodass Claude den gesamten Verlauf sieht. Beachte, dass bei langen Gesprächen die Token-Kosten steigen – in der Produktion solltest du ältere Nachrichten ab einer bestimmten Länge abschneiden oder zusammenfassen.

Praxis: PDF analysieren mit Claude Vision

Eines der stärksten Features der Claude API ist die native PDF-Unterstützung. Du kannst ein PDF direkt an die API schicken – Claude extrahiert Text, analysiert Tabellen und versteht Layout-Strukturen:

import anthropic
import base64

client = anthropic.Anthropic()

# PDF laden und als Base64 kodieren
with open("jahresbericht.pdf", "rb") as f:
    pdf_data = base64.standard_b64encode(f.read()).decode("utf-8")

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "document",
                    "source": {
                        "type": "base64",
                        "media_type": "application/pdf",
                        "data": pdf_data
                    }
                },
                {
                    "type": "text",
                    "text": "Fasse die wichtigsten Kennzahlen aus diesem "
                            "Jahresbericht zusammen. Liste Umsatz, Gewinn "
                            "und Mitarbeiterzahl als Tabelle auf."
                }
            ]
        }
    ]
)

print(message.content[0].text)

Praxis-Tipps für PDF-Analyse:

• PDFs dürfen bis zu 100 Seiten umfassen
• Die maximale Dateigröße beträgt 32 MB
• Tabellen und Diagramme werden erkannt und interpretiert
• Für mehrseitige Dokumente kannst du gezielt nach bestimmten Seiten fragen
• Kombiniere PDF-Input mit einem präzisen System Prompt für bessere Ergebnisse

Claude API vs. OpenAI API: Der große Vergleich

Beide APIs sind hervorragend – aber sie haben unterschiedliche Stärken. Hier der direkte Vergleich:^[3][5]

Fazit des Vergleichs: Die Claude API punktet mit dem größeren Kontextfenster, nativer PDF-Analyse und exzellentem Reasoning. Die OpenAI API im Vergleich bietet mehr SDK-Sprachen, Bildgenerierung und ein breiteres Ökosystem. Für einen detaillierten Vergleich der Chatversionen schau dir unseren separaten Artikel an.

Rate Limits und Best Practices

Anthropic setzt Rate Limits basierend auf deinem Usage Tier. Je mehr du die API nutzt und bezahlst, desto höher steigst du auf:^[1]

Best Practices für die Claude API

• Exponentielles Backoff: Bei 429-Fehlern (Rate Limit) warte 1s, 2s, 4s, 8s – nicht sofort erneut anfragen
• Prompt Caching nutzen: Markiere statische Teile deines Prompts mit cache_control, um Kosten zu sparen
• max_tokens bewusst setzen: Setze den Wert nicht höher als nötig – das spart Kosten und verhindert unnötig lange Antworten
• Batch-Anfragen: Für nicht-zeitkritische Aufgaben nutze die Message Batches API – 50 % günstiger als Einzelanfragen
• Token zählen: Nutze den usage-Block in der API-Antwort, um deinen Verbrauch zu tracken
• Fehlerbehandlung: Fange anthropic.RateLimitError, anthropic.APIError und anthropic.AuthenticationError separat ab

import anthropic
import time

client = anthropic.Anthropic()

def send_with_retry(messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            return client.messages.create(
                model="claude-sonnet-4-20250514",
                max_tokens=1024,
                messages=messages
            )
        except anthropic.RateLimitError:
            wait = 2 ** attempt
            print(f"Rate Limit erreicht. Warte {wait}s...")
            time.sleep(wait)
        except anthropic.APIError as e:
            print(f"API-Fehler: {e}")
            raise
    raise Exception("Max Retries erreicht")

Anthropic SDK: Python & TypeScript Quickstart

Anthropic bietet offizielle SDKs für die beiden populärsten Sprachen. Hier der Schnellstart für beide:^[2]

Python SDK

# Installation
pip install anthropic

# Synchroner Client
import anthropic

client = anthropic.Anthropic()  # API Key aus ANTHROPIC_API_KEY
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hallo Claude!"}]
)
print(response.content[0].text)

# Asynchroner Client (für asyncio)
import asyncio

async_client = anthropic.AsyncAnthropic()

async def main():
    response = await async_client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Hallo Claude!"}]
    )
    print(response.content[0].text)

asyncio.run(main())

TypeScript SDK

// Installation
// npm install @anthropic-ai/sdk

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

const client = new Anthropic();  // API Key aus ANTHROPIC_API_KEY

async function main() {
  const message = await client.messages.create({
    model: "claude-sonnet-4-20250514",
    max_tokens: 1024,
    messages: [
      { role: "user", content: "Hallo Claude!" }
    ],
  });

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

main();

Beide SDKs bieten volle TypeScript-/Type-Hint-Unterstützung, automatische Retries bei transienten Fehlern und Streaming-Methoden. Die API-Versionierung läuft über den anthropic-version-Header, den das SDK automatisch setzt.

Fortgeschritten: Extended Thinking

Für komplexe Aufgaben kannst du Extended Thinking aktivieren – Claude denkt dann in einem internen „Scratchpad“ nach, bevor es antwortet. Das verbessert die Qualität bei mathematischen Problemen, Code-Debugging und mehrstufigem Reasoning erheblich:

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000  # Max. Tokens für den Denkprozess
    },
    messages=[{"role": "user", "content": "Löse dieses Optimierungsproblem..."}]
)

# Thinking-Blocks und Antwort auslesen
for block in response.content:
    if block.type == "thinking":
        print(f"Denkprozess: {block.thinking}")
    elif block.type == "text":
        print(f"Antwort: {block.text}")

Häufig gestellte Fragen zur Claude API

Quellen und Referenzen