---
title: Fallback-Gutschrift
url: https://platform.claude.com/docs/de/build-with-claude/fallback-credit
description: Vermeide es, die Prompt-Cache-Kosten doppelt zu bezahlen, wenn du eine abgelehnte Anfrage auf einem anderen Modell wiederholst.
---

Prompt-Caches gelten pro Modell. Wenn ein Modell eine Anfrage ablehnt und du sie auf einem anderen Modell wiederholst, muss das für das erste Modell bereits gecachte Gesprächspräfix von Grund auf in den Cache des neuen Modells geschrieben werden. Cache-Schreibvorgänge kosten mehr als Cache-Lesevorgänge. „Fallback credit“ (Fallback-Gutschrift) beseitigt diese zusätzlichen Kosten. Die Ablehnung enthält ein Gutschrift-Token, du gibst das Token bei der Wiederholung zurück, und die Wiederholung wird so abgerechnet, als wäre das Gespräch von Anfang an auf dem neuen Modell geführt worden.

Du brauchst diese Seite nur, wenn du die Wiederholung selbst baust: über reines HTTP oder mit eigener Wiederholungslogik. [Serverseitiger Fallback](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#server-side-fallback) und die [SDK-Middleware](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#client-side-fallback) wenden die Fallback-Gutschrift automatisch an. Wenn du eines von beiden verwendest, überspringe diese Seite.

[Ablehnungen und Fallback](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback) behandelt das Erkennen von Ablehnungen und die Wahl eines Fallback-Ansatzes. [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching) erklärt Cache-Lesevorgänge und Cache-Schreibvorgänge, falls dir diese Begriffe neu sind.

## Der grundlegende Ablauf

<Steps>
  <Step title="Mit dem Beta-Header aktivieren">
    Sende die Anfrage, die möglicherweise abgelehnt wird, mit dem Header `anthropic-beta: fallback-credit-2026-07-01`. Der Header `server-side-fallback-2026-07-01` gewährt ebenfalls dieselben Felder, außer auf Amazon Bedrock und Google Cloud, die für diesen Header einen 400-Fehler zurückgeben. Der frühere Header `fallback-credit-2026-06-01` wird weiterhin akzeptiert und gewährt dieselben Felder.
  </Step>

  <Step title="Zwei Felder aus der Ablehnung lesen">
    Bei einer Ablehnung enthält `stop_details` zwei Felder:

    * **`fallback_credit_token`:** eine opake Zeichenkette, die die Gutschrift repräsentiert.
    * **`fallback_has_prefill_claim`:** ein Boolean, der dir sagt, welche Form des Wiederholungs-Bodys du verwenden sollst.

    Beide sind `null`, wenn für die Ablehnung keine Gutschrift verfügbar ist.
  </Step>

  <Step title="Die Wiederholung erstellen">
    Beginne mit dem Body der abgelehnten Anfrage. Setze `model` auf das Fallback-Modell und füge das Token als Top-Level-Parameter `fallback_credit_token` hinzu. Wähle die Body-Form aus der folgenden Tabelle.
  </Step>

  <Step title="Die Wiederholung mit demselben Header senden">
    Sende die Wiederholung mit demselben Beta-Header `fallback-credit-2026-07-01`. Die Wiederholung benötigt den Header, um das Token einzulösen.
  </Step>
</Steps>

Das Feld `fallback_has_prefill_claim` sagt dir, ob die Wiederholung die Teilausgabe des ablehnenden Modells fortsetzen kann, anstatt von vorne zu beginnen:

| `fallback_has_prefill_claim` | Wiederholungs-Body                                                                                                                                                                                                                                                                                                             |
| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `true`                       | Der Body der abgelehnten Anfrage, unverändert, plus eine angehängte Assistant-Nachricht, deren `content` den `content` der abgelehnten Antwort wiedergibt. Das Wiederholungsmodell setzt die Antwort dort fort, wo das ablehnende Modell aufgehört hat, und abgeschlossene Server-Tool-Aufrufe werden nicht erneut ausgeführt. |
| `false`                      | Der Body der abgelehnten Anfrage, unverändert.                                                                                                                                                                                                                                                                                 |

## Beispiel

Das folgende Beispiel stellt eine Anfrage, die möglicherweise abgelehnt wird, und löst das Gutschrift-Token bei einer Wiederholung gegen Claude Opus 4.8 ein. Wenn ein Wiederholungsversuch zurückgewiesen wird, stuft das Beispiel über die Zurückweisungsleiter herab: die Abfolge zunehmend einfacherer Wiederholungsformen, die in [Wenn eine Wiederholung zurückgewiesen wird](https://platform.claude.com/docs/de/build-with-claude/fallback-credit#when-a-retry-is-rejected) behandelt wird.

<CodeGroup>
  ```bash cURL
  # Erste Anfrage (kann abgelehnt werden)
  response=$(curl --fail-with-body -sS https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: fallback-credit-2026-07-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-fable-5",
      "max_tokens": 1024,
      "messages": [{"role": "user", "content": "Hello, Claude"}]
    }')

  # Eine Ablehnung enthält ein einmaliges Credit-Token in stop_details
  token=$(jq -r '.stop_details.fallback_credit_token // empty' <<<"${response}")

  if [[ -n "${token}" ]]; then
    # Wiederhole auf dem Fallback-Modell mit dem Credit-Token (gleicher Body)
    response=$(curl --fail-with-body -sS https://api.anthropic.com/v1/messages \
      -H "x-api-key: $ANTHROPIC_API_KEY" \
      -H "anthropic-version: 2023-06-01" \
      -H "anthropic-beta: fallback-credit-2026-07-01" \
      -H "content-type: application/json" \
      -d "$(jq -n --arg token "${token}" '{
        model: "claude-opus-4-8",
        max_tokens: 1024,
        messages: [{"role": "user", "content": "Hello, Claude"}],
        fallback_credit_token: $token
      }')")
  fi

  # Siehe die SDK-Beispiele für die vollständige Stufenfolge der Ablehnungsbehandlung.
  jq -c '{stop_reason, model}' <<<"${response}"
  ```

  ```bash CLI
  # Erste Anfrage (kann abgelehnt werden)
  response=$(ant beta:messages create \
    --model claude-fable-5 \
    --max-tokens 1024 \
    --message '{"role":"user","content":"Hello, Claude"}' \
    --beta fallback-credit-2026-07-01 \
    --format json)

  # Eine Ablehnung enthält ein einmaliges Credit-Token in stop_details
  token=$(jq -r '.stop_details.fallback_credit_token // empty' <<<"${response}")

  if [[ -n "${token}" ]]; then
    # Erneuter Versuch auf dem Fallback-Modell mit dem Credit-Token
    response=$(ant beta:messages create \
      --model claude-opus-4-8 \
      --max-tokens 1024 \
      --message '{"role":"user","content":"Hello, Claude"}' \
      --fallback-credit-token "${token}" \
      --beta fallback-credit-2026-07-01 \
      --format json)
  fi

  # Siehe die SDK-Beispiele für die vollständige Stufenfolge zur Ablehnungsbehandlung.
  jq -c '{stop_reason, model}' <<<"${response}"
  ```

  ```python Python
  client = Anthropic()

  request = {
      "max_tokens": 1024,
      "messages": [{"role": "user", "content": "Hello, Claude"}],
  }


  def send(model: str, body: dict[str, object]) -> BetaMessage:
      return client.beta.messages.create(
          model=model, betas=["fallback-credit-2026-07-01"], **body
      )


  response = send("claude-fable-5", request)

  if (
      response.stop_reason == "refusal"
      and (details := response.stop_details)
      and (token := details.fallback_credit_token)
  ):
      exact_body = request | {"fallback_credit_token": token}
      # Bevorzuge die Fortsetzungsform, außer der Claim ist False
      if details.fallback_has_prefill_claim is not False:
          echoed = [block.model_dump() for block in response.content]
          match echoed:
              case [*_, {"type": "text"} as final_block]:
                  final_block["text"] = final_block["text"].rstrip()
          attempt = exact_body | {
              "messages": [
                  *request["messages"],
                  {"role": "assistant", "content": echoed},
              ]
          }
      else:
          attempt = exact_body

      try:
          response = send("claude-opus-4-8", attempt)
      except BadRequestError as error:
          if "redemption temporarily unavailable" in error.message:
              raise  # Transient: retry with the token within its five-minute window
          try:
              # Falle auf den unveränderten Body zurück, weiterhin mit dem Token
              response = send("claude-opus-4-8", exact_body)
          except BadRequestError as retry_error:
              if "redemption temporarily unavailable" in retry_error.message:
                  raise  # Transient: retry with the token within its five-minute window
              # Das Token selbst wurde abgelehnt: verwirf es und versuche es ohne erneut.
              response = send("claude-opus-4-8", request)

  print(json.dumps({"stop_reason": response.stop_reason, "model": response.model}))
  ```

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

  const request: Anthropic.Beta.MessageCreateParamsNonStreaming = {
    model: "claude-fable-5",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    betas: ["fallback-credit-2026-07-01"]
  };

  let response = await client.beta.messages.create(request);

  if (
    response.stop_reason === "refusal" &&
    response.stop_details?.type === "refusal" &&
    response.stop_details.fallback_credit_token
  ) {
    const { fallback_credit_token, fallback_has_prefill_claim } = response.stop_details;
    const fallbackModel = "claude-opus-4-8";

    const exactRetry: Anthropic.Beta.MessageCreateParamsNonStreaming = {
      ...request,
      model: fallbackModel,
      fallback_credit_token
    };

    // Reichhaltigste Form zuerst, bei jeder Ablehnung abstufen: die Fortsetzungs-
    // Form (außer die Behauptung ist falsch), der unveränderte Body, der das Token
    // noch trägt, und schließlich das Token aufgeben.
    let attempt = exactRetry;
    if (fallback_has_prefill_claim !== false) {
      const finalBlock = response.content.at(-1);
      const echoed: Anthropic.Beta.BetaContentBlockParam[] =
        finalBlock?.type === "text"
          ? [
              ...response.content.slice(0, -1),
              { ...finalBlock, text: finalBlock.text.trimEnd() }
            ]
          : response.content;
      attempt = {
        ...exactRetry,
        messages: [...request.messages, { role: "assistant", content: echoed }]
      };
    }

    try {
      response = await client.beta.messages.create(attempt);
    } catch (error) {
      // Nur bei einem formbezogenen 400 abstufen. "redemption temporarily
      // unavailable" ist vorübergehend: stattdessen innerhalb des Fünf-Minuten-
      // Fensters des Tokens auf dieselbe Weise erneut versuchen.
      if (
        !(error instanceof Anthropic.BadRequestError) ||
        error.message.includes("redemption temporarily unavailable")
      ) {
        throw error;
      }
      try {
        response = await client.beta.messages.create(exactRetry);
      } catch (retryError) {
        if (
          !(retryError instanceof Anthropic.BadRequestError) ||
          retryError.message.includes("redemption temporarily unavailable")
        ) {
          throw retryError;
        }
        response = await client.beta.messages.create({ ...request, model: fallbackModel });
      }
    }
  }

  const { stop_reason, model } = response;
  console.log(JSON.stringify({ stop_reason, model }));
  ```

  ```csharp C#
  var client = new AnthropicClient();
  const string beta = "fallback-credit-2026-07-01";

  List<BetaMessageParam> requestMessages =
  [
      new() { Role = Role.User, Content = "Hello, Claude" },
  ];
  MessageCreateParams Request(Model model) => new()
  {
      Model = model,
      MaxTokens = 1024,
      Messages = requestMessages,
      Betas = [beta],
  };
  var response = await client.Beta.Messages.Create(Request(Model.ClaudeFable5));

  if (
      response.StopReason == BetaStopReason.Refusal
      && response.StopDetails is { FallbackCreditToken: string token } details
  )
  {
      var exactBody = Request(Model.ClaudeOpus4_8) with { FallbackCreditToken = token };
      var attempt = exactBody;
      // Bevorzuge die Fortsetzungsform, es sei denn, die Behauptung ist falsch
      if (details.FallbackHasPrefillClaim is not false)
      {
          var echoed = JsonArray.Create(response.RawData["content"])!;
          if (
              echoed is [.., JsonObject lastBlock]
              && lastBlock["type"]?.GetValue<string>() is "text"
              && lastBlock["text"]?.GetValue<string>() is string text
          )
          {
              lastBlock["text"] = text.TrimEnd();
          }
          attempt = exactBody with
          {
              Messages =
              [
                  .. requestMessages,
                  new()
                  {
                      Role = Role.Assistant,
                      Content = new BetaMessageParamContent(
                          JsonSerializer.SerializeToElement(echoed)
                      ),
                  },
              ],
          };
      }
      // Eine vorübergehende Ablehnung „Einlösung vorübergehend nicht verfügbar“ wird aus
      // jedem der folgenden Catch-Filter weitergereicht: Wiederhole mit dem Token innerhalb seines Fünf-Minuten-Fensters.
      try
      {
          response = await client.Beta.Messages.Create(attempt);
      }
      catch (AnthropicBadRequestException e)
          when (!e.Message.Contains("redemption temporarily unavailable"))
      {
          try
          {
              // Falle auf den unveränderten Body zurück, weiterhin mit dem Token
              response = await client.Beta.Messages.Create(exactBody);
          }
          catch (AnthropicBadRequestException retryError)
              when (!retryError.Message.Contains("redemption temporarily unavailable"))
          {
              // Das Token selbst wurde abgelehnt: Gib es auf und wiederhole ohne.
              response = await client.Beta.Messages.Create(Request(Model.ClaudeOpus4_8));
          }
      }
  }

  Console.WriteLine(
      JsonSerializer.Serialize(
          new { stop_reason = response.StopReason?.Raw(), model = response.Model.Raw() }
      )
  );
  ```

  ```go Go
  ctx := context.Background()
  client := anthropic.NewClient()

  request := anthropic.BetaMessageNewParams{
  	MaxTokens: 1024,
  	Betas:     []anthropic.AnthropicBeta{anthropic.AnthropicBetaFallbackCredit2026_07_01},
  	Messages: []anthropic.BetaMessageParam{
  		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Hello, Claude")),
  	},
  }

  send := func(model anthropic.Model, body anthropic.BetaMessageNewParams) (*anthropic.BetaMessage, error) {
  	body.Model = model
  	return client.Beta.Messages.New(ctx, body)
  }
  // Ein nicht-transienter 400 bedeutet, dass diese Versuchsform oder dieses Token abgelehnt wurde und
  // die nächste Stufe der Leiter ausgeführt werden sollte. "redemption temporarily
  // unavailable" ist transient: Zeige es an und versuche es mit dem Token innerhalb
  // seines Fünf-Minuten-Fensters erneut.
  canFallBack := func(err error) bool {
  	apiErr, ok := errors.AsType[*anthropic.Error](err)
  	return ok && apiErr.StatusCode == 400 &&
  		!strings.Contains(apiErr.Error(), "redemption temporarily unavailable")
  }

  response, err := send(anthropic.ModelClaudeFable5, request)
  if err != nil {
  	log.Fatal(err)
  }

  if response.StopReason == anthropic.BetaStopReasonRefusal {
  	details := response.StopDetails
  	if token := details.FallbackCreditToken; token != "" {
  		exactBody := request
  		exactBody.FallbackCreditToken = anthropic.BetaMessageNewParamsFallbackCreditTokenUnion{
  			OfString: anthropic.String(token),
  		}
  		attempt := exactBody
  		// Bevorzuge die Fortsetzungsform, es sei denn, der Claim ist false
  		if details.FallbackHasPrefillClaim || !details.JSON.FallbackHasPrefillClaim.Valid() {
  			echoed := response.ToParam()
  			if len(echoed.Content) > 0 {
  				if text := echoed.Content[len(echoed.Content)-1].OfText; text != nil {
  					text.Text = strings.TrimRightFunc(text.Text, unicode.IsSpace)
  				}
  			}
  			attempt.Messages = append(slices.Clone(request.Messages), echoed)
  		}
  		response, err = send(anthropic.ModelClaudeOpus4_8, attempt)
  		if err != nil && canFallBack(err) {
  			// Falle auf den unveränderten Body zurück, weiterhin mit dem Token
  			response, err = send(anthropic.ModelClaudeOpus4_8, exactBody)
  			if err != nil && canFallBack(err) {
  				// Das Token selbst wurde abgelehnt: Gib es auf und versuche es ohne erneut.
  				response, err = send(anthropic.ModelClaudeOpus4_8, request)
  			}
  		}
  		if err != nil {
  			log.Fatal(err)
  		}
  	}
  }

  summary, err := json.Marshal(struct {
  	StopReason anthropic.BetaStopReason `json:"stop_reason"`
  	Model      anthropic.Model          `json:"model"`
  }{response.StopReason, response.Model})
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(string(summary))
  ```

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

  MessageCreateParams.Builder request() {
      return MessageCreateParams.builder()
          .maxTokens(1024L)
          .addUserMessage("Hello, Claude")
          .addBeta(AnthropicBeta.FALLBACK_CREDIT_2026_07_01);
  }

  BetaMessage send(Model model, MessageCreateParams.Builder body) {
      return client.beta().messages().create(body.model(model).build());
  }

  void main() {
      BetaMessage response = send(Model.CLAUDE_FABLE_5, request());

      if (response.stopReason().map(BetaStopReason.REFUSAL::equals).orElse(false)
              && response.stopDetails().orElse(null) instanceof BetaRefusalStopDetails details
              && details.fallbackCreditToken().orElse(null) instanceof String creditToken) {
          MessageCreateParams.Builder attempt = request().fallbackCreditToken(creditToken);
          // Bevorzuge die Fortsetzungsform, sofern die Behauptung nicht falsch ist
          if (details.fallbackHasPrefillClaim().orElse(true)) {
              List<BetaContentBlockParam> echoed = new ArrayList<>(
                  response.content().stream().map(BetaContentBlock::toParam).toList());
              if (!echoed.isEmpty() && echoed.getLast().isText()) {
                  var lastText = echoed.removeLast().asText();
                  echoed.addLast(BetaContentBlockParam.ofText(
                      lastText.toBuilder().text(lastText.text().stripTrailing()).build()));
              }
              attempt.addAssistantMessageOfBetaContentBlockParams(echoed);
          }
          try {
              response = send(Model.CLAUDE_OPUS_4_8, attempt);
          } catch (BadRequestException badRequest) {
              // Vorübergehend: Wiederhole mit dem Token innerhalb seines Fünf-Minuten-Fensters
              if (badRequest.getMessage().contains("redemption temporarily unavailable")) {
                  throw badRequest;
              }
              try {
                  // Greife auf den unveränderten Body zurück, weiterhin mit dem Token
                  response = send(Model.CLAUDE_OPUS_4_8, request().fallbackCreditToken(creditToken));
              } catch (BadRequestException retryBadRequest) {
                  if (retryBadRequest.getMessage().contains("redemption temporarily unavailable")) {
                      throw retryBadRequest;
                  }
                  // Das Token selbst wurde abgelehnt: Verwirf es und wiederhole ohne.
                  response = send(Model.CLAUDE_OPUS_4_8, request());
              }
          }
      }

      IO.println("""
          {"stop_reason": "%s", "model": "%s"}"""
          .formatted(response.stopReason().orElseThrow(), response.model()));
  }
  ```

  ```php PHP
  $client = new Client();
  $beta = 'fallback-credit-2026-07-01';
  $messages = [['role' => 'user', 'content' => 'Hello, Claude']];

  $send = fn (string $model, array $messages, ?string $token = null) => $client->beta->messages->create(
      maxTokens: 1024,
      messages: $messages,
      model: $model,
      fallbackCreditToken: $token,
      betas: [$beta],
  );
  $response = $send('claude-fable-5', $messages);

  $token = $response->stopReason === 'refusal'
      ? $response->stopDetails?->fallbackCreditToken
      : null;

  if ($token !== null) {
      $attemptMessages = $messages;
      // Bevorzuge die Fortsetzungsform, es sei denn, die Behauptung ist falsch
      if ($response->stopDetails->fallbackHasPrefillClaim !== false) {
          $echoed = $response->content
              |> json_encode(...)
              |> (fn (string $json): array => json_decode($json, associative: true));
          $lastIndex = array_key_last($echoed);
          if ($lastIndex !== null && $echoed[$lastIndex]['type'] === 'text') {
              $echoed[$lastIndex]['text'] = rtrim($echoed[$lastIndex]['text']);
          }
          $attemptMessages[] = ['role' => 'assistant', 'content' => $echoed];
      }
      // Vorübergehend: Wiederhole mit dem Token innerhalb seines Fünf-Minuten-Fensters
      $isTransientRedemption = fn (BadRequestException $error): bool =>
          str_contains($error->getMessage(), 'redemption temporarily unavailable');
      try {
          $response = $send('claude-opus-4-8', $attemptMessages, $token);
      } catch (BadRequestException $error) {
          if ($isTransientRedemption($error)) {
              throw $error;
          }
          try {
              // Falle auf den unveränderten Body zurück, weiterhin mit dem Token
              $response = $send('claude-opus-4-8', $messages, $token);
          } catch (BadRequestException $retryError) {
              if ($isTransientRedemption($retryError)) {
                  throw $retryError;
              }
              // Das Token selbst wurde abgelehnt: Gib es auf und wiederhole ohne.
              $response = $send('claude-opus-4-8', $messages);
          }
      }
  }

  echo json_encode(['stop_reason' => $response->stopReason, 'model' => $response->model]), PHP_EOL;
  ```

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

  request = {
    max_tokens: 1024,
    messages: [{role: "user", content: "Hello, Claude"}]
  }

  send_message = ->(model, body) do
    client.beta.messages.create(model:, betas: ["fallback-credit-2026-07-01"], **body)
  end

  response = send_message.call("claude-fable-5", request)

  if response in {stop_reason: :refusal,
                  stop_details: {fallback_credit_token: String => credit_token} => details}
    exact_body = request.merge(fallback_credit_token: credit_token)

    # Bevorzuge die Fortsetzungsform, es sei denn, die Behauptung ist falsch
    attempt = if details.fallback_has_prefill_claim != false
      echoed = response.content.map(&:to_h)
      if echoed.last in {type: :text, text: String => final_text}
        echoed[-1] = echoed.last.merge(text: final_text.rstrip)
      end
      exact_body.merge(
        messages: [*request[:messages], {role: "assistant", content: echoed}]
      )
    else
      exact_body
    end

    begin
      response = send_message.call("claude-opus-4-8", attempt)
    rescue Anthropic::Errors::BadRequestError => error
      # Vorübergehend: Wiederhole mit dem Token innerhalb seines Fünf-Minuten-Fensters
      raise if error.message.include?("redemption temporarily unavailable")
      begin
        # Falle auf den unveränderten Body zurück, weiterhin mit dem Token
        response = send_message.call("claude-opus-4-8", exact_body)
      rescue Anthropic::Errors::BadRequestError => error
        # Vorübergehend: Wiederhole mit dem Token innerhalb seines Fünf-Minuten-Fensters
        raise if error.message.include?("redemption temporarily unavailable")
        # Das Token selbst wurde abgelehnt: Gib es auf und wiederhole ohne.
        response = send_message.call("claude-opus-4-8", request)
      end
    end
  end

  puts JSON.generate({stop_reason: response.stop_reason, model: response.model})
  ```
</CodeGroup>

## Wo es funktioniert

Die Fallback-Gutschrift ist in der Beta auf der Claude API, Amazon Bedrock, Claude Platform on AWS, Google Cloud und Microsoft Foundry verfügbar. Ablehnungen in [Message Batches](https://platform.claude.com/docs/de/build-with-claude/batch-processing) erzeugen keine Gutschrift-Tokens, und die Einlösung gilt nur für direkte Messages-API-Anfragen: Ein bei einer Batch-Anfrage übergebenes Token wird akzeptiert, aber ignoriert. Eine Ablehnung durch Claude Haiku 5.5 enthält keine Fallback-Gutschrift, daher zahlt eine Wiederholung danach die vollen Kosten für das Schreiben des Prompt-Caches des Fallback-Modells.

Das Wiederholungsmodell muss eines der zulässigen Fallback-Ziele des ablehnenden Modells sein. Für Claude Fable 5.1, Claude Fable 5 und Claude Opus 5.5 sind das Claude Opus 4.8 (`claude-opus-4-8`) und Claude Opus 5 (`claude-opus-5`). Für Claude Opus 5 ist es Claude Opus 4.8. Für Claude Sonnet 5.5 ist es Claude Sonnet 5 (`claude-sonnet-5`).

<Accordion title="Zulässige Fallback-Ziele programmatisch nachschlagen">
  Auf der Claude API und Claude Platform auf AWS wird die Zielliste als `allowed_fallback_models` im Eintrag jedes Modells in der [Models API](https://platform.claude.com/docs/de/api/models/list) veröffentlicht, wenn der Beta-Header `server-side-fallback-2026-07-01` gesetzt ist. Die Liste ist unter dem Header `fallback-credit-*` allein noch nicht sichtbar. Sie wird auf Amazon Bedrock, Google Cloud oder Microsoft Foundry nicht bereitgestellt.
</Accordion>

## Prüfen, ob die Gutschrift angewendet wurde

Die Erstattung ist in der `usage` der Wiederholung sichtbar. Verglichen mit dem, was dieselbe Anfrage ohne das Token melden würde, ist `cache_creation_input_tokens` niedriger und `cache_read_input_tokens` um denselben Betrag höher. Eine Verschiebung von null bedeutet, dass das Token anerkannt wurde, es aber nichts neu zu bepreisen gab, zum Beispiel weil der Cache des Wiederholungsmodells bereits warm war.

## Wenn eine Wiederholung zurückgewiesen wird

Die meisten Wiederholungen werden beim ersten Versuch eingelöst. Wenn das nicht der Fall ist, gibt die API einen 400-Fehler zurück, der dir sagt, was du als Nächstes versuchen sollst.

<Steps>
  <Step title="Fortsetzung zurückgewiesen: den unveränderten Body erneut senden">
    Wenn die Wiederholung, die die Assistant-Nachricht anhängt, mit einem 400-Fehler zurückgewiesen wird, sende den Body der abgelehnten Anfrage unverändert erneut, weiterhin mit dem Token.
  </Step>

  <Step title="Token zurückgewiesen: das Token weglassen">
    Wenn auch der unveränderte Body mit einem 400-Fehler zurückgewiesen wird, dessen Meldung `fallback_credit_token` nennt, wiederhole ohne das Token. Die Gutschrift verfällt, aber die Wiederholung selbst geht durch.
  </Step>
</Steps>

<Note>
  Wenn die abgelehnte Anfrage Server-Tools ausgeführt hat, führt eine Wiederholung ohne Token diese Tools erneut aus und rechnet sie erneut ab. Gib in diesem Fall den 400-Fehler an deinen Aufrufer weiter, anstatt auf eine Wiederholung ohne Token durchzufallen.
</Note>

<Accordion title="Wenn der Fehler 'redemption temporarily unavailable' lautet">
  Diese Zurückweisung ist vorübergehend und kein Urteil über deine Wiederholungsform. Wiederhole dieselbe Anfrage mit demselben Token innerhalb des Fünf-Minuten-Fensters des Tokens. Gehe nicht zur nächsten Stufe der Leiter über.
</Accordion>

## Referenz

Die folgenden Abschnitte behandeln Grenzfälle und die vollständigen Einlösungsregeln. Die meisten Integrationen benötigen sie nicht.

<Accordion title="Felder, die mit der abgelehnten Anfrage übereinstimmen müssen">
  Die Einlösung vergleicht die Wiederholung mit der abgelehnten Anfrage. Jedes Feld, das den Prompt formt, muss exakt übereinstimmen. Felder, die den Prompt nicht formen, dürfen sich bei der Wiederholung ändern.

  | Regel                                 | Felder                                                                                                                                                                          |
  | ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | Muss exakt übereinstimmen             | `system`, `messages`, `tools`, `tool_choice`, `thinking` und `cache_control`, plus `output_config`, `mcp_servers`, `context_management` und `container`, wenn du sie verwendest |
  | Darf sich bei der Wiederholung ändern | `model`, `max_tokens`, `stop_sequences`, `temperature`, `top_p`, `top_k`, `stream`, `metadata` und `service_tier`                                                               |

  Die Fortsetzungsform (`fallback_has_prefill_claim: true`) ist die einzige Ausnahme von der `messages`-Übereinstimmung: Sie fügt genau eine Assistant-Nachricht am Ende von `messages` hinzu.

  Entferne bei der Wiederholung keine `thinking`- oder `redacted_thinking`-Blöcke aus früheren Turns, auch wenn eine einfache Wiederholung ohne Token sie normalerweise entfernt. Der Body muss mit der abgelehnten Anfrage übereinstimmen, und der Server behandelt diese Blöcke selbst.
</Accordion>

<Accordion title="Auch Beta-Header müssen übereinstimmen">
  Sende bei der Wiederholung dieselben `anthropic-beta`-Header wie bei der abgelehnten Anfrage. Ein Beta-Header, der bei einer der beiden Anfragen vorhanden ist, bei der anderen aber nicht, kann die Übereinstimmung scheitern lassen, selbst wenn die Bodys identisch sind. Der resultierende 400-Fehler trägt dieselbe Meldung `request body ... does not match` wie ein Body-Unterschied, sodass ein Header-Unterschied leicht als Body-Problem missverstanden wird. Füge insbesondere keine Beta-Header hinzu und lasse keine weg, je nachdem, auf welches Modell die Anfrage abzielt.

  Zwei Header-Familien sind zugunsten der Wiederholung von der Übereinstimmung ausgenommen:

  * **`server-side-fallback-*`:** Eine Wiederholung muss den Parameter `fallbacks` weglassen, und das Weglassen dieses Headers zusammen damit verursacht keine Nichtübereinstimmung.
  * **`fallback-credit-*`:** Behalte diesen Header bei beiden Anfragen. Die Wiederholung benötigt ihn, um das Token einzulösen.

  <Note>
    Bei Modellen, die das 1M-Token-Kontextfenster standardmäßig enthalten, wie Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Sonnet 5.5 und Claude Sonnet 5, hat der Beta-Header `context-1m-2025-08-07` keine Wirkung. Damit die beiden Anfragen identisch bleiben, lasse diesen Header bei beiden weg, anstatt ihn bei einer zu senden und bei der anderen nicht.
  </Note>
</Accordion>

<Accordion title="Wenn fallback_has_prefill_claim fehlt">
  Das Feld hat nur dann keinen Wert, wenn auch das Token keinen hat. Solange du also ein Token besitzt, hat das Feld einen Wert, außer auf Amazon Bedrock, Google Cloud und Microsoft Foundry, wo es noch fehlen kann, während deren Unterstützung für das Feld ausgerollt wird. Behandle in diesem Fall die Wiederholungsform als unbekannt und nicht als `false` (python: `False`). Versuche zuerst die Form mit angehängter Assistant-Nachricht und verlasse dich auf die Zurückweisungsbehandlung in [Wenn eine Wiederholung zurückgewiesen wird](https://platform.claude.com/docs/de/build-with-claude/fallback-credit#when-a-retry-is-rejected), die auf den unveränderten Body zurückfällt.
</Accordion>

<Accordion title="Den content der abgelehnten Antwort wiedergeben">
  Wenn das Token einer Ablehnung die Fortsetzungsform unterstützt, enthält der `content` der Antwort nur die eigene Ausgabe des Modells, und die Erklärung der Ablehnung wird in `stop_details.explanation` geliefert. Du kannst `content` daher unverändert in die angehängte Assistant-Nachricht übernehmen.

  Zwei Anpassungen können vor dem Senden dennoch nötig sein:

  * Wenn der letzte Block, den du sendest, ein `text`-Block ist, entferne dessen nachgestellten Leerraum.
  * Lasse jeden clientseitigen `tool_use`-Block weg, der kein passendes `tool_result` hat.

  Wenn der wiedergegebene Inhalt einen `fallback`-Block aus einem früheren [serverseitigen Fallback](https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback#server-side-fallback) enthält, behalte den Block genau dort, wo er erschien. Er wird bei jeder Anfrage ohne Beta-Header akzeptiert. Die API verwendet seine Position, um die Thinking-Blöcke um ihn herum zu validieren, sodass eine Anfrage, die Thinking-Blöcke von beiden Seiten dieser Grenze wiedergibt, zurückgewiesen wird, wenn der Block weggelassen oder verschoben wird.
</Accordion>

<Accordion title="Geltungsbereich und Lebensdauer des Tokens">
  Das Token lässt sich nur von der Organisation und dem Workspace einlösen, die die Ablehnung erhalten haben, auch auf Microsoft Foundry. Auf Amazon Bedrock und Google Cloud, die keine Workspaces haben, ist das Token stattdessen an die Aufruferidentität der Plattform gebunden.

  Das Token läuft fünf Minuten nach der Ablehnung ab. Sende die Wiederholung danach ohne es. Das Token ist außerdem zustandslos: Der Server speichert nichts darüber, und es gibt keinen Endpunkt, um es zu inspizieren oder zu widerrufen.
</Accordion>

<Accordion title="Wenn ein Token mit keiner der beiden Formen eingelöst werden kann">
  Wenn die Ablehnung eintraf, nachdem innerhalb der Anfrage bereits Server-Tools ausgeführt worden waren, lässt sich das Token nur durch Fortsetzen der Teilantwort einlösen. Diese Einschränkung verhindert, dass die abgeschlossenen Tool-Aufrufe erneut ausgeführt und abgerechnet werden.

  Eine Kombination kann das Token daher mit keiner der beiden Formen einlösbar machen, wenn beides Folgende zutrifft:

  * Die Anfrage verwendete `output_config.format` oder ein `tool_choice`, das Tool-Nutzung erzwingt. Beides schließt die Form mit angehängter Assistant-Nachricht aus.
  * Die Ablehnung traf ein, nachdem Server-Tools ausgeführt worden waren. Das schließt den unveränderten Body aus.

  Wenn die Wiederholung mit unverändertem Body mit einem 400-Fehler zurückgewiesen wird, der besagt, dass das Token durch Fortsetzen der Teilantwort eingelöst werden muss, verwirf das Token. Eine Wiederholung ohne es geht durch, führt aber die abgeschlossenen Server-Tools erneut aus und rechnet sie erneut ab. Gib die Kosten oder den Fehler an deinen Aufrufer weiter, anstatt stillschweigend zu wiederholen.
</Accordion>

## Nächste Schritte

<CardGroup>
  <Card title="Ablehnungen und Fallback" icon="shield" href="https://platform.claude.com/docs/de/build-with-claude/refusals-and-fallback">
    Erkenne Ablehnungen und wähle zwischen serverseitigem Fallback, der SDK-Middleware und einer manuellen Wiederholung.
  </Card>

  <Card title="Prompt-Caching" icon="bolt" href="https://platform.claude.com/docs/de/build-with-claude/prompt-caching">
    Wie Cache-Lesevorgänge und Cache-Schreibvorgänge abgerechnet werden.
  </Card>

  <Card title="Stop-Gründe und Fallback" icon="code" href="https://platform.claude.com/docs/de/build-with-claude/handling-stop-reasons">
    Jeder `stop_reason`-Wert und wie du damit umgehst.
  </Card>

  <Card title="SDK-Middleware" icon="settings" href="https://platform.claude.com/docs/de/cli-sdks-libraries/middleware">
    Der SDK-Helfer, der die Fallback-Gutschrift automatisch anwendet.
  </Card>
</CardGroup>