---
title: Service-Tiers
url: https://platform.claude.com/docs/de/api/service-tiers
description: Verschiedene Service-Tiers ermöglichen es dir, Verfügbarkeit, Leistung und vorhersehbare Kosten entsprechend den Anforderungen deiner Anwendung auszubalancieren.
---

<Warning>
  Kapazitätszusagen für den Priority Tier können nicht mehr erworben werden. Organisationen mit einer bestehenden Zusage können den Priority Tier bis zum Enddatum ihres Vertrags weiter nutzen, und diese Seite bleibt für sie als Referenz verfügbar. Wenn du garantierte Kapazität benötigst, [kontaktiere den Vertrieb](https://claude.com/contact-sales).
</Warning>

Anthropic bietet drei „service tiers“ (Service-Tiers) an:

* **Priority Tier:** Nur für Organisationen mit einer bestehenden Kapazitätszusage verfügbar
* **Standard:** Standard-Tier sowohl für Pilotprojekte als auch für die Skalierung alltäglicher Anwendungsfälle
* **Batch:** Am besten geeignet für asynchrone Workflows, die warten können oder davon profitieren, außerhalb deiner normalen Kapazität zu laufen

## Standardstufe

Der Standard Tier ist der Standard-Service-Tier für alle API-Anfragen. Die API priorisiert diese Anfragen zusammen mit allen anderen Anfragen mit Best-Effort-Verfügbarkeit.

## Priority Tier

Die API priorisiert Anfragen in diesem Tier gegenüber allen anderen Anfragen. Diese Priorisierung hilft, [„server overloaded“-Fehler](https://platform.claude.com/docs/de/api/errors#http-errors) zu minimieren, selbst zu Spitzenzeiten.

Weitere Informationen findest du unter [Bestehende Priority-Tier-Zusagen](https://platform.claude.com/docs/de/api/service-tiers#existing-priority-tier-commitments).

## Wie Anfragen Tiers zugewiesen werden

Bei der Bearbeitung einer Anfrage entscheidet Anthropic in den folgenden Szenarien, eine Anfrage dem Priority Tier zuzuweisen:

* Deine Organisation verfügt über ausreichend Priority-Tier-Kapazität an **Input**-Token pro Minute
* Deine Organisation verfügt über ausreichend Priority-Tier-Kapazität an **Output**-Token pro Minute

Anthropic rechnet die Nutzung wie folgt auf die Priority-Tier-Kapazität an:

**Input-Token**

* Cache-Lesevorgänge mit 0,1 Token pro aus dem Cache gelesenem Token
* Cache-Schreibvorgänge mit 1,25 Token pro in den Cache geschriebenem Token mit einer TTL von 5 Minuten
* Cache-Schreibvorgänge mit 2,00 Token pro in den Cache geschriebenem Token mit einer TTL von 1 Stunde
* Für Anfragen mit [US-only-Inferenz](https://platform.claude.com/docs/de/manage-claude/data-residency) (`inference_geo: "us"`) auf Claude 4.6 und neueren Modellen zählen Input-Token mit 1,1 Token pro Token
* Alle anderen Input-Token zählen mit 1 Token pro Token

**Output-Token**

* Für Anfragen mit [US-only-Inferenz](https://platform.claude.com/docs/de/manage-claude/data-residency) (`inference_geo: "us"`) auf Claude 4.6 und neueren Modellen zählen Output-Token mit 1,1 Token pro Token
* Alle anderen Output-Token zählen mit 1 Token pro Token

Andernfalls werden Anfragen im Standard Tier verarbeitet.

<Note>
  Diese Verbrauchsraten spiegeln die relative Preisgestaltung der einzelnen Token-Typen wider. Beispielsweise wird US-only-Inferenz auf Claude 4.6 und neueren Modellen mit dem Faktor 1,1 berechnet, sodass jedes mit `inference_geo: "us"` verbrauchte Token 1,1 Token von deiner Priority-Tier-Kapazität abzieht.
</Note>

<Note>
  Anfragen, die dem Priority Tier zugewiesen werden, beanspruchen sowohl die Priority-Tier-Kapazität als auch die regulären Ratenlimits. Wenn die Bearbeitung der Anfrage die Ratenlimits überschreiten würde, wird die Anfrage abgelehnt.
</Note>

## Service-Tiers verwenden

Du kannst steuern, welche Service-Tiers für eine Anfrage verwendet werden können, indem du den Parameter `service_tier` setzt:

<CodeGroup>
  ```bash 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-8",
      "max_tokens": 1024,
      "messages": [{"role": "user", "content": "Hello, Claude!"}],
      "service_tier": "auto"
    }'
  ```

  ```bash CLI
  ant messages create --transform usage.service_tier --raw-output <<'YAML'
  model: claude-opus-4-8
  max_tokens: 1024
  messages:
    - role: user
      content: Hello, Claude!
  service_tier: auto  # Automatically use Priority Tier when available, fallback to standard
  YAML
  ```

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

  message = client.messages.create(
      model="claude-opus-4-8",
      max_tokens=1024,
      messages=[{"role": "user", "content": "Hello, Claude!"}],
      service_tier="auto",  # Automatically use Priority Tier when available, fallback to standard
  )
  print(message.usage.service_tier)
  ```

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

  const message = await client.messages.create({
    model: "claude-opus-4-8",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude!" }],
    service_tier: "auto" // Automatically use Priority Tier when available, fallback to standard
  });
  console.log(message.usage.service_tier);
  ```

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

  var message = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus4_8,
      MaxTokens = 1024,
      Messages = [new() { Role = Role.User, Content = "Hello, Claude!" }],
      ServiceTier = ServiceTier.Auto, // Automatically use Priority Tier when available, fallback to standard
  });
  Console.WriteLine(message.Usage.ServiceTier);
  ```

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

  message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus4_8,
  	MaxTokens: 1024,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude!")),
  	},
  	// Automatisch Priority Tier verwenden, wenn verfügbar, sonst Fallback auf Standard
  	ServiceTier: anthropic.MessageNewParamsServiceTierAuto,
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(message.Usage.ServiceTier)
  ```

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

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_4_8)
      .maxTokens(1024L)
      .addUserMessage("Hello, Claude!")
      // Automatisch Priority Tier verwenden, wenn verfügbar, sonst Fallback auf Standard
      .serviceTier(MessageCreateParams.ServiceTier.AUTO)
      .build();

  Message message = client.messages().create(params);
  IO.println(message.usage().serviceTier().orElseThrow());
  ```

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

  $message = $client->messages->create(
      model: 'claude-opus-4-8',
      maxTokens: 1024,
      messages: [['role' => 'user', 'content' => 'Hello, Claude!']],
      serviceTier: 'auto', // Automatically use Priority Tier when available, fallback to standard
  );
  echo $message->usage->serviceTier;
  ```

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

  message = client.messages.create(
    model: "claude-opus-4-8",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude!" }],
    service_tier: :auto # Automatically use Priority Tier when available, fallback to standard
  )
  puts(message.usage.service_tier)
  ```
</CodeGroup>

Der Parameter `service_tier` akzeptiert die folgenden Werte:

* `"auto"` (Standard) – Verwendet die Priority-Tier-Kapazität, falls verfügbar, und greift andernfalls auf deine sonstige Kapazität zurück
* `"standard_only"` – Verwendet nur Standard-Tier-Kapazität; nützlich, wenn du deine Priority-Tier-Kapazität nicht nutzen möchtest

Das `usage`-Objekt der Antwort enthält außerdem den der Anfrage zugewiesenen Service-Tier:

```json
{
  "usage": {
    "input_tokens": 410,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0,
    "output_tokens": 585,
    "service_tier": "priority"
  }
}
```

So kannst du feststellen, welcher Service-Tier der Anfrage zugewiesen wurde.

Wenn du `service_tier="auto"` mit einem Modell mit einer Priority-Tier-Zusage anforderst, liefern diese Antwort-Header Einblicke:

```text wrap
anthropic-priority-input-tokens-limit: 10000
anthropic-priority-input-tokens-remaining: 9618
anthropic-priority-input-tokens-reset: 2025-01-12T23:11:59Z
anthropic-priority-output-tokens-limit: 10000
anthropic-priority-output-tokens-remaining: 6000
anthropic-priority-output-tokens-reset: 2025-01-12T23:12:21Z
```

Anhand des Vorhandenseins dieser Header kannst du erkennen, ob deine Anfrage für den Priority Tier berechtigt war, selbst wenn sie über dem Limit lag.

## Bestehende Priority-Tier-Zusagen

Eine Priority-Tier-Zusage besteht aus:

* Einer Anzahl von Input-Token pro Minute
* Einer Anzahl von Output-Token pro Minute
* Einer Zusagedauer (1, 3, 6 oder 12 Monate)
* Einer bestimmten Modellversion

Der Priority Tier zielt auf eine Verfügbarkeit von 99,5 % mit priorisierten Rechenressourcen ab. Anfragen, die über deine zugesagte Kapazität hinausgehen, fallen automatisch auf den Standard Tier zurück.

### Unterstützte Modelle

Der Priority Tier wird auf allen verfügbaren Claude-Modellen unterstützt, außer Claude Fable 5.1, Claude Haiku 5.5, Claude Mythos 5.1, Claude Mythos 5, [Claude Mythos Preview](https://anthropic.com/glasswing), Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5 und Claude Sonnet 5.

Weitere Details zu den verfügbaren Modellen findest du in der [Modellübersicht](https://platform.claude.com/docs/de/models/overview).