Claude Sonnet 4.6: Was kostet es wirklich?

Kurz gesagt

Claude Sonnet 4.6 kostet 3 $ pro Million Eingabe-Tokens und 15 $ pro Million Ausgabe-Tokens – der gleiche Preis wie Sonnet 4.5, liefert aber eine nahezu Opus-Leistung. Mit Prompt-Caching sinken die Cache-Lesevorgänge auf 0,30 $/MTok (90 % Ersparnis). Die Batch-API halbiert die Kosten auf 1,50 $/MTok für Eingabe und 7,50 $/MTok für Ausgabe. Das 1M-Token-Kontextfenster (Beta) löst eine höhere Preisgestaltung für langen Kontext aus, und zwar 6 $/MTok für Eingabe und 22,50 $/MTok für Ausgabe bei Anfragen über 200.000 Tokens.

Claude Sonnet 4.6 Basispreise

Claude Sonnet 4.6 behält den gleichen Preis wie sein Vorgänger bei und liefert gleichzeitig deutlich bessere Ergebnisse. Hier ist die Kernpreisgestaltung auf einen Blick:

MTok = Millionen Tokens. Alle Preise in USD.

Die hier gebotene Wertigkeit ist kaum zu ignorieren. Frühe Tester bevorzugten Sonnet 4.6 gegenüber dem früheren Premium-Modell Opus 4.5 in 59 % der direkten Vergleiche – bei 60 % der Kosten.

Für die meisten Kodierungs-, Analyse- und Agenten-Aufgaben müssen Sie keine Opus-Preise mehr zahlen, um Ergebnisse auf Opus-Niveau zu erhalten.

Vollständige Preisübersicht nach Funktion

Standard-API-Preise

Die Standardtarife gelten für alle synchronen API-Aufrufe, die über die Anthropic API getätigt werden:

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Summarize this document."}]
)

# Check exact token usage
print(f"Input tokens: {response.usage.input_tokens}")
print(f"Output tokens: {response.usage.output_tokens}")

# Calculate cost
input_cost  = response.usage.input_tokens  / 1_000_000 * 3.00
output_cost = response.usage.output_tokens / 1_000_000 * 15.00
print(f"Request cost: ${input_cost + output_cost:.6f}")

Für den typischen API-Aufruf mit einer 500-Token-Eingabe und 300-Token-Ausgabe betragen die Kosten ungefähr 0,0060 $. Das ist weniger als ein Cent pro Anfrage zu Standardtarifen.

Prompt-Caching-Preise

Prompt-Caching ist der wirkungsvollste Kostenhebel von Sonnet 4.6. Es speichert Teile Ihres Prompts serverseitig und berechnet bei Cache-Treffern drastisch weniger.

Cache-Schreibtarife:- 5-Minuten-Cache: 3,75 $/MTok (1,25× Basis-Eingabepreis) - 1-Stunden-Cache: 6,00 $/MTok (2× Basis-Eingabepreis)

Cache-Lesetarif:- 0,30 $/MTok — ein Zehntel des Standard-Eingabepreises

Wenn Ihr System-Prompt 10.000 Tokens lang ist und Sie 1.000 Anfragen pro Tag verarbeiten: - Ohne Caching: 10.000 × 1.000 × 3 $/MTok = 30 $/Tag- Mit Caching (einmal schreiben, 999× lesen): 3,75 $ + (999 × 0,30 $) × 10.000/MTok ≈ 3,04 $/Tag

Das ist eine 90%ige Reduzierung allein für einen statischen System-Prompt.

import anthropic

client = anthropic.Anthropic()

# Mark expensive static content for caching
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "You are a senior code reviewer specializing in Python, FastAPI, and distributed systems. Here are our coding standards and review guidelines: [large block of standards text]...",
            "cache_control": {"type": "ephemeral"}  # Cache this block
        }
    ],
    messages=[{"role": "user", "content": "Review this pull request: [PR content]"}]
)

# Check what came from cache vs fresh tokens
usage = response.usage
print(f"Cache write tokens: {usage.cache_creation_input_tokens}")
print(f"Cache read tokens:  {usage.cache_read_input_tokens}")
print(f"Uncached tokens:    {usage.input_tokens}")

Wann welche Cache-Dauer verwenden:- 5-Minuten-Cache: Hochfrequente Aufrufe, stoßweiser Datenverkehr, kurze Gesprächsfenster - 1-Stunden-Cache: Hintergrundverarbeitungspipelines, Batch-Jobs mit längeren Pausen, Agenten-Loops

Batch-API-Preise

Die Batch-API bietet einen pauschalen Rabatt von 50 % auf Eingabe- und Ausgabe-Tokens im Austausch für asynchrone Verarbeitung (Ergebnisse innerhalb von 24 Stunden, typischerweise viel früher, verfügbar).

Beste Anwendungsfälle für die Batch-API:- Content-Moderationspipelines - Dokumentenklassifizierung im großen Maßstab - Datenanreicherung über Nacht - Generierung von Einbettungen oder Zusammenfassungen für große Datensätze - Jede nicht-interaktive Verarbeitung, bei der Latenz keine Rolle spielt

Bei 1,50 $/MTok für Eingabe und 7,50 $/MTok für Ausgabe kostet die Verarbeitung einer Million Dokumente mit jeweils 500 Eingabe-Tokens und 100 Ausgabe-Tokens: - Eingabe: 500M Tokens × 1,50 $/MTok = 750 $- Ausgabe: 100M Tokens × 7,50 $/MTok = 750 $- Gesamt: 1.500 $ für 1 Million Dokumente (~0,0015 $ pro Dokument)

Batch-API: 50 % Rabatt für nicht-Echtzeit-Workloads

Die Batch-Verarbeitung ist unkompliziert: Anfragen senden, Ergebnisse asynchron zum halben Preis erhalten. Der Kompromiss ist die Latenz – die Ergebnisse kommen innerhalb von 24 Stunden, meist jedoch viel schneller.

import anthropic, time

client = anthropic.Anthropic()

def batch_classify(texts: list[str]) -> list[str]:
    """Classify a list of texts at Batch API rates."""

    # Submit batch
    requests = [
        {
            "custom_id": f"item-{i}",
            "params": {
                "model": "claude-sonnet-4-6",
                "max_tokens": 20,
                "messages": [{
                    "role": "user",
                    "content": f"Classify as POSITIVE, NEGATIVE, or NEUTRAL. Reply with one word only.\n\n{text}"
                }]
            }
        }
        for i, text in enumerate(texts)
    ]

    batch = client.messages.batches.create(requests=requests)

    # Poll until complete
    while True:
        status = client.messages.batches.retrieve(batch.id)
        if status.processing_status == "ended":
            break
        time.sleep(60)

    # Collect results in order
    results = {}
    for result in client.messages.batches.results(batch.id):
        if result.result.type == "succeeded":
            results[result.custom_id] = result.result.message.content[0].text.strip()

    return [results.get(f"item-{i}", "ERROR") for i in range(len(texts))]

Preise für langen Kontext (1M Token)

Wenn Sie das 1M-Token-Kontextfenster über den Beta-Header context-1m-2025-08-07 aktivieren, werden Anfragen, die 200.000 Eingabe-Tokens überschreiten, zu einem höheren Satz berechnet.

Tariftabelle für langen Kontext

Die 200K-Schwelle basiert auf den gesamten Eingabe-Tokens, welche umfassen: - input_tokens (Standard-Eingabe) - cache_creation_input_tokens (bei Verwendung von Prompt-Caching) - cache_read_input_tokens (bei Verwendung von Prompt-Caching)

Wenn die Summe 200K überschreitet, werden alle Tokens in dieser Anfrage zum höheren Satz berechnet.

Langer Kontext + Batch-API

Der 50%ige Rabatt der Batch-API kumuliert sich mit der Preisgestaltung für langen Kontext:

Die Verarbeitung großer Dokumente in Masse über die Batch-API hält die Kosten für langen Kontext überschaubar.

Preise für Tools und Funktionen

Mehrere Tools verursachen separate Kosten, die über die Token-Kosten hinausgehen.

Websuch-Tool

10,00 $ pro 1.000 Suchanfragen
+ Standard-Token-Kosten für suchgenerierten Inhalt

Jeder Websuchaufruf zählt als eine Nutzung, unabhängig davon, wie viele Ergebnisse zurückgegeben werden. Keine Kosten, wenn die Suche fehlschlägt.

import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    betas=["code-execution-web-tools-2026-02-09"],
    tools=[{"type": "web_search_20260209", "name": "web_search"}],
    messages=[{"role": "user", "content": "What's the latest LLM benchmark news from this week?"}]
)

usage = response.usage
search_count = getattr(usage, 'server_tool_use', {})
print(f"Web searches used: {search_count.get('web_search_requests', 0)}")
# Each search: $0.01

Code-Ausführungs-Tool

Kostenlos, wenn gebündelt mit Websuche oder Web-Abruf (unter Verwendung der Tool-Versionen web_search_20260209 oder web_fetch_20260209).

Bei eigenständiger Verwendung: - 1.550 kostenlose Stunden pro Organisation pro Monat - 0,05 $ pro Stunde pro Container jenseits des kostenlosen Kontingents - Mindestabrechnungseinheit: 5 Minuten

Für die meisten Entwicklungs- und Test-Workloads ist das kostenlose Kontingent mehr als ausreichend.

Web-Abruf-Tool

Keine zusätzlichen Gebühren. Sie zahlen nur die Standard-Token-Kosten für Inhalte, die in das Gespräch gelangen.

Overhead für Computernutzung

Die Computernutzung fügt einen festen Token-Overhead hinzu: - System-Prompt-Ergänzung: 466–499 Tokens - Tool-Definitions-Tokens: 735 Tokens pro Tool (Claude 4.x Modelle)

Für eine Computernutzungssitzung mit 100 Runden à 200 Tokens/Runde plus Screenshots: - Tool-Overhead: 735 Tokens × 3 $/MTok = 0,0022 $ (vernachlässigbar) - Screenshot-Tokens hängen von der Auflösung ab; planen Sie ~2.000–5.000 Tokens pro Screenshot ein

Claude Sonnet 4.6 vs. alle Modelle: Vollständiger Vergleich

Aktuelle Modellpreise

Alle Preise in USD pro Million Tokens.

Sonnet 4.6 vs. Opus 4.6: Die Wertfrage

Für die überwiegende Mehrheit der Aufgaben – Kodierung, Analyse, Dokumentenverarbeitung, Agenten-Workflows – erreicht Sonnet 4.6 die Opus-Leistung zu 60 % des Preises. Opus 4.6 ist den Aufpreis wert, wenn Sie 128K Ausgabe-Tokens oder die absolute maximale Leistung bei neuen Denkaufgaben benötigen.

Sonnet 4.6 vs. Haiku 4.5: Wann welches Modell verwenden

Das intelligente Muster: Verwenden Sie Haiku 4.5 für Routing, Klassifizierung und einfache Extraktion; leiten Sie komplexe Aufgaben an Sonnet 4.6 weiter. Dieser Hybridansatz kostet typischerweise 60–80 % weniger, als wenn Sonnet 4.6 für alles verwendet würde.

Kosten mit Apidog vor der Live-Schaltung testen

Bevor Sie in Produktion gehen, möchten Sie genau wissen, was jede Anfrage kostet. Der visuelle API-Client von Apidog ermöglicht es Ihnen, Claude Sonnet 4.6-Aufrufe zu testen, die vollständige Antwort einschließlich des usage-Objekts zu überprüfen und die Token-Zahlen pro Anfrage zu verfolgen.

Kostentransparenz in Apidog einrichten

1. Erstellen Sie eine neue POST-Anfrage an https://api.anthropic.com/v1/messages
2. Fügen Sie Header hinzu: x-api-key, anthropic-version: 2023-06-01, Content-Type: application/json
3. Setzen Sie den Body mit Ihrem Modell und Ihren Nachrichten
4. Führen Sie die Anfrage aus — das usage-Objekt der Antwort zeigt genaue Token-Zahlen

{
  "usage": {
    "input_tokens": 523,
    "cache_creation_input_tokens": 5000,
    "cache_read_input_tokens": 0,
    "output_tokens": 312
  }
}

Aus diesen Zahlen berechnen Sie die tatsächlichen Kosten: - Eingabe: 523 Tokens × 3 $/MTok = 0,00157 $ - Cache-Schreibvorgang: 5.000 Tokens × 3,75 $/MTok = 0,01875 $ - Ausgabe: 312 Tokens × 15 $/MTok = 0,00468 $ - Gesamtkosten erster Aufruf: 0,025 $ (nachfolgende Aufrufe mit Cache-Treffer: ~0,006 $)

Sie können diese Anfragen als Sammlung in Apidog speichern, mit Ihrem Team teilen und Kostenschätzungen für verschiedene Prompt-Variationen durchführen, bevor Sie Ihr Produktionsdesign finalisieren.

Bereit, mit der Entwicklung zu beginnen? Laden Sie Apidog kostenlos herunter, um Claude Sonnet 4.6 API-Aufrufe visuell zu testen, die Token-Nutzung pro Anfrage zu überprüfen und Ihre Kosten vor der Bereitstellung genau zu kalkulieren.