---
title: Herramienta de obtención web
url: https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-fetch-tool
description: Obtén y lee contenido de URLs específicas para ampliar el contexto de Claude con contenido web en 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). Contenido web obtenido devuelto en la respuesta de la API. El filtrado dinámico de la obtención web no es elegible para ZDR ni HIPAA. Los editores de sitios web podrían conservar datos de las solicitudes (como las URL obtenidas y los metadatos de las solicitudes) según sus propias 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: "Las implementaciones alojadas en Azure solo admiten `web_fetch_20250910`: sin filtrado dinámico, inclusión de respuesta ni omisión de caché."
---

**Compatibilidad con la API**: El uso varía según el producto.

* **Messages API**: Añade una herramienta `web_fetch` a las `tools` de la solicitud.
* **Managed Agents**: Activada de forma predeterminada en el conjunto de herramientas del agente, sin `max_uses`, `citations` ni `cache_control`.

La herramienta de obtención web permite a Claude recuperar el contenido completo de páginas web y documentos PDF especificados.

La versión más reciente de la herramienta de obtención web (`web_fetch_20260318`) admite **filtrado dinámico**: Claude puede escribir y ejecutar código para filtrar el contenido obtenido antes de que llegue a la ventana de contexto, conservando solo la información relevante y descartando el resto. Esto reduce el consumo de tokens mientras mantiene la calidad de las respuestas. El filtrado dinámico está disponible con Claude 4.6 y modelos posteriores, y con [Claude Mythos Preview](https://anthropic.com/glasswing). `web_fetch_20260318` también añade control de [inclusión en la respuesta](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-fetch-tool#response-inclusion) para flujos de trabajo agénticos. Las otras versiones (`web_fetch_20260309` para filtrado dinámico y [omisión de caché](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-fetch-tool#cache-bypass), `web_fetch_20260209` solo para filtrado dinámico, `web_fetch_20250910` para obtención básica) están disponibles.

La obtención web (con y sin filtrado dinámico) está disponible en la Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws), [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed) y [Microsoft Foundry](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry). En Microsoft Foundry, las implementaciones [alojadas en Azure](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry#additional-features-not-supported-when-hosted-on-azure) solo admiten la herramienta básica de obtención web (`web_fetch_20250910`, sin filtrado dinámico). Las implementaciones alojadas en Anthropic admiten todas las versiones.

<Note>
  Para [Claude Mythos Preview](https://anthropic.com/glasswing), la obtención web está disponible en la Claude API y en Microsoft Foundry.
</Note>

<Note>
  Usa el [formulario de comentarios](https://forms.gle/NhWcgmkcvPCMmPE86) para enviar comentarios sobre la calidad de las respuestas del modelo, la propia API o la calidad de la documentación.
</Note>

Para conocer la elegibilidad para la retención cero de datos y la solución alternativa con `allowed_callers`, consulta [Herramientas de servidor](https://platform.claude.com/docs/es/agents-and-tools/tool-use/server-tools#zdr-and-allowed-callers).

<Warning>
  Habilitar la herramienta de obtención web en entornos donde Claude procesa entradas no confiables junto con datos sensibles conlleva riesgos de exfiltración de datos. Usa esta herramienta solo en entornos de confianza o cuando manejes datos no sensibles.

  Para minimizar los riesgos de exfiltración, Claude no puede obtener URLs que aparezcan solo en su propia salida. Claude solo puede obtener URLs que hayan aparecido previamente en la conversación: URLs en mensajes del usuario, URLs en resultados de herramientas del lado del cliente y URLs de resultados previos de búsqueda web u obtención web (consulta [Validación de URL](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-fetch-tool#url-validation)). Claude tampoco puede obtener una URL que parezca contener una credencial, como una clave de API o una contraseña, a menos que esa credencial aparezca en la indicación del sistema o en el texto de un mensaje del usuario.

  Sin embargo, todavía existe un riesgo residual que debes considerar cuidadosamente al usar esta herramienta.

  Si la exfiltración de datos es una preocupación, considera:

  * Deshabilitar por completo la herramienta de obtención web
  * Usar el parámetro [`max_uses`](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-fetch-tool#max-uses) para limitar el número de obtenciones en un turno
  * Usar el parámetro `allowed_domains` para restringir a dominios conocidos y seguros
  * Usar el parámetro `url_sources` para evitar que los resultados de herramientas del lado del cliente cuenten como fuente (consulta [Fuentes de URL](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-fetch-tool#url-sources))
</Warning>

Para conocer la compatibilidad de modelos, consulta la [Referencia de herramientas](https://platform.claude.com/docs/es/agents-and-tools/tool-use/tool-reference).

## Cómo funciona la obtención web

La obtención web es una [herramienta de servidor](https://platform.claude.com/docs/es/agents-and-tools/tool-use/server-tools): la API obtiene el contenido durante la solicitud e inserta los resultados en la conversación. No ejecutas nada ni devuelves un `tool_result`. La excepción es cuando Claude llama a la obtención web y a una de tus herramientas de cliente en el mismo grupo de llamadas a herramientas en paralelo: la API devuelve la respuesta con `stop_reason: "tool_use"` antes de que se haya ejecutado esa obtención, y luego ejecuta la obtención cuando envías de vuelta los bloques `tool_result` del cliente. Consulta [Combinar herramientas de servidor y herramientas de cliente en un turno](https://platform.claude.com/docs/es/agents-and-tools/tool-use/server-tools#mixing-server-tools-and-client-tools-in-one-turn).

Cuando agregas la herramienta de obtención web a tu solicitud de API:

1. Claude determina cuándo obtener contenido según el prompt y las URLs disponibles.
2. La API recupera el contenido de texto completo de la URL especificada.
3. Para PDFs, la API devuelve el contenido como datos codificados en base64 y lo procesa como un documento PDF adjuntado directamente.
4. Claude analiza el contenido obtenido y proporciona una respuesta con citas opcionales.

<Note>
  Actualmente, la herramienta de obtención web no admite sitios web renderizados dinámicamente con JavaScript. Para páginas que necesitan un navegador real (renderizado de JavaScript, hacer clic o completar formularios), considera la [herramienta de uso del navegador](https://platform.claude.com/docs/es/agents-and-tools/tool-use/browser-use-tool), una herramienta de cliente en la que tu aplicación controla el navegador y devuelve a Claude el texto de la página o capturas de pantalla como resultados de herramientas.
</Note>

### Cuándo obtiene contenido Claude

Claude obtiene contenido cuando la solicitud apunta a una página o documento específico:

* Se proporciona una URL en la conversación (o en un resultado previo de herramienta)
* El usuario nombra un recurso específico (un artículo en particular, un README, una página de precios o una sección de documentación) sin una URL, y la [herramienta de búsqueda web](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-search-tool) también está habilitada para que Claude pueda localizarlo primero (consulta [Búsqueda y obtención combinadas](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-fetch-tool#combined-search-and-fetch))

Claude **no** obtiene contenido para preguntas de conocimiento general o abiertas que no hacen referencia a una página específica. “Resume este artículo: `<url>`” activa una obtención. “¿Cuáles son las mejores prácticas para el diseño de APIs REST?” se responde directamente.

### Filtrado dinámico

Obtener páginas web y PDFs completos puede consumir tokens rápidamente, especialmente cuando solo se necesita información específica de documentos grandes. Con `web_fetch_20260209` o posterior, Claude puede escribir y ejecutar código para filtrar el contenido obtenido antes de cargarlo en el contexto.

Este filtrado dinámico es particularmente útil para:

* Extraer secciones específicas de documentos largos
* Procesar datos estructurados de páginas web
* Filtrar información relevante de PDFs
* Reducir los costos de tokens al trabajar con documentos grandes

<Note>
  El filtrado dinámico se ejecuta en la [herramienta de ejecución de código](https://platform.claude.com/docs/es/agents-and-tools/tool-use/code-execution-tool), que la API habilita automáticamente para la solicitud. No necesitas agregar la herramienta de ejecución de código al arreglo `tools`.
</Note>

Para habilitar el filtrado dinámico, usa `web_fetch_20260209` o cualquier versión posterior. Los siguientes ejemplos usan `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>

## Cómo usar la obtención web

<Note>
  Un administrador de la organización puede desactivar la obtención web para tu organización en la página [**Capacidades**](https://platform.claude.com/settings/capabilities) de la Claude Console. Con la obtención web desactivada, una solicitud a la Messages API que incluya la herramienta falla con un error 400 `invalid_request_error` que indica que la obtención web no está habilitada. Con la obtención web activada, el administrador también puede establecer dominios permitidos o bloqueados para la obtención web en la misma página. Para saber cómo se aplican esas listas a una solicitud, consulta [Filtrado de dominios](https://platform.claude.com/docs/es/agents-and-tools/tool-use/server-tools#domain-filtering).
</Note>

Para saber cómo se aplica la configuración de obtención web de tu organización en las sesiones de Claude Managed Agents, consulta [Restringir dominios de búsqueda web y obtención web](https://platform.claude.com/docs/es/managed-agents/tools-web-restrictions).

Proporciona la herramienta de obtención web en tu solicitud 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>

## Definición de la herramienta

La herramienta de obtención web admite los siguientes 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
}
```

Las versiones posteriores de la herramienta añaden dos parámetros opcionales más: `use_cache` requiere `web_fetch_20260309` o posterior (consulta [Omisión de caché](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-fetch-tool#cache-bypass)), y `response_inclusion` requiere `web_fetch_20260318` o posterior (consulta [Inclusión en la respuesta](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-fetch-tool#response-inclusion)).

### Usos máximos

El parámetro `max_uses` limita el número de obtenciones web en un solo turno. Las obtenciones fallidas cuentan para el límite. Si Claude llama a la obtención web directamente más veces de las permitidas, el `web_fetch_tool_result` es un error con el código de error `max_uses_exceeded`. Si Claude llama a la obtención web desde la ejecución de código más veces de las permitidas, la ejecución de código termina con un error. No hay un límite predeterminado.

Un turno puede abarcar varias solicitudes. Una solicitud continúa un turno cuando se reanuda después de [`pause_turn`](https://platform.claude.com/docs/es/agents-and-tools/tool-use/server-tools#the-server-side-loop-and-pause-turn) o cuando su último mensaje contiene solo bloques `tool_result`. Las obtenciones de solicitudes anteriores en ese turno cuentan para el límite, a menos que Claude las haya ejecutado desde la ejecución de código mediante [filtrado dinámico](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-fetch-tool#dynamic-filtering).

### Filtrado de dominios

Para el filtrado de dominios con `allowed_domains` y `blocked_domains`, consulta [Herramientas de servidor](https://platform.claude.com/docs/es/agents-and-tools/tool-use/server-tools#domain-filtering).

En [Claude Managed Agents](https://platform.claude.com/docs/es/managed-agents/overview), establece estos campos en la entrada `web_fetch` del conjunto de herramientas del agente; consulta [Restringir dominios de búsqueda web y obtención web](https://platform.claude.com/docs/es/managed-agents/tools-web-restrictions).

### Límites de contenido

El parámetro `max_content_tokens` limita la cantidad de contenido incluido en el contexto. Si el contenido obtenido supera este límite, la herramienta lo trunca. Esto ayuda a controlar el uso de tokens al obtener documentos grandes. El límite es aproximado: el número real de tokens de entrada usados puede variar ligeramente. El límite se aplica al contenido de texto, no al contenido binario como los PDFs.

Si un PDF obtenido hace que la solicitud supere los [límites de páginas o de tamaño de PDF](https://platform.claude.com/docs/es/build-with-claude/pdf-support#check-pdf-requirements), el `web_fetch_tool_result` es un error con el código de error `content_too_large`. Los PDFs y las imágenes que ya están en la conversación cuentan para esos límites, por lo que eliminarlos puede permitir que la obtención tenga éxito.

En Claude Managed Agents, la entrada `web_fetch` del conjunto de herramientas del agente también acepta `max_content_tokens`; consulta la [configuración de herramientas web](https://platform.claude.com/docs/es/managed-agents/tools-web-restrictions#settings).

### Omisión de caché

<Note>
  Requiere `web_fetch_20260309` o posterior (incluido `web_fetch_20260318`).
</Note>

El parámetro `use_cache` controla si se puede devolver contenido almacenado en caché. Establece `"use_cache": false` para omitir la caché y obtener contenido actualizado. El valor predeterminado es `true`. Desactiva la caché solo cuando el usuario solicite explícitamente contenido actualizado o al obtener fuentes que cambian rápidamente, ya que omitir la caché aumenta la latencia.

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

### Inclusión en la respuesta

<Note>
  Requiere `web_fetch_20260318` o posterior.
</Note>

El parámetro `response_inclusion` controla cómo aparecen los bloques de resultados de obtención en la respuesta de la API cuando el resultado fue consumido por una llamada completada de [ejecución de código](https://platform.claude.com/docs/es/agents-and-tools/tool-use/code-execution-tool) en la misma respuesta. Establece `"response_inclusion": "excluded"` para eliminar por completo de la respuesta esos pares anidados de bloques `server_tool_use` y de resultado, en flujos de trabajo agénticos que no necesitan el contenido bruto de la página. El uso de tokens no se ve afectado, porque Claude lee la salida del código en lugar de estos bloques. El valor predeterminado es `"full"`. La API siempre devuelve completos los resultados de llamadas directas, o de llamadas de ejecución de código que se pausaron antes de completarse, para que puedas enviarlos de vuelta en la siguiente solicitud.

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

### Citas

A diferencia de la búsqueda web, donde las citas siempre están habilitadas, las citas son opcionales para la obtención web y están deshabilitadas de forma predeterminada. Establece `"citations": {"enabled": true}` para permitir que Claude cite pasajes específicos de los documentos obtenidos.

<Note>
  Al mostrar las salidas de la API directamente a los usuarios finales, incluye citas a la fuente original. Si realizas modificaciones a las salidas de la API, incluso reprocesándolas o combinándolas con tu propio material antes de mostrarlas a los usuarios finales, muestra las citas según corresponda tras consultar con tu equipo legal.
</Note>

## Respuesta

Este es un ejemplo de estructura de respuesta:

```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 de obtención

Los resultados de obtención incluyen:

* `url`: La URL que se obtuvo
* `content`: Un bloque de documento que contiene el contenido obtenido
* `retrieved_at`: Marca de tiempo de cuándo se recuperó el contenido

<Note>
  La herramienta de obtención web almacena en caché los resultados para mejorar el rendimiento y reducir solicitudes redundantes. Es posible que el contenido devuelto no siempre refleje la versión más reciente disponible en la URL. El comportamiento de la caché se gestiona automáticamente y puede cambiar con el tiempo para optimizarse para diferentes tipos de contenido y patrones de uso. Para obtener contenido actualizado, establece `"use_cache": false` (consulta [Omisión de caché](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-fetch-tool#cache-bypass)).
</Note>

Para documentos PDF, el contenido se devuelve como datos codificados en 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"
  }
}
```

### Errores

Cuando la herramienta de obtención web encuentra un error, la Claude API devuelve una respuesta 200 (éxito) con el error representado en el cuerpo de la respuesta. Claude recibe el resultado de error y continúa el turno. Por ejemplo:

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

Estos son los códigos de error posibles:

* `invalid_tool_input`: Entrada de herramienta no válida, como una URL mal formada o un esquema que no es HTTP(S)
* `url_too_long`: La URL supera la longitud máxima (250 caracteres)
* `url_not_allowed`: URL bloqueada por las reglas de filtrado de dominios (incluida la configuración de tu organización) o por restricciones del lado de Anthropic, como direcciones privadas, `robots.txt` y URLs que parecen contener una credencial que no proporcionaste
* `url_not_in_prior_context`: La URL no apareció antes en la conversación, o apareció solo en fuentes que `url_sources` excluye (consulta [Validación de URL](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-fetch-tool#url-validation))
* `url_not_accessible`: No se pudo obtener el contenido (error HTTP)
* `too_many_requests`: Se superó el límite de velocidad
* `unsupported_content_type`: Tipo de contenido no admitido (solo texto, HTML y PDF)
* `content_too_large`: El PDF obtenido haría que la solicitud superara los límites de páginas o de tamaño de PDF (consulta [Límites de contenido](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-fetch-tool#content-limits))
* `max_uses_exceeded`: Se superó el número máximo de usos de la herramienta de obtención web
* `unavailable`: Se produjo un error interno

## Validación de URL

Por razones de seguridad, la herramienta de obtención web solo puede obtener URLs que hayan aparecido previamente en el contexto de la conversación. Esto incluye:

* URLs en mensajes del usuario
* URLs en resultados de herramientas del lado del cliente
* URLs de resultados previos de búsqueda web u obtención web

La herramienta no puede obtener URLs que aparezcan solo en la propia salida de Claude o solo en la indicación del sistema. Para que una URL de la indicación del sistema se pueda obtener, inclúyela también en un mensaje del usuario. Los resultados de otras herramientas del lado del servidor, como la [ejecución de código](https://platform.claude.com/docs/es/agents-and-tools/tool-use/code-execution-tool), el [conector MCP](https://platform.claude.com/docs/es/agents-and-tools/mcp-connector) o la [búsqueda de herramientas](https://platform.claude.com/docs/es/agents-and-tools/tool-use/tool-search-tool), tampoco son una fuente permitida. De forma predeterminada, los resultados de herramientas del lado del cliente son una fuente permitida incluso cuando repiten texto que Claude produjo (por ejemplo, un comando que imprime su entrada, o un mensaje de error que lo cita).

La herramienta también rechaza una URL que parezca contener una credencial, como una clave de API o una contraseña, a menos que esa credencial aparezca en la indicación del sistema o en el texto de un mensaje del usuario. Una credencial que aparece solo en un resultado de herramienta no cuenta. El resultado es un error `url_not_allowed`. Para obtener una URL de este tipo, inclúyela en un mensaje del usuario.

### Fuentes de URL

<Note>
  Funciona con `web_fetch_20250910`, `web_fetch_20260209`, `web_fetch_20260309` y `web_fetch_20260318`.
</Note>

El parámetro opcional `url_sources` te permite desactivar cualquiera de las tres fuentes permitidas, o limitar los resultados de herramientas a ciertas herramientas. Tiene una clave para cada fuente, y cada clave tiene como valor predeterminado `{"type": "all"}`:

* `user_input`: URLs en mensajes del usuario. Su `type` es `"all"` o `"none"`.
* `client_tool_results`: URLs en resultados de herramientas del lado del cliente. Su `type` es `"all"`, `"none"`, o un filtro `"only"` o `"except"` que nombra herramientas, como en el siguiente ejemplo.
* `server_tool_results`: URLs de resultados previos de búsqueda web u obtención web. Acepta los mismos valores, y sus filtros nombran `web_search` o `web_fetch`.

Por ejemplo, una herramienta que ejecuta código escrito por Claude devuelve lo que ese código imprima, incluida cualquier URL que Claude haya puesto en él. Para evitar que los resultados de esa herramienta cuenten como fuente, nómbrala en 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 enumera las herramientas como objetos `tool_reference`. Cada nombre debe coincidir con una herramienta del arreglo `tools` de la solicitud: una herramienta de cliente para `client_tool_results`, o una herramienta de servidor para `server_tool_results`. De lo contrario, la solicitud falla con un error. Con `"except"`, una herramienta que agregues a `tools` más adelante cuenta como fuente. Con `"only"`, no cuenta.

Las herramientas del lado del cliente distintas de `run_code` también pueden devolver texto escrito por Claude, por ejemplo en un mensaje de error que lo cita. Para excluir todos los resultados de herramientas del lado del cliente, establece `client_tool_results` en `{"type": "none"}`.

Si una URL apareció solo en fuentes que `url_sources` excluye, obtenerla devuelve el error `url_not_in_prior_context`.

## Búsqueda y obtención combinadas

Cuando tanto la herramienta de búsqueda web como la de obtención web están habilitadas, y el usuario nombra una página o documento específico sin proporcionar una URL (por ejemplo, “lee el README del repositorio anthropics/anthropic-sdk-python”), Claude usa la búsqueda web para localizarlo y luego obtiene el resultado. El siguiente ejemplo solicita una búsqueda y un análisis en una sola solicitud:

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

En este flujo de trabajo, Claude:

1. Usa la búsqueda web para encontrar artículos relevantes.
2. Selecciona los resultados más prometedores.
3. Usa la obtención web para recuperar el contenido completo.
4. Proporciona un análisis detallado con citas.

## Almacenamiento en caché de prompts

Para almacenar en caché las definiciones de herramientas entre turnos, consulta [Uso de herramientas con almacenamiento en caché de prompts](https://platform.claude.com/docs/es/agents-and-tools/tool-use/tool-use-with-prompt-caching).

## Streaming

Con el streaming habilitado, los eventos de obtención forman parte del stream, con una pausa durante la recuperación del contenido:

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

## Solicitudes por lotes

Puedes incluir la herramienta de obtención web en la [Message Batches API](https://platform.claude.com/docs/es/build-with-claude/batch-processing). Las llamadas a la herramienta de obtención web a través de la Message Batches API tienen el mismo precio que las de las solicitudes normales a la Messages API.

## Uso y precios

El uso de la obtención web **no tiene cargos adicionales** más allá de los costos estándar 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
    }
  }
}
```

La herramienta de obtención web está disponible en la Claude API **sin costo adicional**. Solo pagas los costos estándar de tokens por el contenido obtenido que pasa a formar parte del contexto de tu conversación.

Para protegerte contra la obtención inadvertida de contenido grande que consumiría tokens en exceso, usa el parámetro `max_content_tokens` para establecer límites apropiados según tu caso de uso y consideraciones de presupuesto.

Ejemplo de uso de tokens para contenido típico:

* Página web promedio (10 kB): \~2,500 tokens
* Página de documentación grande (100 kB): \~25,000 tokens
* PDF de artículo de investigación (500 kB): \~125,000 tokens

## Próximos pasos

<CardGroup>
  <Card href="https://platform.claude.com/docs/es/agents-and-tools/tool-use/code-execution-tool" title="Herramienta de ejecución de código" icon="code">
    Ejecuta código Python y Bash en un contenedor aislado para analizar datos, generar archivos e iterar sobre soluciones.
  </Card>

  <Card href="https://platform.claude.com/docs/es/agents-and-tools/tool-use/server-tools" title="Herramientas de servidor" icon="cloud">
    Trabaja con herramientas que ejecuta Anthropic: bloques `server_tool_use`, continuación con `pause_turn` y filtrado de dominios.
  </Card>

  <Card href="https://platform.claude.com/docs/es/agents-and-tools/tool-use/tool-reference" title="Referencia de herramientas" icon="book">
    Directorio de herramientas proporcionadas por Anthropic y referencia de propiedades opcionales de definición de herramientas.
  </Card>
</CardGroup>

## Disponibilidad

Herramienta de obtención web está disponible en todos los modelos y es elegible para retención de datos cero.

### Compatibilidad con la API

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

* Disponibilidad: Disponible
* Uso: Añade una herramienta `web_fetch` a las `tools` de la solicitud. Configuraciones como `max_uses`, las listas de dominios, `citations` y `max_content_tokens` se establecen en esa herramienta.

| Estado                 | Plataformas en la nube                                                                                                                                                                                                                                                                                                                                                                                       |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Disponible             | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws), [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/es/build-with-claude/claude-models-on-google-cloud/anthropic-managed), [Microsoft Foundry (hosted on Anthropic)](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry) |
| Disponible<sup>1</sup> | [Microsoft Foundry (hosted on Azure)](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry)                                                                                                                                                                                                                                                                                     |

1. Las implementaciones alojadas en Azure solo admiten `web_fetch_20250910`: sin filtrado dinámico, inclusión de respuesta ni omisión de caché.

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

* Disponibilidad: Disponible
* Uso: Forma parte del conjunto de herramientas del agente y está activada de forma predeterminada una vez que se añade el conjunto de herramientas. Las listas de dominios (sin rutas) y `max_content_tokens` se establecen en la entrada `web_fetch` del conjunto de herramientas; `max_uses`, `citations` y `cache_control` no están disponibles.

| Estado     | Plataformas en la nube                                                                                             |
| ---------- | ------------------------------------------------------------------------------------------------------------------ |
| Disponible | Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws) |

### Manejo de datos

[Descripción general del manejo de datos](https://platform.claude.com/docs/es/manage-claude/api-and-data-retention#feature-eligibility)

| Elemento | Retención de datos cero                                                                                                                                                                                                                                                                              | HIPAA       |
| -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
| Estado   | Elegible (excluye [Modelos cubiertos](https://platform.claude.com/docs/es/manage-claude/api-and-data-retention#model-specific-data-retention-requirements))                                                                                                                                          | No elegible |
| Detalles | Contenido web obtenido devuelto en la respuesta de la API. El filtrado dinámico de la obtención web no es elegible para ZDR ni HIPAA. Los editores de sitios web podrían conservar datos de las solicitudes (como las URL obtenidas y los metadatos de las solicitudes) según sus propias políticas. | —           |

Endpoints aplicables:

* `/v1/messages` con la herramienta `web_fetch`