---
title: Ferramenta web fetch
url: https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-fetch-tool
description: Busque e leia conteúdo de URLs específicas para ampliar o contexto do Claude com conteúdo web ao vivo.
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). Conteúdo web obtido e retornado na resposta da API. A filtragem dinâmica do web fetch não é elegível para ZDR nem para HIPAA. Os editores de sites podem reter dados das requisições (como URLs obtidas e metadados das requisições) de acordo com suas próprias políticas.
  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: "Implantações hospedadas no Azure são compatíveis somente com `web_fetch_20250910`: sem filtragem dinâmica, inclusão de resposta ou bypass de cache."
---

**Suporte da API**: O uso varia conforme o produto.

* **Messages API**: Adicione uma ferramenta `web_fetch` às `tools` da requisição.
* **Managed Agents**: Ativada por padrão no conjunto de ferramentas do agente, sem `max_uses`, `citations` ou `cache_control`.

A ferramenta web fetch permite que Claude recupere o conteúdo completo de páginas web e documentos PDF especificados.

A versão mais recente da ferramenta web fetch (`web_fetch_20260318`) oferece suporte a **filtragem dinâmica**: Claude pode escrever e executar código para filtrar o conteúdo buscado antes que ele chegue à “context window” (janela de contexto), mantendo apenas as informações relevantes e descartando o restante. Isso reduz o consumo de tokens mantendo a qualidade da resposta. A filtragem dinâmica está disponível com Claude 4.6 e modelos posteriores e com o [Claude Mythos Preview](https://anthropic.com/glasswing). `web_fetch_20260318` também adiciona controle de [inclusão na resposta](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-fetch-tool#response-inclusion) para fluxos de trabalho agênticos. As outras versões (`web_fetch_20260309` para filtragem dinâmica e [ignorar o cache](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-fetch-tool#cache-bypass), `web_fetch_20260209` apenas para filtragem dinâmica, `web_fetch_20250910` para busca básica) estão disponíveis.

O web fetch (com e sem filtragem dinâmica) está disponível na Claude API, na [Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws), no [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-models-on-google-cloud/anthropic-managed) e no [Microsoft Foundry](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-microsoft-foundry). No Microsoft Foundry, implantações [hospedadas no Azure](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-microsoft-foundry#additional-features-not-supported-when-hosted-on-azure) oferecem suporte apenas à ferramenta web fetch básica (`web_fetch_20250910`, sem filtragem dinâmica). Implantações hospedadas na Anthropic oferecem suporte a todas as versões.

<Note>
  Para o [Claude Mythos Preview](https://anthropic.com/glasswing), o web fetch está disponível na Claude API e no Microsoft Foundry.
</Note>

<Note>
  Use o [formulário de feedback](https://forms.gle/NhWcgmkcvPCMmPE86) para enviar feedback sobre a qualidade das respostas do modelo, a própria API ou a qualidade da documentação.
</Note>

Para a elegibilidade para retenção zero de dados e a solução alternativa com `allowed_callers`, consulte [Ferramentas de servidor](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/server-tools#zdr-and-allowed-callers).

<Warning>
  Habilitar a ferramenta web fetch em ambientes onde Claude processa entradas não confiáveis junto com dados sensíveis apresenta riscos de exfiltração de dados. Use esta ferramenta apenas em ambientes confiáveis ou ao lidar com dados não sensíveis.

  Para minimizar os riscos de exfiltração, Claude não pode buscar URLs que aparecem apenas em sua própria saída. Claude só pode buscar URLs que apareceram anteriormente na conversa: URLs em mensagens do usuário, URLs em resultados de ferramentas do lado do cliente e URLs de resultados anteriores de pesquisa na web ou web fetch (consulte [Validação de URL](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-fetch-tool#url-validation)). Claude também não pode buscar uma URL que pareça conter uma credencial, como uma chave de API ou uma senha, a menos que essa credencial apareça no prompt do sistema ou no texto de uma mensagem do usuário.

  No entanto, ainda existe um risco residual que você deve considerar cuidadosamente ao usar esta ferramenta.

  Se a exfiltração de dados for uma preocupação, considere:

  * Desabilitar completamente a ferramenta web fetch
  * Usar o parâmetro [`max_uses`](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-fetch-tool#max-uses) para limitar o número de buscas em um turno
  * Usar o parâmetro `allowed_domains` para restringir a domínios conhecidamente seguros
  * Usar o parâmetro `url_sources` para impedir que resultados de ferramentas do lado do cliente contem como fonte (consulte [Fontes de URL](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-fetch-tool#url-sources))
</Warning>

Para suporte a modelos, consulte a [Referência de ferramentas](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/tool-reference).

## Como o web fetch funciona

O web fetch é uma [ferramenta de servidor](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/server-tools): a API busca o conteúdo durante a requisição e insere os resultados na conversa. Você não executa nada nem retorna um `tool_result`. A exceção é quando Claude chama o web fetch e uma de suas ferramentas de cliente no mesmo grupo de chamadas de ferramentas paralelas: a API retorna a resposta com `stop_reason: "tool_use"` antes que essa busca tenha sido executada e, em seguida, executa a busca quando você envia de volta os blocos `tool_result` do cliente. Consulte [Misturando ferramentas de servidor e ferramentas de cliente em um turno](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/server-tools#mixing-server-tools-and-client-tools-in-one-turn).

Quando você adiciona a ferramenta web fetch à sua requisição de API:

1. Claude determina quando buscar conteúdo com base no prompt e nas URLs disponíveis.
2. A API recupera o conteúdo de texto completo da URL especificada.
3. Para PDFs, a API retorna o conteúdo como dados codificados em base64 e o processa como um documento PDF anexado diretamente.
4. Claude analisa o conteúdo buscado e fornece uma resposta com citações opcionais.

<Note>
  A ferramenta web fetch atualmente não oferece suporte a sites renderizados dinamicamente com JavaScript. Para páginas que precisam de um navegador real (renderização de JavaScript, cliques ou preenchimento de formulários), considere a [ferramenta de uso de navegador](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/browser-use-tool), uma ferramenta de cliente em que sua aplicação controla o navegador e retorna o texto da página ou capturas de tela para Claude como resultados de ferramentas.
</Note>

### Quando Claude busca

Claude busca quando a requisição aponta para uma página ou documento específico:

* Uma URL é fornecida na conversa (ou em um resultado de ferramenta anterior)
* O usuário nomeia um recurso específico (um artigo, README, página de preços ou seção de documentação em particular) sem uma URL, e a [ferramenta de pesquisa na web](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-search-tool) também está habilitada para que Claude possa localizá-lo primeiro (consulte [Pesquisa na web e web fetch combinados](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-fetch-tool#combined-search-and-fetch))

Claude **não** busca para perguntas de conhecimento geral ou abertas que não fazem referência a uma página específica. “Resuma este artigo: `<url>`” aciona uma busca. “Quais são as melhores práticas para design de API REST?” é respondida diretamente.

### Filtragem dinâmica

Buscar páginas web e PDFs completos pode consumir tokens rapidamente, especialmente quando apenas informações específicas são necessárias de documentos grandes. Com `web_fetch_20260209` ou posterior, Claude pode escrever e executar código para filtrar o conteúdo buscado antes de carregá-lo no contexto.

Essa filtragem dinâmica é particularmente útil para:

* Extrair seções específicas de documentos longos
* Processar dados estruturados de páginas web
* Filtrar informações relevantes de PDFs
* Reduzir custos de tokens ao trabalhar com documentos grandes

<Note>
  A filtragem dinâmica é executada na [ferramenta de execução de código](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/code-execution-tool), que a API habilita automaticamente para a requisição. Você não precisa adicionar a ferramenta de execução de código ao array `tools`.
</Note>

Para habilitar a filtragem dinâmica, use `web_fetch_20260209` ou qualquer versão posterior. Os exemplos a seguir usam `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>

## Como usar o web fetch

<Note>
  Um administrador da organização pode desativar o web fetch para sua organização na página [**Recursos**](https://platform.claude.com/settings/capabilities) do Claude Console. Com o web fetch desativado, uma requisição à Messages API que inclua a ferramenta falha com um `invalid_request_error` 400 informando que o web fetch não está habilitado. Com o web fetch ativado, o administrador também pode definir domínios permitidos ou bloqueados para o web fetch na mesma página. Para saber como essas listas se aplicam a uma requisição, consulte [Filtragem de domínios](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/server-tools#domain-filtering).
</Note>

Para saber como as configurações de web fetch da sua organização se aplicam em sessões do Claude Managed Agents, consulte [Restringir domínios de pesquisa na web e web fetch](https://platform.claude.com/docs/pt-BR/managed-agents/tools-web-restrictions).

Forneça a ferramenta web fetch na sua requisição de 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>

## Definição da ferramenta

A ferramenta web fetch oferece suporte aos seguintes parâmetros:

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

Versões posteriores da ferramenta adicionam mais dois parâmetros opcionais: `use_cache` requer `web_fetch_20260309` ou posterior (consulte [Ignorar o cache](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-fetch-tool#cache-bypass)), e `response_inclusion` requer `web_fetch_20260318` ou posterior (consulte [Inclusão na resposta](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-fetch-tool#response-inclusion)).

### Máximo de usos

O parâmetro `max_uses` limita o número de buscas web em um único turno. Buscas que falharam contam para o limite. Se Claude chamar o web fetch diretamente mais vezes do que o permitido, o `web_fetch_tool_result` será um erro com o código de erro `max_uses_exceeded`. Se Claude chamar o web fetch a partir da execução de código mais vezes do que o permitido, a execução de código termina com um erro. Não há limite padrão.

Um turno pode abranger várias requisições. Uma requisição continua um turno quando é retomada após [`pause_turn`](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/server-tools#the-server-side-loop-and-pause-turn) ou quando sua última mensagem contém apenas blocos `tool_result`. Buscas de requisições anteriores nesse turno contam para o limite, a menos que Claude as tenha executado a partir da execução de código por meio de [filtragem dinâmica](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-fetch-tool#dynamic-filtering).

### Filtragem de domínios

Para filtragem de domínios com `allowed_domains` e `blocked_domains`, consulte [Ferramentas de servidor](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/server-tools#domain-filtering).

No [Claude Managed Agents](https://platform.claude.com/docs/pt-BR/managed-agents/overview), defina esses campos na entrada `web_fetch` do conjunto de ferramentas do agente; consulte [Restringir domínios de pesquisa na web e web fetch](https://platform.claude.com/docs/pt-BR/managed-agents/tools-web-restrictions).

### Limites de conteúdo

O parâmetro `max_content_tokens` limita a quantidade de conteúdo incluída no contexto. Se o conteúdo buscado exceder esse limite, a ferramenta o trunca. Isso ajuda a controlar o uso de tokens ao buscar documentos grandes. O limite é aproximado: o número real de tokens de entrada usados pode variar em uma pequena quantidade. O limite se aplica a conteúdo de texto, não a conteúdo binário como PDFs.

Se um PDF buscado fizer com que a requisição exceda os [limites de páginas ou de tamanho de PDF](https://platform.claude.com/docs/pt-BR/build-with-claude/pdf-support#check-pdf-requirements), o `web_fetch_tool_result` será um erro com o código de erro `content_too_large`. PDFs e imagens já presentes na conversa contam para esses limites, portanto removê-los pode permitir que a busca seja bem-sucedida.

No Claude Managed Agents, a entrada `web_fetch` do conjunto de ferramentas do agente também aceita `max_content_tokens`; consulte as [configurações da ferramenta web](https://platform.claude.com/docs/pt-BR/managed-agents/tools-web-restrictions#settings).

### Ignorar o cache

<Note>
  Requer `web_fetch_20260309` ou posterior (incluindo `web_fetch_20260318`).
</Note>

O parâmetro `use_cache` controla se conteúdo em cache pode ser retornado. Defina `"use_cache": false` para ignorar o cache e buscar conteúdo atualizado. O padrão é `true`. Desative o cache apenas quando o usuário solicitar explicitamente conteúdo atualizado ou ao buscar fontes que mudam rapidamente, pois ignorar o cache aumenta a “latency” (latência).

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

### Inclusão na resposta

<Note>
  Requer `web_fetch_20260318` ou posterior.
</Note>

O parâmetro `response_inclusion` controla como os blocos de resultado de busca aparecem na resposta da API quando o resultado foi consumido por uma chamada de [execução de código](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/code-execution-tool) concluída na mesma resposta. Defina `"response_inclusion": "excluded"` para remover completamente da resposta esses pares aninhados de blocos `server_tool_use` e de resultado, para fluxos de trabalho agênticos que não precisam do conteúdo bruto da página. O uso de tokens não é afetado, porque Claude lê a saída do código em vez desses blocos. O padrão é `"full"`. A API sempre retorna por completo os resultados de chamadas diretas, ou de chamadas de execução de código que foram pausadas antes de serem concluídas, para que você possa enviá-los de volta na próxima requisição.

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

### Citações

Diferentemente da pesquisa na web, em que as citações estão sempre habilitadas, as citações são opcionais para o web fetch e desabilitadas por padrão. Defina `"citations": {"enabled": true}` para permitir que Claude cite trechos específicos dos documentos buscados.

<Note>
  Ao exibir as saídas da API diretamente para usuários finais, inclua citações da fonte original. Se você estiver fazendo modificações nas saídas da API, incluindo reprocessá-las ou combiná-las com seu próprio material antes de exibi-las aos usuários finais, exiba as citações conforme apropriado com base em consulta à sua equipe jurídica.
</Note>

## Resposta

Aqui está um exemplo de estrutura de resposta:

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

### Resultados da busca

Os resultados da busca incluem:

* `url`: A URL que foi buscada
* `content`: Um bloco de documento contendo o conteúdo buscado
* `retrieved_at`: Timestamp de quando o conteúdo foi recuperado

<Note>
  A ferramenta web fetch armazena resultados em cache para melhorar o desempenho e reduzir requisições redundantes. O conteúdo retornado pode nem sempre refletir a versão mais recente disponível na URL. O comportamento do cache é gerenciado automaticamente e pode mudar ao longo do tempo para otimizar diferentes tipos de conteúdo e padrões de uso. Para buscar conteúdo atualizado, defina `"use_cache": false` (consulte [Ignorar o cache](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-fetch-tool#cache-bypass)).
</Note>

Para documentos PDF, o conteúdo é retornado como dados codificados em 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"
  }
}
```

### Erros

Quando a ferramenta web fetch encontra um erro, a Claude API retorna uma resposta 200 (sucesso) com o erro representado no corpo da resposta. Claude recebe o resultado de erro e continua o turno. Por exemplo:

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

Estes são os códigos de erro possíveis:

* `invalid_tool_input`: Entrada de ferramenta inválida, como uma URL malformada ou um esquema não HTTP(S)
* `url_too_long`: A URL excede o comprimento máximo (250 caracteres)
* `url_not_allowed`: URL bloqueada por regras de filtragem de domínios (incluindo as configurações da sua organização) ou por restrições do lado da Anthropic, como endereços privados, `robots.txt` e URLs que parecem conter uma credencial que você não forneceu
* `url_not_in_prior_context`: A URL não apareceu anteriormente na conversa, ou apareceu apenas em fontes que `url_sources` exclui (consulte [Validação de URL](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-fetch-tool#url-validation))
* `url_not_accessible`: Falha ao buscar o conteúdo (erro HTTP)
* `too_many_requests`: Limite de taxa excedido
* `unsupported_content_type`: Tipo de conteúdo não suportado (apenas texto, HTML e PDF)
* `content_too_large`: O PDF buscado faria a requisição exceder os limites de páginas ou de tamanho de PDF (consulte [Limites de conteúdo](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/web-fetch-tool#content-limits))
* `max_uses_exceeded`: Número máximo de usos da ferramenta web fetch excedido
* `unavailable`: Ocorreu um erro interno

## Validação de URL

Por motivos de segurança, a ferramenta web fetch só pode buscar URLs que apareceram anteriormente no contexto da conversa. Isso inclui:

* URLs em mensagens do usuário
* URLs em resultados de ferramentas do lado do cliente
* URLs de resultados anteriores de pesquisa na web ou web fetch

A ferramenta não pode buscar URLs que aparecem apenas na própria saída de Claude ou apenas no prompt do sistema. Para tornar buscável uma URL do prompt do sistema, inclua-a também em uma mensagem do usuário. Resultados de outras ferramentas do lado do servidor, como [execução de código](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/code-execution-tool), o [conector MCP](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-connector) ou a [pesquisa de ferramentas](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/tool-search-tool), também não são uma fonte permitida. Por padrão, resultados de ferramentas do lado do cliente são uma fonte permitida mesmo quando repetem texto que Claude produziu (por exemplo, um comando que imprime sua entrada ou uma mensagem de erro que a cita).

A ferramenta também recusa uma URL que pareça conter uma credencial, como uma chave de API ou uma senha, a menos que essa credencial apareça no prompt do sistema ou no texto de uma mensagem do usuário. Uma credencial que aparece apenas em um resultado de ferramenta não conta. O resultado é um erro `url_not_allowed`. Para buscar uma URL desse tipo, inclua-a em uma mensagem do usuário.

### Fontes de URL

<Note>
  Funciona com `web_fetch_20250910`, `web_fetch_20260209`, `web_fetch_20260309` e `web_fetch_20260318`.
</Note>

O parâmetro opcional `url_sources` permite desativar qualquer uma das três fontes permitidas ou limitar os resultados de ferramentas a determinadas ferramentas. Ele tem uma chave para cada fonte, e cada chave tem como padrão `{"type": "all"}`:

* `user_input`: URLs em mensagens do usuário. Seu `type` é `"all"` ou `"none"`.
* `client_tool_results`: URLs em resultados de ferramentas do lado do cliente. Seu `type` é `"all"`, `"none"` ou um filtro `"only"` ou `"except"` que nomeia ferramentas, como no exemplo a seguir.
* `server_tool_results`: URLs de resultados anteriores de pesquisa na web ou web fetch. Aceita os mesmos valores, e seus filtros nomeiam `web_search` ou `web_fetch`.

Por exemplo, uma ferramenta que executa código escrito por Claude retorna tudo o que esse código imprime, incluindo qualquer URL que Claude tenha colocado nele. Para impedir que os resultados dessa ferramenta contem como fonte, nomeie-a em um 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"]
      }
    }
  ]
}
```

Um filtro lista ferramentas como objetos `tool_reference`. Cada nome deve corresponder a uma ferramenta no array `tools` da requisição: uma ferramenta de cliente para `client_tool_results` ou uma ferramenta de servidor para `server_tool_results`. Caso contrário, a requisição falha com um erro. Com `"except"`, uma ferramenta que você adicionar a `tools` posteriormente conta como fonte. Com `"only"`, não conta.

Ferramentas do lado do cliente diferentes de `run_code` também podem retornar texto escrito por Claude, por exemplo em uma mensagem de erro que o cita. Para excluir todos os resultados de ferramentas do lado do cliente, defina `client_tool_results` como `{"type": "none"}`.

Se uma URL apareceu apenas em fontes que `url_sources` exclui, buscá-la retorna o erro `url_not_in_prior_context`.

## Pesquisa na web e web fetch combinados

Quando as ferramentas de pesquisa na web e web fetch estão ambas habilitadas, e o usuário nomeia uma página ou documento específico sem fornecer uma URL (por exemplo, “leia o README do repositório anthropics/anthropic-sdk-python”), Claude usa a pesquisa na web para localizá-lo e, em seguida, busca o resultado. O exemplo a seguir solicita uma pesquisa e uma análise em uma única requisição:

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

Neste fluxo de trabalho, Claude:

1. Usa a pesquisa na web para encontrar artigos relevantes.
2. Seleciona os resultados mais promissores.
3. Usa o web fetch para recuperar o conteúdo completo.
4. Fornece uma análise detalhada com citações.

## Cache de prompt

Para armazenar em cache definições de ferramentas entre turnos, consulte [Uso de ferramentas com cache de prompt](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/tool-use-with-prompt-caching).

## Streaming

Com o streaming habilitado, os eventos de busca fazem parte do stream, com uma pausa durante a recuperação do conteúdo:

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

## Requisições em lote

Você pode incluir a ferramenta web fetch na [Message Batches API](https://platform.claude.com/docs/pt-BR/build-with-claude/batch-processing). As chamadas da ferramenta web fetch por meio da Message Batches API têm o mesmo preço que as de requisições regulares à Messages API.

## Uso e preços

O uso do web fetch **não tem cobranças adicionais** além dos custos padrão de tokens:

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

A ferramenta web fetch está disponível na Claude API **sem custo adicional**. Você paga apenas os custos padrão de tokens pelo conteúdo buscado que se torna parte do contexto da sua conversa.

Para se proteger contra a busca inadvertida de conteúdo grande que consumiria tokens em excesso, use o parâmetro `max_content_tokens` para definir limites apropriados com base no seu caso de uso e em considerações de orçamento.

Exemplo de uso de tokens para conteúdo típico:

* Página web média (10 kB): \~2.500 tokens
* Página de documentação grande (100 kB): \~25.000 tokens
* PDF de artigo de pesquisa (500 kB): \~125.000 tokens

## Próximos passos

<CardGroup>
  <Card href="https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/code-execution-tool" title="Ferramenta de execução de código" icon="code">
    Execute código Python e Bash em um contêiner isolado para analisar dados, gerar arquivos e iterar em soluções.
  </Card>

  <Card href="https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/server-tools" title="Ferramentas de servidor" icon="cloud">
    Trabalhe com ferramentas que a Anthropic executa: blocos `server_tool_use`, continuação com `pause_turn` e filtragem de domínios.
  </Card>

  <Card href="https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/tool-reference" title="Referência de ferramentas" icon="book">
    Diretório de ferramentas fornecidas pela Anthropic e referência para propriedades opcionais de definição de ferramentas.
  </Card>
</CardGroup>

## Disponibilidade

Ferramenta web fetch está disponível em todos os modelos e é elegível para retenção zero de dados.

### Suporte da API

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

* Disponibilidade: Disponível
* Uso: Adicione uma ferramenta `web_fetch` às `tools` da requisição. Configurações como `max_uses`, listas de domínios, `citations` e `max_content_tokens` ficam nessa ferramenta.

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

1. Implantações hospedadas no Azure são compatíveis somente com `web_fetch_20250910`: sem filtragem dinâmica, inclusão de resposta ou bypass de cache.

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

* Disponibilidade: Disponível
* Uso: Faz parte do conjunto de ferramentas do agente e fica ativada por padrão depois que o conjunto de ferramentas é adicionado. As listas de domínios (sem caminhos) e `max_content_tokens` ficam na entrada `web_fetch` do conjunto de ferramentas; `max_uses`, `citations` e `cache_control` não estão disponíveis.

| Status     | Plataformas de nuvem                                                                                                  |
| ---------- | --------------------------------------------------------------------------------------------------------------------- |
| Disponível | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws) |

### Tratamento de dados

[Visão geral do tratamento de dados](https://platform.claude.com/docs/pt-BR/manage-claude/api-and-data-retention#feature-eligibility)

| Item     | Retenção zero de dados                                                                                                                                                                                                                                                      | HIPAA        |
| -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------ |
| Status   | Elegível (exclui [Modelos cobertos](https://platform.claude.com/docs/pt-BR/manage-claude/api-and-data-retention#model-specific-data-retention-requirements))                                                                                                                | Não elegível |
| Detalhes | Conteúdo web obtido e retornado na resposta da API. A filtragem dinâmica do web fetch não é elegível para ZDR nem para HIPAA. Os editores de sites podem reter dados das requisições (como URLs obtidas e metadados das requisições) de acordo com suas próprias políticas. | —            |

Endpoints aplicáveis:

* `/v1/messages` com a ferramenta `web_fetch`
