---
title: Latenz reduzieren
url: https://platform.claude.com/docs/de/test-and-evaluate/strengthen-guardrails/reduce-latency
description: Reduziere die Antwortlatenz von Claude, indem du ein schnelleres Modell wie Claude Haiku 5.5 wählst, Prompt- und Ausgabe-Token kürzt und Antworten streamst.
---

„Latency“ (Latenz) bezeichnet die Zeit, die das Modell benötigt, um einen Prompt zu verarbeiten und eine Ausgabe zu generieren. Die Latenz kann von verschiedenen Faktoren beeinflusst werden, etwa der Größe des Modells, der Komplexität des Prompts sowie der zugrunde liegenden Infrastruktur, die das Modell und den Interaktionspunkt unterstützt.

<Note>
  Es ist immer besser, zuerst einen Prompt zu entwickeln, der ohne Modell- oder Prompt-Einschränkungen gut funktioniert, und erst danach Strategien zur Latenzreduzierung auszuprobieren. Wenn du zu früh versuchst, die Latenz zu reduzieren, könnte dich das daran hindern herauszufinden, wie Spitzenleistung aussieht.
</Note>

***

## So misst du Latenz

Wenn es um Latenz geht, begegnen dir möglicherweise verschiedene Begriffe und Messgrößen:

* **Baseline latency (Basislatenz):** Dies ist die Zeit, die das Modell benötigt, um den Prompt zu verarbeiten und die Antwort zu generieren, ohne die Eingabe- und Ausgabe-Token pro Sekunde zu berücksichtigen. Sie vermittelt eine allgemeine Vorstellung von der Geschwindigkeit des Modells.
* **„Time to first token“ (Zeit bis zum ersten Token), oder TTFT:** Diese Metrik misst die Zeit, die das Modell benötigt, um das erste Token der Antwort zu generieren, gerechnet ab dem Zeitpunkt, an dem der Prompt gesendet wurde. Sie ist besonders relevant, wenn du Streaming verwendest (mehr dazu später) und deinen Nutzern ein reaktionsschnelles Erlebnis bieten möchtest.

Für ein tieferes Verständnis dieser Begriffe siehe das [Glossar](https://platform.claude.com/docs/de/about-claude/glossary).

***

## So reduzierst du Latenz

### 1. Wähle das richtige Modell

Eine der direktesten Möglichkeiten, die Latenz zu reduzieren, ist die Wahl des passenden Modells für deinen Anwendungsfall. Anthropic bietet eine [Reihe von Modellen](https://platform.claude.com/docs/de/models/overview) mit unterschiedlichen Fähigkeiten und Leistungsmerkmalen. Berücksichtige deine spezifischen Anforderungen und wähle das Modell, das in Bezug auf Geschwindigkeit und Ausgabequalität am besten zu deinen Bedürfnissen passt.

Für geschwindigkeitskritische Anwendungen bietet **Claude Haiku 5.5** die schnellsten Antwortzeiten bei gleichzeitig hoher Intelligenz. [Effort](https://platform.claude.com/docs/de/build-with-claude/effort) ist seine wichtigste Steuerung für Geschwindigkeit und Kosten. Siehe [Effort zur Steuerung des Nachdenkens verwenden](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#use-effort-to-control-thinking). Das folgende Beispiel nutzt Claude Haiku 5.5 mit Effort `low`, dem günstigsten und schnellsten Level, und lässt in `max_tokens` Raum für das Nachdenken:

<CodeGroup>
  ```bash cURL
  # Für zeitkritische Anwendungen verwende Claude Haiku 5.5 mit niedrigem Effort
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-haiku-5-5",
      "max_tokens": 1024,
      "output_config": {"effort": "low"},
      "messages": [{"role": "user", "content": "Summarize this customer feedback in 2 sentences: [feedback text]"}]
    }'
  ```

  ```bash CLI
  # Für zeitkritische Anwendungen verwende Claude Haiku 5.5 mit niedrigem Effort
  ant messages create \
    --model claude-haiku-5-5 \
    --max-tokens 1024 \
    --output-config '{effort: low}' \
    --message '{"role": "user", "content": "Summarize this customer feedback in 2 sentences: [feedback text]"}'
  ```

  ```python Python
  client = anthropic.Anthropic()

  # Für zeitkritische Anwendungen verwende Claude Haiku 5.5 mit niedrigem Effort
  message = client.messages.create(
      model="claude-haiku-5-5",
      max_tokens=1024,
      output_config={"effort": "low"},
      messages=[
          {
              "role": "user",
              "content": "Summarize this customer feedback in 2 sentences: [feedback text]",
          }
      ],
  )
  print(next(block.text for block in message.content if block.type == "text"))
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  // Für zeitkritische Anwendungen verwende Claude Haiku 5.5 mit niedrigem Effort
  const message = await client.messages.create({
    model: "claude-haiku-5-5",
    max_tokens: 1024,
    output_config: { effort: "low" },
    messages: [
      {
        role: "user",
        content: "Summarize this customer feedback in 2 sentences: [feedback text]"
      }
    ]
  });
  const textBlock = message.content.find((block) => block.type === "text");
  console.log(textBlock?.text);
  ```

  ```csharp C#
  AnthropicClient client = new();

  // Verwende für zeitkritische Anwendungen Claude Haiku 5.5 mit niedrigem Effort
  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeHaiku5_5,
      MaxTokens = 1024,
      OutputConfig = new() { Effort = Effort.Low },
      Messages = [
          new UserMessageParam
          {
              Content = "Summarize this customer feedback in 2 sentences: [feedback text]"
          }
      ]
  };
  var message = await client.Messages.Create(parameters);
  foreach (var block in message.Content)
  {
      if (block.TryPickText(out var textBlock))
      {
          Console.WriteLine(textBlock.Text);
          break;
      }
  }
  ```

  ```go Go
  client := anthropic.NewClient()

  // Für zeitkritische Anwendungen verwende Claude Haiku 5.5 mit niedrigem Effort
  message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeHaiku5_5,
  	MaxTokens: 1024,
  	OutputConfig: anthropic.OutputConfigParam{
  		Effort: anthropic.OutputConfigEffortLow,
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Summarize this customer feedback in 2 sentences: [feedback text]")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  for _, block := range message.Content {
  	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  		fmt.Println(textBlock.Text)
  		break
  	}
  }
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  // Für zeitkritische Anwendungen verwende Claude Haiku 5.5 mit niedrigem Effort
  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_HAIKU_5_5)
      .maxTokens(1024L)
      .outputConfig(OutputConfig.builder()
          .effort(OutputConfig.Effort.LOW)
          .build())
      .addUserMessage("Summarize this customer feedback in 2 sentences: [feedback text]")
      .build();
  Message message = client.messages().create(params);
  IO.println(message.content().stream()
      .flatMap(block -> block.text().stream())
      .map(TextBlock::text)
      .findFirst()
      .orElse(""));
  ```

  ```php PHP
  $client = new Client();

  // Für zeitkritische Anwendungen verwende Claude Haiku 5.5 mit niedrigem Effort
  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [['role' => 'user', 'content' => 'Summarize this customer feedback in 2 sentences: [feedback text]']],
      model: 'claude-haiku-5-5',
      outputConfig: ['effort' => 'low'],
  );
  foreach ($message->content as $block) {
      if ($block->type === 'text') {
          echo $block->text;
          break;
      }
  }
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  # Für zeitkritische Anwendungen verwende Claude Haiku 5.5 mit niedrigem Effort
  message = client.messages.create(
    model: Anthropic::Model::CLAUDE_HAIKU_5_5,
    max_tokens: 1024,
    output_config: { effort: :low },
    messages: [{ role: "user", content: "Summarize this customer feedback in 2 sentences: [feedback text]" }]
  )
  puts message.content.find { |block| block.type == :text }&.text
  ```
</CodeGroup>

Weitere Details zu Modellmetriken findest du unter [Modellübersicht](https://platform.claude.com/docs/de/models/overview).

### 2. Optimiere Prompt- und Ausgabelänge

Minimiere die Anzahl der Token sowohl in deinem Eingabe-Prompt als auch in der erwarteten Ausgabe, während du weiterhin eine hohe Leistung beibehältst. Je weniger Token das Modell verarbeiten und generieren muss, desto schneller erfolgt die Antwort.

Hier sind einige Tipps, die dir helfen, deine Prompts und Ausgaben zu optimieren:

* **Sei klar, aber prägnant:** Versuche, deine Absicht im Prompt klar und prägnant zu vermitteln. Vermeide unnötige Details oder redundante Informationen, aber bedenke, dass [Claude der Kontext](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/claude-prompting-best-practices#be-clear-and-direct) zu deinem Anwendungsfall fehlt und es möglicherweise nicht die beabsichtigten Schlüsse zieht, wenn die Anweisungen unklar sind.
* **Bitte um kürzere Antworten:** Bitte Claude direkt, sich kurz zu fassen. Wenn Claude unerwünscht lange Ausgaben erzeugt, bitte Claude, [seine Ausführlichkeit zu reduzieren](https://platform.claude.com/docs/de/build-with-claude/prompt-engineering/claude-prompting-best-practices#communication-style-and-verbosity).
  <Tip>
    Da LLMs 

    [Token](https://platform.claude.com/docs/de/about-claude/glossary#tokens)

     statt Wörter zählen, ist die Vorgabe einer exakten Wortanzahl oder einer Wortanzahlgrenze keine so effektive Strategie wie die Vorgabe von Grenzen für die Anzahl der Absätze oder Sätze.
  </Tip>
* **Setze angemessene Ausgabelimits:** Verwende den Parameter `max_tokens`, um eine harte Obergrenze für die maximale Länge der generierten Antwort festzulegen. Dies verhindert, dass Claude übermäßig lange Ausgaben generiert.
  <Note>
    Wenn die Antwort 

    `max_tokens`

     Token erreicht, schneidet die API sie ab, möglicherweise mitten im Satz oder mitten im Wort. Dies ist eine grobe Technik, die eventuell eine Nachbearbeitung erfordert. Sie eignet sich in der Regel am besten für Multiple-Choice- oder Kurzantworten, bei denen die Antwort direkt am Anfang steht.
  </Note>

Die richtige Balance zwischen Prompt-Klarheit, Ausgabequalität und Token-Anzahl zu finden, kann etwas Experimentieren erfordern.

### 3. Streame Antworten

„Streaming“ (Streaming) ist eine Funktion, die es dem Modell ermöglicht, mit dem Zurücksenden seiner Antwort zu beginnen, bevor die vollständige Ausgabe fertig ist. Dies kann die wahrgenommene Reaktionsfähigkeit deiner Anwendung erheblich verbessern, da Nutzer die Ausgabe des Modells in Echtzeit sehen können.

Bei aktiviertem Streaming kannst du die Ausgabe des Modells verarbeiten, sobald sie eintrifft, und dabei deine Benutzeroberfläche aktualisieren oder parallel andere Aufgaben ausführen.

Besuche [Streaming von Nachrichten](https://platform.claude.com/docs/de/build-with-claude/streaming), um zu erfahren, wie du Streaming für deinen Anwendungsfall implementieren kannst.

***

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Claude Cookbook: Latenzoptimierung mit der Claude API" icon="book" href="https://platform.claude.com/cookbook/latency-optimization-latency-optimization">
    Folge einem ausführbaren Notebook, das eine Latenz-Evaluierung für einen Beispiel-Agenten erstellt, jeweils eine Technik nach der anderen anwendet und prüft, dass die Ausgabequalität über einem Schwellenwert bleibt.
  </Card>

  <Card title="Halluzinationen reduzieren" icon="shield" href="https://platform.claude.com/docs/de/test-and-evaluate/strengthen-guardrails/reduce-hallucinations">
    Minimiere Halluzinationen in Claudes Ausgaben, indem du Unsicherheit zulässt, Antworten auf direkte Zitate stützt und Behauptungen mit Quellenangaben überprüfst.
  </Card>

  <Card title="Streaming von Nachrichten" icon="bolt" href="https://platform.claude.com/docs/de/build-with-claude/streaming">
    Streame Antworten der Messages API inkrementell mit Server-Sent Events, einschließlich Text-, Tool-Nutzungs- und Deltas für erweitertes Nachdenken.
  </Card>

  <Card title="Claude API Skill" icon="terminal" href="https://platform.claude.com/docs/de/agents-and-tools/agent-skills/claude-api-skill">
    Führe `/claude-api latency-optimize` in Claude Code aus, um zu messen, wo deine Anwendung auf die Claude API wartet, und um Änderungen zu testen, die die Wartezeit verkürzen, ohne die Ausgabequalität zu senken.
  </Card>
</CardGroup>
