---
title: Computer-Use-Tool
url: https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool
description: Gib Claude mit dem Computer-Use-Tool, dem Client-Toolset computer_toolset_20260801, die Steuerung einer Desktop-Umgebung über Screenshots, Maus und Tastatur.
featureMetadata:
  betaHeader: computer-use-2025-11-24, computer-use-2025-01-24
  zdr:
    eligibility: eligible
    note: Excludes [Covered Models](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements). Clientseitiges Tool, bei dem Screenshots und Dateien in deiner Umgebung erfasst und gespeichert werden, nicht von Anthropic.
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-fable-5-1
    - claude-mythos-5-1
    - claude-fable-5
    - claude-mythos-5
    - claude-mythos-preview
    - claude-opus-5-5
    - claude-opus-5
    - claude-sonnet-5-5
    - claude-sonnet-5
    - claude-haiku-5-5
    - claude-haiku-4-5-20251001
    - claude-opus-4-8
    - claude-opus-4-7
    - claude-opus-4-6
    - claude-sonnet-4-6
    - claude-opus-4-5-20251101
    - claude-sonnet-4-5-20250929
  supportedPlatforms:
    Claude API: stable
    Amazon Bedrock: stable
    Amazon Bedrock (bedrock-runtime): stable
    Claude Platform on AWS: stable
    Claude Models on Google Cloud (Anthropic managed): stable
    Claude Models on Google Cloud (Google managed): stable
    Microsoft Foundry: stable
  details:
    - Claude Fable 5.2, Claude Mythos 5.2, Claude Opus 5.5, Claude Sonnet 5.5 und Claude Haiku 5.5 unterstützen Computer Use über das Toolset `computer_toolset_20260801`. Sie geben für jede Version des Computer-Use-Tools, die sie nicht akzeptieren, einen 400-Fehler zurück, etwa für `computer_20251124` in der Claude API. Wie du eine `computer_20251124`-Integration auf das Toolset umstellst, erfährst du unter [Migration von `computer_20251124`](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124). Wie du von `computer_20250124` umstellst, erfährst du unter [Computer Use auf das Toolset umstellen](https://platform.claude.com/docs/de/models/haiku-5-5/migration-guide#computer-use-toolset) im Migrationsleitfaden für Claude Haiku 5.5.
    - Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 4.6 und Claude Opus 4.5 unterstützen Computer Use nur über die Tool-Version `computer_20251124`, die einen Beta-Header erfordert; siehe [Frühere Tool-Versionen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions).
---

<Note>
  **Beginne mit den SDK-Toolsets:** Für `computer_toolset_20260801` bieten die Python- und TypeScript-SDKs eine Computer-Toolset-Klasse in der Beta an. Beginne mit [der Integration eines Partners](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-sdk#partner-integrations) oder sieh dir den Abschnitt [Computer-Toolset](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-sdk#computer-toolset) auf der Seite zu den SDK-Toolsets an. Verwende diese Seite als Tool-Referenz oder wenn du die Tool-Aufrufe selbst verarbeitest.
</Note>

Claude kann über das „computer use tool“ (Computer-Use-Tool) mit Computerumgebungen interagieren. Es bietet Screenshot-Funktionen sowie Maus- und Tastatursteuerung für autonome Desktop-Interaktion.

Das Computer-Use-Tool ist ein von Anthropic definiertes [„client toolset“ (Client-Toolset)](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-reference#client-toolsets): Ein einziger Eintrag `{"type": "computer_toolset_20260801"}` in `tools` gibt Claude 17 Member-Tools wie `screenshot`, `left_click`, `type` und `zoom`, und deine Anwendung führt jeden Aufruf in einer Umgebung aus, die du kontrollierst. Es ist derzeit nicht in [Claude Managed Agents](https://platform.claude.com/docs/de/managed-agents/tools) verfügbar. Claudes Aufrufe sind `tool_use`-Blöcke, deren `name` das Member ist und die `"toolset_name": "computer"` enthalten, oft mehrere in einem Zug (eine [Batch-Aktion](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#batch-actions)).

Für Aufgaben, die innerhalb von Webseiten bleiben, ist das [Browser-Use-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool) besser geeignet: Seine Member-Tools lesen die Seite selbst und agieren direkt auf ihr, und es benötigt keine vollständige Desktop-Umgebung.

Unter [API-Unterstützung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#availability-feature-support) findest du die Modelle und Plattformen, die das Toolset unterstützen. [Frühere Tool-Versionen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions) listet für jede frühere Version den Beta-Header und die Modelle auf, mit denen sie verwendet werden kann.

## Sicherheitsaspekte

Computer Use birgt besondere Risiken, die sich von denen der Standard-API-Funktionen unterscheiden. Diese Risiken sind bei der Interaktion mit dem Internet erhöht.

<Warning>
  Um Risiken zu minimieren, solltest du Vorsichtsmaßnahmen in Betracht ziehen, wie zum Beispiel:

  1. Eine dedizierte virtuelle Maschine oder einen Container mit minimalen Berechtigungen verwenden, um direkte Systemangriffe oder Unfälle zu verhindern.
  2. Dem Modell keinen Zugriff auf sensible Daten wie Kontoanmeldeinformationen geben, um Informationsdiebstahl zu verhindern.
  3. Den Internetzugang auf eine Allowlist von Domains beschränken, um die Gefährdung durch bösartige Inhalte zu verringern.
  4. Einen Menschen Entscheidungen bestätigen lassen, die bedeutende Konsequenzen in der realen Welt haben könnten, sowie alle Aufgaben, die eine ausdrückliche Zustimmung erfordern, etwa das Akzeptieren von Cookies, das Abschließen von Finanztransaktionen oder das Zustimmen zu Nutzungsbedingungen.
</Warning>

Unter bestimmten Umständen befolgt Claude Befehle, die in Inhalten gefunden werden, selbst wenn sie deinen Anweisungen widersprechen. Beispielsweise können Anweisungen auf Webseiten oder in Bildern deine Anweisungen überschreiben oder Claude zu Fehlern veranlassen. Triff Vorsichtsmaßnahmen, um Claude von sensiblen Daten und Aktionen zu isolieren und so Risiken im Zusammenhang mit „prompt injection“ (Prompt-Injection) zu vermeiden.

Anthropic hat das Modell darauf trainiert, diesen Prompt-Injections zu widerstehen, und eine zusätzliche Verteidigungsebene hinzugefügt. Wenn du das Computer-Use-Tool verwendest, scannen Klassifikatoren automatisch, was das Tool zurückgibt, etwa Screenshots, um potenzielle Prompt-Injections zu markieren. Wenn diese Klassifikatoren eine potenzielle Prompt-Injection erkennen, veranlassen sie das Modell zu prüfen, ob die Anweisung wirklich von dir stammt, bevor es danach handelt.

Dieser zusätzliche Schutz ist nicht für jeden Anwendungsfall ideal (zum Beispiel für Anwendungsfälle ohne menschliche Beteiligung). Wenn du ihn abwählen und deaktivieren möchtest, [kontaktiere den Support](https://support.claude.com/en/). Die zuvor aufgeführten Vorsichtsmaßnahmen bleiben auch mit diesen Klassifikatoren wichtig.

Informiere Endnutzer über relevante Risiken und hole ihre Zustimmung ein, bevor du Computer Use in deinen eigenen Produkten aktivierst.

## Schnellstart

Füge das Computer-Use-Toolset als `{"type": "computer_toolset_20260801"}` zum `tools`-Array einer [Messages API](https://platform.claude.com/docs/de/api/messages/create)-Anfrage hinzu. Die Anfrage benötigt keinen Beta-Header. Dieses Beispiel deklariert außerdem das [Text-Editor-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/text-editor-tool) und das [Bash-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/bash-tool), die Claude typischerweise zusammen mit Computer Use verwendet:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "content-type: application/json" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 1024,
      "tools": [
        {
          "type": "computer_toolset_20260801"
        },
        {
          "type": "text_editor_20250728",
          "name": "str_replace_based_edit_tool"
        },
        {
          "type": "bash_20250124",
          "name": "bash"
        }
      ],
      "messages": [
        {
          "role": "user",
          "content": "Save a picture of a cat to my desktop."
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-opus-5-5
  max_tokens: 1024
  tools:
    - type: computer_toolset_20260801
    - type: text_editor_20250728
      name: str_replace_based_edit_tool
    - type: bash_20250124
      name: bash
  messages:
    - role: user
      content: Save a picture of a cat to my desktop.
  YAML
  ```

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

  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      tools=[
          {"type": "computer_toolset_20260801"},
          {"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"},
          {"type": "bash_20250124", "name": "bash"},
      ],
      messages=[{"role": "user", "content": "Save a picture of a cat to my desktop."}],
  )
  print(response)
  ```

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

  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    tools: [
      {
        type: "computer_toolset_20260801"
      },
      {
        type: "text_editor_20250728",
        name: "str_replace_based_edit_tool"
      },
      {
        type: "bash_20250124",
        name: "bash"
      }
    ],
    messages: [{ role: "user", content: "Save a picture of a cat to my desktop." }]
  });

  console.log(response);
  ```

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

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Tools =
      [
          new ComputerToolset20260801(),
          new ToolTextEditor20250728(),
          new ToolBash20250124(),
      ],
      Messages = [new UserMessageParam { Content = "Save a picture of a cat to my desktop." }],
  };

  var response = await client.Messages.Create(parameters);
  Console.WriteLine(response);
  ```

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

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 1024,
  	Tools: []anthropic.ToolUnionParam{
  		{OfComputerToolset20260801: &anthropic.ComputerToolset20260801Param{}},
  		{OfTextEditor20250728: &anthropic.ToolTextEditor20250728Param{}},
  		{OfBashTool20250124: &anthropic.ToolBash20250124Param{}},
  	},
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Save a picture of a cat to my desktop.")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response.RawJSON())
  ```

  ```java Java
  import com.anthropic.models.messages.ComputerToolset20260801;
  // ...
  import com.anthropic.models.messages.ToolBash20250124;
  import com.anthropic.models.messages.ToolTextEditor20250728;

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

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(1024L)
          .addTool(ComputerToolset20260801.builder().build())
          .addTool(ToolTextEditor20250728.builder().build())
          .addTool(ToolBash20250124.builder().build())
          .addUserMessage("Save a picture of a cat to my desktop.")
          .build();

      Message response = client.messages().create(params);
      IO.println(response);
  }
  ```

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

  $response = $client->messages->create(
      maxTokens: 1024,
      messages: [
          ['role' => 'user', 'content' => 'Save a picture of a cat to my desktop.'],
      ],
      model: Model::CLAUDE_OPUS_5_5,
      tools: [
          ['type' => 'computer_toolset_20260801'],
          [
              'type' => 'text_editor_20250728',
              'name' => 'str_replace_based_edit_tool',
          ],
          [
              'type' => 'bash_20250124',
              'name' => 'bash',
          ],
      ],
  );

  echo $response;
  ```

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

  response = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 1024,
    tools: [
      { type: "computer_toolset_20260801" },
      {
        type: "text_editor_20250728",
        name: "str_replace_based_edit_tool"
      },
      {
        type: "bash_20250124",
        name: "bash"
      }
    ],
    messages: [
      { role: "user", content: "Save a picture of a cat to my desktop." }
    ]
  )

  puts response
  ```
</CodeGroup>

Wenn Claude auf dem Desktop agiert, hat die Antwort einen `stop_reason` von `tool_use` und enthält einen oder mehrere Member-`tool_use`-Blöcke, die jeweils ein Member-Tool benennen und `"toolset_name": "computer"` enthalten. Mitten in dieser Aufgabe, nachdem Claude einen Screenshot des Desktops erhalten hat, könnte eine Antwort so aussehen:

```json Output
{
  "id": "msg_01UZ3bXcQH8mTqNhVfL9eK2p",
  "type": "message",
  "role": "assistant",
  "model": "claude-opus-5-5",
  "content": [
    {
      "type": "text",
      "text": "I'll open the web browser to find a picture of a cat."
    },
    {
      "type": "tool_use",
      "id": "toolu_01WkoTUvSHDzTBu2xnGk8Ep8",
      "name": "left_click",
      "toolset_name": "computer",
      "input": { "coordinate": [512, 742] }
    },
    {
      "type": "tool_use",
      "id": "toolu_017nJn3RgSCkTMwuZDb4uUov",
      "name": "screenshot",
      "toolset_name": "computer",
      "input": {}
    }
  ],
  "stop_reason": "tool_use",
  "stop_sequence": null
}
```

Deine Anwendung führt jeden Aufruf der Reihe nach in deiner eigenen Umgebung aus, gibt für jeden `tool_use`-Block einen `tool_result`-Block zurück und ruft die API erneut auf; [Wie Computer Use funktioniert](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#how-computer-use-works) beschreibt diese Schleife, und der Rest dieser Seite zeigt, wie du sie implementierst.

***

## Wie Computer Use funktioniert

<Steps>
  <Step title="Stelle Claude das Computer-Use-Tool und einen Nutzer-Prompt bereit">
    * Füge das Computer-Use-Toolset (und optional weitere Tools) zum `tools`-Array deiner API-Anfrage hinzu.
    * Füge einen Nutzer-Prompt hinzu, der Desktop-Interaktion erfordert, zum Beispiel „Speichere ein Bild einer Katze auf meinem Desktop.“
  </Step>

  <Step title="Claude antwortet mit Member-Tool-Aufrufen">
    * Claude beurteilt, ob Aktionen auf dem Desktop bei der Anfrage des Nutzers helfen können.
    * Falls ja, antwortet Claude mit einem oder mehreren Member-`tool_use`-Blöcken wie `screenshot`, `left_click` oder `type`, die jeweils `"toolset_name": "computer"` enthalten. Eine Antwort mit mehreren solchen Blöcken ist eine [Batch-Aktion](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#batch-actions).
    * Die API-Antwort hat einen `stop_reason` von `tool_use`, was eine Anfrage zur Tool-Nutzung signalisiert.
  </Step>

  <Step title="Führe die Aufrufe der Reihe nach aus und gib Ergebnisse zurück">
    * Iteriere der Reihe nach über jeden `tool_use`-Block in der Antwort. Verzweige für jeden anhand des Member-`name` zusammen mit `toolset_name` und führe diese Aktion mit dem `input` des Blocks auf deinem Container oder deiner virtuellen Maschine aus.
    * Setze die Unterhaltung mit einer neuen `user`-Nachricht fort, die für jeden `tool_use`-Block einen `tool_result`-Block enthält, zugeordnet über `tool_use_id` und jeweils mit `"toolset_name": "computer"`. Gib für `screenshot` und `zoom` ein Bild zurück; für die anderen Aktionen genügt ein kurzer Text wie `OK`.
    * Wenn eine Aktion fehlschlägt, gib für diesen Block `is_error: true` zurück und beantworte den Rest des Batches wie unter [Batch-Aktionen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#batch-actions) beschrieben.
  </Step>

  <Step title="Claude fährt fort, bis die Aufgabe abgeschlossen ist">
    * Claude analysiert die Tool-Ergebnisse, um festzustellen, ob weitere Aktionen nötig sind oder die Aufgabe abgeschlossen ist.
    * Wenn Claude feststellt, dass weitere Aktionen nötig sind, antwortet es mit einem weiteren `tool_use`-`stop_reason`; kehre zu Schritt 3 zurück.
    * Andernfalls gibt es eine Textantwort an den Nutzer zurück.
  </Step>
</Steps>

Die Schritte 3 und 4, ohne Nutzereingabe wiederholt, bilden die „agent loop“ (Agenten-Schleife): Claude antwortet mit einer Anfrage zur Tool-Nutzung, und deine Anwendung antwortet Claude mit den Ergebnissen der Auswertung dieser Anfrage.

### Batch-Aktionen

Claude kann eine kurze Abfolge von Aktionen planen, etwa klicken, tippen und dann einen Screenshot aufnehmen, und sie gemeinsam in einer Antwort zurückgeben. Dies wird als „batch action“ (Batch-Aktion) bezeichnet; sie verwendet dieselbe Antwortstruktur wie die [parallele Tool-Nutzung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/parallel-tool-use), mit einem Unterschied: Du führst die Blöcke der Reihe nach statt gleichzeitig aus.

Eine Antwort mit einem Batch aus drei Aktionen sieht so aus:

```json
{
  "role": "assistant",
  "content": [
    {
      "type": "tool_use",
      "id": "toolu_01HqCF3nJ4Vzr8sTkPZ2wxYA",
      "name": "left_click",
      "toolset_name": "computer",
      "input": { "coordinate": [640, 60] }
    },
    {
      "type": "tool_use",
      "id": "toolu_01Ppr3sZ3TnE9m6VUu4RyH2K",
      "name": "type",
      "toolset_name": "computer",
      "input": { "text": "pictures of cats" }
    },
    {
      "type": "tool_use",
      "id": "toolu_01Xf5W1sD8Q9aBcJ7kLmN2pQ",
      "name": "screenshot",
      "toolset_name": "computer",
      "input": {}
    }
  ]
}
```

Gib für jeden `tool_use`-Block einen `tool_result`-Block zurück, zugeordnet über `tool_use_id`, alle in der nächsten `user`-Nachricht. Jedes Ergebnis für ein Member-Tool muss `"toolset_name": "computer"` enthalten; ein Ergebnis, das es weglässt oder ein anderes Toolset als sein `tool_use`-Block nennt, wird abgelehnt. Nur die Ergebnisse von `screenshot` und `zoom` benötigen ein Bild; für die anderen Members genügt eine kurze Textbestätigung wie `OK` (`cursor_position` gibt die Koordinaten als Text zurück):

```json
{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01HqCF3nJ4Vzr8sTkPZ2wxYA",
      "toolset_name": "computer",
      "content": [{ "type": "text", "text": "OK" }]
    },
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01Ppr3sZ3TnE9m6VUu4RyH2K",
      "toolset_name": "computer",
      "content": [{ "type": "text", "text": "OK" }]
    },
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01Xf5W1sD8Q9aBcJ7kLmN2pQ",
      "toolset_name": "computer",
      "content": [
        {
          "type": "image",
          "source": {
            "type": "base64",
            "media_type": "image/png",
            "data": "iVBORw0KGgo..."
          }
        }
      ]
    }
  ]
}
```

**Führe Blöcke der Reihe nach aus und stoppe beim ersten Fehler.** Spätere Aktionen in einem Batch hängen meist von früheren ab: Das `type` in diesem Beispiel gibt Text in das Element ein, das der vorherige Klick fokussiert hat. Führe die Blöcke nacheinander in der Reihenfolge aus, in der sie in `content` erscheinen, und wenn einer fehlschlägt, führe die restlichen nicht aus. Jeder `tool_use`-Block benötigt trotzdem ein `tool_result`, also beantworte den Batch wie folgt:

* Gib für jede erfolgreiche Aktion ihr normales Ergebnis zurück.
* Gib für die fehlgeschlagene Aktion `is_error: true` mit einer Textbeschreibung dessen zurück, was schiefgelaufen ist.
* Gib für jede spätere Aktion im Batch `is_error: true` mit genau diesem Text zurück (das Browser-Use-Tool verwendet seinen eigenen [Abbruchtext](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#batch-actions)):

```json
{
  "type": "tool_result",
  "tool_use_id": "toolu_01Xf5W1sD8Q9aBcJ7kLmN2pQ",
  "toolset_name": "computer",
  "is_error": true,
  "content": "Not executed: an earlier computer action in this turn failed."
}
```

Claude liest dann, welche Aktionen erfolgreich waren, welche fehlgeschlagen ist und welche übersprungen wurden, und plant in seinem nächsten Zug neu. Eine Anfrage, die einen `tool_use`-Block im Batch unbeantwortet lässt, wird mit einem `invalid_request_error` abgelehnt, sodass eine Agenten-Schleife, die nur den ersten Block liest, bei ihrem nächsten Aufruf fehlschlägt. Wenn deine Anwendung einen Menschen bittet, folgenreiche Aktionen zu bestätigen, führe diese Prüfung vor jedem Block durch, da ein Batch eine mehrstufige Aktion innerhalb eines Zuges abschließen kann.

Claude beendet einen Batch typischerweise mit `screenshot`, damit es das Ergebnis beobachten kann, bevor es über den nächsten Schritt entscheidet. Wenn ein Batch nicht mit einem Screenshot endet, kann deine Anwendung einen Screenshot als zusätzlichen `image`-Block an das letzte Ergebnis im Batch anhängen, sodass Claude immer den aktuellen Zustand des Bildschirms erhält. Das spart einen Roundtrip im Vergleich dazu, darauf zu warten, dass Claude danach fragt. Du kannst Claude auch per Prompt anweisen, jeden Batch mit einem Screenshot zu beenden (siehe [Modellleistung durch Prompting optimieren](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#optimize-model-performance-with-prompting)).

### Die Computerumgebung

Computer Use erfordert eine abgeschottete (sandboxed) Computerumgebung, in der Claude sicher mit Anwendungen und dem Web interagieren kann. Diese Umgebung umfasst:

1. **Virtuelles Display:** Einen virtuellen X11-Displayserver (mit Xvfb), der die Desktop-Oberfläche rendert, die Claude als Screenshots erhält und mit Maus-/Tastaturaktionen steuert.

2. **Desktop-Umgebung:** Eine schlanke Benutzeroberfläche mit Fenstermanager (Mutter) und Panel (Tint2) unter Linux, die Claude eine konsistente grafische Oberfläche zur Interaktion bietet.

3. **Anwendungen:** Vorinstallierte Linux-Anwendungen wie Firefox, LibreOffice, Texteditoren und Dateimanager, die Claude zur Erledigung von Aufgaben verwenden kann.

4. **Tool-Implementierungen:** Integrationscode, der Claudes abstrakte Tool-Anfragen (wie „Maus bewegen“ oder „Screenshot aufnehmen“) in tatsächliche Operationen in der virtuellen Umgebung übersetzt.

5. **Agenten-Schleife:** Ein Programm, das die Kommunikation zwischen Claude und der Umgebung übernimmt, Claudes Aktionen an die Umgebung sendet und die Ergebnisse (Screenshots, Befehlsausgaben) an Claude zurückgibt.

Wenn du Computer Use verwendest, verbindet sich Claude nicht direkt mit dieser Umgebung. Stattdessen übernimmt deine Anwendung Folgendes:

1. Sie empfängt Claudes Anfragen zur Tool-Nutzung.
2. Sie übersetzt sie in Aktionen in deiner Computerumgebung.
3. Sie erfasst die Ergebnisse (wie Screenshots und Befehlsausgaben).
4. Sie gibt diese Ergebnisse an Claude zurück.

Aus Gründen der Sicherheit und Isolation führt die Referenzimplementierung all dies in einem Docker-Container mit geeigneten Port-Mappings aus, um die Umgebung anzusehen und mit ihr zu interagieren.

***

## Wie du Computer Use implementierst

Du aktualisierst eine bestehende `computer_20251124`-Integration? Beginne mit [Migration von `computer_20251124`](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#migrate-from-computer-20251124); der Rest dieses Abschnitts gilt sowohl für neue als auch für migrierte Integrationen.

<Tip>
  Die [Computer-Use-Referenzimplementierung](https://github.com/anthropics/claude-quickstarts/tree/main/computer-use-demo) ist ein vollständiges funktionierendes Beispiel: eine für Computer Use geeignete [containerisierte Umgebung](https://github.com/anthropics/claude-quickstarts/blob/main/computer-use-demo/Dockerfile), Implementierungen [der Computer-Use-Tools](https://github.com/anthropics/claude-quickstarts/tree/main/computer-use-demo/computer_use_demo/tools), eine [Agenten-Schleife](https://github.com/anthropics/claude-quickstarts/blob/main/computer-use-demo/computer_use_demo/loop.py), die die Claude API aufruft und die Tools ausführt, sowie eine Weboberfläche für Container, Schleife und Tools. Um `computer_toolset_20260801` zu verwenden, wähle ein [Modell, das es unterstützt](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#availability-feature-support), und wähle dann in der Seitenleiste der Weboberfläche unter **Tool Versions** das Toolset aus.
</Tip>

### Die Agenten-Schleife verstehen

Der Kern von Computer Use ist die „Agenten-Schleife“: ein Zyklus, in dem Claude Tool-Aktionen anfordert und deine Anwendung sie ausführt und die Ergebnisse an Claude zurückgibt. Die Schleife verwendet den Client, den du im [Schnellstart](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#quick-start) erstellt hast, ein `tools`-Array, das nur das Computer-Use-Toolset deklariert, und die Hilfsfunktion zur Verarbeitung von Tool-Aufrufen unter [Das Computer-Use-Tool implementieren](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#implement-the-computer-use-tool). Wenn du auch andere Tools deklarierst, etwa die Bash- und Text-Editor-Tools aus dem Schnellstart, verarbeite deren `tool_use`-Blöcke im selben Durchlauf; die Hilfsfunktion beantwortet nur Member-Aufrufe von Computer Use, und die Schleife behandelt einen Zug ohne beantwortete Aufrufe als abgeschlossen. Hier ist ein vereinfachtes Beispiel:

<CodeGroup exclude="shell">
  ```python Python
  def sampling_loop(model: str, messages: list[MessageParam], max_iterations: int = 10):
      """
      Run the computer-use agent loop until Claude stops requesting tools
      or the iteration limit is reached.
      """
      for _ in range(max_iterations):
          response = client.messages.create(
              model=model,
              max_tokens=4096,
              messages=messages,
              tools=TOOLS,
          )

          # Add Claude's response to the conversation history
          messages.append({"role": "assistant", "content": response.content})

          # Run the actions Claude requested, in order, and collect the results
          tool_results = process_tool_calls(response)
          if not tool_results:
              return messages  # No more tool use; task complete

          # Send every result back to Claude in a single user message
          messages.append({"role": "user", "content": tool_results})

      return messages
  ```

  ```typescript TypeScript
  async function samplingLoop(
    model: string,
    messages: Anthropic.MessageParam[],
    maxIterations = 10
  ): Promise<Anthropic.MessageParam[]> {
    // Run the computer-use agent loop until Claude stops requesting tools
    // or the iteration limit is reached.
    for (let iteration = 0; iteration < maxIterations; iteration++) {
      const response = await client.messages.create({
        model,
        max_tokens: 4096,
        messages,
        tools
      });

      // Add Claude's response to the conversation history
      messages.push({ role: "assistant", content: response.content });

      // Run any tools Claude requested and collect results
      const toolResults = processToolCalls(response);
      if (toolResults.length === 0) {
        return messages; // No more tool use; task complete
      }

      // Send tool results back to Claude for the next iteration
      messages.push({ role: "user", content: toolResults });
    }

    return messages;
  }
  ```

  ```csharp C#
  async Task<List<MessageParam>> SamplingLoop(
      Model model,
      List<MessageParam> messages,
      int maxIterations = 10
  )
  {
      // Run the computer-use agent loop until Claude stops requesting tools
      // or the iteration limit is reached.
      for (var iteration = 0; iteration < maxIterations; iteration++)
      {
          var response = await client.Messages.Create(
              new MessageCreateParams
              {
                  Model = model,
                  MaxTokens = 4096,
                  Messages = messages,
                  Tools = tools,
              }
          );

          // Add Claude's response to the conversation history
          messages.Add(
              new AssistantMessageParam
              {
                  Content = response
                      .Content.Select(block => new ContentBlockParam(block.Json))
                      .ToList(),
              }
          );

          // Run any tools Claude requested and collect results
          var toolResults = ProcessToolCalls(response);
          if (toolResults.Count == 0)
          {
              return messages; // No more tool use; task complete
          }

          // Send tool results back to Claude for the next iteration
          messages.Add(new UserMessageParam { Content = toolResults });
      }

      return messages;
  }
  ```

  ```go Go
  // samplingLoop runs the computer-use agent loop until Claude stops
  // requesting tools or the iteration limit is reached.
  func samplingLoop(ctx context.Context, model anthropic.Model, messages []anthropic.MessageParam, maxIterations int) ([]anthropic.MessageParam, error) {
  	for range maxIterations {
  		response, err := client.Messages.New(ctx, anthropic.MessageNewParams{
  			Model:     model,
  			MaxTokens: 4096,
  			Messages:  messages,
  			Tools:     tools,
  		})
  		if err != nil {
  			return nil, err
  		}

  		// Add Claude's response to the conversation history
  		messages = append(messages, response.ToParam())

  		// Run the actions Claude requested, in order, and collect the results
  		toolResults := processToolCalls(response)
  		if len(toolResults) == 0 {
  			return messages, nil // No more tool use; task complete
  		}

  		// Send every result back to Claude in a single user message
  		messages = append(messages, anthropic.NewUserMessage(toolResults...))
  	}
  	return messages, nil
  }
  ```

  ```java Java
  /**
   * Run the computer-use agent loop until Claude stops requesting tools
   * or the iteration limit is reached.
   */
  List<MessageParam> samplingLoop(Model model, List<MessageParam> messages, int maxIterations) {
      for (int iteration = 0; iteration < maxIterations; iteration++) {
          Message response = client.messages().create(MessageCreateParams.builder()
              .model(model)
              .maxTokens(4096)
              .messages(messages)
              .addTool(COMPUTER_TOOLSET)
              .build());

          // Add Claude's response to the conversation history
          messages.add(response.toParam());

          // Run any tools Claude requested and collect results
          List<ContentBlockParam> toolResults = processToolCalls(response);
          if (toolResults.isEmpty()) {
              return messages; // No more tool use; task complete
          }

          // Send tool results back to Claude for the next iteration
          messages.add(MessageParam.ofUserOfContentBlockParams(toolResults));
      }
      return messages;
  }
  ```

  ```php PHP
  /**
   * Run the computer-use agent loop until Claude stops requesting tools
   * or the iteration limit is reached.
   */
  function samplingLoop(Model|string $model, array $messages, int $maxIterations = 10): array
  {
      global $client, $tools;

      for ($iteration = 0; $iteration < $maxIterations; $iteration++) {
          $response = $client->messages->create(
              model: $model,
              maxTokens: 4096,
              messages: $messages,
              tools: $tools,
          );

          // Add Claude's response to the conversation history
          $messages[] = MessageParam::with(role: Role::ASSISTANT, content: $response->content);

          // Run any tools Claude requested and collect results
          $toolResults = processToolCalls($response);
          if ($toolResults === []) {
              return $messages; // No more tool use; task complete
          }

          // Send tool results back to Claude for the next iteration
          $messages[] = MessageParam::with(role: Role::USER, content: $toolResults);
      }

      return $messages;
  }
  ```

  ```ruby Ruby
  # Run the computer-use agent loop until Claude stops requesting tools
  # or the iteration limit is reached.
  def sampling_loop(model, messages, max_iterations: 10)
    max_iterations.times do
      response = CLIENT.messages.create(
        model: model,
        max_tokens: 4096,
        messages: messages,
        tools: TOOLS
      )

      # Add Claude's response to the conversation history
      messages << { role: "assistant", content: response.content }

      # Run the actions Claude requested, in order, and collect the results
      tool_results = process_tool_calls(response)
      return messages if tool_results.empty? # No more tool use; task complete

      # Send every result back to Claude in a single user message
      messages << { role: "user", content: tool_results }
    end

    messages
  end
  ```
</CodeGroup>

Die Schleife läuft weiter, bis entweder Claude ohne Anforderung von Tools antwortet (Aufgabe abgeschlossen) oder das maximale Iterationslimit erreicht ist. Diese Schutzmaßnahme verhindert mögliche Endlosschleifen, die zu unerwarteten API-Kosten führen könnten.

### Modellleistung durch Prompting optimieren

1. Gib klar definierte Aufgaben vor und stelle explizite Anweisungen für jeden Schritt bereit.
2. Claude verhält sich manchmal so, als wären seine Aktionen erfolgreich gewesen, ohne deren Ergebnisse explizit zu prüfen. Um dies zu verhindern, kannst du Claude folgenden Prompt geben: `After each step, take a screenshot and carefully evaluate if you have achieved the right outcome. State in one sentence what the screenshot shows and whether the step succeeded. If it didn't, try again. Only when you confirm a step was executed correctly should you move on to the next one.`
3. Manche UI-Elemente (wie Dropdowns und Scrollbalken) sind für Claude mit Mausbewegungen möglicherweise schwer zu bedienen. Wenn du dies feststellst, versuche, das Modell per Prompt zur Verwendung von Tastenkürzeln anzuweisen.
4. Füge für wiederholbare Aufgaben oder UI-Interaktionen Beispiel-Screenshots und Tool-Aufrufe erfolgreicher Ergebnisse in deinen Prompt ein.
5. Wenn sich das Modell anmelden muss, gib ihm Benutzername und Passwort in deinem Prompt innerhalb von XML-Tags wie `<robot_credentials>`. Die Verwendung von Computer Use in Anwendungen, die eine Anmeldung erfordern, erhöht das Risiko schlechter Ergebnisse infolge von Prompt-Injection. Lies [Jailbreaks und Prompt-Injections abschwächen](https://platform.claude.com/docs/de/test-and-evaluate/strengthen-guardrails/mitigate-jailbreaks), bevor du dem Modell Anmeldedaten gibst.
6. Wenn du das `content`-Array eines Nutzer-Zuges erstellst, platziere den Anweisungstext *vor* dem Screenshot-Bild. Wenn die Zielbeschreibung bereitgestellt wird, bevor das Bild verarbeitet wird, verbessert sich die Klickgenauigkeit.
7. Claude verwendet die Aktion `zoom`, um einen Bereich in voller Auflösung zu untersuchen, wenn es nach kleinem Text oder bestimmten UI-Elementen gefragt wird, die in der Standardauflösung des Screenshots nicht lesbar sind, etwa Dateinamen in einer Seitenleiste, Tab-Titel, Statusleistentext, Zeilennummern oder Schaltflächenbeschriftungen. Wenn Claude nicht zoomt, obwohl du es erwartest, frage nach einem bestimmten Bereich oder Element statt nach dem Bildschirm als Ganzem.
8. Wenn jede [Batch-Aktion](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#batch-actions) mit einem Screenshot enden soll, sage das im System-Prompt, zum Beispiel: `End each group of actions with a screenshot so you can verify the result before continuing.`

Wenn du wiederholt auf eine klar umrissene Reihe von Problemen stößt oder im Voraus weißt, welche Aufgaben Claude erledigen muss, gib Claude im System-Prompt explizite Tipps oder Anweisungen dafür.

Führe bei Agenten, die sich über mehrere Sitzungen erstrecken, zu Beginn jeder Sitzung eine End-to-End-Verifizierung durch, nicht nur nach der Implementierung. Browserbasierte Prüfungen erkennen Regressionen aus früheren Sitzungen, die eine reine Code-Review übersieht. Siehe [Effective harnesses for long-running agents](https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents) für Details.

### System-Prompts

Wenn du das Computer-Use-Tool in eine Anfrage aufnimmst, generiert die API einen Computer-Use-spezifischen System-Prompt. Er ähnelt dem [System-Prompt für Tool-Nutzung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/define-tools#tool-use-system-prompt), beginnt aber mit:

> You have access to a set of functions you can use to answer the user’s question. This includes access to a sandboxed computing environment. You do NOT currently have the ability to inspect files or interact with external resources, except by invoking the below functions.

Wie bei der regulären Tool-Nutzung wird der vom Nutzer bereitgestellte `system`-Parameter weiterhin berücksichtigt und beim Aufbau des kombinierten System-Prompts verwendet.

### Verfügbare Aktionen

Jede Aktion ist ein Member-Tool des Computer-Use-Toolsets: Claude benennt das Member in einem `tool_use`-Block, der `"toolset_name": "computer"` enthält, und der `input` des Blocks enthält nur die Parameter dieses Members, ohne `action`-Feld. Das Toolset hat 17 Member-Tools:

| Member                                                        | Eingabe                                                                                                                                                                                                                                      | Beschreibung                                                                                                                                                                                                                                                                                                          |
| ------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `screenshot`                                                  | Keine (`{}`)                                                                                                                                                                                                                                 | Erfasst das gesamte Display und gibt es als Bild zurück.                                                                                                                                                                                                                                                              |
| `zoom`                                                        | `region`: `[x0, y0, x1, y1]`, die obere linke und untere rechte Ecke des zu untersuchenden Bereichs                                                                                                                                          | Erfasst nur diesen Bereich des Displays in voller Auflösung und gibt ihn als Bild zurück, skaliert auf deine üblichen Screenshot-Abmessungen unter Beibehaltung des Seitenverhältnisses. So kann Claude kleinen Text oder dichte UI lesen, die in einem herunterskalierten vollständigen Screenshot nicht lesbar ist. |
| `left_click`                                                  | `coordinate` (optional): `[x, y]`; `text` (optional): Modifikatortasten, die während des Klicks gehalten werden: `shift`, `ctrl`, `alt`, `super` (die Command- oder Windows-Taste) oder eine mit `+` verbundene Kombination wie `ctrl+shift` | Klickt mit der linken Maustaste bei `coordinate` oder an der aktuellen Cursorposition, wenn `coordinate` weggelassen wird.                                                                                                                                                                                            |
| `right_click`, `middle_click`, `double_click`, `triple_click` | Wie bei `left_click`                                                                                                                                                                                                                         | Andere Maustasten und Mehrfachklicks.                                                                                                                                                                                                                                                                                 |
| `left_click_drag`                                             | `start_coordinate`: `[x, y]`; `coordinate`: `[x, y]`; `text` (optional): Modifikatortasten                                                                                                                                                   | Drückt bei `start_coordinate`, zieht zu `coordinate` und lässt los.                                                                                                                                                                                                                                                   |
| `mouse_move`                                                  | `coordinate`: `[x, y]`                                                                                                                                                                                                                       | Bewegt den Cursor ohne Klick, zum Beispiel zum Hovern.                                                                                                                                                                                                                                                                |
| `left_mouse_down`, `left_mouse_up`                            | Keine (`{}`)                                                                                                                                                                                                                                 | Drückt oder löst die linke Maustaste an der aktuellen Cursorposition, für Ziehvorgänge, die `left_click_drag` nicht abbilden kann. Bewege den Cursor zuerst mit `mouse_move`.                                                                                                                                         |
| `cursor_position`                                             | Keine (`{}`)                                                                                                                                                                                                                                 | Meldet die aktuelle `[x, y]`-Position des Cursors als Text.                                                                                                                                                                                                                                                           |
| `scroll`                                                      | `scroll_direction`: `"up"`, `"down"`, `"left"` oder `"right"`; `scroll_amount`: Anzahl der Mausrad-Klicks; `coordinate` (optional): `[x, y]`; `text` (optional): Modifikatortasten                                                           | Scrollt bei `coordinate` oder an der aktuellen Cursorposition.                                                                                                                                                                                                                                                        |
| `type`                                                        | `text`: die zu tippende Zeichenfolge                                                                                                                                                                                                         | Tippt wörtlichen Text am aktuellen Tastaturfokus.                                                                                                                                                                                                                                                                     |
| `key`                                                         | `text`: eine Taste oder eine mit `+` verbundene Kombination wie `"Return"`, `"ctrl+s"` oder `"alt+Tab"`; `repeat` (optional): 1 bis 100, Standard 1                                                                                          | Drückt eine Taste oder Tastenkombination `repeat`-mal.                                                                                                                                                                                                                                                                |
| `hold_key`                                                    | `text`: eine Taste oder Kombination; `duration`: Sekunden, bis zu 300                                                                                                                                                                        | Hält eine Taste für die angegebene Dauer gedrückt.                                                                                                                                                                                                                                                                    |
| `wait`                                                        | `duration`: Sekunden, bis zu 300                                                                                                                                                                                                             | Pausiert vor der nächsten Aktion, zum Beispiel während eine Anwendung lädt.                                                                                                                                                                                                                                           |

Beachte Folgendes bei der Implementierung der Members:

* **Koordinaten sind in Screenshot-Pixeln.** Jeder Wert von `coordinate`, `start_coordinate` und `region` sowie die von `cursor_position` gemeldete Position liegt im Pixelraum der vollständigen Display-Screenshots, die du zurückgibst, mit dem Ursprung oben links. Zoom-Bilder ändern daran nichts: Nach einem `zoom` gibt Claude Koordinaten weiterhin im Raum des vollständigen Screenshots an, nie relativ zum gezoomten Bild. Wenn du Screenshots vor der Rückgabe herunterskalierst, skaliere Claudes Koordinaten wieder hoch, bevor du sie auf das echte Display anwendest (siehe [Screenshots an die Bildlimits anpassen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#handle-coordinate-scaling-for-higher-resolutions)).
* **Alle Members sind standardmäßig aktiviert, einschließlich `zoom`.** Wenn deine Umgebung keine Zoom-Bilder erzeugen kann, schließe das Member mit `configs` aus (siehe [Tool-Parameter](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#tool-parameters)), statt es aktiviert zu lassen und Fehler zurückzugeben. Wenn Claude ein Member aufruft, das du ausgeschlossen hast oder nicht implementierst, gib für diesen Block ein `tool_result` mit `is_error: true` zurück.
* **Verzweige anhand des Paares (`toolset_name`, `name`).** `toolset_name` kennzeichnet einen Block als Computer-Aktion: Ein benutzerdefiniertes Tool in derselben Anfrage kann den Namen eines Members teilen, und eine spätere Toolset-Version kann Members hinzufügen (siehe [Client-Toolsets](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-reference#client-toolsets)).

<Accordion title="Beispielaktionen">
  Jedes Beispiel ist ein vollständiger `tool_use`-Block, wie er in Claudes Antwort erscheint.

  Umschalt+Klick an einer Position, zum Beispiel um eine Auswahl zu erweitern. Anders als bei `hold_key` hält `text` die Modifikatoren nur für die Dauer dieses Klicks oder Scrollvorgangs:

  ```json
  {
    "type": "tool_use",
    "id": "toolu_01Qg8m3XqC5aRy7tD2eS4jUg",
    "name": "left_click",
    "toolset_name": "computer",
    "input": { "coordinate": [500, 300], "text": "shift" }
  }
  ```

  Von einem Punkt zu einem anderen ziehen:

  ```json
  {
    "type": "tool_use",
    "id": "toolu_01Ed6j9VnA3yPw5rB8cQ2gSe",
    "name": "left_click_drag",
    "toolset_name": "computer",
    "input": {
      "start_coordinate": [200, 300],
      "coordinate": [600, 300]
    }
  }
  ```

  Drei Mausrad-Klicks nach unten scrollen:

  ```json
  {
    "type": "tool_use",
    "id": "toolu_01Yc5h8UmZ2xNv4qA7bP9fRd",
    "name": "scroll",
    "toolset_name": "computer",
    "input": {
      "coordinate": [500, 400],
      "scroll_direction": "down",
      "scroll_amount": 3
    }
  }
  ```

  Viermal Tab drücken:

  ```json
  {
    "type": "tool_use",
    "id": "toolu_01Sb4g7TkY9wLu3pX6zM8eQc",
    "name": "key",
    "toolset_name": "computer",
    "input": { "text": "Tab", "repeat": 4 }
  }
  ```

  Hineinzoomen, um einen Bereich in voller Auflösung zu untersuchen:

  ```json
  {
    "type": "tool_use",
    "id": "toolu_01Kf7k2WpB4zQx6sC9dR3hTf",
    "name": "zoom",
    "toolset_name": "computer",
    "input": { "region": [100, 200, 400, 350] }
  }
  ```

  Die Cursorposition melden. Beantworte diesen Aufruf mit einem kurzen Textergebnis, das die Position in Screenshot-Pixeln angibt, zum Beispiel `X=512, Y=384`:

  ```json
  {
    "type": "tool_use",
    "id": "toolu_01Ekh3vqB6yTs2mNc4Rw8pLd",
    "name": "cursor_position",
    "toolset_name": "computer",
    "input": {}
  }
  ```
</Accordion>

### Tool-Parameter

Der Toolset-Eintrag im `tools`-Array akzeptiert vier Parameter; die Regeln, die sie mit dem Browser-Use-Toolset teilen, sind unter [Client-Toolsets](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-reference#client-toolsets) aufgeführt.

| Parameter         | Erforderlich | Beschreibung                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| ----------------- | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `type`            | Ja           | `computer_toolset_20260801`                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `configs`         | Nein         | Einstellungen pro Member, nach Member-Name geschlüsselt; jedes Member akzeptiert `enabled` (Standard `true` für alle 17, einschließlich `zoom`) und `defer_loading` (Standard `false`, für die [Tool-Suche](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-search-tool#deferred-tool-loading)), und Members, die du weglässt, behalten ihre Standardwerte.                                                                  |
| `cache_control`   | Nein         | [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching)-Breakpoint an der Toolset-Definition; nur am Eintrag. Ein Breakpoint an einem beliebigen `tool_use`- oder `tool_result`-Block in einem Batch wird am Ende dieses Batches wirksam; siehe [Tool-Nutzung mit Prompt-Caching](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-use-with-prompt-caching#cache-control-on-tool-definitions). |
| `allowed_callers` | Nein         | Nur `["direct"]`.                                                                                                                                                                                                                                                                                                                                                                                                                               |

Dieser Eintrag schließt zum Beispiel `zoom` für eine Umgebung aus, die es nicht implementiert, und setzt einen Cache-Breakpoint an der Toolset-Definition:

```json
{
  "type": "computer_toolset_20260801",
  "configs": {
    "zoom": { "enabled": false }
  },
  "cache_control": { "type": "ephemeral" }
}
```

Wenn deine Agenten-Schleife pro Roundtrip nur eine Aktion ausführen kann, setze `disable_parallel_tool_use` in `tool_choice` auf `true`; Claude gibt dann pro Zug höchstens einen Member-`tool_use`-Block zurück (siehe [Parallele Tool-Nutzung deaktivieren](https://platform.claude.com/docs/de/agents-and-tools/tool-use/parallel-tool-use#disable-parallel-tool-use)).

Der Eintrag lehnt diese Parameter aus früheren Tool-Versionen ab, und eine Anfrage, die einen davon enthält, gibt einen `invalid_request_error` zurück:

* `name`: Member-Namen sind durch die Toolset-Version festgelegt.
* `display_width_px`, `display_height_px` und `display_number`: Koordinaten liegen immer im Pixelraum der Screenshots, die du zurückgibst.
* `enable_zoom`: Zoom ist ein Member-Tool, das du über `configs` steuerst.

Der Eintrag kann außerdem nicht in derselben Anfrage wie ein `computer_20251124`-Eintrag oder ein anderes Tool namens `computer` deklariert werden. Zu `strict`, `input_examples`, der Platzierung von `defer_loading`, `tool_choice`, Streaming und Aufrufer-Einschränkungen siehe [Client-Toolsets](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-reference#client-toolsets).

### Kombination mit Nachdenken

Um Computer Use mit Nachdenken zu kombinieren, siehe [Nachdenken](https://platform.claude.com/docs/de/build-with-claude/thinking).

<Tip>
  Für das Tool `computer_20251124` legen interne Benchmarks auf den Modellen, die es verwenden, diese `effort`-Einstellungen nahe:

  * **Claude Opus 4.7:** Verwende `high` als Standard; verwende `low` für Workloads mit hohem Durchsatz oder kostensensible Workloads.
  * **Claude Sonnet 4.6 und Claude Opus 4.6:** Verwende `medium` als Standard (bestes Verhältnis von Genauigkeit zu Kosten). Vermeide `max`, was Token-Kosten hinzufügt, ohne die Genauigkeit bei UI-Aufgaben zu verbessern. Auf diesen Modellen verbraucht `low` *weniger* Ausgabe-Token als das vollständige Deaktivieren des Nachdenkens (weniger Fehler bedeuten weniger Wiederholungen), was es zu einer starken Option für kostensensible Schleifen macht.
</Tip>

### Computer Use mit anderen Tools erweitern

Um neben Computer Use weitere Tools hinzuzufügen, nimm sie in dasselbe `tools`-Array auf. Der Abschnitt [Schnellstart](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#quick-start) zeigt dieses Muster mit dem [Bash-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/bash-tool) und dem [Text-Editor-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/text-editor-tool). Du kannst auf die gleiche Weise deine eigenen [benutzerdefinierten Tool-Definitionen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/define-tools) hinzufügen.

Für Aufgaben, die innerhalb von Webseiten bleiben, kannst du auch [das Browser-Use-Tool in derselben Anfrage deklarieren](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool#combine-with-other-tools). Die beiden Toolsets arbeiten unabhängig voneinander, jedes in seinem eigenen Koordinatensystem. Der Wert `toolset_name` unterscheidet Aufrufe von Members, die einen Namen teilen, etwa `screenshot` oder `key`.

### Eine eigene Computer-Use-Umgebung erstellen

Die [Referenzimplementierung](https://github.com/anthropics/claude-quickstarts/tree/main/computer-use-demo) soll dir den Einstieg in Computer Use erleichtern. Sie enthält alle Komponenten, die nötig sind, damit Claude einen Computer verwenden kann. Du kannst jedoch deine eigene Umgebung für Computer Use nach deinen Bedürfnissen erstellen. Du benötigst:

* Eine virtualisierte oder containerisierte Umgebung, die für Computer Use mit Claude geeignet ist
* Eine Implementierung der Aktionen des Computer-Use-Tools
* Eine Agenten-Schleife, die mit der Claude API interagiert und die `tool_use`-Ergebnisse mit deinen Tool-Implementierungen ausführt
* Eine API oder UI, die Nutzereingaben zum Starten der Agenten-Schleife ermöglicht

### Das Computer-Use-Tool implementieren

Das Computer-Use-Tool ist als schemaloses Tool implementiert. Wenn du dieses Tool verwendest, musst du kein Eingabeschema wie bei anderen Tools angeben; das Schema ist in Claudes Modell integriert und kann nicht geändert werden.

<Steps>
  <Step title="Richte deine Computerumgebung ein">
    Erstelle ein virtuelles Display oder verbinde dich mit einem bestehenden Display, mit dem Claude interagiert. Dies umfasst typischerweise die Einrichtung von Xvfb (X Virtual Framebuffer) oder einer ähnlichen Technologie.
  </Step>

  <Step title="Implementiere Aktions-Handler">
    Erstelle Funktionen, um jeden Aktionstyp zu verarbeiten, den Claude anfordern könnte:

    <CodeGroup exclude="shell">
      ```python Python
      # Placeholder image data; a real executor captures the screen and returns the PNG bytes
      PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="


      def capture_screenshot() -> list[ImageBlockParam]:
          # screenshot answers with an image block rather than text: return the result content list
          return [
              {
                  "type": "image",
                  "source": {
                      "type": "base64",
                      "media_type": "image/png",
                      "data": PLACEHOLDER_PNG,
                  },
              }
          ]


      def click(coordinate=None):
          if coordinate is None:
              return "clicked at current cursor"
          x, y = coordinate
          return f"clicked at ({x}, {y})"


      def type_text(text):
          return f"typed: {text}"


      def handle_computer_action(name, tool_input):
          match name:
              case "screenshot":
                  return capture_screenshot()
              case "left_click":
                  # coordinate is optional; without it, click where the cursor already is
                  return click(tool_input.get("coordinate"))
              case "type":
                  return type_text(tool_input["text"])
          # Handle other actions as needed
          raise ValueError(f"Unknown or unimplemented member: {name}")
      ```

      ```typescript TypeScript
      // Placeholder image data; a real executor captures the screen as PNG bytes
      const PLACEHOLDER_PNG =
        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";

      function captureScreenshot(): Anthropic.ImageBlockParam[] {
        // screenshot answers with an image block rather than text
        return [
          {
            type: "image",
            source: {
              type: "base64",
              media_type: "image/png",
              data: PLACEHOLDER_PNG
            }
          }
        ];
      }

      function clickAt(x: number, y: number): string {
        return `clicked at (${x}, ${y})`;
      }

      function clickAtCursor(): string {
        return "clicked at the current cursor position";
      }

      function typeText(text: string): string {
        return `typed: ${text}`;
      }

      function handleComputerAction(
        action: string,
        input: unknown
      ): string | Anthropic.ImageBlockParam[] {
        const params: object = typeof input === "object" && input !== null ? input : {};
        switch (action) {
          case "screenshot":
            return captureScreenshot();
          case "left_click":
            // coordinate is optional on the toolset; without one, click at the cursor
            if ("coordinate" in params && Array.isArray(params.coordinate)) {
              const [x, y] = params.coordinate;
              return clickAt(x, y);
            }
            return clickAtCursor();
          case "type":
            if ("text" in params) {
              return typeText(String(params.text));
            }
            break;
        }
        // Handle other actions as needed
        throw new Error(`Unknown or unimplemented member: ${action}`);
      }
      ```

      ```csharp C#
      // Placeholder image data; a real executor captures the screen and returns the PNG bytes
      const string PlaceholderPng = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";

      // screenshot answers with an image block rather than text: return the result content list
      List<Block> CaptureScreenshot() =>
          [
              new ImageBlockParam(
                  new Base64ImageSource { Data = PlaceholderPng, MediaType = MediaType.ImagePng }
              ),
          ];

      string ClickAt(int x, int y) => $"clicked at ({x}, {y})";

      string ClickAtCursor() => "clicked at the current cursor position";

      string TypeText(string text) => $"typed: {text}";

      ToolResultBlockParamContent HandleComputerAction(
          string action,
          IReadOnlyDictionary<string, JsonElement> input
      ) =>
          action switch
          {
              "screenshot" => CaptureScreenshot(),
              // coordinate is optional on click members; without it, click where the cursor is
              "left_click" when input.TryGetValue("coordinate", out var xy) => ClickAt(
                  xy[0].GetInt32(),
                  xy[1].GetInt32()
              ),
              "left_click" => ClickAtCursor(),
              "type" => TypeText(input["text"].GetString()!),
              // Handle other actions as needed
              _ => throw new NotSupportedException($"Unknown or unimplemented member: {action}"),
          };
      ```

      ```go Go
      // placeholderPNG stands in for a real capture: an executor returns the
      // screen as base64-encoded PNG data.
      const placeholderPNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="

      // captureScreenshot returns an image block rather than text.
      func captureScreenshot() []anthropic.ToolResultBlockParamContentUnion {
      	return []anthropic.ToolResultBlockParamContentUnion{{
      		OfImage: &anthropic.ImageBlockParam{
      			Source: anthropic.ImageBlockParamSourceUnion{
      				OfBase64: &anthropic.Base64ImageSourceParam{
      					MediaType: anthropic.Base64ImageSourceMediaTypeImagePNG,
      					Data:      placeholderPNG,
      				},
      			},
      		},
      	}}
      }

      // textContent wraps text as tool_result content.
      func textContent(text string) []anthropic.ToolResultBlockParamContentUnion {
      	return []anthropic.ToolResultBlockParamContentUnion{
      		{OfText: &anthropic.TextBlockParam{Text: text}},
      	}
      }

      func clickAt(x, y int) string {
      	return fmt.Sprintf("clicked at (%d, %d)", x, y)
      }

      func clickAtCursor() string {
      	return "clicked at the current cursor position"
      }

      func typeText(text string) string {
      	return fmt.Sprintf("typed: %s", text)
      }

      func handleComputerAction(action string, params map[string]any) ([]anthropic.ToolResultBlockParamContentUnion, error) {
      	switch action {
      	case "screenshot":
      		return captureScreenshot(), nil
      	case "left_click":
      		// coordinate is optional; without it, click where the cursor already is
      		coord, ok := params["coordinate"].([]any)
      		if !ok {
      			return textContent(clickAtCursor()), nil
      		}
      		if len(coord) == 2 {
      			x, xok := coord[0].(float64)
      			y, yok := coord[1].(float64)
      			if xok && yok {
      				return textContent(clickAt(int(x), int(y))), nil
      			}
      		}
      	case "type":
      		if text, ok := params["text"].(string); ok {
      			return textContent(typeText(text)), nil
      		}
      	// Handle other actions as needed
      	default:
      		return nil, fmt.Errorf("unknown or unimplemented member: %s", action)
      	}
      	// Reached when a member's input is missing a field or a field has the wrong type
      	return nil, fmt.Errorf("invalid input for %s", action)
      }
      ```

      ```java Java
      /** Placeholder pixels; a real executor captures the screen and base64-encodes the PNG. */
      static final String PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";

      ToolResultBlockParam.Content captureScreenshot() {
          ImageBlockParam image = ImageBlockParam.builder()
              .source(Base64ImageSource.builder()
                  .mediaType(Base64ImageSource.MediaType.IMAGE_PNG)
                  .data(PLACEHOLDER_PNG)
                  .build())
              .build();
          return ToolResultBlockParam.Content.ofBlocks(
              List.of(ToolResultBlockParam.Content.Block.ofImage(image)));
      }

      String clickAt(long x, long y) {
          return "clicked at (" + x + ", " + y + ")";
      }

      String clickAtCursor() {
          return "clicked at current cursor";
      }

      String typeText(String text) {
          return "typed: " + text;
      }

      /** Runs one computer toolset member; {@code action} is the tool_use block's name. */
      ToolResultBlockParam.Content handleComputerAction(String action, Map<String, JsonValue> input) {
          if (action.equals("screenshot")) {
              return captureScreenshot(); // the one member here that answers with an image block
          }
          String output = switch (action) {
              case "left_click" -> {
                  JsonValue coordinate = input.get("coordinate"); // optional on the toolset
                  if (coordinate == null) {
                      yield clickAtCursor();
                  }
                  List<JsonValue> point = (List<JsonValue>) coordinate.asArray().get();
                  long x = ((Number) point.get(0).asNumber().get()).longValue();
                  long y = ((Number) point.get(1).asNumber().get()).longValue();
                  yield clickAt(x, y);
              }
              case "type" -> typeText(input.get("text").asStringOrThrow());
              // Handle other actions as needed
              default -> throw new UnsupportedOperationException("Unknown or unimplemented member: " + action);
          };
          return ToolResultBlockParam.Content.ofString(output);
      }
      ```

      ```php PHP
      // Stand-in for real PNG bytes; a real executor captures the screen
      const PLACEHOLDER_PNG = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==';

      function captureScreenshot(): array
      {
          // screenshot answers with an image block rather than text, so return the result content list
          $image = [
              'type' => 'image',
              'source' => ['type' => 'base64', 'media_type' => 'image/png', 'data' => PLACEHOLDER_PNG],
          ];

          return [$image];
      }

      function clickAt(?array $coordinate): string
      {
          // left_click may omit coordinate, in which case the click lands where the cursor already is
          if ($coordinate === null) {
              return 'clicked at current cursor';
          }
          [$x, $y] = $coordinate;

          return "clicked at ({$x}, {$y})";
      }

      function typeText(string $text): string
      {
          return "typed: {$text}";
      }

      function handleComputerAction(string $name, array $input): string|array
      {
          return match ($name) {
              'screenshot' => captureScreenshot(),
              'left_click' => clickAt($input['coordinate'] ?? null),
              'type' => typeText($input['text']),
              // Handle other actions as needed
              default => throw new \RuntimeException("Unknown or unimplemented member: {$name}"),
          };
      }
      ```

      ```ruby Ruby
      # Stand-in image data; a real executor captures the screen as a PNG.
      PLACEHOLDER_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="

      # screenshot answers with an image block rather than text
      def capture_screenshot
        [
          {
            type: "image",
            source: { type: "base64", media_type: "image/png", data: PLACEHOLDER_PNG }
          }
        ]
      end

      def click(coordinate = nil)
        return "clicked at current cursor" if coordinate.nil?

        x, y = coordinate
        "clicked at (#{x}, #{y})"
      end

      def type_text(text)
        "typed: #{text}"
      end

      def handle_computer_action(name, input)
        case name
        when "screenshot"
          capture_screenshot
        when "left_click"
          # coordinate is optional; without it, click where the cursor already is
          click(input[:coordinate])
        when "type"
          type_text(input[:text])
        # Handle other actions as needed
        else
          raise ArgumentError, "Unknown or unimplemented member: #{name}"
        end
      end
      ```
    </CodeGroup>
  </Step>

  <Step title="Verarbeite Claudes Tool-Aufrufe">
    Extrahiere Tool-Aufrufe aus Claudes Antworten und führe sie aus:

    <CodeGroup exclude="shell">
      ```python Python
      NOT_EXECUTED = "Not executed: an earlier computer action in this turn failed."


      def process_tool_calls(response: Message) -> list[ToolResultBlockParam]:
          """
          Run the computer actions in Claude's response in order and answer each
          one. After the first failure the rest are skipped, because Claude planned
          them assuming the earlier actions succeeded.
          """
          tool_results: list[ToolResultBlockParam] = []
          failed = False
          for block in response.content:
              # Only the computer toolset is declared; route other tools here if you add them
              if block.type != "tool_use" or block.toolset_name != "computer":
                  continue
              result: ToolResultBlockParam = {
                  "type": "tool_result",
                  "tool_use_id": block.id,
                  "toolset_name": "computer",
              }
              if failed:
                  result["content"] = NOT_EXECUTED
                  result["is_error"] = True
              else:
                  try:
                      # A string, or a list of content blocks such as the screenshot image
                      result["content"] = handle_computer_action(block.name, block.input)
                  except Exception as err:
                      result["content"] = f"Error: {err}"
                      result["is_error"] = True
                      failed = True
              tool_results.append(result)
          return tool_results
      ```

      ```typescript TypeScript
      const HALT_TEXT = "Not executed: an earlier computer action in this turn failed.";

      function computerResult(
        toolUseId: string,
        content: string | Anthropic.ImageBlockParam[],
        isError?: boolean
      ): Anthropic.ToolResultBlockParam {
        return {
          type: "tool_result",
          tool_use_id: toolUseId,
          toolset_name: "computer",
          content,
          is_error: isError
        };
      }

      function processToolCalls(response: Anthropic.Message): Anthropic.ToolResultBlockParam[] {
        const toolResults: Anthropic.ToolResultBlockParam[] = [];
        let failed = false;
        for (const block of response.content) {
          if (block.type !== "tool_use") {
            continue;
          }
          if (block.toolset_name !== "computer") {
            // This example declares only the computer toolset; route other tools
            // here if you add them.
            continue;
          }
          if (failed) {
            // A batch stops at its first failure; answer later actions without running them
            toolResults.push(computerResult(block.id, HALT_TEXT, true));
            continue;
          }
          try {
            // A string, or the image block list that screenshot returns
            const result = handleComputerAction(block.name, block.input);
            toolResults.push(computerResult(block.id, result));
          } catch (error) {
            failed = true;
            const message = error instanceof Error ? error.message : String(error);
            toolResults.push(computerResult(block.id, `Error: ${message}`, true));
          }
        }
        return toolResults;
      }
      ```

      ```csharp C#
      const string HaltText = "Not executed: an earlier computer action in this turn failed.";

      List<ContentBlockParam> ProcessToolCalls(Message response)
      {
          List<ContentBlockParam> toolResults = [];
          var failed = false;
          foreach (var block in response.Content)
          {
              if (!block.TryPickToolUse(out var toolUse))
              {
                  continue;
              }

              if (toolUse.ToolsetName != "computer")
              {
                  // This example declares only the computer toolset; route other tools
                  // here if you add them.
                  continue;
              }

              if (failed)
              {
                  // A batch stops at its first failure; answer later actions without running them
                  toolResults.Add(
                      new ToolResultBlockParam(toolUse.ID)
                      {
                          Content = HaltText,
                          IsError = true,
                          ToolsetName = "computer",
                      }
                  );
                  continue;
              }

              try
              {
                  // A string, or the image block list that screenshot returns
                  var result = HandleComputerAction(toolUse.Name, toolUse.Input);
                  toolResults.Add(
                      new ToolResultBlockParam(toolUse.ID) { Content = result, ToolsetName = "computer" }
                  );
              }
              catch (Exception e)
              {
                  failed = true;
                  toolResults.Add(
                      new ToolResultBlockParam(toolUse.ID)
                      {
                          Content = $"Error: {e.Message}",
                          IsError = true,
                          ToolsetName = "computer",
                      }
                  );
              }
          }
          return toolResults;
      }
      ```

      ```go Go
      const notExecuted = "Not executed: an earlier computer action in this turn failed."

      // computerToolResult builds the result for one computer action. Unlike an
      // ordinary tool result, it must echo the toolset name.
      func computerToolResult(toolUseID string, content []anthropic.ToolResultBlockParamContentUnion, isError bool) anthropic.ContentBlockParamUnion {
      	result := anthropic.ToolResultBlockParam{
      		ToolUseID:   toolUseID,
      		ToolsetName: anthropic.String("computer"),
      		Content:     content,
      	}
      	if isError {
      		result.IsError = anthropic.Bool(true)
      	}
      	return anthropic.ContentBlockParamUnion{OfToolResult: &result}
      }

      // processToolCalls runs the computer actions in Claude's response in order and
      // builds one tool_result for each tool_use block. After the first failure it skips
      // the rest: Claude planned them assuming the earlier actions succeeded.
      func processToolCalls(response *anthropic.Message) []anthropic.ContentBlockParamUnion {
      	var toolResults []anthropic.ContentBlockParamUnion
      	failed := false
      	for _, block := range response.Content {
      		switch variant := block.AsAny().(type) {
      		case anthropic.ToolUseBlock:
      			// This example declares only the computer toolset; route other tools here if you add them.
      			if variant.ToolsetName != "computer" {
      				continue
      			}
      			if failed {
      				toolResults = append(toolResults, computerToolResult(variant.ID, textContent(notExecuted), true))
      				continue
      			}
      			var input map[string]any
      			var content []anthropic.ToolResultBlockParamContentUnion
      			err := json.Unmarshal(variant.Input, &input)
      			if err == nil {
      				// Text, or the image block that screenshot returns
      				content, err = handleComputerAction(variant.Name, input)
      			}
      			if err != nil {
      				failed = true
      				content = textContent("Error: " + err.Error())
      			}
      			toolResults = append(toolResults, computerToolResult(variant.ID, content, err != nil))
      		}
      	}
      	return toolResults
      }
      ```

      ```java Java
      /** The exact text the toolset contract prescribes for member calls skipped after a failure. */
      static final String HALT_TEXT = "Not executed: an earlier computer action in this turn failed.";

      /** Every result answering a computer toolset member echoes toolset_name. */
      ToolResultBlockParam.Builder computerResult(ToolUseBlock toolUse) {
          return ToolResultBlockParam.builder()
              .toolUseId(toolUse.id())
              .toolsetName("computer");
      }

      /**
       * Run the computer actions in Claude's response in order and build one
       * tool_result for each tool_use block. After the first failure, skip the rest:
       * Claude planned them assuming the earlier actions succeeded.
       */
      List<ContentBlockParam> processToolCalls(Message response) {
          List<ContentBlockParam> toolResults = new ArrayList<>();
          boolean failed = false;
          for (ContentBlock block : response.content()) {
              // This example declares only the computer toolset; route other tools here if you add them.
              if (!block.isToolUse() || !block.asToolUse().toolsetName().equals(Optional.of("computer"))) {
                  continue;
              }
              ToolUseBlock toolUse = block.asToolUse();
              ToolResultBlockParam result;
              if (failed) {
                  result = computerResult(toolUse)
                      .content(HALT_TEXT)
                      .isError(true)
                      .build();
              } else {
                  try {
                      Map<String, JsonValue> input =
                          (Map<String, JsonValue>) toolUse._input().asObject().get();
                      // A string, or the image block that screenshot returns
                      ToolResultBlockParam.Content output = handleComputerAction(toolUse.name(), input);
                      result = computerResult(toolUse)
                          .content(output)
                          .build();
                  } catch (RuntimeException e) {
                      failed = true;
                      result = computerResult(toolUse)
                          .content("Error: " + e.getMessage())
                          .isError(true)
                          .build();
                  }
              }
              toolResults.add(ContentBlockParam.ofToolResult(result));
          }
          return toolResults;
      }
      ```

      ```php PHP
      const HALT_TEXT = 'Not executed: an earlier computer action in this turn failed.';

      function processToolCalls(Message $response): array
      {
          $toolResults = [];
          $failed = false;
          foreach ($response->content as $block) {
              // This example declares only the computer toolset; route other tools here if you add them.
              if (!($block instanceof \Anthropic\Messages\ToolUseBlock) || $block->toolsetName !== 'computer') {
                  continue;
              }
              $result = ['type' => 'tool_result', 'tool_use_id' => $block->id, 'toolset_name' => 'computer'];
              if ($failed) {
                  // A batch stops at its first failure; the remaining actions are answered without running
                  $toolResults[] = [...$result, 'content' => HALT_TEXT, 'is_error' => true];
                  continue;
              }
              try {
                  // A string, or the image block list that screenshot returns
                  $toolResults[] = [...$result, 'content' => handleComputerAction($block->name, $block->input)];
              } catch (\Throwable $e) {
                  $failed = true;
                  $toolResults[] = [...$result, 'content' => 'Error: ' . $e->getMessage(), 'is_error' => true];
              }
          }

          return $toolResults;
      }
      ```

      ```ruby Ruby
      NOT_EXECUTED = "Not executed: an earlier computer action in this turn failed."

      # Run the computer actions in Claude's response in order and build one
      # tool_result for each tool_use block. After the first failure, skip the rest:
      # Claude planned them assuming the earlier actions succeeded.
      def process_tool_calls(response)
        tool_results = []
        failed = false
        response.content.each do |block|
          # This example declares only the computer toolset; route other tools here
          # if you add them.
          next unless block.is_a?(Anthropic::Models::ToolUseBlock) && block.toolset_name == "computer"

          result = { type: "tool_result", tool_use_id: block.id, toolset_name: "computer" }
          if failed
            result.update(content: NOT_EXECUTED, is_error: true)
          else
            begin
              # A String, or the image content blocks that screenshot returns
              result[:content] = handle_computer_action(block.name, block.input)
            rescue => e
              result.update(content: "Error: #{e.message}", is_error: true)
              failed = true
            end
          end
          tool_results << result
        end
        tool_results
      end
      ```
    </CodeGroup>
  </Step>

  <Step title="Implementiere die Agenten-Schleife">
    Verpacke die beiden vorherigen Schritte in eine Schleife, die die Ergebnisse zurücksendet und sich wiederholt, bis Claude keine Member-Tool-Aufrufe mehr zurückgibt; [Die Agenten-Schleife verstehen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#understanding-the-agentic-loop) zeigt diese Schleife.
  </Step>
</Steps>

### Fehler behandeln

Melde eine fehlgeschlagene Aktion an Claude als `tool_result` mit `is_error: true` und einer kurzen Beschreibung, und füge wie bei jedem anderen Member-Ergebnis `"toolset_name": "computer"` hinzu. Wenn die fehlgeschlagene Aktion Teil einer [Batch-Aktion](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#batch-actions) war, beantworte die verbleibenden Blöcke im Batch mit dem dort gezeigten Abbruchtext, statt sie auszuführen.

Zum Beispiel, wenn die Screenshot-Erfassung fehlschlägt:

```json
{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "toolset_name": "computer",
      "content": "Error: Failed to capture screenshot. Display may be locked or unavailable.",
      "is_error": true
    }
  ]
}
```

Verwende dieselbe Struktur für Koordinaten außerhalb der Display-Grenzen und für Aktionen, die nicht ausgeführt werden können, mit einer Meldung, die beschreibt, was schiefgelaufen ist.

### Screenshots an die Bildlimits anpassen

Screenshots und Zoom-Bilder, die du an das Computer-Use-Toolset zurückgibst, müssen bereits in die [Bildgrößenlimits](https://platform.claude.com/docs/de/build-with-claude/vision#evaluate-image-size) deines Modells passen: Das Toolset nimmt keine Anzeigeabmessungen entgegen und die API skaliert nicht für dich herunter, daher wird ein zu großes `tool_result`-Bild mit einem Validierungsfehler abgelehnt. Da Claude Koordinaten im Pixelraum des Bildes zurückgibt, das es erhält, solltest du den verwendeten Skalierungsfaktor aufbewahren, damit du diese Koordinaten zurück auf deinen Bildschirm abbilden kannst.

<Note>
  Die Limits variieren je nach Modell. Claude Opus 4.7 und neuere Modelle, einschließlich aller Modelle, die `computer_toolset_20260801` unterstützen, akzeptieren bis zu 2.576 Pixel an der langen Kante und insgesamt 4.784 visuelle Token (`⌈width / 28⌉ × ⌈height / 28⌉`, ungefähr 3,75 Megapixel). Frühere Modelle akzeptieren bis zu 1.568 Pixel an der langen Kante und insgesamt ungefähr 1,15 Megapixel. Siehe [Auflösung und Token-Kosten](https://platform.claude.com/docs/de/build-with-claude/vision#evaluate-image-size) für die Stufe jedes Modells. Das folgende Beispiel verwendet die Limits früherer Modelle von 1.568 px / 1,15 MP. Für ein Modell der Hochauflösungsstufe skalierst du auf das Limit für visuelle Token statt auf eine Pixelgesamtzahl, zum Beispiel mit dem Resize-Helper aus [Bild vor dem Hochladen skalieren](https://platform.claude.com/docs/de/build-with-claude/vision-coordinates#resize-your-image-before-uploading).
</Note>

Wenn dein Bildschirm größer als das Limit ist, skaliere jeden Screenshot, bevor du ihn zurückgibst, und rechne die von Claude zurückgegebenen Koordinaten wieder in den ursprünglichen Bildschirmraum um. Da das Toolset keine Anzeigeabmessungen entgegennimmt, brauchst du nur die Skalierung und die Koordinatenumrechnung in deinem Anwendungscode:

<CodeGroup exclude="shell">
  ```python Python
  import math

  screen_width, screen_height = 1512, 982


  def get_scale_factor(width, height):
      """Calculate scale factor to meet API constraints."""
      long_edge = max(width, height)
      total_pixels = width * height

      long_edge_scale = 1568 / long_edge
      total_pixels_scale = math.sqrt(1_150_000 / total_pixels)

      return min(1.0, long_edge_scale, total_pixels_scale)


  # Beim Erstellen eines Screenshots
  scale = get_scale_factor(screen_width, screen_height)
  scaled_width = int(screen_width * scale)
  scaled_height = int(screen_height * scale)

  # Skaliere das Bild auf die skalierten Abmessungen, bevor du es an Claude sendest
  screenshot = capture_and_resize(scaled_width, scaled_height)


  # Skaliere die Koordinaten von Claude bei der Verarbeitung wieder hoch
  def execute_click(x, y):
      screen_x = x / scale
      screen_y = y / scale
      perform_click(screen_x, screen_y)
  ```

  ```typescript TypeScript
  const screenWidth = 1512;
  const screenHeight = 982;
  const MAX_LONG_EDGE = 1568;
  const MAX_PIXELS = 1_150_000;

  function getScaleFactor(width: number, height: number): number {
    const longEdge = Math.max(width, height);
    const totalPixels = width * height;

    const longEdgeScale = MAX_LONG_EDGE / longEdge;
    const totalPixelsScale = Math.sqrt(MAX_PIXELS / totalPixels);

    return Math.min(1.0, longEdgeScale, totalPixelsScale);
  }

  // Beim Erstellen eines Screenshots
  const scale = getScaleFactor(screenWidth, screenHeight);
  const scaledWidth = Math.floor(screenWidth * scale);
  const scaledHeight = Math.floor(screenHeight * scale);

  // Skaliere das Bild auf die skalierten Abmessungen, bevor du es an Claude sendest
  const screenshot = captureAndResize(scaledWidth, scaledHeight);

  // Skaliere die Koordinaten von Claude bei der Verarbeitung wieder hoch
  function executeClick(x: number, y: number): void {
    const screenX = x / scale;
    const screenY = y / scale;
    performClick(screenX, screenY);
  }
  ```

  ```csharp C#
  int screenWidth = 1512, screenHeight = 982;

  double GetScaleFactor(int width, int height)
  {
      // Berechne den Skalierungsfaktor, um die API-Vorgaben einzuhalten.
      int longEdge = Math.Max(width, height);
      int totalPixels = width * height;

      double longEdgeScale = 1568.0 / longEdge;
      double totalPixelsScale = Math.Sqrt(1_150_000.0 / totalPixels);

      return Math.Min(1.0, Math.Min(longEdgeScale, totalPixelsScale));
  }

  // Beim Erstellen des Screenshots
  double scale = GetScaleFactor(screenWidth, screenHeight);
  int scaledWidth = (int)(screenWidth * scale);
  int scaledHeight = (int)(screenHeight * scale);

  // Skaliere das Bild auf die berechneten Maße, bevor du es an Claude sendest
  var screenshot = CaptureAndResize(scaledWidth, scaledHeight);

  // Skaliere die Koordinaten von Claude beim Verarbeiten wieder hoch
  void ExecuteClick(int x, int y)
  {
      double screenX = x / scale;
      double screenY = y / scale;
      PerformClick(screenX, screenY);
  }
  ```

  ```go Go
  func getScaleFactor(width, height int) float64 {
  	longest := float64(max(width, height))
  	area := float64(width * height)
  	return min(1.0, 1568/longest, math.Sqrt(1_150_000/area))
  }

  // ...
  	screenWidth, screenHeight := 1512, 982

  	// Beim Aufnehmen eines Screenshots
  	scale := getScaleFactor(screenWidth, screenHeight)
  	scaledWidth := int(float64(screenWidth) * scale)
  	scaledHeight := int(float64(screenHeight) * scale)

  	// Skaliere das Bild vor dem Senden an Claude auf die skalierten Abmessungen
  	screenshot := captureAndResize(scaledWidth, scaledHeight)

  	// Skaliere Claudes Koordinaten bei der Verarbeitung wieder hoch
  	executeClick := func(x, y int) {
  		performClick(float64(x)/scale, float64(y)/scale)
  	}
  ```

  ```java Java
  static double getScaleFactor(int width, int height) {
      return Math.min(
          1.0,
          Math.min(
              1568.0 / Math.max(width, height),
              Math.sqrt(1_150_000.0 / (width * height))
          )
      );
  }

  void main() {
      int screenWidth = 1512, screenHeight = 982;

      // Beim Erstellen eines Screenshots
      double scale = getScaleFactor(screenWidth, screenHeight);
      int scaledWidth = (int)(screenWidth * scale);
      int scaledHeight = (int)(screenHeight * scale);

      // Skaliere das Bild auf die skalierten Abmessungen, bevor du es an Claude sendest
      var screenshot = captureAndResize(scaledWidth, scaledHeight);

      // Skaliere Claudes Koordinaten bei der Verarbeitung wieder hoch
      BiConsumer<Integer, Integer> executeClick =
          (x, y) -> performClick(x / scale, y / scale);
      // ...
  }
  ```

  ```php PHP
  function getScaleFactor(int $width, int $height): float
  {
      return min(
          1.0,
          1568 / max($width, $height),
          sqrt(1_150_000 / ($width * $height)),
      );
  }

  $screenWidth = 1512;
  $screenHeight = 982;

  // Beim Aufnehmen eines Screenshots
  $scale = getScaleFactor($screenWidth, $screenHeight);
  $scaledWidth = (int)($screenWidth * $scale);
  $scaledHeight = (int)($screenHeight * $scale);

  // Skaliere das Bild auf die skalierten Abmessungen, bevor du es an Claude sendest
  $screenshot = captureAndResize($scaledWidth, $scaledHeight);

  // Beim Verarbeiten von Claudes Koordinaten skaliere sie wieder hoch
  $executeClick = fn(int $x, int $y) => performClick($x / $scale, $y / $scale);
  ```

  ```ruby Ruby
  def get_scale_factor(width, height)
    [1.0, 1568.0 / [width, height].max, Math.sqrt(1_150_000.0 / (width * height))].min
  end

  screen_width, screen_height = 1512, 982

  # Beim Aufnehmen eines Screenshots
  scale = get_scale_factor(screen_width, screen_height)
  scaled_width = (screen_width * scale).to_i
  scaled_height = (screen_height * scale).to_i

  # Verkleinere das Bild vor dem Senden an Claude auf die skalierten Abmessungen
  screenshot = capture_and_resize(scaled_width, scaled_height)

  # Beim Verarbeiten von Claudes Koordinaten skaliere sie wieder hoch
  execute_click = ->(x, y) { perform_click(x / scale, y / scale) }
  ```
</CodeGroup>

<Note>
  **macOS-Retina-Displays** erfassen Screenshots mit einem „device pixel ratio“ (Gerätepixelverhältnis) von 2, sodass das Bild die doppelte Auflösung der logischen Bildschirmkoordinaten hat. Skaliere den Screenshot entweder vor dem Senden um den Faktor 2 herunter, oder halbiere die von Claude zurückgegebenen Koordinaten, bevor du den Klick ausführst.
</Note>

Wenn du eine Anzeigeauflösung wählst und Screenshots zurückgibst:

* Verwende für allgemeine Desktop-Aufgaben 1024x768 oder 1280x720; für Webanwendungen 1280x800 oder 1366x768.
* Vermeide Auflösungen über 1920x1080, um Performance-Probleme zu verhindern.
* Kodiere Screenshots als base64-PNG oder -JPEG und erwäge, große Screenshots zu komprimieren, um die Performance zu verbessern.
* Füge relevante Metadaten wie Zeitstempel oder Anzeigezustand hinzu.
* Wenn du höhere Auflösungen verwendest, stelle sicher, dass die Koordinaten korrekt skaliert werden.

### Screenshot-Verlauf verwalten

Lange Agent-Schleifen sammeln schnell Screenshots an (jeweils ungefähr 1.000–1.800 Eingabe-Token). Die [Anfragelimits](https://platform.claude.com/docs/de/build-with-claude/vision#request-limits) der API gelten ebenfalls.

Sobald eine einzelne Anfrage mehr als 20 Bilder enthält, gilt für jedes Bild darin ein strengeres Limit pro Seite. Eine Schleife, die ihren Screenshot-Verlauf behält, kann diese Anzahl erreichen. Skaliere entweder jeden Screenshot so, dass er unter diesem Limit bleibt, oder entferne ältere Screenshots, um höchstens 20 in der Anfrage zu behalten.

Um [Prompt-Caching](https://platform.claude.com/docs/de/build-with-claude/prompt-caching) wirksam zu halten und gleichzeitig den Kontext zu begrenzen:

* Setze einen `cache_control`-Breakpoint nach dem System-Prompt und den Tool-Definitionen und bis zu drei weitere auf den letzten `tool_result`-Block jedes der jüngsten Turns, und verschiebe sie mit jedem Turn weiter. Innerhalb einer [Batch-Aktion](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#batch-actions) wirken Markierungen auf mehreren Blöcken als ein einziger Breakpoint, aber jede zählt dennoch zum Limit von vier, verwende also höchstens eine pro Turn.

* Entferne alte Screenshots in *Batches*, nicht einen pro Turn. Wenn du jeden Turn einen Screenshot weglässt, ändert sich das Präfix jeden Turn und der Cache wird ungültig. Ein sinnvoller Standard ist, die letzten drei Screenshots zu behalten und alle 25 Turns zu bereinigen, sodass das Präfix zwischen den Bereinigungen byte-identisch bleibt; wenn deine Screenshots das strengere Limit überschreiten, wähle ein Intervall, das jede Anfrage bei höchstens 20 Bildern hält.

* Vermeide bei Claude Fable 5.2, Claude Mythos 5.2, Claude Fable 5.1 und Claude Mythos 5.1 das Bereinigen auf dem Client. Dasselbe gilt für Claude Opus 5.5, Claude Sonnet 5.5 und Claude Haiku 5.5. Auf diesen Modellen [macht das Entfernen eines früheren Screenshots aus einer Anfrage jeden späteren Thinking-Block ungültig, der bereits im Verlauf steht](https://platform.claude.com/docs/de/build-with-claude/thinking#preserved-in-conversation), und zwar im Verlauf dieser und jeder späteren Anfrage.

  * **Stattdessen:** Skaliere Screenshots so, dass sie unter dem strengeren Limit bleiben. [Tool-Result-Clearing](https://platform.claude.com/docs/de/build-with-claude/context-editing#tool-result-clearing) spart Token, aber gelöschte Screenshots zählen weiterhin zu den [Anfragelimits](https://platform.claude.com/docs/de/build-with-claude/vision#request-limits), verwende also [On-Demand-Komprimierung](https://platform.claude.com/docs/de/build-with-claude/compaction-on-demand), bevor eine Schleife sie erreicht.
  * **Wenn du bereinigen musst:** Lass [`prefix_mismatch_behavior: "drop_block"`](https://platform.claude.com/docs/de/build-with-claude/preserved-thinking/prefix-checks#preserved-thinking-controls) ab diesem Zeitpunkt gesetzt. Nach jeder Bereinigung lässt die API die ungültig gewordenen Thinking-Blöcke weg, sowohl bei dieser Anfrage als auch bei jeder späteren. Claude fährt also ohne das Nachdenken fort, das es nach dem entfernten Screenshot erzeugt hat.
  * **Wenn du bei Claude Sonnet 5.5 oder Claude Haiku 5.5 bereinigen musst:** `prefix_mismatch_behavior` funktioniert nur mit `thinking: {"type": "adaptive"}`. Bei jeder anderen Nachdenken-Einstellung auf diesen Modellen halte den Verlauf rein anhängend (append-only) oder entferne jeden `thinking`- und `redacted_thinking`-Block nach dem entfernten Screenshot.

### Klickprobleme diagnostizieren

Wenn Klicks ihr Ziel verfehlen, liegt die Ursache meist in einem der folgenden Punkte:

| Symptom                                                     | Wahrscheinliche Ursache                                                                                                                                      | Versuche                                                                                                                                                                                                                                                                                                                                                                   |
| ----------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Klicks sind durchgehend in eine Richtung versetzt           | Claudes Koordinaten, die sich im Pixelraum der von dir zurückgegebenen Screenshots befinden, werden ohne Skalierung auf ein Display anderer Größe angewendet | Skaliere jede Koordinate vor dem Klicken mit dem Verhältnis deiner Bildschirmgröße zu deiner Screenshot-Größe (siehe [Screenshots an die Bildlimits anpassen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#handle-coordinate-scaling-for-higher-resolutions)); berücksichtige auf macOS-Retina-Displays das Gerätepixelverhältnis von 2 |
| Klicks landen im richtigen Bereich, verfehlen aber das Ziel | Das Ziel ist sehr klein, Details gingen beim Herunterskalieren einer 4K+-Quelle verloren oder das Seitenverhältnis wurde verzerrt                            | Lass das `zoom`-Mitglied aktiviert und implementiere es, damit Claude den Bereich in voller Auflösung untersuchen kann; erfasse mit niedrigerem DPI oder schneide auf den relevanten Bereich zu; behalte beim Skalieren das Seitenverhältnis bei                                                                                                                           |
| Claude klickt auf ein völlig falsches Element               | Mehrdeutige Anweisung oder visuell ähnliche Elemente in der Nähe                                                                                             | Verwende positionsbezogene Prompts („der blaue Submit-Button unten rechts“); teile die Interaktion in kleinere Schritte auf                                                                                                                                                                                                                                                |
| Die Genauigkeit ist durchgehend schlecht                    | Auflösung zu niedrig                                                                                                                                         | Versuche 1280x720 als Ausgangswert                                                                                                                                                                                                                                                                                                                                         |

<Tip>
  **Die Modellwahl beeinflusst die Klickpräzision.** Unter den Modellen, die das `computer_20251124`-Tool verwenden, ist Claude Sonnet 4.6 beim Klicken mechanisch präziser als Claude Opus 4.6 und robuster, wenn Screenshots stark herunterskaliert werden müssen. Claude Opus 4.7 verringert diesen Abstand: Seine Klickpräzision ist ungefähr mit Sonnet 4.6 vergleichbar, und sein höheres Auflösungslimit bedeutet, dass weniger Herunterskalierung nötig ist.
</Tip>

### Best Practices für die Implementierung befolgen

<AccordionGroup>
  <Accordion title="Verzögerungen zwischen Aktionen einfügen">
    Manche Anwendungen brauchen Zeit, um auf Aktionen zu reagieren:

    <CodeGroup exclude="shell">
      ```python Python
      def click_and_wait(x, y, wait_time=0.5):
          click_at(x, y)
          time.sleep(wait_time)  # Allow UI to update
      ```

      ```typescript TypeScript
      async function clickAndWait(x: number, y: number, waitMs = 500): Promise<void> {
        clickAt(x, y);
        await new Promise((resolve) => setTimeout(resolve, waitMs)); // Allow UI to update
      }
      ```

      ```csharp C#
      static void ClickAndWait(int x, int y, double waitSeconds = 0.5)
      {
          ClickAt(x, y);
          Thread.Sleep(TimeSpan.FromSeconds(waitSeconds));  // Allow UI to update
      }
      ```

      ```go Go
      func clickAndWaitFor(x, y int, wait time.Duration) {
      	clickAt(x, y)
      	time.Sleep(wait) // Allow UI to update
      }

      func clickAndWait(x, y int) {
      	clickAndWaitFor(x, y, 500*time.Millisecond)
      }
      ```

      ```java Java
      void clickAndWait(int x, int y) throws InterruptedException {
          clickAndWait(x, y, 500);
      }

      void clickAndWait(int x, int y, long waitTimeMillis) throws InterruptedException {
          clickAt(x, y);
          Thread.sleep(waitTimeMillis);  // Allow UI to update
      }
      ```

      ```php PHP
      function clickAndWait(int $x, int $y, float $waitSeconds = 0.5): void
      {
          clickAt($x, $y);
          usleep((int) ($waitSeconds * 1_000_000));  // Allow UI to update
      }
      ```

      ```ruby Ruby
      def click_and_wait(x, y, wait_time: 0.5)
        click_at(x, y)
        sleep(wait_time) # Allow UI to update
      end
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Aktionen vor dem Ausführen validieren">
    Prüfe, ob angeforderte Aktionen sicher und gültig sind:

    <CodeGroup exclude="shell">
      ```python Python
      display_width, display_height = 1024, 768


      def validate_action(action_type, params):
          if action_type == "left_click" and "coordinate" in params:
              x, y = params["coordinate"]
              if not (0 <= x < display_width and 0 <= y < display_height):
                  return False, "Coordinates out of bounds"
          return True, None
      ```

      ```typescript TypeScript
      const displayWidth = 1024;
      const displayHeight = 768;

      interface ActionParams {
        coordinate?: [number, number];
      }

      function validateAction(actionType: string, params: ActionParams): [boolean, string | null] {
        if (actionType === "left_click" && params.coordinate) {
          const [x, y] = params.coordinate;
          if (!(x >= 0 && x < displayWidth && y >= 0 && y < displayHeight)) {
            return [false, "Coordinates out of bounds"];
          }
        }
        return [true, null];
      }
      ```

      ```csharp C#
      const int DisplayWidth = 1024;
      const int DisplayHeight = 768;
      // ...
      static (bool IsValid, string? Error) ValidateAction(string actionType, IReadOnlyDictionary<string, JsonElement> parameters)
      {
          if (actionType == "left_click" && parameters.TryGetValue("coordinate", out JsonElement coordinate))
          {
              int x = coordinate[0].GetInt32();
              int y = coordinate[1].GetInt32();
              if (x is < 0 or >= DisplayWidth || y is < 0 or >= DisplayHeight)
              {
                  return (false, "Coordinates out of bounds");
              }
          }
          return (true, null);
      }
      ```

      ```go Go
      const (
      	displayWidth  = 1024
      	displayHeight = 768
      )

      func validateAction(actionType string, params map[string]any) (bool, string) {
      	raw, hasCoordinate := params["coordinate"]
      	if actionType == "left_click" && hasCoordinate {
      		coord, ok := raw.([]any)
      		if !ok || len(coord) != 2 {
      			return false, "Invalid coordinate"
      		}
      		x, y := int(coord[0].(float64)), int(coord[1].(float64))
      		if !(0 <= x && x < displayWidth && 0 <= y && y < displayHeight) {
      			return false, "Coordinates out of bounds"
      		}
      	}
      	return true, ""
      }
      ```

      ```java Java
      static final int DISPLAY_WIDTH = 1024;
      static final int DISPLAY_HEIGHT = 768;

      record Validation(boolean valid, String error) {}

      Validation validateAction(String actionType, Map<String, JsonValue> params) {
          if (actionType.equals("left_click") && params.containsKey("coordinate")) {
              List<JsonValue> coord = (List<JsonValue>) params.get("coordinate").asArray().get();
              long x = ((Number) coord.get(0).asNumber().get()).longValue();
              long y = ((Number) coord.get(1).asNumber().get()).longValue();
              if (!(0 <= x && x < DISPLAY_WIDTH && 0 <= y && y < DISPLAY_HEIGHT)) {
                  return new Validation(false, "Coordinates out of bounds");
              }
          }
          return new Validation(true, null);
      }
      ```

      ```php PHP
      const DISPLAY_WIDTH = 1024;
      const DISPLAY_HEIGHT = 768;

      /** @return array{bool, ?string} */
      function validateAction(string $actionType, array $params): array
      {
          if ($actionType === 'left_click' && isset($params['coordinate'])) {
              [$x, $y] = $params['coordinate'];
              if (!(0 <= $x && $x < DISPLAY_WIDTH && 0 <= $y && $y < DISPLAY_HEIGHT)) {
                  return [false, 'Coordinates out of bounds'];
              }
          }
          return [true, null];
      }
      ```

      ```ruby Ruby
      DISPLAY_WIDTH = 1024
      DISPLAY_HEIGHT = 768

      def validate_action(action_type, params)
        if action_type == "left_click" && params.key?(:coordinate)
          x, y = params[:coordinate]
          unless (0...DISPLAY_WIDTH).cover?(x) && (0...DISPLAY_HEIGHT).cover?(y)
            return [false, "Coordinates out of bounds"]
          end
        end
        [true, nil]
      end
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Aktionen zum Debuggen protokollieren">
    Führe ein Protokoll aller Aktionen zur Fehlerbehebung:

    <CodeGroup exclude="shell">
      ```python Python
      import logging


      def log_action(action_type, params, result):
          logging.info(f"Action: {action_type}, Params: {params}, Result: {result}")
      ```

      ```typescript TypeScript
      function logAction(actionType: string, params: unknown, result: unknown): void {
        console.error(
          `Action: ${actionType}, Params: ${JSON.stringify(params)}, Result: ${JSON.stringify(
            result
          )}`
        );
      }
      ```

      ```csharp C#
      static void LogAction(string actionType, object? parameters, object? result)
      {
          Console.Error.WriteLine($"Action: {actionType}, Params: {parameters}, Result: {result}");
      }
      ```

      ```go Go
      func logAction(actionType string, params map[string]any, result any) {
      	log.Printf("Action: %s, Params: %v, Result: %v", actionType, params, result)
      }
      ```

      ```java Java
      import static java.lang.System.Logger.Level.INFO;

      static final System.Logger LOGGER = System.getLogger("computer-use");

      void logAction(String actionType, Object params, Object result) {
          LOGGER.log(INFO, "Action: {0}, Params: {1}, Result: {2}", actionType, params, result);
      }
      ```

      ```php PHP
      function logAction(string $actionType, array $params, mixed $result): void
      {
          error_log(sprintf(
              'Action: %s, Params: %s, Result: %s',
              $actionType,
              json_encode($params),
              json_encode($result),
          ));
      }
      ```

      ```ruby Ruby
      require "logger"

      LOGGER = Logger.new($stderr)

      def log_action(action_type, params, result)
        LOGGER.info("Action: #{action_type}, Params: #{params}, Result: #{result}")
      end
      ```
    </CodeGroup>
  </Accordion>
</AccordionGroup>

***

## Migration von `computer_20251124`

Eine `computer_20251124`-Integration funktioniert ohne Änderungen mit den Modellen, die für diese Version unter [Frühere Tool-Versionen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions) aufgeführt sind. Aktualisiere die Integration, bevor du sie auf ein Modell umstellst, das `computer_20251124` nicht akzeptiert, etwa Claude Opus 5.5 in der Claude API.

Nimm für das Upgrade die folgenden Änderungen gemeinsam vor:

1. **Entferne den Beta-Header.** Entferne `anthropic-beta: computer-use-2025-11-24` aus deinen Anfragen. Entferne beim SDK `betas` (csharp, go: `Betas`; java: `.addBeta()`) und rufe die Messages API über den Standard-Client statt über den Beta-Namespace auf.
2. **Ändere den `tools`-Eintrag.** Setze `type` auf `computer_toolset_20260801` und lösche `name`, `display_width_px`, `display_height_px`, `display_number` und `enable_zoom`. Das Toolset lehnt jedes dieser Felder ab.
3. **Entscheide, ob Zoom aktiviert bleiben soll.** Zoom ist im Toolset standardmäßig aktiviert, während `enable_zoom` standardmäßig `false` ist. Wenn deine Umgebung Zoom nicht implementiert, füge `"configs": {"zoom": {"enabled": false}}` hinzu, um das bisherige Verhalten beizubehalten; andernfalls implementiere es (siehe [Verfügbare Aktionen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#available-actions)).
4. **Verarbeite jeden Block in einem Turn.** Aktualisiere deine Agent-Schleife so, dass sie über jeden `tool_use`-Block in einer Antwort iteriert, statt nur den ersten zu lesen, und anhand des `name` des Blocks zusammen mit `toolset_name` statt anhand von `input.action` verteilt. Member-Eingaben enthalten kein `action`-Feld mehr; die übrigen Felder sind unverändert.
5. **Führe Blöcke der Reihe nach aus und verwende den Abbruchtext.** Führe die Blöcke sequenziell aus, stoppe beim ersten Fehler und beantworte die übrigen Blöcke mit `Not executed: an earlier computer action in this turn failed.`, wie in [Batch-Aktionen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#batch-actions) beschrieben. Wenn deine Schleife noch keine Batches ausführen kann, erklärt [Tool-Parameter](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#tool-parameters), wie du Claude auf eine Aktion pro Turn beschränkst.
6. **Gib `toolset_name` in Ergebnissen zurück.** Füge `"toolset_name": "computer"` zu jedem `tool_result` hinzu, das einen Member-Aufruf beantwortet. Ergebnisse dürfen nur `text`- und `image`-Inhalte enthalten.
7. **Unterstütze `repeat` bei `key`.** Das `key`-Mitglied akzeptiert eine optionale `repeat`-Anzahl von 1 bis 100. Ein Handler, der unbekannte Felder ignoriert, würde die Taste nur einmal drücken, sorge also dafür, dass dein `key`-Handler `repeat` berücksichtigt.
8. **Skaliere Screenshots selbst.** Das Toolset lehnt einen Screenshot oder ein Zoom-Bild, das die Bildlimits des Modells überschreitet, ab, statt es herunterzuskalieren. Skaliere vor dem Zurückgeben des Bildes und rechne die Koordinaten weiterhin um, wie in [Screenshots an die Bildlimits anpassen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#handle-coordinate-scaling-for-higher-resolutions) beschrieben.
9. **Entferne nicht unterstützte Optionen.** Verschiebe ein etwaiges `defer_loading` aus dem Eintrag in `configs`, mit demselben Wert für jedes aktivierte Mitglied. Die anderen Optionen, die bei Toolset-Einträgen nicht unterstützt werden, sind unter [Client-Toolsets](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-reference#client-toolsets) aufgeführt.

Dies ist der `tools`-Eintrag vor der Änderung, gesendet mit dem Header `anthropic-beta: computer-use-2025-11-24`:

```json
{
  "type": "computer_20251124",
  "name": "computer",
  "display_width_px": 1024,
  "display_height_px": 768,
  "display_number": 1
}
```

Dies ist der `tools`-Eintrag nach der Änderung, gesendet ohne Beta-Header. Das `configs`-Objekt hält Zoom deaktiviert, passend zum früheren Eintrag, der `enable_zoom` nicht setzt; lass `configs` ganz weg, um den Standard zu übernehmen und Claude zoomen zu lassen:

```json
{
  "type": "computer_toolset_20260801",
  "configs": {
    "zoom": { "enabled": false }
  }
}
```

Das folgende Paar zeigt einen `tool_use`-Block vor und nach der Änderung. Der Aktionsname wandert von `input.action` nach `name`, und der Block erhält `toolset_name`:

```json
{
  "type": "tool_use",
  "id": "toolu_01A9r5kQm2LxWc7vT3nZ4bJs",
  "name": "computer",
  "input": { "action": "left_click", "coordinate": [500, 300] }
}
```

```json
{
  "type": "tool_use",
  "id": "toolu_01A9r5kQm2LxWc7vT3nZ4bJs",
  "name": "left_click",
  "toolset_name": "computer",
  "input": { "coordinate": [500, 300] }
}
```

## Frühere Tool-Versionen

Zwei frühere Versionen des Computer-Use-Tools sind als Beta verfügbar. Jede erfordert bei jeder Anfrage ihren [„beta header“ (Beta-Header)](https://platform.claude.com/docs/de/api/beta-headers), und ihre Parameter sind in der [Beta-Referenz der Messages API](https://platform.claude.com/docs/de/api/beta/messages/create) dokumentiert. Übergib den Header mit dem SDK über `betas` (csharp, go: `Betas`; java: `.addBeta()`) und verwende den Beta-Namespace; nur das Computer-Use-Tool benötigt den Header, nicht die Bash- oder Texteditor-Tools in derselben Anfrage.

| Tool-Version        | Beta-Header               | Verwenden mit                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Parameter                                                                    |
| ------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
| `computer_20251124` | `computer-use-2025-11-24` | Claude Fable 5.1, Claude Mythos 5.1, Claude Fable 5, Claude Mythos 5, Claude Opus 5, Claude Sonnet 5, Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 4.6 und Claude Opus 4.5                                                                                                                                                                                                                                                                                                                                                                                                                                                    | [API-Referenz](https://platform.claude.com/docs/de/api/beta/messages/create) |
| `computer_20250124` | `computer-use-2025-01-24` | Claude Sonnet 4.5 ([abgekündigt](https://platform.claude.com/docs/de/about-claude/model-deprecations)), Claude Haiku 4.5, Claude Opus 4.1 ([eingestellt, außer auf Claude Models on Google Cloud (Google managed) und Bedrock](https://platform.claude.com/docs/de/about-claude/model-deprecations)), Claude Sonnet 4 ([eingestellt, außer auf Claude Models on Google Cloud (Google managed) und Bedrock](https://platform.claude.com/docs/de/about-claude/model-deprecations)) und Claude Opus 4 ([eingestellt, außer auf Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/de/about-claude/model-deprecations)) | [API-Referenz](https://platform.claude.com/docs/de/api/beta/messages/create) |

Auf Amazon Bedrock akzeptieren Claude Fable 5.2, Claude Mythos 5.2, Claude Opus 5.5, Claude Sonnet 5.5 und Claude Haiku 5.5 außerdem das Tool `computer_20251124` mit dem Beta-Header `computer-use-2025-11-24`. Sende `computer-use-2025-11-24` bei der InvokeModel API von Amazon Bedrock im Array `anthropic_beta` des Anfragekörpers statt in einem Header. Zu dieser API siehe [Claude auf Amazon Bedrock (`bedrock-runtime`)](https://platform.claude.com/docs/de/build-with-claude/claude-on-amazon-bedrock-legacy).

***

## Einschränkungen

1. **Latency (Latenz):** Die Latenz von Computer Use bei Mensch-KI-Interaktionen kann im Vergleich zu regulären, von Menschen gesteuerten Computeraktionen zu langsam sein. Konzentriere dich auf Anwendungsfälle, bei denen Geschwindigkeit nicht entscheidend ist (zum Beispiel Informationsbeschaffung im Hintergrund, automatisierte Softwaretests), in vertrauenswürdigen Umgebungen.
2. **Genauigkeit und Zuverlässigkeit von Computer Vision:** Claude kann Fehler machen oder halluzinieren, wenn es beim Generieren von Aktionen bestimmte Koordinaten ausgibt. Claudes Ausgabe des [zusammengefassten Nachdenkens](https://platform.claude.com/docs/de/build-with-claude/thinking#summarized-thinking) kann dir helfen, das Reasoning des Modells zu verstehen und mögliche Probleme zu erkennen; setze `display: "summarized"` in der Thinking-Konfiguration, da die Modelle, die das Toolset unterstützen, den Thinking-Text standardmäßig weglassen.
3. **Genauigkeit und Zuverlässigkeit der Tool-Auswahl:** Claude kann Fehler machen oder halluzinieren, wenn es beim Generieren von Aktionen Tools auswählt, oder unerwartete Aktionen ausführen, um Probleme zu lösen. Zudem kann die Zuverlässigkeit bei der Interaktion mit Nischenanwendungen oder mehreren Anwendungen gleichzeitig geringer sein. Formuliere Prompts sorgfältig, wenn du komplexe Aufgaben anforderst.
4. **Zuverlässigkeit beim Scrollen:** Die Scroll-Aktion unterstützt die Richtungssteuerung (hoch, runter, links, rechts) und einen festgelegten Betrag. In Anwendungen, in denen Scrollen keine Wirkung zeigt, können Tastaturalternativen wie Bild ab helfen.
5. **Interaktion mit Tabellenkalkulationen:** Verwende die feingranularen Maussteuerungsaktionen (`left_mouse_down`, `left_mouse_up`) und Kombinationen mit Modifikatortasten, um einzelne Zellen auszuwählen. Komplexe Tabellenkalkulationsoperationen können dennoch mehrere Versuche erfordern.
6. **Kontoerstellung und Inhaltsgenerierung auf sozialen und Kommunikationsplattformen:** Obwohl Claude Websites besucht, ist seine Fähigkeit eingeschränkt, Konten zu erstellen, Inhalte zu generieren und zu teilen oder sich anderweitig auf Social-Media-Websites und -Plattformen als Mensch auszugeben.
7. **Schwachstellen:** Jailbreaks und Prompt Injection können Computer Use wie jedes Frontier-KI-System beeinträchtigen, auch über in Webseiten oder Bilder eingebettete Anweisungen; wende die Vorsichtsmaßnahmen aus dem Abschnitt [Sicherheitsaspekte](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#security-considerations) an.
8. **Unangemessene oder illegale Handlungen:** Gemäß den Nutzungsbedingungen von Anthropic darfst du Computer Use nicht einsetzen, um gegen Gesetze oder die Richtlinie zur zulässigen Nutzung zu verstoßen.

Überprüfe und verifiziere Claudes Computer-Use-Aktionen und -Protokolle immer sorgfältig. Verwende Claude nicht ohne menschliche Aufsicht für Aufgaben, die perfekte Präzision oder sensible Benutzerinformationen erfordern.

## Datenaufbewahrung

Computer Use ist ein clientseitiges Tool. Alle Screenshots, Mausaktionen, Tastatureingaben und alle an einer Sitzung beteiligten Dateien werden in deiner Umgebung erfasst und gespeichert, nicht von Anthropic. Anthropic verarbeitet die Screenshot-Bilder und Aktionsanfragen in Echtzeit als Teil des API-Aufrufs. Die Aufbewahrung dieser API-Anfragen richtet sich nach [API und Datenaufbewahrung](https://platform.claude.com/docs/de/manage-claude/api-and-data-retention).

Da deine Anwendung steuert, wo und wie Computer-Use-Daten gespeichert werden, ist Computer Use ZDR-berechtigt.

## Preise

„Computer use“ (Computernutzung) folgt der standardmäßigen [Preisgestaltung für Tool-Nutzung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/overview#pricing). Bei der Verwendung des Computer-Use-Tools gilt:

**Overhead der Toolset-Definition:** Die Deklaration von `computer_toolset_20260801` mit seinen Standardmitgliedern fügt einer Anfrage etwa 4.500 Input-Token hinzu (etwa 4.590 bei Claude Sonnet 5 und etwa 4.520 bei den anderen unterstützten Modellen). Dies umfasst die Definitionen der Mitglieds-Tools und den System-Prompt für die Tool-Nutzung. Das Deaktivieren von `zoom` mit `configs` entfernt etwa 410 dieser Token. Die genaue Anzahl für eine Anfrage wird im `usage` der Antwort angegeben, und du kannst sie vorab mit dem [Token-Counting-Endpunkt](https://platform.claude.com/docs/de/build-with-claude/token-counting) abschätzen.

**Frühere Tool-Versionen:** Die folgenden Zahlen gelten für die Tool-Versionen `computer_20251124` und `computer_20250124`, nicht für `computer_toolset_20260801`:

* System-Prompt-Overhead: 466–499 Token, die dem System-Prompt hinzugefügt werden
* Tool-Definition: etwa 735 Input-Token pro Tool-Definition (gemessen mit `computer_20250124`)

**Zusätzlicher Token-Verbrauch:**

* Screenshot- und Zoom-Bilder, die in Tool-Ergebnissen zurückgegeben werden, abgerechnet als Bild-Input (siehe [Vision-Preisgestaltung](https://platform.claude.com/docs/de/build-with-claude/vision#evaluate-image-size))
* Ergebnisse der Tool-Ausführung, die an Claude zurückgegeben werden

<Note>
  Wenn du neben Computer Use auch Bash- oder Texteditor-Tools verwendest, haben diese Tools ihre eigenen Token-Kosten, wie auf den jeweiligen Seiten dokumentiert.
</Note>

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Computer-Toolset in den SDKs" icon="code" href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-sdk#computer-toolset">
    Starte mit dem Treiber eines Partners oder schreibe deinen eigenen in Python oder TypeScript. Das SDK führt die Schleife und den Genehmigungs-Callback aus, den du übergibst.
  </Card>

  <Card title="Fehlerbehebung bei der Tool-Nutzung" icon="wrench" href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/troubleshooting-tool-use">
    Behebe die häufigsten Fehler bei der Tool-Nutzung mit Diagnosetabellen von Symptom zu Lösung.
  </Card>

  <Card title="Referenzimplementierung" icon="github-logo" href="https://github.com/anthropics/claude-quickstarts/tree/main/computer-use-demo">
    Starte mit der vollständigen Docker-basierten Implementierung.
  </Card>

  <Card title="Tool-Nutzung mit Claude" icon="tool" href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/overview">
    Verbinde Claude mit externen Tools und APIs. Erfahre, wo Tools ausgeführt werden, wann Claude sie aufruft und welches Tool zu deiner Aufgabe passt.
  </Card>

  <Card title="Best Practices im Detail" icon="book" href="https://claude.com/blog/best-practices-for-computer-and-browser-use-with-claude">
    Durch Benchmarks gestützte Empfehlungen zu Auflösung, Nachdenk-Aufwand und Kontextverwaltung.
  </Card>

  <Card title="Browser-Use-Tool" icon="browser" href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool">
    Lass Claude in deiner eigenen Browser-Umgebung navigieren, Webseiten lesen und mit ihnen interagieren, für Aufgaben, die im Browser bleiben.
  </Card>
</CardGroup>

## Verfügbarkeit

Computer-Use-Tool ist auf ausgewählten Modellen verfügbar oder in der Beta und für Zero Data Retention und HIPAA-Bereitschaft berechtigt.

### API-Unterstützung

#### [Messages API](https://platform.claude.com/docs/de/build-with-claude/working-with-messages)

* Verfügbarkeit: Verfügbar

| Status    | Cloud-Plattformen                                                                                                                                                                                              | Modelle                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Verfügbar | Claude API, [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/google-managed)                                               | [Claude Fable 5.2](https://platform.claude.com/docs/de/models/fable-5-2/overview), [Claude Mythos 5.2](https://platform.claude.com/docs/de/models/mythos-5-2/overview), [Claude Fable 5.1](https://platform.claude.com/docs/de/models/fable-5-1/overview), [Claude Mythos 5.1](https://platform.claude.com/docs/de/models/mythos-5-1/overview), [Claude Fable 5](https://platform.claude.com/docs/de/models/fable-5/overview), [Claude Mythos 5](https://platform.claude.com/docs/de/models/mythos-5/overview), Claude Mythos Preview, [Claude Opus 5.5](https://platform.claude.com/docs/de/models/opus-5-5/overview), [Claude Opus 5](https://platform.claude.com/docs/de/models/opus-5/overview), [Claude Sonnet 5.5](https://platform.claude.com/docs/de/models/sonnet-5-5/overview), [Claude Sonnet 5](https://platform.claude.com/docs/de/models/sonnet-5/overview), [Claude Haiku 5.5](https://platform.claude.com/docs/de/models/haiku-5-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/de/models/opus-4-8/overview) |
| Verfügbar | [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed)                                                     | [Claude Fable 5.2](https://platform.claude.com/docs/de/models/fable-5-2/overview), [Claude Mythos 5.2](https://platform.claude.com/docs/de/models/mythos-5-2/overview), [Claude Fable 5.1](https://platform.claude.com/docs/de/models/fable-5-1/overview), [Claude Mythos 5.1](https://platform.claude.com/docs/de/models/mythos-5-1/overview), [Claude Fable 5](https://platform.claude.com/docs/de/models/fable-5/overview), [Claude Mythos 5](https://platform.claude.com/docs/de/models/mythos-5/overview), [Claude Opus 5.5](https://platform.claude.com/docs/de/models/opus-5-5/overview), [Claude Opus 5](https://platform.claude.com/docs/de/models/opus-5/overview), [Claude Sonnet 5.5](https://platform.claude.com/docs/de/models/sonnet-5-5/overview), [Claude Sonnet 5](https://platform.claude.com/docs/de/models/sonnet-5/overview), [Claude Haiku 5.5](https://platform.claude.com/docs/de/models/haiku-5-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/de/models/opus-4-8/overview)                        |
| Verfügbar | [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws), [Microsoft Foundry](https://platform.claude.com/docs/de/build-with-claude/claude-in-microsoft-foundry) | [Claude Fable 5.2](https://platform.claude.com/docs/de/models/fable-5-2/overview), [Claude Mythos 5.2](https://platform.claude.com/docs/de/models/mythos-5-2/overview), [Claude Fable 5.1](https://platform.claude.com/docs/de/models/fable-5-1/overview), [Claude Mythos 5.1](https://platform.claude.com/docs/de/models/mythos-5-1/overview), [Claude Fable 5](https://platform.claude.com/docs/de/models/fable-5/overview), [Claude Mythos 5](https://platform.claude.com/docs/de/models/mythos-5/overview), [Claude Opus 5.5](https://platform.claude.com/docs/de/models/opus-5-5/overview), [Claude Opus 5](https://platform.claude.com/docs/de/models/opus-5/overview), [Claude Sonnet 5.5](https://platform.claude.com/docs/de/models/sonnet-5-5/overview), [Claude Sonnet 5](https://platform.claude.com/docs/de/models/sonnet-5/overview), [Claude Haiku 5.5](https://platform.claude.com/docs/de/models/haiku-5-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/de/models/opus-4-8/overview)                        |
| Verfügbar | [Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock)                                                                                                               | [Claude Fable 5.1](https://platform.claude.com/docs/de/models/fable-5-1/overview), [Claude Mythos 5.1](https://platform.claude.com/docs/de/models/mythos-5-1/overview), [Claude Fable 5](https://platform.claude.com/docs/de/models/fable-5/overview), [Claude Mythos 5](https://platform.claude.com/docs/de/models/mythos-5/overview), [Claude Opus 5.5](https://platform.claude.com/docs/de/models/opus-5-5/overview), [Claude Opus 5](https://platform.claude.com/docs/de/models/opus-5/overview), [Claude Sonnet 5.5](https://platform.claude.com/docs/de/models/sonnet-5-5/overview), [Claude Sonnet 5](https://platform.claude.com/docs/de/models/sonnet-5/overview), [Claude Haiku 5.5](https://platform.claude.com/docs/de/models/haiku-5-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/de/models/opus-4-8/overview)                                                                                                                                                                                                |
| Verfügbar | [Amazon Bedrock (bedrock-runtime)](https://platform.claude.com/docs/de/build-with-claude/claude-on-amazon-bedrock-legacy)                                                                                      | [Claude Fable 5.2](https://platform.claude.com/docs/de/models/fable-5-2/overview), [Claude Mythos 5.2](https://platform.claude.com/docs/de/models/mythos-5-2/overview), [Claude Fable 5.1](https://platform.claude.com/docs/de/models/fable-5-1/overview), [Claude Fable 5](https://platform.claude.com/docs/de/models/fable-5/overview), [Claude Opus 5.5](https://platform.claude.com/docs/de/models/opus-5-5/overview), [Claude Opus 5](https://platform.claude.com/docs/de/models/opus-5/overview), [Claude Sonnet 5.5](https://platform.claude.com/docs/de/models/sonnet-5-5/overview), [Claude Sonnet 5](https://platform.claude.com/docs/de/models/sonnet-5/overview), [Claude Haiku 5.5](https://platform.claude.com/docs/de/models/haiku-5-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/de/models/opus-4-8/overview)                                                                                                                                                                                              |
| Beta      | Alle unterstützten Plattformen                                                                                                                                                                                 | [Claude Haiku 4.5](https://platform.claude.com/docs/de/models/haiku-4-5/overview), [Claude Opus 4.7](https://platform.claude.com/docs/de/models/opus-4-7/overview), [Claude Opus 4.6](https://platform.claude.com/docs/de/models/opus-4-6/overview), [Claude Sonnet 4.6](https://platform.claude.com/docs/de/models/sonnet-4-6/overview), [Claude Opus 4.5](https://platform.claude.com/docs/de/models/opus-4-5/overview), [Claude Sonnet 4.5](https://platform.claude.com/docs/de/models/sonnet-4-5/overview)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |

#### [Managed Agents](https://platform.claude.com/docs/de/managed-agents/overview)

* Verfügbarkeit: Nicht verfügbar

### Erforderliche Beta-Header

[Übersicht über Beta-Header](https://platform.claude.com/docs/de/api/beta-headers)

Mit Beta-Headern kannst du auf experimentelle Funktionen und neue Modellfähigkeiten zugreifen, bevor sie Teil der Standard-API werden.

| Header                    | Modelle                                                                                                                                                                                                                                                                                                                                |
| ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `computer-use-2025-11-24` | [Claude Opus 4.7](https://platform.claude.com/docs/de/models/opus-4-7/overview), [Claude Opus 4.6](https://platform.claude.com/docs/de/models/opus-4-6/overview), [Claude Sonnet 4.6](https://platform.claude.com/docs/de/models/sonnet-4-6/overview), [Claude Opus 4.5](https://platform.claude.com/docs/de/models/opus-4-5/overview) |
| `computer-use-2025-01-24` | [Claude Haiku 4.5](https://platform.claude.com/docs/de/models/haiku-4-5/overview), [Claude Sonnet 4.5](https://platform.claude.com/docs/de/models/sonnet-4-5/overview)                                                                                                                                                                 |

### Datenverarbeitung

[Übersicht über die Datenverarbeitung](https://platform.claude.com/docs/de/manage-claude/api-and-data-retention#feature-eligibility)

| Element | Zero Data Retention                                                                                                                                                                                                                          | HIPAA      |
| ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
| Status  | Berechtigt (ausgenommen: [Abgedeckte Modelle](https://platform.claude.com/docs/de/manage-claude/api-and-data-retention#model-specific-data-retention-requirements))                                                                          | Berechtigt |
| Details | Clientseitiges Tool, bei dem Screenshots und Dateien in deiner Umgebung erfasst und gespeichert werden, nicht von Anthropic. [Mehr erfahren](https://platform.claude.com/docs/de/agents-and-tools/tool-use/computer-use-tool#data-retention) | —          |

Zutreffende Endpunkte:

* `/v1/messages` mit Toolset oder Tool `computer`
