---
title: Batch-Verarbeitung
url: https://platform.claude.com/docs/de/build-with-claude/batch-processing
description: Verarbeite große Mengen von Messages-Anfragen asynchron mit der Message Batches API, senke die Kosten um 50 % und erhöhe den Durchsatz.
---

„Batch processing“ (Batch-Verarbeitung) ist ein leistungsstarker Ansatz, um große Mengen von Anfragen effizient zu bearbeiten. Anstatt Anfragen einzeln mit sofortigen Antworten zu verarbeiten, ermöglicht dir die Batch-Verarbeitung, mehrere Anfragen gemeinsam zur asynchronen Verarbeitung einzureichen. Dieses Muster ist besonders nützlich, wenn:

* Du große Datenmengen verarbeiten musst
* Sofortige Antworten nicht erforderlich sind
* Du auf Kosteneffizienz optimieren möchtest
* Du groß angelegte Evaluierungen oder Analysen durchführst

Die Message Batches API ist Anthropics erste Implementierung dieses Musters.

<Note>
  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).
</Note>

# Message Batches API

Die Message Batches API ist eine leistungsstarke, kosteneffiziente Möglichkeit, große Mengen von [Messages](https://platform.claude.com/docs/de/api/messages/create)-Anfragen asynchron zu verarbeiten. Dieser Ansatz eignet sich gut für Aufgaben, die keine sofortigen Antworten erfordern, wobei die meisten Batches in weniger als 1 Stunde abgeschlossen werden, während die Kosten um 50 % gesenkt und der Durchsatz erhöht wird.

Zusätzlich zu diesem Leitfaden kannst du [die API-Referenz direkt erkunden](https://platform.claude.com/docs/de/api/messages/batches/create).

## So funktioniert die Message Batches API

Wenn du eine Anfrage an die Message Batches API sendest:

1. Das System erstellt einen neuen Message Batch mit den bereitgestellten Messages-Anfragen.
2. Der Batch wird dann asynchron verarbeitet, wobei jede Anfrage unabhängig bearbeitet wird.
3. Du kannst den Status des Batches abfragen und die Ergebnisse abrufen, sobald die Verarbeitung aller Anfragen beendet ist.

Dies ist besonders nützlich für Massenoperationen, die keine sofortigen Ergebnisse erfordern, wie zum Beispiel:

* Groß angelegte Evaluierungen: Verarbeite Tausende von Testfällen effizient.
* Inhaltsmoderation: Analysiere große Mengen nutzergenerierter Inhalte asynchron.
* Datenanalyse: Generiere Erkenntnisse oder Zusammenfassungen für große Datensätze.
* Massenhafte Inhaltserstellung: Erstelle große Textmengen für verschiedene Zwecke (zum Beispiel Produktbeschreibungen, Artikelzusammenfassungen).

### Batch-Einschränkungen

* Ein Message Batch ist auf entweder 100.000 Message-Anfragen oder 256 MB Größe begrenzt, je nachdem, was zuerst erreicht wird.
* Das System verarbeitet jeden Batch so schnell wie möglich, wobei die meisten Batches innerhalb von 1 Stunde abgeschlossen werden. Du kannst auf die Batch-Ergebnisse zugreifen, wenn alle Nachrichten abgeschlossen sind oder nach 24 Stunden, je nachdem, was zuerst eintritt. Batches laufen ab, wenn die Verarbeitung nicht innerhalb von 24 Stunden abgeschlossen wird.
* Batch-Ergebnisse sind 29 Tage nach der Erstellung verfügbar. Danach kannst du den Batch weiterhin ansehen, aber seine Ergebnisse stehen nicht mehr zum Download zur Verfügung.
* Batches sind auf einen [Workspace](https://platform.claude.com/settings/workspaces) beschränkt. Du kannst alle Batches (und deren Ergebnisse) einsehen, die innerhalb des Workspace erstellt wurden, in dem deine Anfrage ausgeführt wird.
* „Rate limits“ (Ratenlimits) gelten sowohl für HTTP-Anfragen an die Batches API als auch für die Anzahl der Anfragen innerhalb eines Batches, die auf Verarbeitung warten. Siehe [Ratenlimits der Message Batches API](https://platform.claude.com/docs/de/api/rate-limits#message-batches-api). Darüber hinaus kann die Verarbeitung je nach aktueller Nachfrage und deinem Anfragevolumen verlangsamt werden. In diesem Fall kann es vorkommen, dass mehr Anfragen nach 24 Stunden ablaufen.
* Aufgrund des hohen Durchsatzes und der gleichzeitigen Verarbeitung können Batches das konfigurierte [Ausgabenlimit](https://platform.claude.com/settings/billing) deines Workspace geringfügig überschreiten.
* Jede Anfrage in einem Batch muss einen `max_tokens`-Wert von mindestens `1` haben. `max_tokens: 0` ([Cache-Vorwärmen](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#pre-warming-the-cache)) wird innerhalb eines Batches nicht unterstützt, da ein während der Batch-Verarbeitung geschriebener ephemerer Cache-Eintrag wahrscheinlich ablaufen würde, bevor die Folgeanfrage ausgeführt wird.

### Unterstützte Modelle

Alle [aktiven Modelle](https://platform.claude.com/docs/de/models/overview) unterstützen die Message Batches API.

### Was in Batches verarbeitet werden kann

Nahezu jede Anfrage, die du an die Messages API stellen kannst, kann in einen Batch aufgenommen werden. Dazu gehören:

* Vision
* „Tool use“ (Tool-Nutzung), einschließlich aller [Server-Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/server-tools) (Websuche, Web-Abruf, Codeausführung, MCP-Konnektoren, Advisor und Tool-Suche)
* System-Nachrichten
* Mehrstufige Konversationen
* „Extended thinking“ (erweitertes Nachdenken)
* Die meisten Beta-Funktionen

Da jede Anfrage im Batch unabhängig verarbeitet wird, kannst du verschiedene Arten von Anfragen innerhalb eines einzelnen Batches mischen.

Eine kleine Anzahl von Messages-API-Parametern wird in Batch-Anfragen **nicht** unterstützt. Wenn du einen davon angibst, wird ein Validierungsfehler zurückgegeben:

| Parameter                                                                              | Grund                                                                                                                    |
| -------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| `stream: true`                                                                         | Batch-Ergebnisse werden als einzelne Datei zurückgegeben, nicht als Stream.                                              |
| `speed` ([Fast Mode](https://platform.claude.com/docs/de/build-with-claude/fast-mode)) | Fast Mode optimiert die synchrone Latenz, was für die asynchrone Batch-Verarbeitung nicht relevant ist.                  |
| `max_tokens: 0`                                                                        | Siehe [Batch-Einschränkungen](https://platform.claude.com/docs/de/build-with-claude/batch-processing#batch-limitations). |

<Tip>
  Da die Verarbeitung von Batches länger als 5 Minuten dauern kann, solltest du die [1-Stunden-Cache-Dauer](https://platform.claude.com/docs/de/build-with-claude/prompt-caching#1-hour-cache-duration) mit „prompt caching“ (Prompt-Caching) in Betracht ziehen, um bessere Cache-Trefferquoten zu erzielen, wenn du Batches mit gemeinsamem Kontext verarbeitest.
</Tip>

## Preise

Die Batches API bietet erhebliche Kosteneinsparungen. Die gesamte Nutzung wird zu 50 % der Standard-API-Preise abgerechnet.

| Model                                                                                                                                | Batch input  | Batch output  |
| :----------------------------------------------------------------------------------------------------------------------------------- | :----------- | :------------ |
| Claude Fable 5.1                                                                                                                     | $5 / MTok    | $25 / MTok    |
| Claude Mythos 5.1 ([limited availability](https://support.claude.com/en/articles/14604842))                                          | $5 / MTok    | $25 / MTok    |
| Claude Fable 5                                                                                                                       | $5 / MTok    | $25 / MTok    |
| Claude Mythos 5 ([limited availability](https://support.claude.com/en/articles/14604842))                                            | $5 / MTok    | $25 / MTok    |
| Claude Opus 5.5                                                                                                                      | $2 / MTok    | $10 / MTok    |
| Claude Opus 5                                                                                                                        | $2.50 / MTok | $12.50 / MTok |
| Claude Opus 4.8                                                                                                                      | $2.50 / MTok | $12.50 / MTok |
| Claude Opus 4.7                                                                                                                      | $2.50 / MTok | $12.50 / MTok |
| Claude Opus 4.6                                                                                                                      | $2.50 / MTok | $12.50 / MTok |
| Claude Opus 4.5                                                                                                                      | $2.50 / MTok | $12.50 / MTok |
| Claude Opus 4.1 ([retired, except on Bedrock and Google Cloud](https://platform.claude.com/docs/de/about-claude/model-deprecations)) | $7.50 / MTok | $37.50 / MTok |
| Claude Opus 4 ([retired, except on Google Cloud](https://platform.claude.com/docs/de/about-claude/model-deprecations))               | $7.50 / MTok | $37.50 / MTok |
| Claude Sonnet 5.5                                                                                                                    | $1 / MTok    | $5 / MTok     |
| Claude Sonnet 5                                                                                                                      | $1 / MTok    | $5 / MTok     |
| Claude Sonnet 4.6                                                                                                                    | $1.50 / MTok | $7.50 / MTok  |
| Claude Sonnet 4.5                                                                                                                    | $1.50 / MTok | $7.50 / MTok  |
| Claude Sonnet 4 ([retired, except on Bedrock and Google Cloud](https://platform.claude.com/docs/de/about-claude/model-deprecations)) | $1.50 / MTok | $7.50 / MTok  |
| Claude Haiku 5.5 (for prompts up to 100,000 tokens)                                                                                  | $0.05 / MTok | $0.25 / MTok  |
| Claude Haiku 5.5 (for prompts over 100,000 tokens)                                                                                   | $0.25 / MTok | $1.25 / MTok  |
| Claude Haiku 4.5                                                                                                                     | $0.50 / MTok | $2.50 / MTok  |
| Claude Haiku 3.5 ([retired, except on Google Cloud](https://platform.claude.com/docs/de/about-claude/model-deprecations))            | $0.40 / MTok | $2 / MTok     |

* **MTok:** Million tokens. $5 / MTok is $5 for every million tokens.
* **Limited access:** Available only to organizations verified through Anthropic’s verification programs, such as the [Cyber Verification Program](https://support.claude.com/en/articles/14604842). To request access, apply to the program that covers your use case.
* **Retired:** May still be available on other cloud platforms. See [Model deprecations](https://platform.claude.com/docs/de/about-claude/model-deprecations) for more.

## So verwendest du die Message Batches API

### Deinen Batch vorbereiten und erstellen

Ein Message Batch besteht aus einer Liste von Anfragen zum Erstellen einer Message. Die Form einer einzelnen Anfrage umfasst:

* Eine eindeutige `custom_id` zur Identifizierung der Messages-Anfrage. Muss 1 bis 64 Zeichen lang sein und darf nur alphanumerische Zeichen, Bindestriche und Unterstriche enthalten (entsprechend `^[a-zA-Z0-9_-]{1,64}$`).
* Ein `params`-Objekt mit den Standardparametern der [Messages API](https://platform.claude.com/docs/de/api/messages/create)

Du kannst [einen Batch erstellen](https://platform.claude.com/docs/de/api/messages/batches/create), indem du diese Liste im Parameter `requests` übergibst:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages/batches \
       --header "x-api-key: $ANTHROPIC_API_KEY" \
       --header "anthropic-version: 2023-06-01" \
       --header "content-type: application/json" \
       --data \
  '{
      "requests": [
          {
              "custom_id": "my-first-request",
              "params": {
                  "model": "claude-opus-5-5",
                  "max_tokens": 1024,
                  "messages": [
                      {"role": "user", "content": "Hello, world"}
                  ]
              }
          },
          {
              "custom_id": "my-second-request",
              "params": {
                  "model": "claude-opus-5-5",
                  "max_tokens": 1024,
                  "messages": [
                      {"role": "user", "content": "Hi again, friend"}
                  ]
              }
          }
      ]
  }'
  ```

  ```bash CLI
  ant messages:batches create <<'YAML'
  requests:
    - custom_id: my-first-request
      params:
        model: claude-opus-5-5
        max_tokens: 1024
        messages:
          - role: user
            content: Hello, world
    - custom_id: my-second-request
      params:
        model: claude-opus-5-5
        max_tokens: 1024
        messages:
          - role: user
            content: Hi again, friend
  YAML
  ```

  ```python Python
  from anthropic.types.message_create_params import MessageCreateParamsNonStreaming
  from anthropic.types.messages.batch_create_params import Request

  client = anthropic.Anthropic()

  message_batch = client.messages.batches.create(
      requests=[
          Request(
              custom_id="my-first-request",
              params=MessageCreateParamsNonStreaming(
                  model="claude-opus-5-5",
                  max_tokens=1024,
                  messages=[
                      {
                          "role": "user",
                          "content": "Hello, world",
                      }
                  ],
              ),
          ),
          Request(
              custom_id="my-second-request",
              params=MessageCreateParamsNonStreaming(
                  model="claude-opus-5-5",
                  max_tokens=1024,
                  messages=[
                      {
                          "role": "user",
                          "content": "Hi again, friend",
                      }
                  ],
              ),
          ),
      ]
  )

  print(message_batch)
  ```

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

  const messageBatch = await client.messages.batches.create({
    requests: [
      {
        custom_id: "my-first-request",
        params: {
          model: "claude-opus-5-5",
          max_tokens: 1024,
          messages: [{ role: "user", content: "Hello, world" }]
        }
      },
      {
        custom_id: "my-second-request",
        params: {
          model: "claude-opus-5-5",
          max_tokens: 1024,
          messages: [{ role: "user", content: "Hi again, friend" }]
        }
      }
    ]
  });

  console.log(messageBatch);
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Messages;
  using Anthropic.Models.Messages.Batches;

  AnthropicClient client = new();

  var batch = await client.Messages.Batches.Create(new BatchCreateParams
  {
      Requests =
      [
          new()
          {
              CustomID = "my-first-request",
              Params = new()
              {
                  Model = Model.ClaudeOpus5_5,
                  MaxTokens = 1024,
                  Messages =
                  [
                      new() { Role = Role.User, Content = "Hello, world" }
                  ]
              }
          },
          new()
          {
              CustomID = "my-second-request",
              Params = new()
              {
                  Model = Model.ClaudeOpus5_5,
                  MaxTokens = 1024,
                  Messages =
                  [
                      new() { Role = Role.User, Content = "Hi again, friend" }
                  ]
              }
          }
      ]
  });

  Console.WriteLine(batch);
  ```

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

  batch, _ := client.Messages.Batches.New(context.Background(),
  	anthropic.MessageBatchNewParams{
  		Requests: []anthropic.MessageBatchNewParamsRequest{
  			{
  				CustomID: "my-first-request",
  				Params: anthropic.MessageBatchNewParamsRequestParams{
  					Model:     anthropic.ModelClaudeOpus5_5,
  					MaxTokens: 1024,
  					Messages: []anthropic.MessageParam{
  						anthropic.NewUserMessage(
  							anthropic.NewTextBlock("Hello, world"),
  						),
  					},
  				},
  			},
  			{
  				CustomID: "my-second-request",
  				Params: anthropic.MessageBatchNewParamsRequestParams{
  					Model:     anthropic.ModelClaudeOpus5_5,
  					MaxTokens: 1024,
  					Messages: []anthropic.MessageParam{
  						anthropic.NewUserMessage(
  							anthropic.NewTextBlock("Hi again, friend"),
  						),
  					},
  				},
  			},
  		},
  	})

  fmt.Println(batch.ID)
  ```

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

  BatchCreateParams params = BatchCreateParams.builder()
    .addRequest(
      BatchCreateParams.Request.builder()
        .customId("my-first-request")
        .params(
          BatchCreateParams.Request.Params.builder()
            .model(Model.CLAUDE_OPUS_5_5)
            .maxTokens(1024)
            .addUserMessage("Hello, world")
            .build()
        )
        .build()
    )
    .addRequest(
      BatchCreateParams.Request.builder()
        .customId("my-second-request")
        .params(
          BatchCreateParams.Request.Params.builder()
            .model(Model.CLAUDE_OPUS_5_5)
            .maxTokens(1024)
            .addUserMessage("Hi again, friend")
            .build()
        )
        .build()
    )
    .build();

  MessageBatch messageBatch = client.messages().batches().create(params);

  System.out.println(messageBatch);
  ```

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

  $batch = $client->messages->batches->create(
      requests: [
          [
              'custom_id' => 'my-first-request',
              'params' => [
                  'model' => 'claude-opus-5-5',
                  'max_tokens' => 1024,
                  'messages' => [
                      ['role' => 'user', 'content' => 'Hello, world']
                  ]
              ]
          ],
          [
              'custom_id' => 'my-second-request',
              'params' => [
                  'model' => 'claude-opus-5-5',
                  'max_tokens' => 1024,
                  'messages' => [
                      ['role' => 'user', 'content' => 'Hi again, friend']
                  ]
              ]
          ]
      ],
  );

  echo $batch->id;
  ```

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

  batch = client.messages.batches.create(
    requests: [
      {
        custom_id: "my-first-request",
        params: {
          model: "claude-opus-5-5",
          max_tokens: 1024,
          messages: [
            { role: "user", content: "Hello, world" }
          ]
        }
      },
      {
        custom_id: "my-second-request",
        params: {
          model: "claude-opus-5-5",
          max_tokens: 1024,
          messages: [
            { role: "user", content: "Hi again, friend" }
          ]
        }
      }
    ]
  )

  puts batch
  ```
</CodeGroup>

In diesem Beispiel werden zwei separate Anfragen gemeinsam zur asynchronen Verarbeitung in einem Batch zusammengefasst. Jede Anfrage hat eine eindeutige `custom_id` und enthält die Standardparameter, die du für einen Messages-API-Aufruf verwenden würdest.

<Tip>
  **Teste deine Batch-Anfragen mit der Messages API**

  Die Validierung des `params`-Objekts für jede Message-Anfrage erfolgt asynchron, und Validierungsfehler werden zurückgegeben, wenn die Verarbeitung des gesamten Batches beendet ist. Du kannst sicherstellen, dass du deine Eingabe korrekt aufbaust, indem du die Form deiner Anfrage zuerst mit der [Messages API](https://platform.claude.com/docs/de/api/messages/create) überprüfst.
</Tip>

Wenn ein Batch erstmals erstellt wird, hat die Antwort den Verarbeitungsstatus `in_progress`.

```json Output
{
  "id": "msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d",
  "type": "message_batch",
  "processing_status": "in_progress",
  "request_counts": {
    "processing": 2,
    "succeeded": 0,
    "errored": 0,
    "canceled": 0,
    "expired": 0
  },
  "ended_at": null,
  "created_at": "2024-09-24T18:37:24.100435Z",
  "expires_at": "2024-09-25T18:37:24.100435Z",
  "cancel_initiated_at": null,
  "results_url": null
}
```

### Deinen Batch verfolgen

Das Feld `processing_status` des Message Batch gibt an, in welcher Verarbeitungsphase sich der Batch befindet. Es beginnt mit `in_progress` und wird auf `ended` aktualisiert, sobald alle Anfragen im Batch fertig verarbeitet wurden und die Ergebnisse bereitstehen. Du kannst den Zustand deines Batches überwachen, indem du die [Console](https://platform.claude.com/settings/workspaces/default/batches) besuchst oder den [Abruf-Endpunkt](https://platform.claude.com/docs/de/api/messages/batches/retrieve) verwendest.

#### Abfragen des Abschlusses eines Message Batch

Um einen Message Batch abzufragen, benötigst du seine `id`, die in der Antwort beim Erstellen eines Batches oder beim Auflisten von Batches bereitgestellt wird. Du kannst eine Polling-Schleife implementieren, die den Batch-Status regelmäßig überprüft, bis die Verarbeitung beendet ist:

<CodeGroup>
  ```bash cURL
  #!/bin/sh
  # ...
  # Prüfe den Status; wiederhole, bis processing_status "ended" ist
  curl -s "https://api.anthropic.com/v1/messages/batches/$MESSAGE_BATCH_ID" \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    --header "anthropic-version: 2023-06-01" \
    | jq -r '.processing_status'
  ```

  ```bash CLI
  #!/bin/bash
  # ...
  # Status prüfen; wiederholen, bis processing_status "ended" ist
  ant messages:batches retrieve \
    --message-batch-id "$MESSAGE_BATCH_ID" \
    --transform processing_status --raw-output
  ```

  ```python Python
  import time

  client = anthropic.Anthropic()

  MESSAGE_BATCH_ID = "msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d"

  message_batch = None
  while True:
      message_batch = client.messages.batches.retrieve(MESSAGE_BATCH_ID)
      if message_batch.processing_status == "ended":
          break

      print(f"Batch {MESSAGE_BATCH_ID} is still processing...")
      time.sleep(60)
  print(message_batch)
  ```

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

  const messageBatchId = "msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d";

  let messageBatch;
  while (true) {
    messageBatch = await client.messages.batches.retrieve(messageBatchId);
    if (messageBatch.processing_status === "ended") {
      break;
    }

    console.log(`Batch ${messageBatchId} is still processing... waiting`);
    await new Promise((resolve) => setTimeout(resolve, 60_000));
  }
  console.log(messageBatch);
  ```

  ```csharp C#
  AnthropicClient client = new();
  string messageBatchId = Environment.GetEnvironmentVariable("MESSAGE_BATCH_ID");

  MessageBatch messageBatch = null;
  while (true)
  {
      messageBatch = await client.Messages.Batches.Retrieve(messageBatchId);
      if (messageBatch.ProcessingStatus == "ended")
      {
          break;
      }

      Console.WriteLine($"Batch {messageBatchId} is still processing...");
      await Task.Delay(60000);
  }
  Console.WriteLine(messageBatch);
  ```

  ```go Go
  client := anthropic.NewClient()
  messageBatchID := os.Getenv("MESSAGE_BATCH_ID")

  var messageBatch *anthropic.MessageBatch
  for {
  	var err error
  	messageBatch, err = client.Messages.Batches.Get(context.TODO(), messageBatchID, anthropic.MessageBatchGetParams{})
  	if err != nil {
  		log.Fatal(err)
  	}
  	if messageBatch.ProcessingStatus == "ended" {
  		break
  	}

  	fmt.Printf("Batch %s is still processing...\n", messageBatchID)
  	time.Sleep(60 * time.Second)
  }
  fmt.Println(messageBatch)
  ```

  ```java Java
  import com.anthropic.models.messages.batches.MessageBatch;
  // ...
          AnthropicClient client = AnthropicOkHttpClient.fromEnv();
          String messageBatchId = "msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d";

          MessageBatch messageBatch = null;
          while (true) {
              messageBatch = client.messages().batches().retrieve(messageBatchId);
              if (messageBatch.processingStatus().equals(MessageBatch.ProcessingStatus.ENDED)) {
                  break;
              }

              System.out.println("Batch " + messageBatchId + " is still processing...");
              Thread.sleep(60000);
          }
          System.out.println(messageBatch);
  ```

  ```php PHP
  $client = new Client();
  $messageBatchId = getenv("MESSAGE_BATCH_ID");

  $messageBatch = null;
  while (true) {
      $messageBatch = $client->messages->batches->retrieve(
          messageBatchID: $messageBatchId,
      );
      if ($messageBatch->processingStatus === "ended") {
          break;
      }

      echo "Batch {$messageBatchId} is still processing...\n";
      sleep(60);
  }
  echo json_encode($messageBatch, JSON_PRETTY_PRINT);
  ```

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

  message_batch_id = ENV["MESSAGE_BATCH_ID"]
  message_batch = nil
  loop do
    message_batch = client.messages.batches.retrieve(message_batch_id)
    break if message_batch.processing_status == :ended

    puts "Batch #{message_batch_id} is still processing..."
    sleep 60
  end
  puts message_batch
  ```
</CodeGroup>

### Alle Message Batches auflisten

Du kannst alle Message Batches in deinem Workspace über den [List-Endpunkt](https://platform.claude.com/docs/de/api/messages/batches/list) auflisten. Die API unterstützt Paginierung und ruft bei Bedarf automatisch weitere Seiten ab:

<CodeGroup>
  ```bash cURL
  #!/bin/sh
  # Ruft eine Seite ab. Solange has_more der Antwort true ist, übergib deren
  # last_id als after_id, um die nächste Seite abzurufen. (Die SDKs und die CLI
  # führen die Paginierung automatisch durch.)
  curl -s "https://api.anthropic.com/v1/messages/batches?limit=20" \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    --header "anthropic-version: 2023-06-01"
  ```

  ```bash CLI
  # Ruft bei Bedarf automatisch weitere Seiten ab
  ant messages:batches list --limit 20
  ```

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

  # Ruft bei Bedarf automatisch weitere Seiten ab.
  for message_batch in client.messages.batches.list(limit=20):
      print(message_batch)
  ```

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

  // Ruft bei Bedarf automatisch weitere Seiten ab.
  for await (const messageBatch of client.messages.batches.list({
    limit: 20
  })) {
    console.log(messageBatch);
  }
  ```

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

  var parameters = new BatchListParams
  {
      Limit = 20
  };

  // Ruft bei Bedarf automatisch weitere Seiten ab
  var page = await client.Messages.Batches.List(parameters);
  await foreach (var messageBatch in page.Paginate())
  {
      Console.WriteLine(messageBatch);
  }
  ```

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

  // Ruft bei Bedarf automatisch weitere Seiten ab
  iter := client.Messages.Batches.ListAutoPaging(context.TODO(), anthropic.MessageBatchListParams{
  	Limit: anthropic.Int(20),
  })

  for iter.Next() {
  	messageBatch := iter.Current()
  	fmt.Println(messageBatch)
  }

  if err := iter.Err(); err != nil {
  	log.Fatal(err)
  }
  ```

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

  // Ruft bei Bedarf automatisch weitere Seiten ab
  for (MessageBatch messageBatch : client
    .messages()
    .batches()
    .list(BatchListParams.builder().limit(20).build())
    .autoPager()) {
    System.out.println(messageBatch);
  }
  ```

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

  // Ruft bei Bedarf automatisch weitere Seiten ab
  foreach ($client->messages->batches->list(limit: 20)->pagingEachItem() as $messageBatch) {
      echo $messageBatch->id . "\n";
  }
  ```

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

  # Ruft bei Bedarf automatisch weitere Seiten ab
  client.messages.batches.list(limit: 20).auto_paging_each do |message_batch|
    puts message_batch
  end
  ```
</CodeGroup>

### Batch-Ergebnisse abrufen

Sobald die Batch-Verarbeitung beendet ist, hat jede Messages-Anfrage im Batch ein Ergebnis. Es gibt vier Ergebnistypen:

| Ergebnistyp | Beschreibung                                                                                                                                                                                            |
| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `succeeded` | Die Anfrage war erfolgreich. Enthält das Message-Ergebnis.                                                                                                                                              |
| `errored`   | Bei der Anfrage ist ein Fehler aufgetreten und es wurde keine Message erstellt. Mögliche Fehler sind ungültige Anfragen und interne Serverfehler. Diese Anfragen werden dir nicht in Rechnung gestellt. |
| `canceled`  | Der Nutzer hat den Batch abgebrochen, bevor diese Anfrage an das Modell gesendet werden konnte. Diese Anfragen werden dir nicht in Rechnung gestellt.                                                   |
| `expired`   | Der Batch hat seine 24-Stunden-Ablauffrist erreicht, bevor diese Anfrage an das Modell gesendet werden konnte. Diese Anfragen werden dir nicht in Rechnung gestellt.                                    |

Die `request_counts` des Batches zeigen eine Übersicht deiner Ergebnisse und geben an, wie viele Anfragen jeden dieser vier Zustände erreicht haben.

Die Ergebnisse des Batches stehen unter der Eigenschaft `results_url` des Message Batch zum Download bereit und, sofern die Organisationsberechtigung dies zulässt, in der Console. Aufgrund der potenziell großen Größe der Ergebnisse wird empfohlen, die [Ergebnisse zu streamen](https://platform.claude.com/docs/de/api/messages/batches/results), anstatt sie alle auf einmal herunterzuladen.

<CodeGroup>
  ```bash cURL
  #!/bin/sh
  # Rufe die results_url des Batches ab und streame dann die .jsonl-Ergebnisse,
  # auf die sie verweist. Für die Behandlung einzelner Ergebnisse (Retries, Validierungsfehler)
  # verwende die SDK-Beispiele in den anderen Tabs.
  RESULTS_URL=$(curl -s "https://api.anthropic.com/v1/messages/batches/msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d" \
    --header "anthropic-version: 2023-06-01" \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    | jq -r '.results_url')

  curl -s "$RESULTS_URL" \
    --header "anthropic-version: 2023-06-01" \
    --header "x-api-key: $ANTHROPIC_API_KEY" \
    | jq -r '"\(.result.type): \(.custom_id)"'
  ```

  ```bash CLI
  # Gibt eine Zeile pro Ergebnis aus, z. B. `{"custom_id":"test-1","type":"succeeded",…}`.
  # Für die Behandlung einzelner Ergebnisse (Wiederholungen, Validierungsfehler) verwende die SDK-
  # Beispiele in den anderen Tabs.
  ant messages:batches results \
    --message-batch-id msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d \
    --transform '{custom_id,"type":result.type,"error":result.error.error.type}' \
    --format jsonl
  ```

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

  # Ergebnisdatei speichereffizient in Chunks streamen und einzeln verarbeiten
  for result in client.messages.batches.results(
      "msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d",
  ):
      outcome = result.result
      match outcome.type:
          case "succeeded":
              print(f"Success! {result.custom_id}")
          case "errored":
              if outcome.error.error.type == "invalid_request_error":
                  # Request-Body muss vor dem erneuten Senden korrigiert werden
                  print(f"Validation error {result.custom_id}")
              else:
                  # Request kann direkt erneut gesendet werden
                  print(f"Server error {result.custom_id}")
          case "expired":
              print(f"Request expired {result.custom_id}")
  ```

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

  // Ergebnisdatei in speichereffizienten Blöcken streamen und einzeln verarbeiten
  for await (const result of await client.messages.batches.results(
    "msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d"
  )) {
    switch (result.result.type) {
      case "succeeded":
        console.log(`Success! ${result.custom_id}`);
        break;
      case "errored":
        if (result.result.error.type === "invalid_request_error") {
          // Request-Body muss vor dem erneuten Senden der Anfrage korrigiert werden
          console.log(`Validation error: ${result.custom_id}`);
        } else {
          // Anfrage kann direkt wiederholt werden
          console.log(`Server error: ${result.custom_id}`);
        }
        break;
      case "expired":
        console.log(`Request expired: ${result.custom_id}`);
        break;
    }
  }
  ```

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

  await foreach (var result in client.Messages.Batches.ResultsStreaming("msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d"))
  {
      switch (result.Result.Type)
      {
          case "succeeded":
              Console.WriteLine($"Success! {result.CustomID}");
              break;
          case "errored":
              if (result.Result.Error?.Type == "invalid_request")
              {
                  Console.WriteLine($"Validation error: {result.CustomID}");
              }
              else
              {
                  Console.WriteLine($"Server error: {result.CustomID}");
              }
              break;
          case "expired":
              Console.WriteLine($"Request expired: {result.CustomID}");
              break;
      }
  }
  ```

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

  stream := client.Messages.Batches.ResultsStreaming(context.TODO(), "msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d", anthropic.MessageBatchResultsParams{})

  for stream.Next() {
  	result := stream.Current()

  	switch variant := result.Result.AsAny().(type) {
  	case anthropic.MessageBatchSucceededResult:
  		fmt.Printf("Success! %s\n", result.CustomID)
  	case anthropic.MessageBatchErroredResult:
  		fmt.Printf("Error: %s - %s\n", result.CustomID, variant.Error.Error.Message)
  	case anthropic.MessageBatchExpiredResult:
  		fmt.Printf("Request expired: %s\n", result.CustomID)
  	}
  }

  if err := stream.Err(); err != nil {
  	log.Fatal(err)
  }
  ```

  ```java Java
  import com.anthropic.core.http.StreamResponse;
  import com.anthropic.models.messages.batches.BatchResultsParams;
  import com.anthropic.models.messages.batches.MessageBatchIndividualResponse;
  // ...
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      // Ergebnisdatei speichereffizient in Chunks streamen und einzeln verarbeiten
      try (
        StreamResponse<MessageBatchIndividualResponse> streamResponse = client
          .messages()
          .batches()
          .resultsStreaming(
            BatchResultsParams.builder()
              .messageBatchId("msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d")
              .build()
          )
      ) {
        streamResponse
          .stream()
          .forEach(result -> {
            switch (result.result().type().value()) {
              case SUCCEEDED -> System.out.println("Success! " + result.customId());
              case ERRORED -> {
                if (result.result().asErrored().error().error().isInvalidRequestError()) {
                  // Request-Body muss vor dem erneuten Senden des Requests korrigiert werden
                  System.out.println("Validation error: " + result.customId());
                } else {
                  // Request kann direkt erneut gesendet werden
                  System.out.println("Server error: " + result.customId());
                }
              }
              case EXPIRED -> System.out.println("Request expired: " + result.customId());
            }
          });
      }
  ```

  ```php PHP
  use Anthropic\Messages\Batches\MessageBatchErroredResult;
  use Anthropic\Messages\Batches\MessageBatchExpiredResult;
  use Anthropic\Messages\Batches\MessageBatchSucceededResult;

  $client = new Client();

  foreach ($client->messages->batches->resultsStream(messageBatchID: 'msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d') as $result) {
      switch (true) {
          case $result->result instanceof MessageBatchSucceededResult:
              echo "Success! {$result->customID}\n";
              break;
          case $result->result instanceof MessageBatchErroredResult:
              if ($result->result->error->error->type === "invalid_request_error") {
                  echo "Validation error: {$result->customID}\n";
              } else {
                  echo "Server error: {$result->customID}\n";
              }
              break;
          case $result->result instanceof MessageBatchExpiredResult:
              echo "Request expired: {$result->customID}\n";
              break;
      }
  }
  ```

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

  client.messages.batches.results_streaming("msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d").each do |result|
    outcome = result.result
    case outcome
    when Anthropic::Models::Messages::MessageBatchSucceededResult
      puts "Success! #{result.custom_id}"
    when Anthropic::Models::Messages::MessageBatchErroredResult
      if outcome.error.type == :invalid_request
        puts "Validation error: #{result.custom_id}"
      else
        puts "Server error: #{result.custom_id}"
      end
    when Anthropic::Models::Messages::MessageBatchExpiredResult
      puts "Request expired: #{result.custom_id}"
    end
  end
  ```
</CodeGroup>

Die Ergebnisse liegen im `.jsonl`-Format vor, wobei jede Zeile ein gültiges JSON-Objekt ist, das das Ergebnis einer einzelnen Anfrage im Message Batch darstellt. Für jedes gestreamte Ergebnis kannst du abhängig von seiner `custom_id` und seinem Ergebnistyp etwas anderes tun. Hier ist ein Beispielsatz von Ergebnissen:

```jsonl .jsonl file
{"custom_id":"my-second-request","result":{"type":"succeeded","message":{"id":"msg_014VwiXbi91y3JMjcpyGBHX5","type":"message","role":"assistant","model":"claude-opus-5-5","content":[{"type":"text","text":"Hello again! It's nice to see you. How can I assist you today? Is there anything specific you'd like to chat about or any questions you have?"}],"stop_reason":"end_turn","stop_sequence":null,"usage":{"input_tokens":11,"output_tokens":36}}}}
{"custom_id":"my-first-request","result":{"type":"succeeded","message":{"id":"msg_01FqfsLoHwgeFbguDgpz48m7","type":"message","role":"assistant","model":"claude-opus-5-5","content":[{"type":"text","text":"Hello! How can I assist you today? Feel free to ask me any questions or let me know if there's anything you'd like to chat about."}],"stop_reason":"end_turn","stop_sequence":null,"usage":{"input_tokens":10,"output_tokens":34}}}}
```

Wenn dein Ergebnis einen Fehler enthält, wird sein `result.error` auf die standardmäßige [Fehlerform](https://platform.claude.com/docs/de/api/errors#error-shapes) gesetzt.

<Tip>
  **Batch-Ergebnisse entsprechen möglicherweise nicht der Eingabereihenfolge**

  Batch-Ergebnisse können in beliebiger Reihenfolge zurückgegeben werden und entsprechen möglicherweise nicht der Reihenfolge der Anfragen bei der Erstellung des Batches. Im vorangehenden Beispiel wird das Ergebnis der zweiten Batch-Anfrage vor dem der ersten zurückgegeben. Um Ergebnisse korrekt ihren entsprechenden Anfragen zuzuordnen, verwende immer das Feld `custom_id`.
</Tip>

### Einen Message Batch abbrechen

Du kannst einen Message Batch, der gerade verarbeitet wird, über den [Cancel-Endpunkt](https://platform.claude.com/docs/de/api/messages/batches/cancel) abbrechen. Unmittelbar nach dem Abbruch ist der `processing_status` eines Batches `canceling`. Du kannst dieselbe zuvor beschriebene Polling-Technik verwenden, um zu warten, bis der Abbruch abgeschlossen ist. Abgebrochene Batches enden mit dem Status `ended` und können Teilergebnisse für Anfragen enthalten, die vor dem Abbruch verarbeitet wurden.

<CodeGroup>
  ```bash cURL
  #!/bin/sh
  # ...
  curl --request POST https://api.anthropic.com/v1/messages/batches/$MESSAGE_BATCH_ID/cancel \
      --header "x-api-key: $ANTHROPIC_API_KEY" \
      --header "anthropic-version: 2023-06-01"
  ```

  ```bash CLI
  #!/bin/bash
  # ...
  ant messages:batches cancel --message-batch-id "$MESSAGE_BATCH_ID"
  ```

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

  MESSAGE_BATCH_ID = "msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d"

  message_batch = client.messages.batches.cancel(
      MESSAGE_BATCH_ID,
  )
  print(message_batch)
  ```

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

  const messageBatch = await client.messages.batches.cancel(MESSAGE_BATCH_ID);
  console.log(messageBatch);
  ```

  ```csharp C#
  AnthropicClient client = new();
  string messageBatchId = Environment.GetEnvironmentVariable("MESSAGE_BATCH_ID");

  var messageBatch = await client.Messages.Batches.Cancel(messageBatchId);
  Console.WriteLine(messageBatch);
  ```

  ```go Go
  client := anthropic.NewClient()
  messageBatchID := os.Getenv("MESSAGE_BATCH_ID")

  messageBatch, err := client.Messages.Batches.Cancel(context.TODO(), messageBatchID, anthropic.MessageBatchCancelParams{})
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(messageBatch)
  ```

  ```java Java
  import com.anthropic.models.messages.batches.*;
  // ...
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      MessageBatch messageBatch = client
        .messages()
        .batches()
        .cancel("msgbatch_01HkcTjaV5uDC8jWR4ZsDV8d");
      System.out.println(messageBatch);
  ```

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

  $messageBatch = $client->messages->batches->cancel(
      messageBatchID: 'msgbatch_example_id',
  );
  echo $messageBatch;
  ```

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

  message_batch_id = ENV.fetch("MESSAGE_BATCH_ID")
  message_batch = client.messages.batches.cancel(message_batch_id)
  puts message_batch
  ```
</CodeGroup>

Die Antwort zeigt den Batch im Zustand `canceling`:

```json Output
{
  "id": "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF",
  "type": "message_batch",
  "processing_status": "canceling",
  "request_counts": {
    "processing": 2,
    "succeeded": 0,
    "errored": 0,
    "canceled": 0,
    "expired": 0
  },
  "ended_at": null,
  "created_at": "2024-09-24T18:37:24.100435Z",
  "expires_at": "2024-09-25T18:37:24.100435Z",
  "cancel_initiated_at": "2024-09-24T18:39:03.114875Z",
  "results_url": null
}
```

### Prompt-Caching mit Message Batches verwenden

Die Message Batches API unterstützt Prompt-Caching, wodurch du potenziell Kosten und Verarbeitungszeit für Batch-Anfragen reduzieren kannst. Die Preisnachlässe von Prompt-Caching und Message Batches können kombiniert werden, was zu noch größeren Kosteneinsparungen führt, wenn beide Funktionen zusammen verwendet werden. Da Batch-Anfragen jedoch asynchron und gleichzeitig verarbeitet werden, werden Cache-Treffer nach dem Best-Effort-Prinzip bereitgestellt. Nutzer erzielen typischerweise Cache-Trefferquoten zwischen 30 % und 98 %, abhängig von ihren Traffic-Mustern.

Um die Wahrscheinlichkeit von Cache-Treffern in deinen Batch-Anfragen zu maximieren:

1. Füge identische `cache_control`-Blöcke in jede Message-Anfrage innerhalb deines Batches ein.
2. Halte einen stetigen Strom von Anfragen aufrecht, um zu verhindern, dass Cache-Einträge nach ihrer 5-minütigen Lebensdauer ablaufen.
3. Strukturiere deine Anfragen so, dass sie möglichst viel gecachten Inhalt gemeinsam nutzen.

Beispiel für die Implementierung von Prompt-Caching in einem Batch:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages/batches \
       --header "x-api-key: $ANTHROPIC_API_KEY" \
       --header "anthropic-version: 2023-06-01" \
       --header "content-type: application/json" \
       --data \
  '{
      "requests": [
          {
              "custom_id": "my-first-request",
              "params": {
                  "model": "claude-opus-5-5",
                  "max_tokens": 1024,
                  "system": [
                      {
                          "type": "text",
                          "text": "You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n"
                      },
                      {
                          "type": "text",
                          "text": "<the entire contents of Pride and Prejudice>",
                          "cache_control": {"type": "ephemeral"}
                      }
                  ],
                  "messages": [
                      {"role": "user", "content": "Analyze the major themes in Pride and Prejudice."}
                  ]
              }
          },
          {
              "custom_id": "my-second-request",
              "params": {
                  "model": "claude-opus-5-5",
                  "max_tokens": 1024,
                  "system": [
                      {
                          "type": "text",
                          "text": "You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n"
                      },
                      {
                          "type": "text",
                          "text": "<the entire contents of Pride and Prejudice>",
                          "cache_control": {"type": "ephemeral"}
                      }
                  ],
                  "messages": [
                      {"role": "user", "content": "Write a summary of Pride and Prejudice."}
                  ]
              }
          }
      ]
  }'
  ```

  ```bash CLI
  ant messages:batches create <<'YAML'
  requests:
    - custom_id: my-first-request
      params:
        model: claude-opus-5-5
        max_tokens: 1024
        system:
          - type: text
            text: >
              You are an AI assistant tasked with analyzing literary works. Your
              goal is to provide insightful commentary on themes, characters, and
              writing style.
          - type: text
            text: "<the entire contents of Pride and Prejudice>"
            cache_control:
              type: ephemeral
        messages:
          - role: user
            content: Analyze the major themes in Pride and Prejudice.
    - custom_id: my-second-request
      params:
        model: claude-opus-5-5
        max_tokens: 1024
        system:
          - type: text
            text: >
              You are an AI assistant tasked with analyzing literary works. Your
              goal is to provide insightful commentary on themes, characters, and
              writing style.
          - type: text
            text: "<the entire contents of Pride and Prejudice>"
            cache_control:
              type: ephemeral
        messages:
          - role: user
            content: Write a summary of Pride and Prejudice.
  YAML
  ```

  ```python Python
  from anthropic.types.message_create_params import MessageCreateParamsNonStreaming
  from anthropic.types.messages.batch_create_params import Request

  client = anthropic.Anthropic()

  message_batch = client.messages.batches.create(
      requests=[
          Request(
              custom_id="my-first-request",
              params=MessageCreateParamsNonStreaming(
                  model="claude-opus-5-5",
                  max_tokens=1024,
                  system=[
                      {
                          "type": "text",
                          "text": "You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n",
                      },
                      {
                          "type": "text",
                          "text": "<the entire contents of Pride and Prejudice>",
                          "cache_control": {"type": "ephemeral"},
                      },
                  ],
                  messages=[
                      {
                          "role": "user",
                          "content": "Analyze the major themes in Pride and Prejudice.",
                      }
                  ],
              ),
          ),
          Request(
              custom_id="my-second-request",
              params=MessageCreateParamsNonStreaming(
                  model="claude-opus-5-5",
                  max_tokens=1024,
                  system=[
                      {
                          "type": "text",
                          "text": "You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n",
                      },
                      {
                          "type": "text",
                          "text": "<the entire contents of Pride and Prejudice>",
                          "cache_control": {"type": "ephemeral"},
                      },
                  ],
                  messages=[
                      {
                          "role": "user",
                          "content": "Write a summary of Pride and Prejudice.",
                      }
                  ],
              ),
          ),
      ]
  )
  ```

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

  const messageBatch = await client.messages.batches.create({
    requests: [
      {
        custom_id: "my-first-request",
        params: {
          model: "claude-opus-5-5",
          max_tokens: 1024,
          system: [
            {
              type: "text",
              text: "You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n"
            },
            {
              type: "text",
              text: "<the entire contents of Pride and Prejudice>",
              cache_control: { type: "ephemeral" }
            }
          ],
          messages: [
            { role: "user", content: "Analyze the major themes in Pride and Prejudice." }
          ]
        }
      },
      {
        custom_id: "my-second-request",
        params: {
          model: "claude-opus-5-5",
          max_tokens: 1024,
          system: [
            {
              type: "text",
              text: "You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n"
            },
            {
              type: "text",
              text: "<the entire contents of Pride and Prejudice>",
              cache_control: { type: "ephemeral" }
            }
          ],
          messages: [{ role: "user", content: "Write a summary of Pride and Prejudice." }]
        }
      }
    ]
  });
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Messages;
  using Anthropic.Models.Messages.Batches;

  AnthropicClient client = new()
  {
      ApiKey = Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY")
  };

  var messageBatch = await client.Messages.Batches.Create(new BatchCreateParams
  {
      Requests =
      [
          new()
          {
              CustomID = "my-first-request",
              Params = new()
              {
                  Model = Model.ClaudeOpus5_5,
                  MaxTokens = 1024,
                  System = new List<TextBlockParam>
                  {
                      new()
                      {
                          Text = "You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n"
                      },
                      new()
                      {
                          Text = "<the entire contents of Pride and Prejudice>",
                          CacheControl = new()
                      }
                  },
                  Messages =
                  [
                      new() { Role = Role.User, Content = "Analyze the major themes in Pride and Prejudice." }
                  ]
              }
          },
          new()
          {
              CustomID = "my-second-request",
              Params = new()
              {
                  Model = Model.ClaudeOpus5_5,
                  MaxTokens = 1024,
                  System = new List<TextBlockParam>
                  {
                      new()
                      {
                          Text = "You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n"
                      },
                      new()
                      {
                          Text = "<the entire contents of Pride and Prejudice>",
                          CacheControl = new()
                      }
                  },
                  Messages =
                  [
                      new() { Role = Role.User, Content = "Write a summary of Pride and Prejudice." }
                  ]
              }
          }
      ]
  });
  ```

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

  messageBatch, err := client.Messages.Batches.New(context.TODO(), anthropic.MessageBatchNewParams{
  	Requests: []anthropic.MessageBatchNewParamsRequest{
  		{
  			CustomID: "my-first-request",
  			Params: anthropic.MessageBatchNewParamsRequestParams{
  				Model:     anthropic.ModelClaudeOpus5_5,
  				MaxTokens: 1024,
  				System: []anthropic.TextBlockParam{
  					{
  						Text: "You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n",
  					},
  					{
  						Text:         "<the entire contents of Pride and Prejudice>",
  						CacheControl: anthropic.NewCacheControlEphemeralParam(),
  					},
  				},
  				Messages: []anthropic.MessageParam{
  					anthropic.NewUserMessage(anthropic.NewTextBlock("Analyze the major themes in Pride and Prejudice.")),
  				},
  			},
  		},
  		{
  			CustomID: "my-second-request",
  			Params: anthropic.MessageBatchNewParamsRequestParams{
  				Model:     anthropic.ModelClaudeOpus5_5,
  				MaxTokens: 1024,
  				System: []anthropic.TextBlockParam{
  					{
  						Text: "You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n",
  					},
  					{
  						Text:         "<the entire contents of Pride and Prejudice>",
  						CacheControl: anthropic.NewCacheControlEphemeralParam(),
  					},
  				},
  				Messages: []anthropic.MessageParam{
  					anthropic.NewUserMessage(anthropic.NewTextBlock("Write a summary of Pride and Prejudice.")),
  				},
  			},
  		},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(messageBatch)
  ```

  ```java Java
  import com.anthropic.models.messages.CacheControlEphemeral;
  // ...
  import com.anthropic.models.messages.batches.*;
  // ...
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      BatchCreateParams createParams = BatchCreateParams.builder()
        .addRequest(
          BatchCreateParams.Request.builder()
            .customId("my-first-request")
            .params(
              BatchCreateParams.Request.Params.builder()
                .model(Model.CLAUDE_OPUS_5_5)
                .maxTokens(1024)
                .systemOfTextBlockParams(
                  List.of(
                    TextBlockParam.builder()
                      .text(
                        "You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n"
                      )
                      .build(),
                    TextBlockParam.builder()
                      .text("<the entire contents of Pride and Prejudice>")
                      .cacheControl(CacheControlEphemeral.builder().build())
                      .build()
                  )
                )
                .addUserMessage("Analyze the major themes in Pride and Prejudice.")
                .build()
            )
            .build()
        )
        .addRequest(
          BatchCreateParams.Request.builder()
            .customId("my-second-request")
            .params(
              BatchCreateParams.Request.Params.builder()
                .model(Model.CLAUDE_OPUS_5_5)
                .maxTokens(1024)
                .systemOfTextBlockParams(
                  List.of(
                    TextBlockParam.builder()
                      .text(
                        "You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n"
                      )
                      .build(),
                    TextBlockParam.builder()
                      .text("<the entire contents of Pride and Prejudice>")
                      .cacheControl(CacheControlEphemeral.builder().build())
                      .build()
                  )
                )
                .addUserMessage("Write a summary of Pride and Prejudice.")
                .build()
            )
            .build()
        )
        .build();

      MessageBatch messageBatch = client.messages().batches().create(createParams);
  ```

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

  $messageBatch = $client->messages->batches->create(
      requests: [
          [
              'custom_id' => 'my-first-request',
              'params' => [
                  'model' => 'claude-opus-5-5',
                  'max_tokens' => 1024,
                  'system' => [
                      [
                          'type' => 'text',
                          'text' => 'You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n'
                      ],
                      [
                          'type' => 'text',
                          'text' => '<the entire contents of Pride and Prejudice>',
                          'cache_control' => ['type' => 'ephemeral']
                      ]
                  ],
                  'messages' => [
                      ['role' => 'user', 'content' => 'Analyze the major themes in Pride and Prejudice.']
                  ]
              ]
          ],
          [
              'custom_id' => 'my-second-request',
              'params' => [
                  'model' => 'claude-opus-5-5',
                  'max_tokens' => 1024,
                  'system' => [
                      [
                          'type' => 'text',
                          'text' => 'You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n'
                      ],
                      [
                          'type' => 'text',
                          'text' => '<the entire contents of Pride and Prejudice>',
                          'cache_control' => ['type' => 'ephemeral']
                      ]
                  ],
                  'messages' => [
                      ['role' => 'user', 'content' => 'Write a summary of Pride and Prejudice.']
                  ]
              ]
          ]
      ],
  );
  ```

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

  message_batch = client.messages.batches.create(
    requests: [
      {
        custom_id: "my-first-request",
        params: {
          model: "claude-opus-5-5",
          max_tokens: 1024,
          system: [
            {
              type: "text",
              text: "You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n"
            },
            {
              type: "text",
              text: "<the entire contents of Pride and Prejudice>",
              cache_control: { type: "ephemeral" }
            }
          ],
          messages: [
            { role: "user", content: "Analyze the major themes in Pride and Prejudice." }
          ]
        }
      },
      {
        custom_id: "my-second-request",
        params: {
          model: "claude-opus-5-5",
          max_tokens: 1024,
          system: [
            {
              type: "text",
              text: "You are an AI assistant tasked with analyzing literary works. Your goal is to provide insightful commentary on themes, characters, and writing style.\n"
            },
            {
              type: "text",
              text: "<the entire contents of Pride and Prejudice>",
              cache_control: { type: "ephemeral" }
            }
          ],
          messages: [
            { role: "user", content: "Write a summary of Pride and Prejudice." }
          ]
        }
      }
    ]
  )
  ```
</CodeGroup>

In diesem Beispiel enthalten beide Anfragen im Batch identische System-Nachrichten und den vollständigen Text von „Stolz und Vorurteil“, markiert mit `cache_control`, um die Wahrscheinlichkeit von Cache-Treffern zu erhöhen.

### Server-Tools und die agentische Schleife

Alle [Server-Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/server-tools) (Websuche, Web-Abruf, Codeausführung, MCP-Konnektoren, Advisor und Tool-Suche) funktionieren in Batch-Anfragen. Der Batch-Worker führt dieselbe serverseitige agentische Schleife aus wie die synchrone Messages API.

Da keine offene Verbindung aufrechterhalten werden muss, führt die Batch-Schleife **mehr Iterationen pro Turn** aus als eine synchrone Anfrage, bevor sie `stop_reason: "pause_turn"` zurückgibt. Wenn ein Batch-Ergebnis mit `pause_turn` zurückkommt, wurde der Turn nicht abgeschlossen; du kannst ihn fortsetzen, indem du den pausierten Assistant-Inhalt in einer Folgeanfrage (Batch oder synchron) einreichst, genau wie im [pause\_turn-Fortsetzungsmuster](https://platform.claude.com/docs/de/agents-and-tools/tool-use/server-tools#the-server-side-loop-and-pause-turn) gezeigt.

Der Batch-Worker drosselt zusätzlich `web_search` pro Organisation, damit eine hochgradig gleichzeitige Batch-Verarbeitung das Websuche-Ratenlimit deiner Organisation nicht ausschöpft. Der Batch wiederholt gedrosselte Anfragen automatisch; du musst dies nicht selbst handhaben, aber sehr große Websuche-Batches können länger bis zum Abschluss benötigen.

### Erweiterte Ausgabe (Beta)

Der Beta-Header `output-300k-2026-03-24` erhöht die `max_tokens`-Obergrenze auf 300.000 für Batch-Anfragen mit Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 5.5, Claude Sonnet 5, Claude Sonnet 4.6 oder Claude Haiku 5.5. Füge den Header hinzu, um in einem einzigen Turn Ausgaben zu generieren, die weit über das Standardlimit von 128k `max_tokens` hinausgehen.

<Note>
  Die erweiterte Ausgabe ist nur in der Message Batches API verfügbar, nicht in der synchronen Messages API. Sie wird auf der Claude API und der Claude Platform auf AWS unterstützt und ist derzeit nicht auf Amazon Bedrock, Google Cloud oder Microsoft Foundry verfügbar.
</Note>

Verwende die erweiterte Ausgabe für die Generierung langer Inhalte wie Entwürfe in Buchlänge und technische Dokumentation, umfassende strukturierte Datenextraktion, große Codegenerierungs-Gerüste und lange Argumentationsketten.

Eine einzelne Generierung mit 300k Token kann über eine Stunde dauern, plane deine Batch-Einreichungen daher mit Blick auf das 24-Stunden-Verarbeitungsfenster. Es gelten die Standard-Batch-Preise (50 % der Standard-API-Preise).

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages/batches \
       --header "x-api-key: $ANTHROPIC_API_KEY" \
       --header "anthropic-version: 2023-06-01" \
       --header "anthropic-beta: output-300k-2026-03-24" \
       --header "content-type: application/json" \
       --data \
  '{
      "requests": [
          {
              "custom_id": "long-form-request",
              "params": {
                  "model": "claude-opus-5-5",
                  "max_tokens": 300000,
                  "messages": [
                      {"role": "user", "content": "Write a comprehensive technical guide to building distributed systems, covering architecture patterns, consistency models, fault tolerance, and operational best practices."}
                  ]
              }
          }
      ]
  }'
  ```

  ```bash CLI
  ant beta:messages:batches create --beta output-300k-2026-03-24 <<'YAML'
  requests:
    - custom_id: long-form-request
      params:
        model: claude-opus-5-5
        max_tokens: 300000
        messages:
          - role: user
            content: >-
              Write a comprehensive technical guide to building distributed
              systems, covering architecture patterns, consistency models,
              fault tolerance, and operational best practices.
  YAML
  ```

  ```python Python
  from anthropic.types.beta.message_create_params import MessageCreateParamsNonStreaming
  from anthropic.types.beta.messages.batch_create_params import Request

  client = anthropic.Anthropic()

  message_batch = client.beta.messages.batches.create(
      betas=["output-300k-2026-03-24"],
      requests=[
          Request(
              custom_id="long-form-request",
              params=MessageCreateParamsNonStreaming(
                  model="claude-opus-5-5",
                  max_tokens=300_000,
                  messages=[
                      {
                          "role": "user",
                          "content": "Write a comprehensive technical guide to building distributed systems, covering architecture patterns, consistency models, fault tolerance, and operational best practices.",
                      }
                  ],
              ),
          ),
      ],
  )

  print(message_batch)
  ```

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

  const messageBatch = await client.beta.messages.batches.create({
    betas: ["output-300k-2026-03-24"],
    requests: [
      {
        custom_id: "long-form-request",
        params: {
          model: "claude-opus-5-5",
          max_tokens: 300000,
          messages: [
            {
              role: "user",
              content:
                "Write a comprehensive technical guide to building distributed systems, covering architecture patterns, consistency models, fault tolerance, and operational best practices."
            }
          ]
        }
      }
    ]
  });

  console.log(messageBatch);
  ```

  ```csharp C#
  using Anthropic;
  using Anthropic.Models.Beta.Messages;
  using Anthropic.Models.Beta.Messages.Batches;
  using Model = Anthropic.Models.Messages.Model;

  AnthropicClient client = new();

  var batch = await client.Beta.Messages.Batches.Create(new BatchCreateParams
  {
      Betas = ["output-300k-2026-03-24"],
      Requests =
      [
          new()
          {
              CustomID = "long-form-request",
              Params = new()
              {
                  Model = Model.ClaudeOpus5_5,
                  MaxTokens = 300_000,
                  Messages =
                  [
                      new() { Role = Role.User, Content = "Write a comprehensive technical guide to building distributed systems, covering architecture patterns, consistency models, fault tolerance, and operational best practices." }
                  ]
              }
          }
      ]
  });

  Console.WriteLine(batch);
  ```

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

  batch, err := client.Beta.Messages.Batches.New(context.Background(),
  	anthropic.BetaMessageBatchNewParams{
  		Betas: []anthropic.AnthropicBeta{"output-300k-2026-03-24"},
  		Requests: []anthropic.BetaMessageBatchNewParamsRequest{
  			{
  				CustomID: "long-form-request",
  				Params: anthropic.BetaMessageBatchNewParamsRequestParams{
  					Model:     anthropic.ModelClaudeOpus5_5,
  					MaxTokens: 300_000,
  					Messages: []anthropic.BetaMessageParam{
  						anthropic.NewBetaUserMessage(
  							anthropic.NewBetaTextBlock("Write a comprehensive technical guide to building distributed systems, covering architecture patterns, consistency models, fault tolerance, and operational best practices."),
  						),
  					},
  				},
  			},
  		},
  	})
  if err != nil {
  	panic(err)
  }

  fmt.Println(batch.ID)
  ```

  ```java Java
  import com.anthropic.models.beta.messages.batches.*;

  void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    BatchCreateParams params = BatchCreateParams.builder()
      .addBeta("output-300k-2026-03-24")
      .addRequest(
        BatchCreateParams.Request.builder()
          .customId("long-form-request")
          .params(
            BatchCreateParams.Request.Params.builder()
              .model(Model.CLAUDE_OPUS_5_5)
              .maxTokens(300_000L)
              .addUserMessage("Write a comprehensive technical guide to building distributed systems, covering architecture patterns, consistency models, fault tolerance, and operational best practices.")
              .build()
          )
          .build()
      )
      .build();

    BetaMessageBatch messageBatch = client.beta().messages().batches().create(params);

    IO.println(messageBatch);
  }
  ```

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

  $batch = $client->beta->messages->batches->create(
      betas: ['output-300k-2026-03-24'],
      requests: [
          [
              'custom_id' => 'long-form-request',
              'params' => [
                  'model' => 'claude-opus-5-5',
                  'max_tokens' => 300_000,
                  'messages' => [
                      ['role' => 'user', 'content' => 'Write a comprehensive technical guide to building distributed systems, covering architecture patterns, consistency models, fault tolerance, and operational best practices.']
                  ]
              ]
          ]
      ],
  );

  echo $batch->id;
  ```

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

  batch = client.beta.messages.batches.create(
    betas: ["output-300k-2026-03-24"],
    requests: [
      {
        custom_id: "long-form-request",
        params: {
          model: "claude-opus-5-5",
          max_tokens: 300_000,
          messages: [
            { role: "user", content: "Write a comprehensive technical guide to building distributed systems, covering architecture patterns, consistency models, fault tolerance, and operational best practices." }
          ]
        }
      }
    ]
  )

  puts batch
  ```
</CodeGroup>

### Best Practices für effektives Batching

Um das Beste aus der Batches API herauszuholen:

* Überwache den Batch-Verarbeitungsstatus regelmäßig und implementiere eine geeignete Wiederholungslogik für fehlgeschlagene Anfragen.
* Verwende aussagekräftige `custom_id`-Werte, um Ergebnisse leicht den Anfragen zuzuordnen, da die Reihenfolge nicht garantiert ist.
* Erwäge, sehr große Datensätze zur besseren Handhabbarkeit in mehrere Batches aufzuteilen.
* Führe einen Probelauf einer einzelnen Anfrageform mit der Messages API durch, um Validierungsfehler zu vermeiden.

### Fehlerbehebung bei häufigen Problemen

Bei unerwartetem Verhalten:

* Überprüfe, dass die Gesamtgröße der Batch-Anfrage 256 MB nicht überschreitet. Wenn die Anfrage zu groß ist, erhältst du möglicherweise einen 413-Fehler `request_too_large`.
* Prüfe, dass du für alle Anfragen im Batch [unterstützte Modelle](https://platform.claude.com/docs/de/build-with-claude/batch-processing#supported-models) verwendest.
* Stelle sicher, dass jede Anfrage im Batch eine eindeutige `custom_id` hat.
* Stelle sicher, dass seit dem `created_at`-Zeitpunkt des Batches (nicht dem `ended_at`-Zeitpunkt der Verarbeitung) weniger als 29 Tage vergangen sind. Wenn mehr als 29 Tage vergangen sind, sind die Ergebnisse nicht mehr einsehbar.
* Vergewissere dich, dass der Batch nicht abgebrochen wurde.

Beachte, dass das Fehlschlagen einer Anfrage in einem Batch die Verarbeitung anderer Anfragen nicht beeinflusst.

## Batch-Speicherung und Datenschutz

* **Workspace-Isolation**: Batches sind innerhalb des Workspace isoliert, in dem sie erstellt wurden. Auf sie kann nur durch API-Anfragen in demselben Workspace oder durch Nutzer mit der Berechtigung zum Anzeigen von Workspace-Batches in der Console zugegriffen werden.

* **Verfügbarkeit der Ergebnisse**: Batch-Ergebnisse sind 29 Tage nach Erstellung des Batches verfügbar, was ausreichend Zeit für Abruf und Verarbeitung lässt.

## Datenaufbewahrung

Die Batch-Verarbeitung speichert Anfrage- und Antwortdaten bis zu 29 Tage nach der Batch-Erstellung. Du kannst einen Message Batch jederzeit nach der Verarbeitung über den Endpunkt `DELETE /v1/messages/batches/{batch_id}` löschen. Um einen laufenden Batch zu löschen, brich ihn zuerst ab. Die asynchrone Verarbeitung erfordert die serverseitige Speicherung sowohl der Eingaben als auch der Ausgaben bis zum Abschluss des Batches und dem Abruf der Ergebnisse.

Zur ZDR-Berechtigung über alle Funktionen hinweg siehe [API und Datenaufbewahrung](https://platform.claude.com/docs/de/manage-claude/api-and-data-retention).

## FAQ

<AccordionGroup>
  <Accordion title="Wie lange dauert die Verarbeitung eines Batches?">
    Die Verarbeitung von Batches kann bis zu 24 Stunden dauern, aber viele werden früher abgeschlossen. Die tatsächliche Verarbeitungszeit hängt von der Größe des Batches, der aktuellen Nachfrage und deinem Anfragevolumen ab. Es ist möglich, dass ein Batch abläuft und nicht innerhalb von 24 Stunden abgeschlossen wird.
  </Accordion>

  <Accordion title="Ist die Batches API für alle Modelle verfügbar?">
    Siehe [Unterstützte Modelle](https://platform.claude.com/docs/de/build-with-claude/batch-processing#supported-models) für die Liste der unterstützten Modelle.
  </Accordion>

  <Accordion title="Kann ich die Message Batches API mit anderen API-Funktionen verwenden?">
    Ja, die Message Batches API unterstützt nahezu alle Funktionen, die in der Messages API verfügbar sind, einschließlich der meisten Beta-Funktionen. Eine kleine Anzahl von Parametern (`stream`, `speed` und `max_tokens: 0`) wird nicht unterstützt. Die vollständige Liste findest du unter [Was in Batches verarbeitet werden kann](https://platform.claude.com/docs/de/build-with-claude/batch-processing#what-can-be-batched).
  </Accordion>

  <Accordion title="Wie wirkt sich die Message Batches API auf die Preise aus?">
    Die Message Batches API bietet einen Rabatt von 50 % auf die gesamte Nutzung im Vergleich zu den Standard-API-Preisen. Dies gilt für Eingabe-Token, Ausgabe-Token und alle speziellen Token. Weitere Informationen zu den Preisen findest du unter [Preise](https://claude.com/pricing#anthropic-api).
  </Accordion>

  <Accordion title="Kann ich einen Batch aktualisieren, nachdem er eingereicht wurde?">
    Nein, sobald ein Batch eingereicht wurde, kann er nicht mehr geändert werden. Wenn du Änderungen vornehmen musst, solltest du den aktuellen Batch abbrechen und einen neuen einreichen. Beachte, dass der Abbruch möglicherweise nicht sofort wirksam wird.
  </Accordion>

  <Accordion title="Gibt es Ratenlimits für die Message Batches API und interagieren sie mit den Ratenlimits der Messages API?">
    Die Message Batches API hat auf HTTP-Anfragen basierende Ratenlimits zusätzlich zu Limits für die Anzahl der zu verarbeitenden Anfragen. Siehe [Ratenlimits der Message Batches API](https://platform.claude.com/docs/de/api/rate-limits#message-batches-api). Die Nutzung der Batches API hat keinen Einfluss auf die Ratenlimits der Messages API.
  </Accordion>

  <Accordion title="Wie gehe ich mit Fehlern in meinen Batch-Anfragen um?">
    Wenn du die Ergebnisse abrufst, hat jede Anfrage ein `result`-Feld, das angibt, ob sie `succeeded`, `errored`, `canceled` oder `expired` ist. Für `errored`-Ergebnisse werden zusätzliche Fehlerinformationen bereitgestellt. Sieh dir das Fehlerantwortobjekt in der [API-Referenz](https://platform.claude.com/docs/de/api/messages/batches/create) an.
  </Accordion>

  <Accordion title="Wie handhabt die Message Batches API Datenschutz und Datentrennung?">
    Die Message Batches API ist mit starken Maßnahmen für Datenschutz und Datentrennung konzipiert:

    1. Batches und ihre Ergebnisse sind innerhalb des Workspace isoliert, in dem sie erstellt wurden. Das bedeutet, dass auf sie nur durch API-Anfragen in demselben Workspace zugegriffen werden kann.
    2. Jede Anfrage innerhalb eines Batches wird unabhängig verarbeitet, ohne Datenlecks zwischen Anfragen.
    3. Ergebnisse sind nur für eine begrenzte Zeit (29 Tage) verfügbar und folgen Anthropics [Datenaufbewahrungsrichtlinie](https://support.claude.com/en/articles/7996866-how-long-do-you-store-personal-data).
    4. Das Herunterladen von Batch-Ergebnissen in der Console kann auf Organisationsebene oder pro Workspace deaktiviert werden.
  </Accordion>

  <Accordion title="Kann ich Prompt-Caching in der Message Batches API verwenden?">
    Ja, es ist möglich, Prompt-Caching mit der Message Batches API zu verwenden. Da asynchrone Batch-Anfragen jedoch gleichzeitig und in beliebiger Reihenfolge verarbeitet werden können, werden Cache-Treffer nach dem Best-Effort-Prinzip bereitgestellt.
  </Accordion>
</AccordionGroup>

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Suchergebnisse" icon="magnifying-glass" href="https://platform.claude.com/docs/de/build-with-claude/search-results">
    Ermögliche natürliche Zitate für RAG-Anwendungen, indem du Suchergebnisse mit Quellenangabe bereitstellst.
  </Card>

  <Card title="Prompt-Caching" icon="database" href="https://platform.claude.com/docs/de/build-with-claude/prompt-caching">
    Reduziere Kosten und Latenz, indem du Prompt-Präfixe cachst, die von Anfragen in einem Batch gemeinsam genutzt werden.
  </Card>
</CardGroup>