--- 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. --- Per scoprire come la "zero data retention" (conservazione zero dei dati), o ZDR, si applica a questa funzionalità, consulta [API e conservazione dei dati](https://platform.claude.com/docs/it/manage-claude/api-and-data-retention). Lo strumento web fetch consente a Claude di recuperare il contenuto completo da pagine web e documenti PDF specificati. La versione più recente dello strumento di recupero web (`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 i 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 versioni precedenti (`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 recupero di base) restano 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) 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 web fetch di base (`web_fetch_20250910`, senza filtraggio dinamico). I deployment ospitati su Anthropic supportano tutte le versioni. Il web fetch non è attualmente disponibile su Amazon Bedrock o Google Cloud. Per [Claude Mythos Preview](https://anthropic.com/glasswing), il web fetch è disponibile sulla Claude API e su Microsoft Foundry. Non è attualmente disponibile per Mythos Preview su Amazon Bedrock o Google Cloud. 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. Per l'idoneità alla Zero Data Retention e la soluzione alternativa `allowed_callers`, consulta [Strumenti server](https://platform.claude.com/docs/it/agents-and-tools/tool-use/server-tools#zdr-and-allowed-callers). Abilitare lo strumento 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 (anche quando un risultato riporta testo generato da Claude) e URL provenienti da precedenti risultati di ricerca web o di recupero web (consulta [Validazione 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 è una preoccupazione, considera di: * Disabilitare completamente lo strumento web fetch * Usare il parametro `max_uses` per limitare il numero di richieste * Usare il parametro `allowed_domains` per limitare l'accesso a domini noti e sicuri Per il supporto dei modelli, consulta il [Riferimento degli strumenti](https://platform.claude.com/docs/it/agents-and-tools/tool-use/tool-reference). ## Come funziona il web fetch Il web fetch è un [server tool](https://platform.claude.com/docs/it/agents-and-tools/tool-use/server-tools) (strumento server): 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 parallele agli strumenti: l'API restituisce la risposta con `stop_reason: "tool_use"` prima che quel fetch sia stato eseguito, quindi esegue il fetch quando invii 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 web fetch alla tua richiesta API: 1. Claude determina quando recuperare contenuti 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 opzionali. Lo strumento web fetch attualmente non supporta siti web renderizzati dinamicamente con JavaScript. Per le pagine che richiedono un vero browser (rendering JavaScript, clic o compilazione di moduli), considera lo [strumento 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 screenshot come risultati degli strumenti. ### Quando Claude esegue il fetch Claude esegue il fetch quando la richiesta punta a una pagina o un documento specifico: * Un URL è fornito nella conversazione (o in un risultato di strumento precedente) * L'utente nomina una risorsa specifica (un particolare articolo, README, pagina dei prezzi o sezione di documentazione) senza un URL, e anche lo [strumento web search](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-search-tool) è abilitato, così Claude può prima localizzarla (vedi [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: ``" 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 servono solo informazioni specifiche da documenti di grandi dimensioni. 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 dei token quando si lavora con documenti di grandi dimensioni 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`. Per abilitare il filtraggio dinamico, usa `web_fetch_20260209` o qualsiasi versione successiva. Gli esempi seguenti usano `web_fetch_20260318`: ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -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 <<'YAML' 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 YAML ``` ```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() { Role = Role.User, 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: '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: "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 ``` ## Come usare il web fetch Fornisci lo strumento web fetch nella tua richiesta API: ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "content-type: application/json" \ -d '{ "model": "claude-opus-5-5", "max_tokens": 1024, "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 1024 \ --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=1024, 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: 1024, 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 = 1024, Messages = [new() { Role = Role.User, 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: 1024, 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(1024L) .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: 1024, messages: [ ['role' => 'user', 'content' => 'Please analyze the content at https://example.com/article'] ], 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: "claude-opus-5-5", max_tokens: 1024, 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 ``` ## Definizione dello strumento Lo strumento web fetch supporta i seguenti parametri: ```json JSON { "type": "web_fetch_20250910", "name": "web_fetch", // Optional: Limit the number of fetches per request "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: 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 opzionali: `use_cache` richiede `web_fetch_20260309` o successiva (vedi [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 successiva (vedi [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 eseguiti. I fetch non riusciti vengono conteggiati nel limite. Se Claude tenta più fetch di quelli consentiti, il `web_fetch_tool_result` è un errore con il codice di errore `max_uses_exceeded`. Attualmente non esiste un limite predefinito. ### 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, dove ogni dominio elencato deve essere un semplice nome host senza percorso; consulta [Limitare i domini di web search e web fetch](https://platform.claude.com/docs/it/managed-agents/tools-web-restrictions). ### Limiti di contenuto Il parametro `max_content_tokens` limita la quantità di contenuto incluso 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 si applica al contenuto testuale, non al contenuto binario come i PDF. Il limite del parametro `max_content_tokens` è approssimativo. Il numero effettivo di token di input utilizzati può variare leggermente. 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 Richiede `web_fetch_20260309` o successiva (inclusa `web_fetch_20260318`). 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 "latency" (latenza). ```json { "tools": [ { "type": "web_fetch_20260309", "name": "web_fetch", "use_cache": false } ] } ``` ### Inclusione nella risposta Richiede `web_fetch_20260318` o successiva. Il parametro `response_inclusion` controlla come i blocchi dei risultati di fetch appaiono nella risposta API quando il risultato è stato consumato da una chiamata di [esecuzione del codice](https://platform.claude.com/docs/it/agents-and-tools/tool-use/code-execution-tool) completata nello stesso turno. Imposta `"response_inclusion": "excluded"` per eliminare completamente dalla risposta quelle coppie annidate di blocchi `server_tool_use` e risultato, riducendo i costi dei token di output per i flussi di lavoro agentici che non hanno bisogno di restituire al client il contenuto grezzo della pagina. Il valore predefinito è `"full"`. I risultati delle chiamate dirette, o delle chiamate di esecuzione del codice che si sono messe in pausa prima del completamento, vengono sempre restituiti per intero in modo che possano essere rinviati al turno successivo. ```json { "tools": [ { "type": "web_fetch_20260318", "name": "web_fetch", "response_inclusion": "excluded" } ] } ``` ### Citazioni A differenza del web search, dove le citazioni sono sempre abilitate, le citazioni sono opzionali per il web fetch e disabilitate per impostazione predefinita. Imposta `"citations": {"enabled": true}` per consentire a Claude di citare passaggi specifici dai documenti recuperati. 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 materiale tuo prima di mostrarli agli utenti finali, mostra le citazioni in modo appropriato in base a una consultazione con il tuo team legale. ## 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 Lo strumento web fetch memorizza i risultati nella cache per migliorare le prestazioni e ridurre le richieste ridondanti. Il contenuto restituito potrebbe non riflettere sempre l'ultima versione disponibile all'URL. Il comportamento della cache è gestito automaticamente e può cambiare nel tempo per ottimizzare diversi tipi di contenuto e modelli di utilizzo. Per recuperare contenuto aggiornato, imposta `"use_cache": false` (vedi [Bypass della cache](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-fetch-tool#cache-bypass)). 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 web fetch incontra un errore, la Claude API restituisce una risposta 200 (successo) con l'errore rappresentato nel corpo della risposta. Claude vede il risultato di 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 è apparso in precedenza nella conversazione (vedi [Validazione 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`: "Rate limit" (limite di velocità) superato * `unsupported_content_type`: Tipo di contenuto non supportato (solo testo, HTML e PDF) * `max_uses_exceeded`: Numero massimo di utilizzi dello strumento web fetch superato * `unavailable`: Si è verificato un errore interno ## Validazione degli URL Per motivi di sicurezza, lo strumento web fetch può recuperare solo URL che sono apparsi in precedenza nel contesto della conversazione. Questo include: * URL nei messaggi dell'utente * URL nei risultati degli strumenti lato client * URL provenienti da risultati precedenti di web search 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 degli strumenti](https://platform.claude.com/docs/it/agents-and-tools/tool-use/tool-search-tool), sono una fonte consentita. 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 è sufficiente. Il risultato è un errore `url_not_allowed`. Per recuperare un URL di questo tipo, includilo in un messaggio dell'utente. ## Ricerca e fetch combinati Quando sia lo strumento web search sia lo strumento web fetch sono abilitati, e l'utente nomina una pagina o un documento specifico senza fornire un URL (ad esempio, "leggi il README dal repository anthropics/anthropic-sdk-python"), Claude usa il web search per localizzarlo, quindi esegue il fetch del risultato. L'esempio seguente richiede una ricerca e un'analisi in un'unica richiesta: ```bash cURL curl https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -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() { Role = Role.User, 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: '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: "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 ``` In questo flusso di lavoro, Claude: 1. Usa il web search per trovare articoli rilevanti. 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 executes // 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 web fetch nella [Messages Batches API](https://platform.claude.com/docs/it/build-with-claude/batch-processing). Le chiamate allo strumento web fetch tramite la Messages Batches API hanno lo stesso prezzo di quelle nelle normali richieste della 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 Esegui codice Python e bash in un container sandbox per analizzare dati, generare file e iterare sulle soluzioni. Lavora con gli strumenti eseguiti da Anthropic: blocchi server\_tool\_use, continuazione pause\_turn e filtraggio dei domini. Elenco degli strumenti forniti da Anthropic e riferimento per le proprietà opzionali di definizione degli strumenti.