---
title: Strumento web fetch
url: https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-fetch-tool
description: Recupera e leggi contenuti da URL specifici per arricchire il contesto di Claude con contenuti web in tempo reale.
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). Contenuto web recuperato restituito nella risposta dell’API. Il filtro dinamico per web fetch non è idoneo per ZDR o HIPAA. Gli editori dei siti web potrebbero conservare i dati delle richieste (come gli URL recuperati e i metadati delle richieste) secondo le proprie policy.
  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: "I deployment ospitati su Azure supportano solo `web_fetch_20250910`: niente filtro dinamico, inclusione della risposta o bypass della cache."
---

**Supporto API**: L’utilizzo varia in base al prodotto.

* **Messages API**: Aggiungi uno strumento `web_fetch` ai `tools` della richiesta.
* **Managed Agents**: Attivo per impostazione predefinita nel toolset dell’agente, senza `max_uses`, `citations` o `cache_control`.

Lo strumento di web fetch consente a Claude di recuperare il contenuto completo da pagine web e documenti PDF specificati.

L’ultima versione dello strumento di web fetch (`web_fetch_20260318`) supporta il **dynamic filtering** (filtraggio dinamico): Claude può scrivere ed eseguire codice per filtrare il contenuto recuperato prima che raggiunga la “context window” (finestra di contesto), mantenendo solo le informazioni rilevanti e scartando il resto. Questo riduce il consumo di token mantenendo la qualità delle risposte. Il filtraggio dinamico è disponibile con Claude 4.6 e modelli successivi e con [Claude Mythos Preview](https://anthropic.com/glasswing). `web_fetch_20260318` aggiunge inoltre il controllo dell’[inclusione nella risposta](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-fetch-tool#response-inclusion) per i flussi di lavoro agentici. Le altre versioni (`web_fetch_20260309` per il filtraggio dinamico e il [bypass della cache](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-fetch-tool#cache-bypass), `web_fetch_20260209` solo per il filtraggio dinamico, `web_fetch_20250910` per il fetch di base) sono disponibili.

Il web fetch (con e senza filtraggio dinamico) è disponibile sulla Claude API, su [Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws), su [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed) e su [Microsoft Foundry](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry). Su Microsoft Foundry, i deployment [ospitati su Azure](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry#additional-features-not-supported-when-hosted-on-azure) supportano solo lo strumento di web fetch di base (`web_fetch_20250910`, senza filtraggio dinamico). I deployment ospitati su Anthropic supportano tutte le versioni.

<Note>
  Per [Claude Mythos Preview](https://anthropic.com/glasswing), il web fetch è disponibile sulla Claude API e su Microsoft Foundry.
</Note>

<Note>
  Usa il [modulo di feedback](https://forms.gle/NhWcgmkcvPCMmPE86) per fornire feedback sulla qualità delle risposte del modello, sull’API stessa o sulla qualità della documentazione.
</Note>

Per l’idoneità alla conservazione zero dei dati e la soluzione alternativa con `allowed_callers`, consulta [Strumenti server](https://platform.claude.com/docs/it/agents-and-tools/tool-use/server-tools#zdr-and-allowed-callers).

<Warning>
  Abilitare lo strumento di web fetch in ambienti in cui Claude elabora input non attendibili insieme a dati sensibili comporta rischi di esfiltrazione dei dati. Usa questo strumento solo in ambienti attendibili o quando gestisci dati non sensibili.

  Per ridurre al minimo i rischi di esfiltrazione, Claude non può recuperare URL che compaiono solo nel proprio output. Claude può recuperare solo URL che sono già comparsi nella conversazione: URL nei messaggi dell’utente, URL nei risultati degli strumenti lato client e URL provenienti da precedenti risultati di ricerca web o web fetch (consulta [Convalida degli URL](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-fetch-tool#url-validation)). Claude inoltre non può recuperare un URL che sembra contenere una credenziale, come una chiave API o una password, a meno che tale credenziale non compaia nel prompt di sistema o nel testo di un messaggio dell’utente.

  Tuttavia, esiste comunque un rischio residuo che dovresti valutare attentamente quando usi questo strumento.

  Se l’esfiltrazione dei dati è un problema, considera di:

  * Disabilitare completamente lo strumento di web fetch
  * Usare il parametro [`max_uses`](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-fetch-tool#max-uses) per limitare il numero di fetch in un turno
  * Usare il parametro `allowed_domains` per limitare l’accesso a domini noti e sicuri
  * Usare il parametro `url_sources` per impedire che i risultati degli strumenti lato client vengano considerati come fonte (consulta [Fonti degli URL](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-fetch-tool#url-sources))
</Warning>

Per il supporto dei modelli, consulta il [Riferimento agli strumenti](https://platform.claude.com/docs/it/agents-and-tools/tool-use/tool-reference).

## Come funziona il web fetch

Il web fetch è uno [strumento server](https://platform.claude.com/docs/it/agents-and-tools/tool-use/server-tools): l’API recupera il contenuto durante la richiesta e inserisce i risultati nella conversazione. Non devi eseguire nulla né restituire un `tool_result`. L’eccezione si verifica quando Claude chiama il web fetch e uno dei tuoi strumenti client nello stesso gruppo di chiamate di strumenti parallele: l’API restituisce la risposta con `stop_reason: "tool_use"` prima che quel fetch sia stato eseguito, quindi esegue il fetch quando rinvii i blocchi `tool_result` del client. Consulta [Combinare strumenti server e strumenti client in un unico turno](https://platform.claude.com/docs/it/agents-and-tools/tool-use/server-tools#mixing-server-tools-and-client-tools-in-one-turn).

Quando aggiungi lo strumento di web fetch alla tua richiesta API:

1. Claude determina quando recuperare il contenuto in base al prompt e agli URL disponibili.
2. L’API recupera il contenuto testuale completo dall’URL specificato.
3. Per i PDF, l’API restituisce il contenuto come dati codificati in base64 e lo elabora come un documento PDF allegato direttamente.
4. Claude analizza il contenuto recuperato e fornisce una risposta con citazioni facoltative.

<Note>
  Lo strumento di web fetch attualmente non supporta i siti web renderizzati dinamicamente con JavaScript. Per le pagine che richiedono un browser reale (rendering JavaScript, clic o compilazione di moduli), considera lo [strumento di browser use](https://platform.claude.com/docs/it/agents-and-tools/tool-use/browser-use-tool), uno strumento client in cui la tua applicazione controlla il browser e restituisce a Claude il testo della pagina o gli screenshot come risultati degli strumenti.
</Note>

### Quando Claude esegue il fetch

Claude esegue il fetch quando la richiesta punta a una pagina o a un documento specifico:

* Un URL è fornito nella conversazione (o in un precedente risultato di uno strumento)
* L’utente nomina una risorsa specifica (un particolare articolo, README, pagina dei prezzi o sezione della documentazione) senza un URL, e anche lo [strumento di ricerca web](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-search-tool) è abilitato in modo che Claude possa prima individuarla (consulta [Ricerca e fetch combinati](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-fetch-tool#combined-search-and-fetch))

Claude **non** esegue il fetch per domande di cultura generale o aperte che non fanno riferimento a una pagina specifica. “Riassumi questo articolo: `<url>`” attiva un fetch. “Quali sono le best practice per la progettazione di API REST?” riceve una risposta diretta.

### Filtraggio dinamico

Recuperare pagine web e PDF completi può consumare rapidamente token, soprattutto quando da documenti di grandi dimensioni servono solo informazioni specifiche. Con `web_fetch_20260209` o versioni successive, Claude può scrivere ed eseguire codice per filtrare il contenuto recuperato prima di caricarlo nel contesto.

Questo filtraggio dinamico è particolarmente utile per:

* Estrarre sezioni specifiche da documenti lunghi
* Elaborare dati strutturati da pagine web
* Filtrare informazioni rilevanti dai PDF
* Ridurre i costi in token quando si lavora con documenti di grandi dimensioni

<Note>
  Il filtraggio dinamico viene eseguito sullo [strumento di esecuzione del codice](https://platform.claude.com/docs/it/agents-and-tools/tool-use/code-execution-tool), che l’API abilita automaticamente per la richiesta. Non è necessario aggiungere lo strumento di esecuzione del codice all’array `tools`.
</Note>

Per abilitare il filtraggio dinamico, usa `web_fetch_20260209` o qualsiasi versione successiva. Gli esempi seguenti usano `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>

## Come usare il web fetch

<Note>
  Un amministratore dell’organizzazione può disattivare il web fetch per la tua organizzazione nella pagina [**Funzionalità**](https://platform.claude.com/settings/capabilities) della Claude Console. Con il web fetch disattivato, una richiesta alla Messages API che include lo strumento non riesce con un errore 400 `invalid_request_error` che indica che il web fetch non è abilitato. Con il web fetch attivato, l’amministratore può anche impostare domini consentiti o bloccati per il web fetch nella stessa pagina. Per sapere come questi elenchi si applicano a una richiesta, consulta [Filtraggio dei domini](https://platform.claude.com/docs/it/agents-and-tools/tool-use/server-tools#domain-filtering).
</Note>

Per sapere come le impostazioni di web fetch della tua organizzazione si applicano nelle sessioni di Claude Managed Agents, consulta [Limitare i domini di ricerca web e web fetch](https://platform.claude.com/docs/it/managed-agents/tools-web-restrictions).

Fornisci lo strumento di web fetch nella tua richiesta API:

<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>

## Definizione dello strumento

Lo strumento di web fetch supporta i seguenti parametri:

```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
}
```

Le versioni successive dello strumento aggiungono altri due parametri facoltativi: `use_cache` richiede `web_fetch_20260309` o versioni successive (consulta [Bypass della cache](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-fetch-tool#cache-bypass)), e `response_inclusion` richiede `web_fetch_20260318` o versioni successive (consulta [Inclusione nella risposta](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-fetch-tool#response-inclusion)).

### Utilizzi massimi

Il parametro `max_uses` limita il numero di web fetch in un singolo turno. I fetch non riusciti vengono conteggiati nel limite. Se Claude chiama direttamente il web fetch più volte di quanto consentito, il `web_fetch_tool_result` è un errore con il codice di errore `max_uses_exceeded`. Se Claude chiama il web fetch dall’esecuzione del codice più volte di quanto consentito, l’esecuzione del codice termina con un errore. Non esiste un limite predefinito.

Un turno può estendersi su più richieste. Una richiesta continua un turno quando riprende dopo [`pause_turn`](https://platform.claude.com/docs/it/agents-and-tools/tool-use/server-tools#the-server-side-loop-and-pause-turn) o quando il suo ultimo messaggio contiene solo blocchi `tool_result`. I fetch delle richieste precedenti in quel turno vengono conteggiati nel limite, a meno che Claude non li abbia eseguiti dall’esecuzione del codice tramite il [filtraggio dinamico](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-fetch-tool#dynamic-filtering).

### Filtraggio dei domini

Per il filtraggio dei domini con `allowed_domains` e `blocked_domains`, consulta [Strumenti server](https://platform.claude.com/docs/it/agents-and-tools/tool-use/server-tools#domain-filtering).

Su [Claude Managed Agents](https://platform.claude.com/docs/it/managed-agents/overview), imposta questi campi nella voce `web_fetch` del toolset dell’agente; consulta [Limitare i domini di ricerca web e web fetch](https://platform.claude.com/docs/it/managed-agents/tools-web-restrictions).

### Limiti del contenuto

Il parametro `max_content_tokens` limita la quantità di contenuto inclusa nel contesto. Se il contenuto recuperato supera questo limite, lo strumento lo tronca. Questo aiuta a controllare l’uso dei token quando si recuperano documenti di grandi dimensioni. Il limite è approssimativo: il numero effettivo di token di input utilizzati può variare leggermente. Il limite si applica al contenuto testuale, non al contenuto binario come i PDF.

Se un PDF recuperato fa superare alla richiesta i [limiti di pagine o di dimensione dei PDF](https://platform.claude.com/docs/it/build-with-claude/pdf-support#check-pdf-requirements), il `web_fetch_tool_result` è un errore con il codice di errore `content_too_large`. I PDF e le immagini già presenti nella conversazione vengono conteggiati in questi limiti, quindi rimuoverli può consentire al fetch di riuscire.

Su Claude Managed Agents, anche la voce `web_fetch` del toolset dell’agente accetta `max_content_tokens`; consulta le [impostazioni degli strumenti web](https://platform.claude.com/docs/it/managed-agents/tools-web-restrictions#settings).

### Bypass della cache

<Note>
  Richiede `web_fetch_20260309` o versioni successive (incluso `web_fetch_20260318`).
</Note>

Il parametro `use_cache` controlla se può essere restituito contenuto memorizzato nella cache. Imposta `"use_cache": false` per bypassare la cache e recuperare contenuto aggiornato. Il valore predefinito è `true`. Disabilita la cache solo quando l’utente richiede esplicitamente contenuto aggiornato o quando recuperi fonti che cambiano rapidamente, perché bypassare la cache aumenta la latenza.

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

### Inclusione nella risposta

<Note>
  Richiede `web_fetch_20260318` o versioni successive.
</Note>

Il parametro `response_inclusion` controlla come i blocchi dei risultati del fetch compaiono nella risposta dell’API quando il risultato è stato utilizzato da una chiamata di [esecuzione del codice](https://platform.claude.com/docs/it/agents-and-tools/tool-use/code-execution-tool) completata nella stessa risposta. Imposta `"response_inclusion": "excluded"` per rimuovere completamente dalla risposta quelle coppie annidate di blocchi `server_tool_use` e di risultato, per i flussi di lavoro agentici che non hanno bisogno del contenuto grezzo della pagina. L’utilizzo dei token non cambia, perché Claude legge l’output del codice anziché questi blocchi. Il valore predefinito è `"full"`. L’API restituisce sempre per intero i risultati delle chiamate dirette, o delle chiamate di esecuzione del codice che si sono messe in pausa prima di essere completate, in modo che tu possa rinviarli nella richiesta successiva.

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

### Citazioni

A differenza della ricerca web, in cui le citazioni sono sempre abilitate, per il web fetch le citazioni sono facoltative e disabilitate per impostazione predefinita. Imposta `"citations": {"enabled": true}` per consentire a Claude di citare passaggi specifici dai documenti recuperati.

<Note>
  Quando mostri gli output dell’API direttamente agli utenti finali, includi le citazioni alla fonte originale. Se apporti modifiche agli output dell’API, anche rielaborandoli o combinandoli con il tuo materiale prima di mostrarli agli utenti finali, mostra le citazioni in modo appropriato in base alla consultazione con il tuo team legale.
</Note>

## Risposta

Ecco un esempio di struttura della risposta:

```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"
}
```

### Risultati del fetch

I risultati del fetch includono:

* `url`: L’URL che è stato recuperato
* `content`: Un blocco documento contenente il contenuto recuperato
* `retrieved_at`: Timestamp del momento in cui il contenuto è stato recuperato

<Note>
  Lo strumento di web fetch memorizza i risultati nella cache per migliorare le prestazioni e ridurre le richieste ridondanti. Il contenuto restituito potrebbe non riflettere sempre la versione più recente disponibile all’URL. Il comportamento della cache è gestito automaticamente e può cambiare nel tempo per ottimizzarsi per diversi tipi di contenuto e modelli di utilizzo. Per recuperare contenuto aggiornato, imposta `"use_cache": false` (consulta [Bypass della cache](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-fetch-tool#cache-bypass)).
</Note>

Per i documenti PDF, il contenuto viene restituito come dati codificati in base64:

```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"
  }
}
```

### Errori

Quando lo strumento di web fetch riscontra un errore, la Claude API restituisce una risposta 200 (successo) con l’errore rappresentato nel corpo della risposta. Claude riceve il risultato dell’errore e continua il turno. Ad esempio:

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

Questi sono i possibili codici di errore:

* `invalid_tool_input`: Input dello strumento non valido, come un URL malformato o uno schema non HTTP(S)
* `url_too_long`: L’URL supera la lunghezza massima (250 caratteri)
* `url_not_allowed`: URL bloccato dalle regole di filtraggio dei domini (incluse le impostazioni della tua organizzazione) o da restrizioni lato Anthropic, come indirizzi privati, `robots.txt` e URL che sembrano contenere una credenziale che non hai fornito
* `url_not_in_prior_context`: L’URL non è comparso in precedenza nella conversazione, oppure è comparso solo in fonti escluse da `url_sources` (consulta [Convalida degli URL](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-fetch-tool#url-validation))
* `url_not_accessible`: Impossibile recuperare il contenuto (errore HTTP)
* `too_many_requests`: Limite di velocità superato
* `unsupported_content_type`: Tipo di contenuto non supportato (solo testo, HTML e PDF)
* `content_too_large`: Il PDF recuperato farebbe superare alla richiesta i limiti di pagine o di dimensione dei PDF (consulta [Limiti del contenuto](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-fetch-tool#content-limits))
* `max_uses_exceeded`: Numero massimo di utilizzi dello strumento di web fetch superato
* `unavailable`: Si è verificato un errore interno

## Convalida degli URL

Per motivi di sicurezza, lo strumento di web fetch può recuperare solo URL che sono già comparsi nel contesto della conversazione. Ciò include:

* URL nei messaggi dell’utente
* URL nei risultati degli strumenti lato client
* URL provenienti da precedenti risultati di ricerca web o web fetch

Lo strumento non può recuperare URL che compaiono solo nell’output di Claude o solo nel prompt di sistema. Per rendere recuperabile un URL presente nel prompt di sistema, includilo anche in un messaggio dell’utente. Nemmeno i risultati di altri strumenti lato server, come l’[esecuzione del codice](https://platform.claude.com/docs/it/agents-and-tools/tool-use/code-execution-tool), il [connettore MCP](https://platform.claude.com/docs/it/agents-and-tools/mcp-connector) o la [ricerca di strumenti](https://platform.claude.com/docs/it/agents-and-tools/tool-use/tool-search-tool), sono una fonte consentita. Per impostazione predefinita, i risultati degli strumenti lato client sono una fonte consentita anche quando riportano testo prodotto da Claude (ad esempio, un comando che stampa il proprio input o un messaggio di errore che lo cita).

Lo strumento rifiuta inoltre un URL che sembra contenere una credenziale, come una chiave API o una password, a meno che tale credenziale non compaia nel prompt di sistema o nel testo di un messaggio dell’utente. Una credenziale che compare solo nel risultato di uno strumento non viene considerata. Il risultato è un errore `url_not_allowed`. Per recuperare un URL di questo tipo, includilo in un messaggio dell’utente.

### Fonti degli URL

<Note>
  Funziona con `web_fetch_20250910`, `web_fetch_20260209`, `web_fetch_20260309` e `web_fetch_20260318`.
</Note>

Il parametro facoltativo `url_sources` ti consente di disattivare una qualsiasi delle tre fonti consentite, oppure di limitare i risultati degli strumenti a determinati strumenti. Ha una chiave per ciascuna fonte, e ogni chiave ha come valore predefinito `{"type": "all"}`:

* `user_input`: URL nei messaggi dell’utente. Il suo `type` è `"all"` o `"none"`.
* `client_tool_results`: URL nei risultati degli strumenti lato client. Il suo `type` è `"all"`, `"none"`, oppure un filtro `"only"` o `"except"` che nomina degli strumenti, come nell’esempio seguente.
* `server_tool_results`: URL provenienti da precedenti risultati di ricerca web o web fetch. Accetta gli stessi valori, e i suoi filtri nominano `web_search` o `web_fetch`.

Ad esempio, uno strumento che esegue codice scritto da Claude restituisce tutto ciò che quel codice stampa, incluso qualsiasi URL che Claude vi abbia inserito. Per impedire che i risultati di quello strumento vengano considerati come fonte, nominalo in un filtro `"except"`:

```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"]
      }
    }
  ]
}
```

Un filtro elenca gli strumenti come oggetti `tool_reference`. Ogni nome deve corrispondere a uno strumento nell’array `tools` della richiesta: uno strumento client per `client_tool_results`, o uno strumento server per `server_tool_results`. In caso contrario, la richiesta non riesce con un errore. Con `"except"`, uno strumento che aggiungi a `tools` in seguito viene considerato come fonte. Con `"only"`, non lo è.

Anche strumenti lato client diversi da `run_code` possono restituire testo scritto da Claude, ad esempio in un messaggio di errore che lo cita. Per escludere tutti i risultati degli strumenti lato client, imposta `client_tool_results` su `{"type": "none"}`.

Se un URL è comparso solo in fonti escluse da `url_sources`, il suo recupero restituisce l’errore `url_not_in_prior_context`.

## Ricerca e fetch combinati

Quando sono abilitati sia lo strumento di ricerca web sia lo strumento di web fetch, e l’utente nomina una pagina o un documento specifico senza fornire un URL (ad esempio, “leggi il README del repository anthropics/anthropic-sdk-python”), Claude usa la ricerca web per individuarlo, quindi recupera il risultato. L’esempio seguente richiede una ricerca e un’analisi in un’unica richiesta:

<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 questo flusso di lavoro, Claude:

1. Usa la ricerca web per trovare articoli pertinenti.
2. Seleziona i risultati più promettenti.
3. Usa il web fetch per recuperare il contenuto completo.
4. Fornisce un’analisi dettagliata con citazioni.

## Cache dei prompt

Per memorizzare nella cache le definizioni degli strumenti tra i turni, consulta [Uso degli strumenti con la cache dei prompt](https://platform.claude.com/docs/it/agents-and-tools/tool-use/tool-use-with-prompt-caching).

## Streaming

Con lo streaming abilitato, gli eventi di fetch fanno parte dello stream, con una pausa durante il recupero del contenuto:

```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...
```

## Richieste batch

Puoi includere lo strumento di web fetch nella [Message Batches API](https://platform.claude.com/docs/it/build-with-claude/batch-processing). Le chiamate allo strumento di web fetch tramite la Message Batches API hanno lo stesso prezzo di quelle nelle normali richieste alla Messages API.

## Utilizzo e prezzi

L’utilizzo di web fetch **non comporta costi aggiuntivi** oltre ai costi standard dei token:

```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
    }
  }
}
```

Lo strumento web fetch è disponibile sulla Claude API **senza costi aggiuntivi**. Paghi solo i costi standard dei token per il contenuto recuperato che diventa parte del contesto della tua conversazione.

Per proteggerti dal recupero involontario di contenuti di grandi dimensioni che consumerebbero una quantità eccessiva di token, usa il parametro `max_content_tokens` per impostare limiti appropriati in base al tuo caso d’uso e alle tue considerazioni di budget.

Esempio di utilizzo dei token per contenuti tipici:

* Pagina web media (10 kB): \~2.500 token
* Pagina di documentazione di grandi dimensioni (100 kB): \~25.000 token
* PDF di un articolo di ricerca (500 kB): \~125.000 token

## Passaggi successivi

<CardGroup>
  <Card href="https://platform.claude.com/docs/it/agents-and-tools/tool-use/code-execution-tool" title="Strumento di esecuzione del codice" icon="code">
    Esegui codice Python e Bash in un container isolato per analizzare dati, generare file e iterare sulle soluzioni.
  </Card>

  <Card href="https://platform.claude.com/docs/it/agents-and-tools/tool-use/server-tools" title="Strumenti server" icon="cloud">
    Lavora con gli strumenti eseguiti da Anthropic: blocchi `server_tool_use`, continuazione con `pause_turn` e filtraggio dei domini.
  </Card>

  <Card href="https://platform.claude.com/docs/it/agents-and-tools/tool-use/tool-reference" title="Riferimento agli strumenti" icon="book">
    Elenco degli strumenti forniti da Anthropic e riferimento per le proprietà facoltative della definizione degli strumenti.
  </Card>
</CardGroup>

## Disponibilità

La funzionalità Strumento web fetch è disponibile su tutti i modelli e idonea per conservazione zero dei dati.

### Supporto API

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

* Disponibilità: Disponibile
* Utilizzo: Aggiungi uno strumento `web_fetch` ai `tools` della richiesta. Impostazioni come `max_uses`, gli elenchi di domini, `citations` e `max_content_tokens` vanno su quello strumento.

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

1. I deployment ospitati su Azure supportano solo `web_fetch_20250910`: niente filtro dinamico, inclusione della risposta o bypass della cache.

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

* Disponibilità: Disponibile
* Utilizzo: Fa parte del toolset dell’agente ed è attivo per impostazione predefinita una volta aggiunto il toolset. Gli elenchi di domini (senza percorsi) e `max_content_tokens` vanno nella voce `web_fetch` del toolset; `max_uses`, `citations` e `cache_control` non sono disponibili.

| Stato       | Piattaforme cloud                                                                                                                                                                                                                                                              |
| ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Disponibile | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws), [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed) |

### Gestione dei dati

[Panoramica sulla gestione dei dati](https://platform.claude.com/docs/it/manage-claude/api-and-data-retention#feature-eligibility)

| Elemento | Conservazione zero dei dati                                                                                                                                                                                                                                                         | HIPAA      |
| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------- |
| Stato    | Idoneo (esclude [Modelli coperti](https://platform.claude.com/docs/it/manage-claude/api-and-data-retention#model-specific-data-retention-requirements))                                                                                                                             | Non idoneo |
| Dettagli | Contenuto web recuperato restituito nella risposta dell’API. Il filtro dinamico per web fetch non è idoneo per ZDR o HIPAA. Gli editori dei siti web potrebbero conservare i dati delle richieste (come gli URL recuperati e i metadati delle richieste) secondo le proprie policy. | —          |

Endpoint applicabili:

* `/v1/messages` con lo strumento `web_fetch`
