---
title: Web-Fetch-Tool
url: https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool
description: Rufe Inhalte von bestimmten URLs ab und lies sie, um Claudes Kontext mit aktuellen Webinhalten zu erweitern.
featureMetadata:
  status: stable
  zdr:
    eligibility: eligible
    note: Excludes [Covered Models](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements). Abgerufene Webinhalte, die in der API-Antwort zurückgegeben werden. Die dynamische Filterung für das Web-Fetch-Tool ist nicht für ZDR oder HIPAA berechtigt. Website-Betreiber bewahren Anfragedaten (etwa abgerufene URLs und Anfrage-Metadaten) möglicherweise gemäß ihren eigenen Richtlinien auf.
  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
    Claude Platform on AWS: stable
    Claude Models on Google Cloud (Anthropic managed): stable
    Microsoft Foundry:
      availability: stable
      note: "Auf Azure gehostete Deployments unterstützen nur `web_fetch_20250910`: keine dynamische Filterung, kein Einschließen der Antwort und keine Cache-Umgehung."
---

**API-Unterstützung**: Nutzung unterscheidet sich je nach Produkt.

* **Messages API**: Füge den `tools` der Anfrage ein `web_fetch`-Tool hinzu.
* **Managed Agents**: Im Toolset des Agenten standardmäßig aktiviert, ohne `max_uses`, `citations` oder `cache_control`.

Das Web-Fetch-Tool ermöglicht es Claude, den vollständigen Inhalt von angegebenen Webseiten und PDF-Dokumenten abzurufen.

Die neueste Version des Web-Fetch-Tools (`web_fetch_20260318`) unterstützt **dynamisches Filtern** (“dynamic filtering”): Claude kann Code schreiben und ausführen, um abgerufene Inhalte zu filtern, bevor sie das Kontextfenster erreichen, sodass nur relevante Informationen erhalten bleiben und der Rest verworfen wird. Dies reduziert den Token-Verbrauch bei gleichbleibender Antwortqualität. Dynamisches Filtern ist mit Claude 4.6 und neueren Modellen sowie [Claude Mythos Preview](https://anthropic.com/glasswing) verfügbar. `web_fetch_20260318` fügt außerdem die Steuerung der [Antwortaufnahme](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool#response-inclusion) (“response inclusion”) für agentische Workflows hinzu. Die anderen Versionen (`web_fetch_20260309` für dynamisches Filtern und [Cache-Umgehung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool#cache-bypass), `web_fetch_20260209` nur für dynamisches Filtern, `web_fetch_20250910` für einfaches Abrufen) sind verfügbar.

Web Fetch (mit und ohne dynamisches Filtern) ist über die Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws), [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed) und [Microsoft Foundry](https://platform.claude.com/docs/de/build-with-claude/claude-in-microsoft-foundry) verfügbar. Auf Microsoft Foundry unterstützen Deployments, die [auf Azure gehostet](https://platform.claude.com/docs/de/build-with-claude/claude-in-microsoft-foundry#additional-features-not-supported-when-hosted-on-azure) werden, nur das einfache Web-Fetch-Tool (`web_fetch_20250910`, ohne dynamisches Filtern). Auf Anthropic gehostete Deployments unterstützen alle Versionen.

<Note>
  Für [Claude Mythos Preview](https://anthropic.com/glasswing) ist Web Fetch über die Claude API und Microsoft Foundry verfügbar.
</Note>

<Note>
  Nutze das [Feedback-Formular](https://forms.gle/NhWcgmkcvPCMmPE86), um Feedback zur Qualität der Modellantworten, zur API selbst oder zur Qualität der Dokumentation zu geben.
</Note>

Informationen zur Berechtigung für Zero Data Retention und zum `allowed_callers`-Workaround findest du unter [Server-Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/server-tools#zdr-and-allowed-callers).

<Warning>
  Das Aktivieren des Web-Fetch-Tools in Umgebungen, in denen Claude nicht vertrauenswürdige Eingaben zusammen mit sensiblen Daten verarbeitet, birgt Risiken der Datenexfiltration. Verwende dieses Tool nur in vertrauenswürdigen Umgebungen oder beim Umgang mit nicht sensiblen Daten.

  Um Exfiltrationsrisiken zu minimieren, kann Claude keine URLs abrufen, die nur in seiner eigenen Ausgabe vorkommen. Claude kann nur URLs abrufen, die zuvor in der Konversation vorgekommen sind: URLs in Benutzernachrichten, URLs in clientseitigen Tool-Ergebnissen und URLs aus vorherigen Web-Search- oder Web-Fetch-Ergebnissen (siehe [URL-Validierung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool#url-validation)). Claude kann außerdem keine URL abrufen, die anscheinend Zugangsdaten enthält, etwa einen API-Key oder ein Passwort, es sei denn, diese Zugangsdaten kommen im System-Prompt oder im Text einer Benutzernachricht vor.

  Es besteht jedoch weiterhin ein Restrisiko, das du bei der Verwendung dieses Tools sorgfältig abwägen solltest.

  Wenn Datenexfiltration ein Problem darstellt, ziehe Folgendes in Betracht:

  * Das Web-Fetch-Tool vollständig deaktivieren
  * Den Parameter [`max_uses`](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool#max-uses) verwenden, um die Anzahl der Abrufe in einem Turn zu begrenzen
  * Den Parameter `allowed_domains` verwenden, um auf bekannte sichere Domains zu beschränken
  * Den Parameter `url_sources` verwenden, damit clientseitige Tool-Ergebnisse nicht als Quelle zählen (siehe [URL-Quellen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool#url-sources))
</Warning>

Informationen zur Modellunterstützung findest du in der [Tool-Referenz](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-reference).

## Wie Web Fetch funktioniert

Web Fetch ist ein [Server-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/server-tools): Die API ruft die Inhalte während der Anfrage ab und fügt die Ergebnisse in die Konversation ein. Du musst nichts ausführen oder ein `tool_result` zurückgeben. Die Ausnahme ist, wenn Claude Web Fetch und eines deiner Client-Tools in derselben Gruppe paralleler Tool-Aufrufe aufruft: Die API gibt die Antwort mit `stop_reason: "tool_use"` zurück, bevor dieser Abruf ausgeführt wurde, und führt den Abruf dann aus, wenn du die Client-`tool_result`-Blöcke zurücksendest. Siehe [Server-Tools und Client-Tools in einem Turn mischen](https://platform.claude.com/docs/de/agents-and-tools/tool-use/server-tools#mixing-server-tools-and-client-tools-in-one-turn).

Wenn du das Web-Fetch-Tool zu deiner API-Anfrage hinzufügst:

1. Claude bestimmt anhand des Prompts und der verfügbaren URLs, wann Inhalte abgerufen werden.
2. Die API ruft den vollständigen Textinhalt von der angegebenen URL ab.
3. Bei PDFs gibt die API den Inhalt als base64-kodierte Daten zurück und verarbeitet ihn wie ein direkt angehängtes PDF-Dokument.
4. Claude analysiert den abgerufenen Inhalt und liefert eine Antwort mit optionalen Zitaten.

<Note>
  Das Web-Fetch-Tool unterstützt derzeit keine Websites, die dynamisch mit JavaScript gerendert werden. Für Seiten, die einen echten Browser benötigen (JavaScript-Rendering, Klicken oder Ausfüllen von Formularen), ziehe das [Browser-Use-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-tool) in Betracht, ein Client-Tool, bei dem deine Anwendung den Browser steuert und Seitentext oder Screenshots als Tool-Ergebnisse an Claude zurückgibt.
</Note>

### Wann Claude Inhalte abruft

Claude ruft Inhalte ab, wenn die Anfrage auf eine bestimmte Seite oder ein bestimmtes Dokument verweist:

* Eine URL wird in der Konversation (oder in einem vorherigen Tool-Ergebnis) angegeben
* Der Benutzer nennt eine bestimmte Ressource (einen bestimmten Artikel, eine README, eine Preisseite oder einen Dokumentationsabschnitt) ohne URL, und das [Web-Search-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-search-tool) ist ebenfalls aktiviert, sodass Claude sie zuerst finden kann (siehe [Kombinierte Suche und Abruf](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool#combined-search-and-fetch))

Claude ruft **nicht** ab bei Allgemeinwissensfragen oder offenen Fragen, die sich nicht auf eine bestimmte Seite beziehen. „Fasse diesen Artikel zusammen: `<url>`“ löst einen Abruf aus. „Was sind Best Practices für REST-API-Design?“ wird direkt beantwortet.

### Dynamisches Filtern

Das Abrufen vollständiger Webseiten und PDFs kann schnell Token verbrauchen, besonders wenn nur bestimmte Informationen aus großen Dokumenten benötigt werden. Mit `web_fetch_20260209` oder neuer kann Claude Code schreiben und ausführen, um die abgerufenen Inhalte zu filtern, bevor sie in den Kontext geladen werden.

Dieses dynamische Filtern ist besonders nützlich für:

* Das Extrahieren bestimmter Abschnitte aus langen Dokumenten
* Das Verarbeiten strukturierter Daten von Webseiten
* Das Filtern relevanter Informationen aus PDFs
* Das Reduzieren von Token-Kosten bei der Arbeit mit großen Dokumenten

<Note>
  Dynamisches Filtern läuft auf dem [Code-Execution-Tool](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool), das die API für die Anfrage automatisch aktiviert. Du musst das Code-Execution-Tool nicht zum `tools`-Array hinzufügen.
</Note>

Um dynamisches Filtern zu aktivieren, verwende `web_fetch_20260209` oder eine neuere Version. Die folgenden Beispiele verwenden `web_fetch_20260318`:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 4096,
      "messages": [
        {
          "role": "user",
          "content": "Fetch the content at https://example.com/research-paper and extract the key findings."
        }
      ],
      "tools": [{
        "type": "web_fetch_20260318",
        "name": "web_fetch"
      }]
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-opus-5-5 \
    --max-tokens 4096 \
    --message '{role: user, content: "Fetch the content at https://example.com/research-paper and extract the key findings."}' \
    --tool '{type: web_fetch_20260318, name: web_fetch}'
  ```

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

  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      messages=[
          {
              "role": "user",
              "content": "Fetch the content at https://example.com/research-paper and extract the key findings.",
          }
      ],
      tools=[{"type": "web_fetch_20260318", "name": "web_fetch"}],
  )
  print(response)
  ```

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

  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content:
          "Fetch the content at https://example.com/research-paper and extract the key findings."
      }
    ],
    tools: [{ type: "web_fetch_20260318", name: "web_fetch" }]
  });

  console.log(response);
  ```

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

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Messages = [new UserMessageParam { Content = "Fetch the content at https://example.com/research-paper and extract the key findings." }],
      Tools = [new ToolUnion(new WebFetchTool20260318())]
  };

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

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

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Fetch the content at https://example.com/research-paper and extract the key findings.")),
  	},
  	Tools: []anthropic.ToolUnionParam{
  		{OfWebFetchTool20260318: &anthropic.WebFetchTool20260318Param{}},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response.RawJSON())
  ```

  ```java Java
  import com.anthropic.models.messages.WebFetchTool20260318;

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

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(4096L)
          .addUserMessage("Fetch the content at https://example.com/research-paper and extract the key findings.")
          .addTool(WebFetchTool20260318.builder().build())
          .build();

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

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

  $message = $client->messages->create(
      maxTokens: 4096,
      messages: [
          ['role' => 'user', 'content' => 'Fetch the content at https://example.com/research-paper and extract the key findings.']
      ],
      model: Model::CLAUDE_OPUS_5_5,
      tools: [[
          'type' => 'web_fetch_20260318',
          'name' => 'web_fetch',
      ]],
  );
  echo $message;
  ```

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

  message = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 4096,
    messages: [
      { role: "user", content: "Fetch the content at https://example.com/research-paper and extract the key findings." }
    ],
    tools: [{
      type: "web_fetch_20260318",
      name: "web_fetch"
    }]
  )
  puts message
  ```
</CodeGroup>

## Wie du Web Fetch verwendest

<Note>
  Ein Organisationsadministrator kann Web Fetch für deine Organisation auf der Seite [**Funktionen**](https://platform.claude.com/settings/capabilities) der Claude Console deaktivieren. Wenn Web Fetch deaktiviert ist, schlägt eine Messages-API-Anfrage, die das Tool enthält, mit einem 400-`invalid_request_error` fehl, der besagt, dass Web Fetch nicht aktiviert ist. Wenn Web Fetch aktiviert ist, kann der Administrator auf derselben Seite auch erlaubte oder blockierte Domains für Web Fetch festlegen. Wie diese Listen auf eine Anfrage angewendet werden, erfährst du unter [Domain-Filterung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/server-tools#domain-filtering).
</Note>

Wie die Web-Fetch-Einstellungen deiner Organisation in Claude-Managed-Agents-Sitzungen angewendet werden, erfährst du unter [Web-Search- und Web-Fetch-Domains einschränken](https://platform.claude.com/docs/de/managed-agents/tools-web-restrictions).

Stelle das Web-Fetch-Tool in deiner API-Anfrage bereit:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 4096,
      "messages": [
        {
          "role": "user",
          "content": "Please analyze the content at https://example.com/article"
        }
      ],
      "tools": [{
        "type": "web_fetch_20250910",
        "name": "web_fetch",
        "max_uses": 5
      }]
    }'
  ```

  ```bash CLI
  ant messages create \
    --model claude-opus-5-5 \
    --max-tokens 4096 \
    --message '{role: user, content: "Please analyze the content at https://example.com/article"}' \
    --tool '{type: web_fetch_20250910, name: web_fetch, max_uses: 5}'
  ```

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

  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      messages=[
          {
              "role": "user",
              "content": "Please analyze the content at https://example.com/article",
          }
      ],
      tools=[{"type": "web_fetch_20250910", "name": "web_fetch", "max_uses": 5}],
  )
  print(response)
  ```

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

  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: "Please analyze the content at https://example.com/article"
      }
    ],
    tools: [
      {
        type: "web_fetch_20250910",
        name: "web_fetch",
        max_uses: 5
      }
    ]
  });

  console.log(response);
  ```

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

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Messages = [new UserMessageParam { Content = "Please analyze the content at https://example.com/article" }],
      Tools = [new ToolUnion(new WebFetchTool20250910() { MaxUses = 5 })]
  };

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

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

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Please analyze the content at https://example.com/article")),
  	},
  	Tools: []anthropic.ToolUnionParam{
  		{OfWebFetchTool20250910: &anthropic.WebFetchTool20250910Param{
  			MaxUses: anthropic.Int(5),
  		}},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response.RawJSON())
  ```

  ```java Java
  import com.anthropic.models.messages.WebFetchTool20250910;

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

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(4096L)
          .addUserMessage("Please analyze the content at https://example.com/article")
          .addTool(WebFetchTool20250910.builder()
              .maxUses(5L)
              .build())
          .build();

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

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

  $message = $client->messages->create(
      maxTokens: 4096,
      messages: [
          ['role' => 'user', 'content' => 'Please analyze the content at https://example.com/article']
      ],
      model: Model::CLAUDE_OPUS_5_5,
      tools: [[
          'type' => 'web_fetch_20250910',
          'name' => 'web_fetch',
          'max_uses' => 5,
      ]],
  );
  echo $message;
  ```

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

  message = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 4096,
    messages: [
      { role: "user", content: "Please analyze the content at https://example.com/article" }
    ],
    tools: [{
      type: "web_fetch_20250910",
      name: "web_fetch",
      max_uses: 5
    }]
  )
  puts message
  ```
</CodeGroup>

## Tool-Definition

Das Web-Fetch-Tool unterstützt die folgenden Parameter:

```json JSON
{
  "type": "web_fetch_20250910",
  "name": "web_fetch",

  // Optional: Limit the number of fetches
  "max_uses": 10,

  // Optional: Only fetch from these domains
  "allowed_domains": ["example.com", "docs.example.com"],

  // Optional: Never fetch from these domains (cannot be combined with allowed_domains)
  "blocked_domains": ["private.example.com"],

  // Optional: Don't fetch URLs that appear only in client-side tool results
  "url_sources": {
    "client_tool_results": { "type": "none" }
  },

  // Optional: Enable citations for fetched content
  "citations": {
    "enabled": true
  },

  // Optional: Maximum content length in tokens
  "max_content_tokens": 100000
}
```

Spätere Tool-Versionen fügen zwei weitere optionale Parameter hinzu: `use_cache` erfordert `web_fetch_20260309` oder neuer (siehe [Cache-Umgehung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool#cache-bypass)), und `response_inclusion` erfordert `web_fetch_20260318` oder neuer (siehe [Antwortaufnahme](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool#response-inclusion)).

### Maximale Nutzungen

Der Parameter `max_uses` begrenzt die Anzahl der Web-Abrufe in einem einzelnen Turn. Fehlgeschlagene Abrufe werden auf das Limit angerechnet. Wenn Claude Web Fetch direkt öfter aufruft als erlaubt, ist das `web_fetch_tool_result` ein Fehler mit dem Fehlercode `max_uses_exceeded`. Wenn Claude Web Fetch aus der Code-Ausführung heraus öfter aufruft als erlaubt, endet der Code-Ausführungslauf mit einem Fehler. Es gibt kein Standardlimit.

Ein Turn kann sich über mehrere Anfragen erstrecken. Eine Anfrage setzt einen Turn fort, wenn sie nach [`pause_turn`](https://platform.claude.com/docs/de/agents-and-tools/tool-use/server-tools#the-server-side-loop-and-pause-turn) weiterläuft oder wenn ihre letzte Nachricht nur `tool_result`-Blöcke enthält. Abrufe aus früheren Anfragen in diesem Turn werden auf das Limit angerechnet, es sei denn, Claude hat sie über [dynamisches Filtern](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool#dynamic-filtering) aus der Code-Ausführung heraus ausgeführt.

### Domain-Filterung

Informationen zur Domain-Filterung mit `allowed_domains` und `blocked_domains` findest du unter [Server-Tools](https://platform.claude.com/docs/de/agents-and-tools/tool-use/server-tools#domain-filtering).

Bei [Claude Managed Agents](https://platform.claude.com/docs/de/managed-agents/overview) legst du diese Felder im `web_fetch`-Eintrag des Agent-Toolsets fest; siehe [Web-Search- und Web-Fetch-Domains einschränken](https://platform.claude.com/docs/de/managed-agents/tools-web-restrictions).

### Inhaltslimits

Der Parameter `max_content_tokens` begrenzt die Menge an Inhalten, die in den Kontext aufgenommen werden. Wenn der abgerufene Inhalt dieses Limit überschreitet, kürzt das Tool ihn. Dies hilft, die Token-Nutzung beim Abrufen großer Dokumente zu kontrollieren. Das Limit ist ungefähr: Die tatsächliche Anzahl der verwendeten Input-Token kann geringfügig abweichen. Das Limit gilt für Textinhalte, nicht für binäre Inhalte wie PDFs.

Wenn ein abgerufenes PDF dazu führt, dass die Anfrage die [PDF-Seiten- oder PDF-Größenlimits](https://platform.claude.com/docs/de/build-with-claude/pdf-support#check-pdf-requirements) überschreitet, ist das `web_fetch_tool_result` ein Fehler mit dem Fehlercode `content_too_large`. PDFs und Bilder, die sich bereits in der Konversation befinden, werden auf diese Limits angerechnet, sodass deren Entfernung den Abruf erfolgreich machen kann.

Bei Claude Managed Agents akzeptiert der `web_fetch`-Eintrag des Agent-Toolsets ebenfalls `max_content_tokens`; siehe die [Web-Tool-Einstellungen](https://platform.claude.com/docs/de/managed-agents/tools-web-restrictions#settings).

### Cache-Umgehung

<Note>
  Erfordert `web_fetch_20260309` oder neuer (einschließlich `web_fetch_20260318`).
</Note>

Der Parameter `use_cache` steuert, ob zwischengespeicherte Inhalte zurückgegeben werden dürfen. Setze `"use_cache": false`, um den Cache zu umgehen und aktuelle Inhalte abzurufen. Der Standardwert ist `true`. Deaktiviere das Caching nur, wenn der Benutzer ausdrücklich aktuelle Inhalte anfordert oder wenn du sich schnell ändernde Quellen abrufst, da das Umgehen des Caches die Latenz erhöht.

```json
{
  "tools": [
    {
      "type": "web_fetch_20260309",
      "name": "web_fetch",
      "use_cache": false
    }
  ]
}
```

### Antwortaufnahme

<Note>
  Erfordert `web_fetch_20260318` oder neuer.
</Note>

Der Parameter `response_inclusion` steuert, wie Abruf-Ergebnisblöcke in der API-Antwort erscheinen, wenn das Ergebnis von einem abgeschlossenen [Code-Execution](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool)-Aufruf in derselben Antwort verarbeitet wurde. Setze `"response_inclusion": "excluded"`, um diese verschachtelten `server_tool_use`- und Ergebnisblock-Paare vollständig aus der Antwort zu entfernen, für agentische Workflows, die die rohen Seiteninhalte nicht benötigen. Die Token-Nutzung bleibt davon unberührt, da Claude die Ausgabe des Codes liest und nicht diese Blöcke. Der Standardwert ist `"full"`. Ergebnisse aus direkten Aufrufen oder aus Code-Execution-Aufrufen, die vor dem Abschluss pausiert wurden, gibt die API immer vollständig zurück, damit du sie in der nächsten Anfrage zurücksenden kannst.

```json
{
  "tools": [
    {
      "type": "web_fetch_20260318",
      "name": "web_fetch",
      "response_inclusion": "excluded"
    }
  ]
}
```

### Zitate

Anders als bei der Websuche, bei der Zitate immer aktiviert sind, sind Zitate bei Web Fetch optional und standardmäßig deaktiviert. Setze `"citations": {"enabled": true}`, damit Claude bestimmte Passagen aus abgerufenen Dokumenten zitieren kann.

<Note>
  Wenn du API-Ausgaben direkt Endbenutzern anzeigst, füge Zitate zur Originalquelle hinzu. Wenn du Änderungen an API-Ausgaben vornimmst, einschließlich der Weiterverarbeitung oder Kombination mit eigenem Material, bevor du sie Endbenutzern anzeigst, zeige Zitate nach Rücksprache mit deinem Rechtsteam entsprechend an.
</Note>

## Antwort

Hier ist ein Beispiel für eine Antwortstruktur:

```json Output
{
  "role": "assistant",
  "content": [
    // 1. Claude's decision to fetch
    {
      "type": "text",
      "text": "I'll fetch the content from the article to analyze it."
    },
    // 2. The fetch request
    {
      "type": "server_tool_use",
      "id": "srvtoolu_01234567890abcdef",
      "name": "web_fetch",
      "input": {
        "url": "https://example.com/article"
      }
    },
    // 3. Fetch results
    {
      "type": "web_fetch_tool_result",
      "tool_use_id": "srvtoolu_01234567890abcdef",
      "content": {
        "type": "web_fetch_result",
        "url": "https://example.com/article",
        "content": {
          "type": "document",
          "source": {
            "type": "text",
            "media_type": "text/plain",
            "data": "Full text content of the article..."
          },
          "title": "Article Title",
          "citations": { "enabled": true }
        },
        "retrieved_at": "2025-08-25T10:30:00Z"
      }
    },
    // 4. Claude's analysis with citations (if enabled)
    {
      "text": "Based on the article, ",
      "type": "text"
    },
    {
      "text": "the main argument presented is that artificial intelligence will transform healthcare",
      "type": "text",
      "citations": [
        {
          "type": "char_location",
          "document_index": 0,
          "document_title": "Article Title",
          "start_char_index": 1234,
          "end_char_index": 1456,
          "cited_text": "Artificial intelligence is poised to revolutionize healthcare delivery..."
        }
      ]
    }
  ],
  "id": "msg_a930390d3a",
  "usage": {
    "input_tokens": 25039,
    "output_tokens": 931,
    "server_tool_use": {
      "web_fetch_requests": 1
    }
  },
  "stop_reason": "end_turn"
}
```

### Abrufergebnisse

Abrufergebnisse enthalten:

* `url`: Die URL, die abgerufen wurde
* `content`: Ein Dokumentblock mit dem abgerufenen Inhalt
* `retrieved_at`: Zeitstempel, wann der Inhalt abgerufen wurde

<Note>
  Das Web-Fetch-Tool speichert Ergebnisse im Cache, um die Leistung zu verbessern und redundante Anfragen zu reduzieren. Der zurückgegebene Inhalt spiegelt möglicherweise nicht immer die neueste unter der URL verfügbare Version wider. Das Cache-Verhalten wird automatisch verwaltet und kann sich im Laufe der Zeit ändern, um es für verschiedene Inhaltstypen und Nutzungsmuster zu optimieren. Um aktuelle Inhalte abzurufen, setze `"use_cache": false` (siehe [Cache-Umgehung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool#cache-bypass)).
</Note>

Bei PDF-Dokumenten wird der Inhalt als base64-kodierte Daten zurückgegeben:

```json Output
{
  "type": "web_fetch_tool_result",
  "tool_use_id": "srvtoolu_02",
  "content": {
    "type": "web_fetch_result",
    "url": "https://example.com/paper.pdf",
    "content": {
      "type": "document",
      "source": {
        "type": "base64",
        "media_type": "application/pdf",
        "data": "JVBERi0xLjQKJcOkw7zDtsOfCjIgMCBvYmo..."
      },
      "citations": { "enabled": true }
    },
    "retrieved_at": "2025-08-25T10:30:02Z"
  }
}
```

### Fehler

Wenn das Web-Fetch-Tool auf einen Fehler stößt, gibt die Claude API eine 200-Antwort (Erfolg) zurück, wobei der Fehler im Antworttext dargestellt wird. Claude erhält das Fehlerergebnis und setzt den Turn fort. Zum Beispiel:

```json Output
{
  "type": "web_fetch_tool_result",
  "tool_use_id": "srvtoolu_a93jad",
  "content": {
    "type": "web_fetch_tool_result_error",
    "error_code": "url_not_accessible"
  }
}
```

Dies sind die möglichen Fehlercodes:

* `invalid_tool_input`: Ungültige Tool-Eingabe, etwa eine fehlerhafte URL oder ein Nicht-HTTP(S)-Schema
* `url_too_long`: URL überschreitet die maximale Länge (250 Zeichen)
* `url_not_allowed`: URL durch Domain-Filterregeln (einschließlich der Einstellungen deiner Organisation) oder durch Einschränkungen auf Anthropic-Seite blockiert, etwa private Adressen, `robots.txt` und URLs, die anscheinend Zugangsdaten enthalten, die du nicht bereitgestellt hast
* `url_not_in_prior_context`: URL kam zuvor nicht in der Konversation vor oder kam nur in Quellen vor, die `url_sources` ausschließt (siehe [URL-Validierung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool#url-validation))
* `url_not_accessible`: Abrufen des Inhalts fehlgeschlagen (HTTP-Fehler)
* `too_many_requests`: Ratenlimit überschritten
* `unsupported_content_type`: Inhaltstyp nicht unterstützt (nur Text, HTML und PDF)
* `content_too_large`: Abgerufenes PDF würde dazu führen, dass die Anfrage die PDF-Seiten- oder PDF-Größenlimits überschreitet (siehe [Inhaltslimits](https://platform.claude.com/docs/de/agents-and-tools/tool-use/web-fetch-tool#content-limits))
* `max_uses_exceeded`: Maximale Nutzungen des Web-Fetch-Tools überschritten
* `unavailable`: Ein interner Fehler ist aufgetreten

## URL-Validierung

Aus Sicherheitsgründen kann das Web-Fetch-Tool nur URLs abrufen, die zuvor im Konversationskontext vorgekommen sind. Dazu gehören:

* URLs in Benutzernachrichten
* URLs in clientseitigen Tool-Ergebnissen
* URLs aus vorherigen Web-Search- oder Web-Fetch-Ergebnissen

Das Tool kann keine URLs abrufen, die nur in Claudes eigener Ausgabe oder nur im System-Prompt vorkommen. Um eine URL aus dem System-Prompt abrufbar zu machen, füge sie zusätzlich in eine Benutzernachricht ein. Ergebnisse anderer serverseitiger Tools, wie [Code-Ausführung](https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool), der [MCP-Connector](https://platform.claude.com/docs/de/agents-and-tools/mcp-connector) oder [Tool-Suche](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-search-tool), sind ebenfalls keine erlaubte Quelle. Standardmäßig sind clientseitige Tool-Ergebnisse eine erlaubte Quelle, selbst wenn sie Text wiedergeben, den Claude erzeugt hat (zum Beispiel ein Befehl, der seine Eingabe ausgibt, oder eine Fehlermeldung, die sie zitiert).

Das Tool lehnt außerdem eine URL ab, die anscheinend Zugangsdaten enthält, etwa einen API-Key oder ein Passwort, es sei denn, diese Zugangsdaten kommen im System-Prompt oder im Text einer Benutzernachricht vor. Zugangsdaten, die nur in einem Tool-Ergebnis vorkommen, zählen nicht. Das Ergebnis ist ein `url_not_allowed`-Fehler. Um eine solche URL abzurufen, füge sie in eine Benutzernachricht ein.

### URL-Quellen

<Note>
  Funktioniert mit `web_fetch_20250910`, `web_fetch_20260209`, `web_fetch_20260309` und `web_fetch_20260318`.
</Note>

Mit dem optionalen Parameter `url_sources` kannst du jede der drei erlaubten Quellen deaktivieren oder Tool-Ergebnisse auf bestimmte Tools beschränken. Er hat für jede Quelle einen Schlüssel, und jeder Schlüssel hat den Standardwert `{"type": "all"}`:

* `user_input`: URLs in Benutzernachrichten. Sein `type` ist `"all"` oder `"none"`.
* `client_tool_results`: URLs in clientseitigen Tool-Ergebnissen. Sein `type` ist `"all"`, `"none"` oder ein `"only"`- bzw. `"except"`-Filter, der Tools benennt, wie im folgenden Beispiel.
* `server_tool_results`: URLs aus vorherigen Web-Search- oder Web-Fetch-Ergebnissen. Er akzeptiert dieselben Werte, und seine Filter benennen `web_search` oder `web_fetch`.

Ein Tool, das von Claude geschriebenen Code ausführt, gibt beispielsweise alles zurück, was dieser Code ausgibt, einschließlich jeder URL, die Claude darin eingefügt hat. Damit die Ergebnisse dieses Tools nicht als Quelle zählen, benenne es in einem `"except"`-Filter:

```json
{
  "tools": [
    {
      "type": "web_fetch_20260318",
      "name": "web_fetch",
      "url_sources": {
        "client_tool_results": {
          "type": "except",
          "tools": [{ "type": "tool_reference", "name": "run_code" }]
        }
      }
    },
    {
      "name": "run_code",
      "description": "Run Python code and return its output",
      "input_schema": {
        "type": "object",
        "properties": { "code": { "type": "string" } },
        "required": ["code"]
      }
    }
  ]
}
```

Ein Filter listet Tools als `tool_reference`-Objekte auf. Jeder Name muss mit einem Tool im `tools`-Array der Anfrage übereinstimmen: einem Client-Tool für `client_tool_results` oder einem Server-Tool für `server_tool_results`. Andernfalls schlägt die Anfrage mit einem Fehler fehl. Unter `"except"` zählt ein Tool, das du später zu `tools` hinzufügst, als Quelle. Unter `"only"` nicht.

Auch andere clientseitige Tools als `run_code` können Text zurückgeben, den Claude geschrieben hat, zum Beispiel in einer Fehlermeldung, die ihn zitiert. Um alle clientseitigen Tool-Ergebnisse auszuschließen, setze `client_tool_results` auf `{"type": "none"}`.

Wenn eine URL nur in Quellen vorkam, die `url_sources` ausschließt, gibt ihr Abruf den Fehler `url_not_in_prior_context` zurück.

## Kombinierte Suche und Abruf

Wenn sowohl das Web-Search- als auch das Web-Fetch-Tool aktiviert sind und der Benutzer eine bestimmte Seite oder ein bestimmtes Dokument nennt, ohne eine URL anzugeben (zum Beispiel „lies die README aus dem Repository anthropics/anthropic-sdk-python“), verwendet Claude die Websuche, um sie zu finden, und ruft dann das Ergebnis ab. Das folgende Beispiel fordert eine Suche und eine Analyse in einer Anfrage an:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 4096,
      "messages": [
        {
          "role": "user",
          "content": "Find recent articles about quantum computing and analyze the most relevant one in detail"
        }
      ],
      "tools": [
        {
          "type": "web_search_20250305",
          "name": "web_search",
          "max_uses": 3
        },
        {
          "type": "web_fetch_20250910",
          "name": "web_fetch",
          "max_uses": 5,
          "citations": {"enabled": true}
        }
      ]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-opus-5-5
  max_tokens: 4096
  messages:
    - role: user
      content: >-
        Find recent articles about quantum computing
        and analyze the most relevant one in detail
  tools:
    - type: web_search_20250305
      name: web_search
      max_uses: 3
    - type: web_fetch_20250910
      name: web_fetch
      max_uses: 5
      citations:
        enabled: true
  YAML
  ```

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

  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      messages=[
          {
              "role": "user",
              "content": "Find recent articles about quantum computing and analyze the most relevant one in detail",
          }
      ],
      tools=[
          {"type": "web_search_20250305", "name": "web_search", "max_uses": 3},
          {
              "type": "web_fetch_20250910",
              "name": "web_fetch",
              "max_uses": 5,
              "citations": {"enabled": True},
          },
      ],
  )
  print(response)
  ```

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

  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content:
          "Find recent articles about quantum computing and analyze the most relevant one in detail"
      }
    ],
    tools: [
      { type: "web_search_20250305", name: "web_search", max_uses: 3 },
      {
        type: "web_fetch_20250910",
        name: "web_fetch",
        max_uses: 5,
        citations: { enabled: true }
      }
    ]
  });

  console.log(response);
  ```

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

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Messages = [new UserMessageParam { Content = "Find recent articles about quantum computing and analyze the most relevant one in detail" }],
      Tools = [
          new ToolUnion(new WebSearchTool20250305() { MaxUses = 3 }),
          new ToolUnion(new WebFetchTool20250910() { MaxUses = 5, Citations = new() { Enabled = true } })
      ]
  };

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

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

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Find recent articles about quantum computing and analyze the most relevant one in detail")),
  	},
  	Tools: []anthropic.ToolUnionParam{
  		{OfWebSearchTool20250305: &anthropic.WebSearchTool20250305Param{
  			MaxUses: anthropic.Int(3),
  		}},
  		{OfWebFetchTool20250910: &anthropic.WebFetchTool20250910Param{
  			MaxUses:   anthropic.Int(5),
  			Citations: anthropic.CitationsConfigParam{Enabled: anthropic.Bool(true)},
  		}},
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response.RawJSON())
  ```

  ```java Java
  import com.anthropic.models.messages.CitationsConfigParam;
  // ...
  import com.anthropic.models.messages.WebFetchTool20250910;
  import com.anthropic.models.messages.WebSearchTool20250305;

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

      MessageCreateParams params = MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(4096L)
          .addUserMessage("Find recent articles about quantum computing and analyze the most relevant one in detail")
          .addTool(WebSearchTool20250305.builder()
              .maxUses(3L)
              .build())
          .addTool(WebFetchTool20250910.builder()
              .maxUses(5L)
              .citations(CitationsConfigParam.builder()
                  .enabled(true)
                  .build())
              .build())
          .build();

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

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

  $message = $client->messages->create(
      maxTokens: 4096,
      messages: [
          ['role' => 'user', 'content' => 'Find recent articles about quantum computing and analyze the most relevant one in detail']
      ],
      model: Model::CLAUDE_OPUS_5_5,
      tools: [
          [
              'type' => 'web_search_20250305',
              'name' => 'web_search',
              'max_uses' => 3,
          ],
          [
              'type' => 'web_fetch_20250910',
              'name' => 'web_fetch',
              'max_uses' => 5,
              'citations' => ['enabled' => true],
          ],
      ],
  );
  echo $message;
  ```

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

  message = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 4096,
    messages: [
      { role: "user", content: "Find recent articles about quantum computing and analyze the most relevant one in detail" }
    ],
    tools: [
      {
        type: "web_search_20250305",
        name: "web_search",
        max_uses: 3
      },
      {
        type: "web_fetch_20250910",
        name: "web_fetch",
        max_uses: 5,
        citations: { enabled: true }
      }
    ]
  )
  puts message
  ```
</CodeGroup>

In diesem Workflow:

1. Verwendet Claude die Websuche, um relevante Artikel zu finden.
2. Wählt Claude die vielversprechendsten Ergebnisse aus.
3. Verwendet Claude Web Fetch, um den vollständigen Inhalt abzurufen.
4. Liefert Claude eine detaillierte Analyse mit Zitaten.

## Prompt-Caching

Um Tool-Definitionen über Turns hinweg zwischenzuspeichern, siehe [Tool-Nutzung mit Prompt-Caching](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-use-with-prompt-caching).

## Streaming

Bei aktiviertem Streaming sind Abruf-Events Teil des Streams, mit einer Pause während des Abrufs der Inhalte:

```sse Output
event: message_start
data: {"type": "message_start", "message": {"id": "msg_abc123", "type": "message"}}

event: content_block_start
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "text", "text": ""}}

// Claude's decision to fetch

event: content_block_start
data: {"type": "content_block_start", "index": 1, "content_block": {"type": "server_tool_use", "id": "srvtoolu_xyz789", "name": "web_fetch"}}

// Fetch URL streamed
event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "input_json_delta", "partial_json": "{\"url\":\"https://example.com/article\"}"}}

// Pause while fetch runs

// Fetch results streamed
event: content_block_start
data: {"type": "content_block_start", "index": 2, "content_block": {"type": "web_fetch_tool_result", "tool_use_id": "srvtoolu_xyz789", "content": {"type": "web_fetch_result", "url": "https://example.com/article", "content": {"type": "document", "source": {"type": "text", "media_type": "text/plain", "data": "Article content..."}}}}}

// Claude's response continues...
```

## Batch-Anfragen

Du kannst das Web-Fetch-Tool in die [Message Batches API](https://platform.claude.com/docs/de/build-with-claude/batch-processing) aufnehmen. Web-Fetch-Tool-Aufrufe über die Message Batches API werden genauso abgerechnet wie die in regulären Messages-API-Anfragen.

## Nutzung und Preise

Die Nutzung von Web Fetch verursacht **keine zusätzlichen Gebühren** über die Standard-Token-Kosten hinaus:

```json
{
  "usage": {
    "input_tokens": 25039,
    "output_tokens": 931,
    "cache_read_input_tokens": 0,
    "cache_creation_input_tokens": 0,
    "server_tool_use": {
      "web_fetch_requests": 1
    }
  }
}
```

Das Web-Fetch-Tool ist auf der Claude API **ohne zusätzliche Kosten** verfügbar. Du zahlst nur die Standard-Token-Kosten für die abgerufenen Inhalte, die Teil deines Gesprächskontexts werden.

Um dich davor zu schützen, versehentlich große Inhalte abzurufen, die übermäßig viele Token verbrauchen würden, verwende den Parameter `max_content_tokens`, um angemessene Limits basierend auf deinem Anwendungsfall und deinen Budgetüberlegungen festzulegen.

Beispielhafter Token-Verbrauch für typische Inhalte:

* Durchschnittliche Webseite (10 kB): \~2.500 Token
* Große Dokumentationsseite (100 kB): \~25.000 Token
* Forschungsarbeit als PDF (500 kB): \~125.000 Token

## Nächste Schritte

<CardGroup>
  <Card href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/code-execution-tool" title="Code-Execution-Tool" icon="code">
    Führe Python- und Bash-Code in einem Sandbox-Container aus, um Daten zu analysieren, Dateien zu generieren und Lösungen iterativ zu verbessern.
  </Card>

  <Card href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/server-tools" title="Server-Tools" icon="cloud">
    Arbeite mit Tools, die Anthropic ausführt: `server_tool_use`-Blöcke, `pause_turn`-Fortsetzung und Domain-Filterung.
  </Card>

  <Card href="https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-reference" title="Tool-Referenz" icon="book">
    Verzeichnis der von Anthropic bereitgestellten Tools und Referenz für optionale Eigenschaften von Tool-Definitionen.
  </Card>
</CardGroup>

## Verfügbarkeit

Web-Fetch-Tool ist auf allen Modellen verfügbar und für Zero Data Retention berechtigt.

### API-Unterstützung

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

* Verfügbarkeit: Verfügbar
* Nutzung: Füge den `tools` der Anfrage ein `web_fetch`-Tool hinzu. Einstellungen wie `max_uses`, Domain-Listen, `citations` und `max_content_tokens` werden an diesem Tool gesetzt.

| Status                | Cloud-Plattformen                                                                                                                                                                                                                                                                                                                                                                                            |
| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Verfügbar             | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws), [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed), [Microsoft Foundry (hosted on Anthropic)](https://platform.claude.com/docs/de/build-with-claude/claude-in-microsoft-foundry) |
| Verfügbar<sup>1</sup> | [Microsoft Foundry (hosted on Azure)](https://platform.claude.com/docs/de/build-with-claude/claude-in-microsoft-foundry)                                                                                                                                                                                                                                                                                     |

1. Auf Azure gehostete Deployments unterstützen nur `web_fetch_20250910`: keine dynamische Filterung, kein Einschließen der Antwort und keine Cache-Umgehung.

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

* Verfügbarkeit: Verfügbar
* Nutzung: Teil des Toolsets des Agenten und standardmäßig aktiviert, sobald das Toolset hinzugefügt wird. Domain-Listen (ohne Pfade) und `max_content_tokens` werden im Eintrag `web_fetch` des Toolsets gesetzt; `max_uses`, `citations` und `cache_control` sind nicht verfügbar.

| Status    | Cloud-Plattformen                                                                                                                                                                                                                                                              |
| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Verfügbar | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws), [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed) |

### 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))                                                                                                                                   | Nicht berechtigt |
| Details | Abgerufene Webinhalte, die in der API-Antwort zurückgegeben werden. Die dynamische Filterung für das Web-Fetch-Tool ist nicht für ZDR oder HIPAA berechtigt. Website-Betreiber bewahren Anfragedaten (etwa abgerufene URLs und Anfrage-Metadaten) möglicherweise gemäß ihren eigenen Richtlinien auf. | —                |

Zutreffende Endpunkte:

* `/v1/messages` mit Tool `web_fetch`
