---
title: Nachdenken steuern
url: https://platform.claude.com/docs/de/build-with-claude/thinking-steering-and-cost
description: Steuere mit Effort-Stufen, System-Prompt-Anleitungen und nachrichtenbezogener Steuerung, wie oft und wie tief Claude denkt, und verstehe die Kosten und Preisgestaltung des Nachdenkens.
---
Um zu erfahren, wie „zero data retention“ (Null-Datenspeicherung), oder ZDR, auf diese Funktion angewendet wird, siehe [API und Datenspeicherung](https://platform.claude.com/docs/de/manage-claude/api-and-data-retention).
Claudes „thinking“ (Nachdenken) ist adaptiv: Das Modell bewertet jede Anfrage und entscheidet, ob und wie viel es nachdenkt. Du legst eine Absicht fest, gibst optional den Effort an, und das Modell setzt Reasoning dort ein, wo es dieses für hilfreich hält.
Das macht Nachdenken zu einer guten Wahl für Workloads, die triviale und komplexe Anfragen mischen, sowie für agentische Workflows mit langem Horizont, bei denen die richtige Menge an Reasoning von Schritt zu Schritt variiert.
Wie du Nachdenken aktivierst, wie du die Ausgabe des Nachdenkens liest und was es mit der [Ausgabe des Nachdenkens bei Claude Fable 5 und Claude Mythos 5](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-output-on-claude-fable-5-and-claude-mythos-5) auf sich hat, erfährst du in der Übersicht zu [Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking). Diese Seite behandelt, wie Claude entscheidet, wann es nachdenkt, wie du das Nachdenken steuerst und welche Mechanismen für Caching, Kosten und Preise sich daraus ergeben.
## Wie Claude entscheidet, wann es nachdenkt
Nachdenken ist für das Modell optional. Bei jeder Anfrage wägt Claude die Komplexität der Eingabe ab und entscheidet, ob tieferes Reasoning die Antwort verbessern würde. Eine einfache Faktenfrage erhält möglicherweise eine direkte Antwort ganz ohne „thinking block“ (Thinking-Block); ein mehrstufiges Mathematikproblem oder eine knifflige Debugging-Aufgabe löst tieferes Reasoning aus.
Die Entscheidung fällt pro Anfrage. Dieselbe Konversation kann Turns mit und ohne Nachdenken enthalten, und ein Turn, in dem Claude sich entschieden hat, nicht zu denken, enthält keinen Thinking-Block. Baue keine Anwendungslogik, die davon ausgeht, dass jeder Assistant-Turn mit einem beginnt.
Die primäre Kontrolle über diese Entscheidung ist der Parameter [effort](https://platform.claude.com/docs/de/build-with-claude/effort), der als weiche Vorgabe dafür dient, wie bereitwillig und wie tief Claude denken soll; siehe [Effort-Stufen](https://platform.claude.com/docs/de/build-with-claude/thinking-steering-and-cost#effort-levels) auf dieser Seite für die Wirkung jeder Stufe.
Wenn du möchtest, dass Claude seltener denkt, senke zuerst die Effort-Stufe, bevor du zu Prompt-basierter Steuerung greifst.
Nachdenken verschränkt sich außerdem automatisch mit der „tool use“ (Tool-Nutzung): Claude kann zwischen Tool-Aufrufen nachdenken und jedes Tool-Ergebnis reflektieren, bevor es entscheidet, was als Nächstes zu tun ist ([verschachteltes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking#interleaved-thinking)). Dafür brauchst du weder einen Beta-Header noch zusätzliche Konfiguration.
Das vollständige Bild, wie die Thinking-Konfiguration und der Effort-Parameter zusammenwirken, findest du unter [Nachdenken und Effort](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-and-effort).
## Steuern, wie oft Claude denkt
Ob Claude in einem bestimmten Turn denkt, lässt sich per Prompt beeinflussen. Effort legt die Grundhaltung fest, aber du kannst die Entscheidung auch direkt mit Anweisungen in natürlicher Sprache formen, entweder global im „system prompt“ (System-Prompt) oder pro Nachricht aus dem User-Turn.
Verwende die beiden Hebel gemeinsam in dieser Reihenfolge:
1. Setze die Effort-Stufe, die zur Standardbalance deines Workloads zwischen Qualität und Latenz passt.
2. Füge Prompt-Anleitungen nur hinzu, wenn Claudes Auslöseverhalten auf dieser Stufe immer noch nicht deinen Anforderungen entspricht.
Um bei Claude Sonnet 5.5 und Claude Haiku 5.5 weniger Nachdenken zu erhalten, senke die Effort-Stufe. Claude Sonnet 5.5 im System-Prompt zu bitten, weniger nachzudenken, reduziert sein Nachdenken nicht zuverlässig, und in Anthropics Tests hat die Anweisung im Prompt an Claude Haiku 5.5, direkt zu antworten, es nicht vom Nachdenken abgehalten. Siehe [Prompting für Claude Sonnet 5.5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#calibrate-effort) und [Prompting für Claude Haiku 5.5](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#use-effort-to-control-thinking).
Umfassendere Prompting-Hinweise zum Nachdenken findest du unter [Nutze die Fähigkeiten für Nachdenken und verschachteltes Nachdenken](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/claude-prompting-best-practices#leverage-thinking-and-interleaved-thinking-capabilities).
### Effort-Stufen
Effort ist der primäre Steuerungshebel für das Nachdenken. Jede Stufe setzt einen anderen Standard dafür, wie oft und wie tief Claude denkt:
| Effort-Stufe | Denkverhalten |
| ------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------- |
| `max` | Claude denkt am bereitwilligsten und am tiefsten, ohne Beschränkung der Denklänge. |
| `xhigh` | Claude denkt bereitwilliger und tiefer als bei `high`, geeignet für ausgedehnte Erkundung. |
| `high` (Standard bei den meisten Modellen) | Claude denkt bei den meisten Anfragen, die davon profitieren. Bietet tiefes Reasoning bei komplexen Aufgaben. |
| `medium` (Standard bei Claude Opus 5.5 und Claude Haiku 5.5) | Claude denkt in moderatem Umfang nach. Überspringt das Nachdenken möglicherweise bei einfachen Anfragen. |
| `low` | Claude minimiert das Nachdenken. Überspringt das Nachdenken bei einfachen Aufgaben, bei denen Geschwindigkeit am wichtigsten ist. |
Auf jeder Stufe entscheidet Claude pro Anfrage, ob es nachdenkt. In einer Tool-Nutzungs-Schleife trägt typischerweise die erste Anfrage nach einer neuen Benutzereingabe den Großteil des Reasonings, und Folgeanfragen, die nur Tool-Ergebnisse verarbeiten, können das Nachdenken überspringen, auch bei `xhigh` und `max`. Das Nachdenken pro Anfrage nimmt außerdem tendenziell ab, je länger eine Konversation wird. Keine Stufe garantiert einen Thinking-Block bei jeder Anfrage.
Diese Tabelle beschreibt, wie jede Stufe das Denkverhalten verändert. Hinweise dazu, welche Stufe du für einen bestimmten Workload wählen solltest, einschließlich modellspezifischer Empfehlungen, findest du unter [Wann der Effort-Parameter angepasst werden sollte](https://platform.claude.com/docs/de/build-with-claude/effort#when-to-adjust-the-effort-parameter) auf der Effort-Seite.
Effort wird unter `output_config.effort` gesetzt, nicht innerhalb des `thinking`-Objekts; vollständige Beispiele pro Sprache findest du unter [Effort](https://platform.claude.com/docs/de/build-with-claude/effort#basic-usage).
```json
{
"model": "claude-opus-5-5",
"max_tokens": 4096,
"output_config": { "effort": "medium" },
"messages": [{ "role": "user", "content": "..." }]
}
```
Die Verfügbarkeit der Stufen variiert je nach Modell; die [Effort-Verfügbarkeitstabelle](https://platform.claude.com/docs/de/build-with-claude/effort#effort-levels) auf der Effort-Seite ist maßgeblich dafür, welche Stufen jedes Modell unterstützt.
### System-Prompt-Anleitungen
Anleitungen im System-Prompt verschieben Claudes Denkschwelle für jede Anfrage in der Konversation. Wenn Claude häufiger denkt, als dein Workload es erfordert, füge deinem System-Prompt eine Anleitung wie diese hinzu:
```text wrap
Extended thinking adds latency and should only be used when it
will meaningfully improve answer quality, typically for problems
that require multistep reasoning. When in doubt, respond directly.
```
Um stattdessen zum Nachdenken zu ermutigen, verwende eine Formulierung wie:
```text wrap
This task involves multistep reasoning. Think carefully before responding.
```
Die Wirksamkeit der Steuerung kann empfindlich auf die genaue Wortwahl reagieren. Wenn eine Formulierung nicht das gewünschte Verhalten erzeugt, probiere eine direktere Variante.
### Nachrichtenbezogene Steuerung
Du kannst das Nachdenken auch pro Nachricht aus dem User-Turn steuern, unabhängig vom System-Prompt. Das Anhängen von `"Please think hard before responding."` an eine User-Nachricht ermutigt Claude, in diesem Turn nachzudenken; `"Answer directly without deliberating."` hält Claude davon ab.
Steuerung pro Nachricht ist nützlich, wenn nur einige Anfragen in einer Konversation ausgedehntes Reasoning rechtfertigen. Ein Agent-Harness kann beispielsweise bei Planungsschritten die ermutigende Formulierung und bei Routinebestätigungen die bremsende Formulierung anhängen, ohne den System-Prompt anzufassen oder zwischen den Turns Anfrageparameter zu ändern.
Bei Claude Haiku 5.5 reduziert die bremsende Formulierung das Nachdenken nicht zuverlässig. Auf der Claude API und Google Cloud führst du Routine-Turns auf diesem Modell mit weniger Nachdenken aus, indem du stattdessen eine [Effort-Änderung pro Nachricht](https://platform.claude.com/docs/de/build-with-claude/effort#change-effort-mid-conversation-beta) (Beta) verwendest, die außerdem den Prompt-Cache erhält.
### Steuerung an deinem Workload überprüfen
Prompt-basierte Steuerung verändert das Modellverhalten, behandle sie also wie jede andere Prompt-Änderung: Miss, bevor du auslieferst. Führe eine repräsentative Stichprobe deines Traffics mit und ohne die Anleitung aus und vergleiche, wie oft Nachdenken ausgelöst wird (das Vorhandensein von Thinking-Blöcken in Antworten), die Nutzung von Output-Token, die Latenz und die Antwortqualität bei den Fällen, die dir wichtig sind.
Claude dazu zu steuern, seltener zu denken, kann die Qualität bei Aufgaben verringern, die von Reasoning profitieren. Das Senken der [Effort](https://platform.claude.com/docs/de/build-with-claude/effort)-Stufe ist meist der bessere erste Hebel, da es sich um eine kalibrierte Kontrolle und nicht um eine wortwahlempfindliche Anweisung handelt. Miss die Auswirkungen auf deine spezifischen Workloads, bevor du Prompt-basiertes Tuning in Produktion bringst.
## Mechaniken
Drei Mechaniken ergeben sich daraus, dass Claude sein Nachdenken selbst verwaltet: Turn-Validierung, Prompt-Caching und wie du die Kosten begrenzt.
### Turn-Validierung
Assistant-Turns müssen nicht mit einem Thinking-Block beginnen. (Modelle, die ein veraltetes manuelles Thinking-Budget verwenden, erzwingen, dass der letzte Assistant-Turn einer Anfrage mit aktiviertem Nachdenken mit einem beginnt; siehe [Turn-Struktur im manuellen Modus](https://platform.claude.com/docs/de/build-with-claude/extended-thinking#turn-structure-in-manual-mode).)
Für Multi-Turn-Anwendungen bedeutet das, dass du den Konversationsverlauf in beliebiger Form zurückgeben kannst:
* Assistant-Turns, in denen Claude sich entschieden hat, nicht zu denken, sind unverändert gültiger Verlauf.
* Du kannst eine Konversation fortsetzen, die ohne Nachdenken begonnen hat oder eine andere Thinking-Konfiguration verwendet hat, ohne ihren Verlauf umzuschreiben.
* Ein aus gemischten Quellen zusammengesetzter Verlauf benötigt keine wieder eingefügten Thinking-Blöcke am Anfang jedes Assistant-Turns, um die Validierung zu bestehen.
Die Lockerung betrifft die Validierung, nicht das, was du senden solltest. Wenn du Thinking-Blöcke hast, gib sie unverändert zurück, insbesondere während der Tool-Nutzung, wo sie das Reasoning hinter Claudes Tool-Aufrufen tragen. Die vollständigen Regeln findest du in der Übersicht [Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking).
### Prompt-Caching
Aufeinanderfolgende Anfragen, die dieselbe Thinking-Konfiguration und Effort-Stufe beibehalten, erhalten das „prompt caching“ (Prompt-Caching); die vollständigen Regeln findest du unter [Nachdenken und Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-and-prompt-caching). Der aufgelöste Effort-Wert wird in den Prompt gerendert, sodass eine Änderung zwischen Anfragen Cache-Breakpoints invalidiert, genau wie eine Änderung des veralteten Parameters [`budget_tokens`](https://platform.claude.com/docs/de/build-with-claude/extended-thinking#extended-thinking-with-prompt-caching) bei Modellen, die ihn verwenden. `effort` explizit auf den Standardwert des Modells zu setzen, ist gleichbedeutend mit dem Weglassen und bricht den Cache nicht.
Die praktische Konsequenz: Wähle pro Konversation eine Thinking-Konfiguration und eine Effort-Stufe auf oberster Ebene und behalte sie bei. Wenn einige Turns mehr oder weniger Nachdenken benötigen, verwende bei Modellen, die dies unterstützen, eine [Effort-Änderung pro Nachricht](https://platform.claude.com/docs/de/build-with-claude/effort#change-effort-mid-conversation-beta) (Beta) oder steuere mit [Prompting pro Nachricht](https://platform.claude.com/docs/de/build-with-claude/thinking-steering-and-cost#tuning-thinking-behavior). Beide lassen frühere Cache-Breakpoints intakt, während eine Änderung der Thinking-Konfiguration oder der Effort-Stufe auf oberster Ebene dies nicht tut.
Das folgende Beispiel demonstriert die Invalidierung mit einem Multi-Turn-Skript, das du selbst ausführen kannst:
Dieser Workflow lässt sich nicht gut in einen einmaligen Shell-Befehl übertragen. Sieh dir die SDK-Tabs für das Multi-Turn-Muster an; HTTP-Anfragen pro Turn folgen den Beispielen auf der Seite [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching).
Dieser Workflow lässt sich nicht gut in einen einmaligen Shell-Befehl übertragen. Sieh dir die SDK-Tabs für das Multi-Turn-Muster an; CLI-Aufrufe pro Turn folgen den Beispielen auf der Seite [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching).
```python
import requests
client = Anthropic()
def fetch_article_content(url):
text = requests.get(url).text
lines = (line.strip() for line in text.splitlines())
return "\n".join(line for line in lines if line)
# Lade den Inhalt des Artikels
book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
book_content = fetch_article_content(book_url)
# Verwende gerade genug Text für das Caching (die ersten Kapitel)
LARGE_TEXT = book_content[:10000]
# Kein System-Prompt – Caching stattdessen in den Nachrichten
MESSAGES = [
{
"role": "user",
"content": [
{
"type": "text",
"text": LARGE_TEXT,
"cache_control": {"type": "ephemeral"},
},
{"type": "text", "text": "Analyze the tone of this passage."},
],
}
]
# Erste Anfrage – Cache anlegen
print("First request - establishing cache")
response1 = client.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
thinking={"type": "adaptive"},
messages=MESSAGES,
)
print(f"First response usage: {response1.usage}")
MESSAGES.append({"role": "assistant", "content": response1.content})
MESSAGES.append({"role": "user", "content": "Analyze the characters in this passage."})
# Zweite Anfrage – gleiche Konfiguration (Cache-Treffer erwartet)
print("\nSecond request - same configuration (cache hit expected)")
response2 = client.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
thinking={"type": "adaptive"},
messages=MESSAGES,
)
print(f"Second response usage: {response2.usage}")
MESSAGES.append({"role": "assistant", "content": response2.content})
MESSAGES.append({"role": "user", "content": "Analyze the setting in this passage."})
# Dritte Anfrage – anderes Effort-Level (Cache-Fehltreffer erwartet)
print("\nThird request - different effort level (cache miss expected)")
response3 = client.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
thinking={"type": "adaptive"},
output_config={"effort": "low"},
messages=MESSAGES,
)
print(f"Third response usage: {response3.usage}")
```
```typescript
const client = new Anthropic();
async function fetchArticleContent(url: string): Promise {
const response = await fetch(url);
const text = await response.text();
const lines = text.split("\n").map((line) => line.trim());
return lines.filter((line) => line).join("\n");
}
const bookUrl = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt";
const bookContent = await fetchArticleContent(bookUrl);
const LARGE_TEXT = bookContent.substring(0, 10000);
// Kein System-Prompt – Caching stattdessen in den Nachrichten
const messages: Anthropic.MessageParam[] = [
{
role: "user",
content: [
{
type: "text",
text: LARGE_TEXT,
cache_control: { type: "ephemeral" }
},
{
type: "text",
text: "Analyze the tone of this passage."
}
]
}
];
// Erste Anfrage – Cache anlegen
console.log("First request - establishing cache");
const response1 = await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
thinking: { type: "adaptive" },
messages
});
console.log("First response usage: ", response1.usage);
messages.push(
{ role: "assistant", content: response1.content },
{ role: "user", content: "Analyze the characters in this passage." }
);
// Zweite Anfrage – gleiche Konfiguration (Cache-Treffer erwartet)
console.log("\nSecond request - same configuration (cache hit expected)");
const response2 = await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
thinking: { type: "adaptive" },
messages
});
console.log("Second response usage: ", response2.usage);
messages.push(
{ role: "assistant", content: response2.content },
{ role: "user", content: "Analyze the setting in this passage." }
);
// Dritte Anfrage – anderes Effort-Level (Cache-Miss erwartet)
console.log("\nThird request - different effort level (cache miss expected)");
const response3 = await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 16000,
thinking: { type: "adaptive" },
output_config: { effort: "low" },
messages
});
console.log("Third response usage: ", response3.usage);
```
```csharp
AnthropicClient client = new();
string bookUrl = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt";
string bookContent = await FetchArticleContent(bookUrl);
string largeText = bookContent.Substring(0, Math.Min(10000, bookContent.Length));
Console.WriteLine("First request - establishing cache");
var parameters1 = new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 16000,
Thinking = new ThinkingConfigAdaptive(),
Messages =
[
new()
{
Role = Role.User,
Content = new MessageParamContent(new List
{
new ContentBlockParam(new TextBlockParam()
{
Text = largeText,
CacheControl = new CacheControlEphemeral(),
}),
new ContentBlockParam(new TextBlockParam()
{
Text = "Analyze the tone of this passage."
}),
})
}
]
};
var response1 = await client.Messages.Create(parameters1);
Console.WriteLine($"First response usage: {response1.Usage}");
Console.WriteLine("\nSecond request - same configuration (cache hit expected)");
var parameters2 = new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 16000,
Thinking = new ThinkingConfigAdaptive(),
Messages =
[
new()
{
Role = Role.User,
Content = new MessageParamContent(new List
{
new ContentBlockParam(new TextBlockParam()
{
Text = largeText,
CacheControl = new CacheControlEphemeral(),
}),
new ContentBlockParam(new TextBlockParam()
{
Text = "Analyze the tone of this passage."
}),
})
},
new()
{
Role = Role.Assistant,
Content = response1.Content.Select(block => new ContentBlockParam(block.Json)).ToList()
},
new()
{
Role = Role.User,
Content = "Analyze the characters in this passage."
}
]
};
var response2 = await client.Messages.Create(parameters2);
Console.WriteLine($"Second response usage: {response2.Usage}");
Console.WriteLine("\nThird request - different effort level (cache miss expected)");
var parameters3 = new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 16000,
Thinking = new ThinkingConfigAdaptive(),
OutputConfig = new OutputConfig
{
Effort = Effort.Low
},
Messages =
[
new()
{
Role = Role.User,
Content = new MessageParamContent(new List
{
new ContentBlockParam(new TextBlockParam()
{
Text = largeText,
CacheControl = new CacheControlEphemeral(),
}),
new ContentBlockParam(new TextBlockParam()
{
Text = "Analyze the tone of this passage."
}),
})
},
new()
{
Role = Role.Assistant,
Content = response1.Content.Select(block => new ContentBlockParam(block.Json)).ToList()
},
new()
{
Role = Role.User,
Content = "Analyze the characters in this passage."
},
new()
{
Role = Role.Assistant,
Content = response2.Content.Select(block => new ContentBlockParam(block.Json)).ToList()
},
new()
{
Role = Role.User,
Content = "Analyze the setting in this passage."
}
]
};
var response3 = await client.Messages.Create(parameters3);
Console.WriteLine($"Third response usage: {response3.Usage}");
static async Task FetchArticleContent(string url)
{
using HttpClient httpClient = new();
string content = await httpClient.GetStringAsync(url);
return content;
}
```
```go
client := anthropic.NewClient()
bookURL := "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
bookContent, err := fetchArticleContent(bookURL)
if err != nil {
log.Fatal(err)
}
largeText := bookContent
if len(largeText) > 10000 {
largeText = largeText[:10000]
}
// Kein System-Prompt – Caching stattdessen in den Nachrichten
messages := []anthropic.MessageParam{
anthropic.NewUserMessage(
anthropic.ContentBlockParamUnion{OfText: &anthropic.TextBlockParam{
Text: largeText,
CacheControl: anthropic.NewCacheControlEphemeralParam(),
}},
anthropic.NewTextBlock("Analyze the tone of this passage."),
),
}
// Erste Anfrage – Cache anlegen
fmt.Println("First request - establishing cache")
response1, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Thinking: anthropic.ThinkingConfigParamUnion{
OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{},
},
Messages: messages,
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("First response usage: %s\n", response1.Usage.RawJSON())
messages = append(messages, response1.ToParam())
messages = append(messages, anthropic.NewUserMessage(anthropic.NewTextBlock("Analyze the characters in this passage.")))
// Zweite Anfrage – gleiche Konfiguration (Cache-Treffer erwartet)
fmt.Println("\nSecond request - same configuration (cache hit expected)")
response2, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Thinking: anthropic.ThinkingConfigParamUnion{
OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{},
},
Messages: messages,
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("Second response usage: %s\n", response2.Usage.RawJSON())
messages = append(messages, response2.ToParam())
messages = append(messages, anthropic.NewUserMessage(anthropic.NewTextBlock("Analyze the setting in this passage.")))
// Dritte Anfrage – anderes Effort-Level (Cache-Miss erwartet)
fmt.Println("\nThird request - different effort level (cache miss expected)")
response3, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 16000,
Thinking: anthropic.ThinkingConfigParamUnion{
OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{},
},
OutputConfig: anthropic.OutputConfigParam{
Effort: anthropic.OutputConfigEffortLow,
},
Messages: messages,
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("Third response usage: %s\n", response3.Usage.RawJSON())
```
```java
import com.anthropic.models.messages.CacheControlEphemeral;
// ...
void main() throws Exception {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
String bookUrl = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt";
String bookContent = fetchArticleContent(bookUrl);
String largeText = bookContent.substring(0, Math.min(10000, bookContent.length()));
// Erste Anfrage – Cache wird aufgebaut
IO.println("First request - establishing cache");
MessageCreateParams params1 = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.thinking(ThinkingConfigAdaptive.builder().build())
.addUserMessageOfBlockParams(List.of(
ContentBlockParam.ofText(TextBlockParam.builder()
.text(largeText)
.cacheControl(CacheControlEphemeral.builder().build())
.build()),
ContentBlockParam.ofText(TextBlockParam.builder()
.text("Analyze the tone of this passage.")
.build())
))
.build();
Message response1 = client.messages().create(params1);
IO.println("First response usage: " + response1.usage());
// Zweite Anfrage – gleiche Konfiguration (Cache-Treffer erwartet)
IO.println("\nSecond request - same configuration (cache hit expected)");
MessageCreateParams params2 = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.thinking(ThinkingConfigAdaptive.builder().build())
.addUserMessageOfBlockParams(List.of(
ContentBlockParam.ofText(TextBlockParam.builder()
.text(largeText)
.cacheControl(CacheControlEphemeral.builder().build())
.build()),
ContentBlockParam.ofText(TextBlockParam.builder()
.text("Analyze the tone of this passage.")
.build())
))
.addAssistantMessageOfBlockParams(response1.content().stream()
.map(block -> block.toParam())
.collect(java.util.stream.Collectors.toList()))
.addUserMessage("Analyze the characters in this passage.")
.build();
Message response2 = client.messages().create(params2);
IO.println("Second response usage: " + response2.usage());
// Dritte Anfrage – anderes Effort-Level (Cache-Miss erwartet)
IO.println("\nThird request - different effort level (cache miss expected)");
MessageCreateParams params3 = MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(16000L)
.thinking(ThinkingConfigAdaptive.builder().build())
.outputConfig(OutputConfig.builder()
.effort(OutputConfig.Effort.LOW)
.build())
.addUserMessageOfBlockParams(List.of(
ContentBlockParam.ofText(TextBlockParam.builder()
.text(largeText)
.cacheControl(CacheControlEphemeral.builder().build())
.build()),
ContentBlockParam.ofText(TextBlockParam.builder()
.text("Analyze the tone of this passage.")
.build())
))
.addAssistantMessageOfBlockParams(response1.content().stream()
.map(block -> block.toParam())
.collect(java.util.stream.Collectors.toList()))
.addUserMessage("Analyze the characters in this passage.")
.addAssistantMessageOfBlockParams(response2.content().stream()
.map(block -> block.toParam())
.collect(java.util.stream.Collectors.toList()))
.addUserMessage("Analyze the setting in this passage.")
.build();
Message response3 = client.messages().create(params3);
IO.println("Third response usage: " + response3.usage());
}
String fetchArticleContent(String url) throws Exception {
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(url))
.build();
HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
return response.body();
}
```
```php
function fetchArticleContent($url) {
$content = file_get_contents($url);
$lines = explode("\n", $content);
$cleanedLines = array_filter(array_map('trim', $lines));
return implode("\n", $cleanedLines);
}
$client = new Client();
$bookUrl = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt";
$bookContent = fetchArticleContent($bookUrl);
$largeText = substr($bookContent, 0, 10000);
echo "First request - establishing cache\n";
$response1 = $client->messages->create(
maxTokens: 16000,
messages: [[
'role' => 'user',
'content' => [
[
'type' => 'text',
'text' => $largeText,
'cache_control' => ['type' => 'ephemeral']
],
[
'type' => 'text',
'text' => 'Analyze the tone of this passage.'
]
]
]],
model: 'claude-opus-5-5',
thinking: ['type' => 'adaptive'],
);
echo "First response usage: " . json_encode($response1->usage) . "\n";
echo "\nSecond request - same configuration (cache hit expected)\n";
$response2 = $client->messages->create(
maxTokens: 16000,
messages: [
[
'role' => 'user',
'content' => [
[
'type' => 'text',
'text' => $largeText,
'cache_control' => ['type' => 'ephemeral']
],
[
'type' => 'text',
'text' => 'Analyze the tone of this passage.'
]
]
],
[
'role' => 'assistant',
'content' => $response1->content
],
[
'role' => 'user',
'content' => 'Analyze the characters in this passage.'
]
],
model: 'claude-opus-5-5',
thinking: ['type' => 'adaptive'],
);
echo "Second response usage: " . json_encode($response2->usage) . "\n";
echo "\nThird request - different effort level (cache miss expected)\n";
$response3 = $client->messages->create(
maxTokens: 16000,
messages: [
[
'role' => 'user',
'content' => [
[
'type' => 'text',
'text' => $largeText,
'cache_control' => ['type' => 'ephemeral']
],
[
'type' => 'text',
'text' => 'Analyze the tone of this passage.'
]
]
],
[
'role' => 'assistant',
'content' => $response1->content
],
[
'role' => 'user',
'content' => 'Analyze the characters in this passage.'
],
[
'role' => 'assistant',
'content' => $response2->content
],
[
'role' => 'user',
'content' => 'Analyze the setting in this passage.'
]
],
model: 'claude-opus-5-5',
thinking: ['type' => 'adaptive'],
outputConfig: ['effort' => 'low'],
);
echo "Third response usage: " . json_encode($response3->usage) . "\n";
```
```ruby
require "net/http"
require "uri"
def fetch_article_content(url)
uri = URI.parse(url)
response = Net::HTTP.get_response(uri)
text = response.body
lines = text.split("\n").map(&:strip)
lines.reject(&:empty?).join("\n")
end
client = Anthropic::Client.new
book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
book_content = fetch_article_content(book_url)
large_text = book_content[0...10000]
puts "First request - establishing cache"
response1 = client.messages.create(
model: "claude-opus-5-5",
max_tokens: 16000,
thinking: {
type: "adaptive"
},
messages: [{
role: "user",
content: [
{
type: "text",
text: large_text,
cache_control: { type: "ephemeral" }
},
{
type: "text",
text: "Analyze the tone of this passage."
}
]
}]
)
puts "First response usage: #{response1.usage}"
puts "\nSecond request - same configuration (cache hit expected)"
response2 = client.messages.create(
model: "claude-opus-5-5",
max_tokens: 16000,
thinking: {
type: "adaptive"
},
messages: [
{
role: "user",
content: [
{
type: "text",
text: large_text,
cache_control: { type: "ephemeral" }
},
{
type: "text",
text: "Analyze the tone of this passage."
}
]
},
{
role: "assistant",
content: response1.content
},
{
role: "user",
content: "Analyze the characters in this passage."
}
]
)
puts "Second response usage: #{response2.usage}"
puts "\nThird request - different effort level (cache miss expected)"
response3 = client.messages.create(
model: "claude-opus-5-5",
max_tokens: 16000,
thinking: {
type: "adaptive"
},
output_config: {
effort: "low"
},
messages: [
{
role: "user",
content: [
{
type: "text",
text: large_text,
cache_control: { type: "ephemeral" }
},
{
type: "text",
text: "Analyze the tone of this passage."
}
]
},
{
role: "assistant",
content: response1.content
},
{
role: "user",
content: "Analyze the characters in this passage."
},
{
role: "assistant",
content: response2.content
},
{
role: "user",
content: "Analyze the setting in this passage."
}
]
)
puts "Third response usage: #{response3.usage}"
```
Hier ist die Ausgabe des Skripts (du siehst möglicherweise leicht abweichende Zahlen):
```text Output wrap
First request - establishing cache
First response usage: { cache_creation_input_tokens: 3546, cache_read_input_tokens: 0, input_tokens: 15, output_tokens: 1033 }
Second request - same configuration (cache hit expected)
Second response usage: { cache_creation_input_tokens: 0, cache_read_input_tokens: 3546, input_tokens: 1062, output_tokens: 1630 }
Third request - different effort level (cache miss expected)
Third response usage: { cache_creation_input_tokens: 3546, cache_read_input_tokens: 0, input_tokens: 2706, output_tokens: 1468 }
```
Mit dem Cache-Breakpoint im Messages-Array invalidiert die Änderung des Efforts von `medium`, dem Standard bei Claude Opus 5.5, auf `low` den Cache: Die dritte Anfrage zeigt `cache_creation_input_tokens=3546` und `cache_read_input_tokens=0`, während die zweite einen vollständigen Cache-Lesezugriff zeigte.
### Kostenkontrolle
Du legst kein Thinking-Token-Budget fest. Zwei Kontrollen begrenzen die Kosten:
* `max_tokens` ist eine harte Obergrenze für die gesamte Ausgabe der Anfrage, Nachdenken und Antworttext zusammen. Claude generiert nie darüber hinaus. In einer Tool-Use-Schleife hat jede Anfrage im Turn ihr eigenes `max_tokens`, sodass es nicht die Ausgaben des gesamten Turns begrenzt.
* `effort` ist eine weiche Vorgabe dafür, wie viel dieser Ausgabe Claude dem Nachdenken zuweist. Es formt das Verhalten, garantiert aber keine Token-Anzahl.
Da Nachdenken auf `max_tokens` angerechnet wird, setze es hoch genug, um Platz sowohl für das Reasoning als auch für die Antwort zu lassen. Ein `max_tokens`, das für eine Antwort ohne Nachdenken bemessen ist, ist oft zu klein, sobald Claude bei schwierigen Anfragen zu denken beginnt.
Bei Effort `high` und darüber kann Claude ausgiebig denken und schöpft das Budget mit höherer Wahrscheinlichkeit aus. Wenn du [`stop_reason: "max_tokens"`](https://platform.claude.com/docs/de/build-with-claude/thinking-troubleshooting#stopped-at-max-tokens) in Antworten siehst, hast du zwei Abhilfen:
* Erhöhe `max_tokens`, um dem Modell mehr Platz für Nachdenken plus Antwort zu geben.
* Senke die Effort-Stufe, damit Claude weniger denkt und mehr vom Budget für Antworttext übrig lässt.
Welche die richtige ist, hängt davon ab, ob die abgeschnittenen Antworten das Reasoning benötigten. Wenn die Qualität bei diesen Anfragen wichtig ist, erhöhe die Obergrenze; wenn sie überdacht waren, senke den Effort.
## Preisgestaltung
Nachdenken verursacht Kosten für:
* Token, die Claude beim Nachdenken verwendet (als Output-Token abgerechnet)
* Thinking-Blöcke aus früheren Assistant-Turns, die im Kontext verbleiben, gemäß dem [Standard zur Beibehaltung](https://platform.claude.com/docs/de/build-with-claude/thinking#thinking-block-preservation-by-model): standardmäßig alle Turns bei Keep-All-Modellen, andernfalls nur der letzte Turn (als Input-Token abgerechnet)
* Standardmäßige Text-Output-Token
Wenn Nachdenken aktiv ist, wird automatisch ein spezialisierter System-Prompt eingebunden, um diese Funktion zu unterstützen.
Was dir in Rechnung gestellt wird, ist unabhängig von der `display`-Einstellung gleich; nur was du siehst, ändert sich:
| | `display: "summarized"` | `display: "omitted"` |
| ---------------------------------- | ----------------------------------------------------------------- | -------------------------------------------------- |
| **Input-Token** | Token in deiner ursprünglichen Anfrage | Wie bei summarized |
| **Output-Token (abgerechnet)** | Die vollständigen Thinking-Token, die Claude intern generiert hat | Wie bei summarized |
| **Output-Token (sichtbar)** | Der zusammengefasste Denktext | Null Thinking-Token (das Feld `thinking` ist leer) |
| **Erstellung der Zusammenfassung** | Keine Kosten | Nicht anwendbar |
Die abgerechnete Anzahl an Output-Token stimmt **nicht** mit der sichtbaren Token-Anzahl in der Antwort überein. Dir wird der vollständige Denkprozess in Rechnung gestellt, nicht der in der Antwort sichtbare Denkinhalt.
Um zu sehen, wie viele abgerechnete Output-Token für internes Reasoning aufgewendet wurden, lies `usage.output_tokens_details.thinking_tokens` in der Antwort. Dieser Wert spiegelt das rohe Reasoning wider, das das Modell generiert hat (nicht den im Body zurückgegebenen zusammengefassten Text), und ist immer kleiner oder gleich `output_tokens`. Ziehe ihn von `output_tokens` ab, um den Nicht-Reasoning-Anteil der Ausgabe anzunähern. Beim Streaming erscheint diese Aufschlüsselung nur im abschließenden `message_delta`-Event.
```json
{
"usage": {
"input_tokens": 25,
"output_tokens": 348,
"output_tokens_details": {
"thinking_tokens": 312
}
}
}
```
`output_tokens` bleibt die inklusive, maßgebliche Gesamtsumme, die für die Abrechnung verwendet wird. `output_tokens_details` ist eine schreibgeschützte Aufschlüsselung zur Beobachtbarkeit. Vollständige Preisinformationen einschließlich Basistarifen, Cache-Writes, Cache-Hits und Output-Token findest du unter [Preisgestaltung](https://platform.claude.com/docs/de/about-claude/pricing).
## Nächste Schritte
Aktiviere Nachdenken, lies Denkausgaben und prüfe die Unterstützung pro Modell.
Bewahre Thinking-Blöcke über Tool-Aufrufe hinweg und verwalte das Nachdenken in Multi-Turn-Konversationen.
Steuere, wie viel Nachdenken und Ausgabe Claude pro Anfrage zuweist.