Claude Opus 4.7 API nutzen: Eine Anleitung

TL;DR

Claude Opus 4.7 (claude-opus-4-7) ist Anthropic’s leistungsfähigstes GA-Modell. Es unterstützt ein Kontextfenster von 1 Million Tokens, eine maximale Ausgabe von 128K, adaptives Denken, ein neues xhigh Anstrengungslevel, Aufgabenbudgets, hochauflösendes Sehen (3,75 MP) und die Nutzung von Tools. Dieser Leitfaden behandelt die API-Einrichtung, Authentifizierung und funktionierende Codebeispiele in Python, TypeScript und cURL für jede wichtige Funktion.

Einleitung

Anthropic hat Claude Opus 4.7 am 16. April 2026 veröffentlicht. Es ist das leistungsstärkste Modell der Claude-Familie und die erste Wahl für komplexe Schlussfolgerungen, autonome Agenten und bildlastige Workflows.

Wenn Sie die Claude-API bereits verwendet haben, ist der Großteil der Oberfläche vertraut. Aber Opus 4.7 führt mehrere neue Funktionen und grundlegende Änderungen ein, die Code-Updates erfordern. Erweiterte Denkbudgets sind weggefallen. Sampling-Parameter (temperature, top_p, top_k) sind weggefallen. Der Denkmodus unterstützt jetzt nur noch adaptives Denken, und er ist standardmäßig deaktiviert.

Dieser Leitfaden führt Sie durch jeden Schritt: das Abrufen Ihres API-Schlüssels, das Senden Ihrer ersten Anfrage, die Verwendung von adaptivem Denken, das Senden von hochauflösenden Bildern, die Einrichtung der Tool-Nutzung, die Konfiguration von Aufgabenbudgets und das Streamen von Antworten. Jedes Beispiel ist getestet und bereit zum Kopieren. Sie erfahren auch, wie Sie Ihre API-Aufrufe mit Apidog debuggen und testen können, was die Inspektion von mehrstufigen Tool-Nutzungs-Konversationen wesentlich einfacher macht als das Parsen von rohem JSON.

Erste Schritte

Holen Sie sich Ihren API-Schlüssel

1. Melden Sie sich unter console.anthropic.com an
2. Navigieren Sie im Dashboard zu API Keys (API-Schlüssel)
3. Klicken Sie auf Create Key (Schlüssel erstellen) und kopieren Sie den Schlüssel
4. Speichern Sie ihn als Umgebungsvariable:

export ANTHROPIC_API_KEY="sk-ant-your-key-here"

Installieren Sie das SDK

Python:

pip install anthropic

TypeScript/Node.js:

npm install @anthropic-ai/sdk

API-Endpunkt

Alle Anfragen gehen an:

POST https://api.anthropic.com/v1/messages

Erforderliche Header:

x-api-key: YOUR_API_KEY
anthropic-version: 2023-06-01
content-type: application/json

Grundlegende Textanfrage

Der einfachste API-Aufruf. Senden Sie eine Nachricht, erhalten Sie eine Antwort.

Python:

import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Erklären Sie in drei Sätzen, wie HTTP/2 Server Push funktioniert."}
    ]
)

print(message.content[0].text)

TypeScript:

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

const client = new Anthropic();

const message = await client.messages.create({
  model: "claude-opus-4-7",
  max_tokens: 1024,
  messages: [
    { role: "user", content: "Erklären Sie in drei Sätzen, wie HTTP/2 Server Push funktioniert." }
  ],
});

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

cURL:

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-opus-4-7",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "Erklären Sie in drei Sätzen, wie HTTP/2 Server Push funktioniert."}
    ]
  }'

Adaptives Denken

Adaptives Denken ist der einzige unterstützte Denkmodus auf Opus 4.7. Es ermöglicht Claude, Reasoning-Tokens dynamisch basierend auf der Aufgabenkomplexität zuzuweisen. Es ist standardmäßig deaktiviert – Sie müssen es explizit aktivieren.

Python:

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16384,
    thinking={
        "type": "adaptive",
        "display": "summarized"  # optional: siehe Denk-Ausgabe
    },
    messages=[
        {"role": "user", "content": "Analysieren Sie die Zeitkomplexität dieses Algorithmus und schlagen Sie Optimierungen vor:\n\ndef find_pairs(arr, target):\n    result = []\n    for i in range(len(arr)):\n        for j in range(i+1, len(arr)):\n            if arr[i] + arr[j] == target:\n                result.append((arr[i], arr[j]))\n    return result"}
    ]
)

for block in message.content:
    if block.type == "thinking":
        print("Denken:", block.thinking)
    elif block.type == "text":
        print("Antwort:", block.text)

Wichtige Punkte:

• "type": "adaptive" aktiviert das Denken. Setzen Sie nicht budget_tokens – dies führt jetzt zu einem 400-Fehler.
• "display": "summarized" macht den Denk-Inhalt in der Antwort sichtbar. Standard ist "omitted".
• Kombinieren Sie es mit dem Parameter effort, um die Denktiefe zu steuern.

Verwenden des Effort-Parameters

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16384,
    thinking={"type": "adaptive"},
    output_config={"effort": "xhigh"},  # xhigh | high | medium | low
    messages=[
        {"role": "user", "content": "Überprüfen Sie diesen Pull Request auf Sicherheitslücken..."}
    ]
)

Anstrengungslevel für Opus 4.7:

Hochauflösendes Sehen

Opus 4.7 akzeptiert Bilder mit bis zu 2.576 Pixeln an der langen Kante (3,75 Megapixel). Koordinaten werden 1:1 auf tatsächliche Pixel abgebildet.

Python – ein Bild von einer URL analysieren:

message = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://example.com/architecture-diagram.png"
                    }
                },
                {
                    "type": "text",
                    "text": "Beschreiben Sie dieses Architekturdiagramm. Listen Sie jeden Dienst und die Verbindungen zwischen ihnen auf."
                }
            ]
        }
    ]
)

print(message.content[0].text)

Python – ein lokales Bild mit Base64 analysieren:

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-opus-4-7",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/png",
                        "data": image_data
                    }
                },
                {
                    "type": "text",
                    "text": "Welche UI-Bugs sehen Sie in diesem Screenshot?"
                }
            ]
        }
    ]
)

Höher auflösende Bilder verbrauchen mehr Tokens. Wenn Sie keine volle Wiedergabetreue benötigen, ändern Sie die Größe der Bilder, bevor Sie sie senden, um Kosten zu senken.

Tool-Nutzung (Funktionsaufruf)

Die Tool-Nutzung ermöglicht es Claude, von Ihnen definierte Funktionen aufzurufen. Opus 4.7 neigt dazu, standardmäßig weniger Tool-Aufrufe zu verwenden und bevorzugt das Denken. Erhöhen Sie den Anstrengungslevel, um die Tool-Nutzung zu steigern.

Python:

import json

tools = [
    {
        "name": "get_weather",
        "description": "Aktuelles Wetter für eine Stadt abrufen. Gibt Temperatur, Bedingungen und Luftfeuchtigkeit zurück.",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "Stadtname, z.B. 'San Francisco'"
                },
                "units": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Temperatureinheit"
                }
            },
            "required": ["city"]
        }
    }
]

messages = [
    {"role": "user", "content": "Wie ist das Wetter gerade in Tokio?"}
]

# Erster Aufruf — Claude fordert ein Tool an
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    tools=tools,
    messages=messages,
)

# Tool-Aufrufe verarbeiten
if response.stop_reason == "tool_use":
    messages.append({"role": "assistant", "content": response.content})

    tool_results = []
    for block in response.content:
        if block.type == "tool_use":
            # Führen Sie hier Ihre Funktion aus
            result = {"temperature": 22, "conditions": "Teilweise bewölkt", "humidity": 65}

            tool_results.append({
                "type": "tool_result",
                "tool_use_id": block.id,
                "content": json.dumps(result)
            })

    messages.append({"role": "user", "content": tool_results})

    # Zweiter Aufruf — Claude verwendet das Tool-Ergebnis
    final_response = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=1024,
        tools=tools,
        messages=messages,
    )
    print(final_response.content[0].text)

Agenten-Loop-Muster

Für autonome Agenten, die mehrere Tool-Aufrufe hintereinander ausführen:

def run_agent(system_prompt: str, tools: list, user_message: str) -> str:
    messages = [{"role": "user", "content": user_message}]

    while True:
        response = client.messages.create(
            model="claude-opus-4-7",
            max_tokens=16384,
            system=system_prompt,
            tools=tools,
            thinking={"type": "adaptive"},
            output_config={"effort": "xhigh"},
            messages=messages,
        )

        messages.append({"role": "assistant", "content": response.content})

        if response.stop_reason != "tool_use":
            return "".join(
                block.text for block in response.content
                if hasattr(block, "text")
            )

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

        messages.append({"role": "user", "content": tool_results})

Aufgabenbudgets (Beta)

Aufgabenbudgets geben Claude ein Token-Kontingent für eine gesamte Agenten-Loop. Das Modell sieht einen laufenden Countdown und schließt die Arbeit ab, wenn das Budget aufgebraucht ist.

response = client.beta.messages.create(
    model="claude-opus-4-7",
    max_tokens=128000,
    output_config={
        "effort": "high",
        "task_budget": {"type": "tokens", "total": 128000},
    },
    messages=[
        {"role": "user", "content": "Überprüfen Sie die Codebasis und schlagen Sie einen Refactoring-Plan vor."}
    ],
    betas=["task-budgets-2026-03-13"],
)

Wichtige Einschränkungen:

• Mindestbudget: 20.000 Tokens
• Advisory, keine harte Grenze – Claude kann überschreiten
• Anders als max_tokens (harte Obergrenze, die das Modell nicht sehen kann)
• Erfordert den Beta-Header task-budgets-2026-03-13

Streamen von Antworten

Streamen Sie Antworten für Echtzeit-Ausgaben in Chat-Oberflächen.

Python:

with client.messages.stream(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=[
        {"role": "user", "content": "Schreiben Sie eine Python-Funktion zum Parsen von CSV-Dateien mit Fehlerbehandlung."}
    ]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

TypeScript:

const stream = await client.messages.stream({
  model: "claude-opus-4-7",
  max_tokens: 4096,
  messages: [
    { role: "user", content: "Schreiben Sie eine Python-Funktion zum Parsen von CSV-Dateien mit Fehlerbehandlung." }
  ],
});

for await (const event of stream) {
  if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
    process.stdout.write(event.delta.text);
  }
}

Wenn Sie adaptives Denken mit display: "summarized" aktiviert haben, werden die Denkblöcke zuerst gestreamt, gefolgt von der Textantwort. Ohne display: "summarized" sehen Benutzer eine Pause während des Denkens, gefolgt von der Textausgabe.

Prompt-Caching

Reduzieren Sie Kosten für wiederholten Kontext (System-Prompts, lange Dokumente), indem Sie diese zwischenspeichern.

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "Sie sind ein erfahrener Code-Reviewer. Überprüfen Sie den Code auf Sicherheitslücken, Leistungsprobleme und Verstöße gegen Best Practices...",
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[
        {"role": "user", "content": "Überprüfen Sie diese Funktion:\n\ndef process_user_input(data):\n    return eval(data)"}
    ]
)

Cache-Preise für Opus 4.7:

Ein einzelner Cache-Lesezugriff amortisiert den 5-Minuten-Cache-Schreibvorgang. Zwei Lesezugriffe amortisieren den 1-Stunden-Schreibvorgang.

Mehrstufige Konversationen

Behalten Sie den Kontext über mehrere Runden hinweg bei, indem Sie ihn dem Nachrichten-Array hinzufügen.

messages = []

# Runde 1
messages.append({"role": "user", "content": "Ich muss eine REST-API für eine To-Do-App erstellen."})

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=messages,
)

messages.append({"role": "assistant", "content": response.content})

# Runde 2
messages.append({"role": "user", "content": "Fügen Sie die Authentifizierung mit JWT-Tokens hinzu."})

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=4096,
    messages=messages,
)

Testen Ihrer API-Aufrufe mit Apidog

Der Aufbau einer Claude-API-Integration umfasst komplexe Payloads: mehrstufige Nachrichten, Tool-Definitionen, Tool-Ergebnisse, Base64-Bilder und Streaming-Antworten. Ein Tool wie Apidog vereinfacht das Debugging und Testen.

Richten Sie Ihre Umgebung ein:

1. Erstellen Sie ein neues Projekt in Apidog und fügen Sie den Claude Messages API-Endpunkt hinzu.
2. Speichern Sie Ihren ANTHROPIC_API_KEY in Umgebungsvariablen.
3. Legen Sie die erforderlichen Header fest (x-api-key, anthropic-version, content-type).

Testen Sie Tool-Use-Flows:

Mit Apidog können Sie Anfragen verketten, sodass Sie eine vollständige Tool-Use-Schleife simulieren können: Senden Sie die ursprüngliche Nachricht, überprüfen Sie Claudes Tool-Aufruf, erstellen Sie das Tool-Ergebnis und senden Sie es zurück. Der visuelle Anfrage-/Antwortinspektor zeigt genau, was in jeder Payload enthalten ist.

Modelle vergleichen:

Führen Sie dieselben Prompts für claude-opus-4-6 und claude-opus-4-7 aus, um die Token-Anzahl, die Antwortqualität und die Latenz zu vergleichen. Apidogs Test-Runner macht A/B-Vergleiche wiederholbar.

Schemas validieren:

Definieren Sie JSON-Schemas für Ihr erwartetes Antwortformat und lassen Sie Apidog automatisch überprüfen, ob Claudes Antworten übereinstimmen. Dies fängt Regressionen ab, wenn Sie Prompts ändern oder Modelle wechseln.

Häufige Fehler und Behebungen

Preisübersicht

Hinweis: Der neue Tokenizer von Opus 4.7 kann für denselben Text bis zu 35 % mehr Tokens verbrauchen als Opus 4.6. Verwenden Sie den Endpunkt /v1/messages/count_tokens, um die Kosten vor der Produktionseinführung abzuschätzen.

Fazit

Claude Opus 4.7 ist das leistungsfähigste Modell in der Claude-Familie. Die API ist weitgehend kompatibel mit Opus 4.6, aber die Entfernung erweiterter Denkbudgets und Sampling-Parameter erfordert Codeänderungen. Die neuen Funktionen – adaptives Denken, xhigh-Anstrengung, Aufgabenbudgets und hochauflösendes Sehen – geben Ihnen mehr Kontrolle darüber, wie das Modell denkt und wie viel es kostet.

Beginnen Sie mit der grundlegenden Textanfrage, fügen Sie adaptives Denken für komplexe Aufgaben hinzu und integrieren Sie Tool-Nutzung und Aufgabenbudgets, wenn Ihr Agent wächst. Verwenden Sie Apidog, um Ihre Integration zu testen, Payloads zu validieren und die Leistung über verschiedene Modellversionen hinweg zu vergleichen.