---
title: Claude en Microsoft Foundry
url: https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry
description: Accede a los modelos Claude a través de Microsoft Foundry con endpoints y autenticación nativos de Azure.
---

Esta guía te muestra cómo configurar Claude en Microsoft Foundry y realizar llamadas a la API. Puedes usar uno de los SDK de cliente de Anthropic o solicitudes HTTP directas. Cuando accedes a Claude en Microsoft Foundry, pagas el uso de Claude a través de Azure Marketplace. En [IDs de modelo de la API e implementaciones](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry#api-model-ids-and-deployments) se indican los modelos disponibles. También están disponibles funciones como la [“context window” (ventana de contexto) de 1M de tokens](https://platform.claude.com/docs/es/build-with-claude/context-windows). Administras los costos a través de tu suscripción de Azure.

Claude está disponible en los tipos de implementación Global Standard y US Data Zone Standard en recursos de Foundry, y se factura en Claude Consumption Units a través de Azure Marketplace. Visita [precios de Claude en Microsoft Foundry](https://platform.claude.com/docs/es/about-claude/pricing#claude-in-microsoft-foundry-pricing) para obtener más detalles.

## Opciones de alojamiento

Los modelos de Claude en Microsoft Foundry están disponibles en dos opciones de alojamiento. Eliges la opción de alojamiento cuando configuras la implementación.

|                                | Alojado en Azure                                                                                                                                        | Alojado en Anthropic                                                                                                                                                                                                                                                                                                                                                                        |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Dónde se ejecuta la inferencia | Servicio operado por Anthropic que se ejecuta en infraestructura de Azure                                                                               | Servicio operado por Anthropic que se ejecuta en infraestructura de Anthropic                                                                                                                                                                                                                                                                                                               |
| Disponibilidad de modelos      | [Algunos modelos Opus, Sonnet y Haiku](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry#api-model-ids-and-deployments) | [Todos los modelos de Claude disponibles en Microsoft Foundry](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry#api-model-ids-and-deployments)                                                                                                                                                                                                             |
| Tipos de implementación        | Global Standard, US Data Zone Standard                                                                                                                  | Global Standard                                                                                                                                                                                                                                                                                                                                                                             |
| Recomendado para               | La mayoría de las cargas de trabajo                                                                                                                     | Cargas de trabajo que necesitan [modelos alojados solo en Anthropic](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry#api-model-ids-and-deployments) o [funciones disponibles solo cuando se aloja en Anthropic](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry#additional-features-not-supported-when-hosted-on-azure) |

Para las implementaciones alojadas en Azure, Anthropic procesa los prompts y las respuestas en infraestructura de Azure y almacena allí el contenido retenido. El contenido retenido incluye el contenido marcado por los sistemas de seguridad de Anthropic para que Anthropic lo revise. Los datos operativos que no contienen prompts ni respuestas se almacenan en los sistemas de Anthropic fuera de Azure. Algunos ejemplos son las puntuaciones de los clasificadores de seguridad, los identificadores y los datos de uso y facturación.

<Note>
  Anthropic actúa como procesador independiente para Microsoft. Los clientes que usan Claude a través de Microsoft Foundry están sujetos a los [términos de uso de datos](https://www.anthropic.com/legal) de Anthropic. Anthropic proporciona sus compromisos de seguridad y de datos.
</Note>

## Requisitos previos

Antes de comenzar, asegúrate de tener:

* Una suscripción activa de Azure
* Acceso al [portal de Foundry](https://ai.azure.com/)
* Un rol de “role-based access control” (control de acceso basado en roles), o RBAC, de Azure, como **Foundry User** o **Cognitive Services User**, para el recurso de Foundry que crees en [Aprovisionamiento](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry#provisioning)
* Opcional: la [CLI de Azure](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli) para obtener tokens de [Microsoft Entra ID](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry#microsoft-entra-authentication) con `az account get-access-token`

## Instalar un SDK

Los [SDK cliente](https://platform.claude.com/docs/es/cli-sdks-libraries/overview) de Anthropic admiten Foundry mediante un paquete o clase cliente específicos de la plataforma. Los ejemplos de esta página también muestran solicitudes con cURL y la CLI `ant`. Para configurar la CLI, consulta el [inicio rápido de la CLI](https://platform.claude.com/docs/es/cli-sdks-libraries/cli/quickstart).

<Tabs>
  <Tab title="Python">
    ```bash
    pip install -U "anthropic"

    # Para la autenticación con Entra ID, instala también la biblioteca Azure Identity
    pip install azure-identity
    ```
  </Tab>

  <Tab title="TypeScript">
    ```bash
    npm install @anthropic-ai/foundry-sdk

    # Para la autenticación con Entra ID, instala también la biblioteca Azure Identity
    npm install @azure/identity
    ```
  </Tab>

  <Tab title="C#">
    ```bash
    dotnet add package Anthropic.Foundry
    ```
  </Tab>

  <Tab title="Go">
    ```bash
    go get github.com/anthropics/anthropic-sdk-go/v2/foundry

    # Para la autenticación con Entra ID, instala también la biblioteca Azure Identity
    go get github.com/Azure/azure-sdk-for-go/sdk/azidentity
    ```
  </Tab>

  <Tab title="Java">
    <Tabs>
      <Tab title="Gradle">
        ```kotlin
        implementation("com.anthropic:anthropic-java:3.12.0")
        implementation("com.anthropic:anthropic-java-foundry:3.12.0")
        ```
      </Tab>

      <Tab title="Maven">
        ```xml
        <dependency>
            <groupId>com.anthropic</groupId>
            <artifactId>anthropic-java</artifactId>
            <version>3.12.0</version>
        </dependency>
        <dependency>
            <groupId>com.anthropic</groupId>
            <artifactId>anthropic-java-foundry</artifactId>
            <version>3.12.0</version>
        </dependency>
        ```
      </Tab>
    </Tabs>

    Para la autenticación con Entra ID, agrega también la biblioteca Azure Identity (`com.azure:azure-identity`) a tu compilación, en la versión más reciente de [Maven Central](https://central.sonatype.com/artifact/com.azure/azure-identity).
  </Tab>

  <Tab title="PHP">
    ```bash
    composer require "anthropic-ai/sdk" "guzzlehttp/guzzle:^7"
    ```
  </Tab>

  <Tab title="Ruby">
    ```bash
    bundle add anthropic
    ```

    Para la autenticación con Entra ID, le pasas al cliente un proveedor de tokens. El proveedor de [Autenticación con Microsoft Entra](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry#microsoft-entra-authentication) obtiene sus tokens de la [CLI de Azure](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli), así que instala la CLI de Azure para usar ese proveedor.
  </Tab>
</Tabs>

## Aprovisionamiento

Foundry usa una jerarquía de dos niveles: los **recursos** contienen tu configuración de seguridad y facturación, mientras que las **implementaciones** son las instancias del modelo a las que llamas a través de la API. Primero crearás un recurso de Foundry y luego crearás una o más implementaciones de Claude dentro de él.

### Aprovisionamiento de recursos de Foundry

Para aprovisionar tu recurso:

1. Navega al [portal de Foundry](https://ai.azure.com/).
2. Crea o selecciona un recurso de Foundry en una [región de Azure donde tu modelo esté disponible](https://learn.microsoft.com/en-us/azure/foundry/foundry-models/how-to/use-foundry-models-claude). Puedes seguir las [instrucciones de Microsoft para crear un recurso de Foundry](https://learn.microsoft.com/en-us/azure/ai-services/multi-service-resource?pivots=azportal) o [crear un proyecto de Foundry](https://learn.microsoft.com/en-us/azure/foundry/how-to/create-projects), que crea un recurso por ti.
3. Anota el nombre de tu recurso, que es `{resource}` en endpoints de la API como `https://{resource}.services.ai.azure.com/anthropic/v1/*`.

Para restringir el acceso de red, puedes [agregar tu recurso a una red privada](https://learn.microsoft.com/en-us/azure/foundry/how-to/configure-private-link) (Azure Virtual Network).

### Crear implementaciones de Foundry

Después de crear tu recurso, implementa un modelo de Claude para que esté disponible para llamadas a la API. Estos pasos describen el nuevo portal de Foundry (el interruptor **New Foundry** está activado):

1. Inicia sesión en el portal de Foundry. Desde la página de inicio del portal, selecciona **Discover** en la navegación superior derecha y luego **Models** en el panel izquierdo para abrir el catálogo de modelos.

2. Busca y selecciona un modelo de Claude (por ejemplo, claude-opus-5-5). Cada modelo aparece una sola vez en el catálogo, independientemente de cuántas opciones de alojamiento admita.

3. En la tarjeta del modelo, selecciona **Deploy** y luego **Custom settings** para abrir el panel de configuración de la implementación. Si en su lugar seleccionas **Default settings**, la implementación se configura automáticamente como Alojado en Azure para los modelos disponibles en ambas opciones de alojamiento.

4. En tu primera implementación de Claude, revisa los términos de Azure Marketplace, selecciona una industria y selecciona **Agree and Proceed** para aceptar los términos y suscribirte a la oferta de Azure Marketplace.

5. Configura la implementación:

   * **Deployment name:** De forma predeterminada es el ID del modelo, pero puedes personalizarlo (por ejemplo, `my-claude-deployment`). El nombre de la implementación no se puede cambiar después de crearla.
   * **Model version:** Esta configuración determina la [opción de alojamiento](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry#hosting-options). Expande **Model version settings**, abre el menú desplegable **Model version** y selecciona la versión etiquetada con la opción de alojamiento que quieras.
   * **Region scope:** Selecciona **Global**, o **Data Zone** si la implementación está alojada en Azure. **Data Zone** crea una implementación US Data Zone Standard, que mantiene la inferencia dentro de Estados Unidos. Para conocer los precios, consulta [Geografía de inferencia](https://platform.claude.com/docs/es/about-claude/pricing#foundry-inference-geography).

6. Selecciona **Deploy** y espera a que se complete el aprovisionamiento.

7. Una vez implementado, selecciona **Build** en la navegación superior derecha, luego **Models** en el panel izquierdo, y abre tu implementación. La pestaña **Details** muestra el **Target URI** (la URL de tu endpoint) y la **Key** (tu clave de API).

Si el interruptor **New Foundry** está desactivado, estás en el diseño clásico del portal. Allí, abre **Model catalog** en el panel izquierdo para buscar e implementar un modelo, y abre **Models + endpoints** (en **My assets**) para ver tus implementaciones y los detalles de sus endpoints.

<Note>
  El nombre de implementación que elijas se convierte en el valor que pasas en el parámetro `model` de tus solicitudes a la API. Puedes crear varias implementaciones del mismo modelo con nombres diferentes para administrar configuraciones o “rate limits” (límites de velocidad) separados.
</Note>

## Autenticación

Claude en Microsoft Foundry admite dos métodos de autenticación: claves de API y tokens de Entra ID. Ambos métodos usan endpoints con el formato `https://{resource}.services.ai.azure.com/anthropic/v1/*`. Para los [modelos Claude Mythos](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry#api-model-ids-and-deployments), usa [tokens de Entra ID](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry#microsoft-entra-authentication).

### Autenticación con clave de API

Después de aprovisionar tu recurso de Claude en Foundry, puedes obtener una clave de API desde el portal de Foundry:

1. En el portal de Foundry, selecciona **Build** en la navegación superior derecha y luego **Models** en el panel izquierdo.
2. Abre tu implementación de Claude y selecciona la pestaña **Details**.
3. Copia el valor de **Key** (y anota el **Target URI** de tu endpoint).
4. Usa el encabezado `api-key` o `x-api-key` en tus solicitudes, o proporciónala al SDK.

El cliente de Foundry del SDK requiere una clave de API y un nombre de recurso o una URL base, y los lee automáticamente de las siguientes variables de entorno si están definidas:

* `ANTHROPIC_FOUNDRY_API_KEY` - Tu clave de API
* `ANTHROPIC_FOUNDRY_RESOURCE` - El nombre de tu recurso (por ejemplo, `example-resource`)
* `ANTHROPIC_FOUNDRY_BASE_URL` - Alternativa al nombre del recurso en todos los SDK excepto C#: la URL base completa (por ejemplo, `https://example-resource.services.ai.azure.com/anthropic/`)

<Note>
  Los parámetros `resource` y `base_url` son mutuamente excluyentes. Proporciona el nombre del recurso (que el SDK usa para construir la URL como `https://{resource}.services.ai.azure.com/anthropic/`) o la URL base completa directamente.
</Note>

**Ejemplo usando clave de API:**

<CodeGroup>
  ```bash cURL
  curl https://{resource}.services.ai.azure.com/anthropic/v1/messages \
    -H "content-type: application/json" \
    -H "api-key: YOUR_AZURE_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 1024,
      "messages": [
        {"role": "user", "content": "Hello!"}
      ]
    }'
  ```

  ```bash CLI
  # ant lee ANTHROPIC_API_KEY
  export ANTHROPIC_API_KEY="YOUR_AZURE_API_KEY"

  ant messages create \
    --base-url https://example-resource.services.ai.azure.com/anthropic \
    --model claude-opus-5-5 \
    --max-tokens 1024 \
    --message '{role: user, content: "Hello!"}'
  ```

  ```python Python
  import os
  from anthropic import AnthropicFoundry

  client = AnthropicFoundry(
      api_key=os.environ.get("ANTHROPIC_FOUNDRY_API_KEY"),
      resource="example-resource",  # your resource name
  )

  message = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[{"role": "user", "content": "Hello!"}],
  )
  print(message.content)
  ```

  ```typescript TypeScript
  import AnthropicFoundry from "@anthropic-ai/foundry-sdk";

  const client = new AnthropicFoundry({
    apiKey: process.env.ANTHROPIC_FOUNDRY_API_KEY,
    resource: "example-resource" // your resource name
  });

  const message = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello!" }]
  });
  console.log(message.content);
  ```

  ```csharp C#
  using Anthropic.Foundry;
  using Anthropic.Models.Messages;

  // El cliente de C# siempre construye la URL base a partir del nombre del recurso.
  // No lee ANTHROPIC_FOUNDRY_BASE_URL.
  var client = new AnthropicFoundryClient(
      new AnthropicFoundryApiKeyCredentials(
          Environment.GetEnvironmentVariable("ANTHROPIC_FOUNDRY_API_KEY")!,
          "example-resource"
      )
  );

  var response = await client.Messages.Create(new MessageCreateParams
  {
      Model = "claude-opus-5-5",
      MaxTokens = 1024,
      Messages = [new UserMessageParam { Content = "Hello!" }],
  });

  Console.WriteLine(
      string.Join("", response.Content
          .Select(block => block.Value)
          .OfType<TextBlock>()
          .Select(textBlock => textBlock.Text)));
  ```

  ```go Go
  package main

  import (
  	"context"
  	"fmt"
  	"os"

  	"github.com/anthropics/anthropic-sdk-go/v2"
  	"github.com/anthropics/anthropic-sdk-go/v2/foundry"
  )

  func main() {
  	client, err := foundry.NewClient(foundry.ClientConfig{
  		APIKey:   os.Getenv("ANTHROPIC_FOUNDRY_API_KEY"),
  		Resource: "example-resource", // your resource name
  	})
  	if err != nil {
  		panic(err)
  	}

  	message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
  		Model:     "claude-opus-5-5",
  		MaxTokens: 1024,
  		Messages: []anthropic.MessageParam{
  			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
  		},
  	})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(message.Content)
  }
  ```

  ```java Java
  import com.anthropic.client.AnthropicClient;
  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
  import com.anthropic.foundry.backends.FoundryBackend;
  import com.anthropic.models.messages.MessageCreateParams;

  void main() {
      // Requiere las variables de entorno: ANTHROPIC_FOUNDRY_API_KEY, ANTHROPIC_FOUNDRY_RESOURCE
      AnthropicClient client = AnthropicOkHttpClient.builder()
          .backend(FoundryBackend.fromEnv())
          .build();

      MessageCreateParams params = MessageCreateParams.builder()
          .model("claude-opus-5-5")
          .maxTokens(1024)
          .addUserMessage("Hello!")
          .build();

      client.messages().create(params).content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }
  ```

  ```php PHP
  use Anthropic\Foundry;

  $client = Foundry\Client::withCredentials(
      apiKey: getenv('ANTHROPIC_FOUNDRY_API_KEY'),
      baseUrl: 'https://example-resource.services.ai.azure.com/anthropic',
  );

  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [
          ['role' => 'user', 'content' => 'Hello!']
      ],
      model: 'claude-opus-5-5',
  );
  echo array_find($message->content, fn ($block) => $block->type === 'text')->text;
  ```

  ```ruby Ruby
  require "anthropic"

  client = Anthropic::FoundryClient.new(
    api_key: ENV.fetch("ANTHROPIC_FOUNDRY_API_KEY"),
    resource: "example-resource" # your resource name
  )

  message = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [{role: "user", content: "Hello!"}]
  )

  message.content.grep(Anthropic::Models::TextBlock).each { |block| puts block.text }
  ```
</CodeGroup>

<Warning>
  Mantén tus claves de API seguras. Nunca las incluyas en el control de versiones ni las compartas públicamente. Cualquier persona con acceso a tu clave de API puede realizar solicitudes a Claude a través de tu recurso de Foundry.
</Warning>

### Autenticación con Microsoft Entra

La autenticación con Entra ID te permite administrar el acceso con Azure RBAC, integrarte con la administración de identidades de tu organización y evitar manejar claves de API manualmente. Para usar tokens de Entra ID:

1. Habilita la [autenticación con Microsoft Entra ID](https://learn.microsoft.com/en-us/azure/ai-foundry/model-inference/how-to/configure-entra-id) para tu recurso de Foundry.
2. Obtén un token de acceso de Entra ID.
3. Usa el token en el encabezado `Authorization: Bearer {TOKEN}`.

**Ejemplo usando Entra ID:**

<CodeGroup>
  ```bash cURL
  # Haz una solicitud con un token de Microsoft Entra ID. Reemplaza {resource} con el nombre de tu recurso
  curl https://{resource}.services.ai.azure.com/anthropic/v1/messages \
    -H "content-type: application/json" \
    -H "Authorization: Bearer $(az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv)" \
    -H "anthropic-version: 2026-10-21" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 1024,
      "messages": [
        {"role": "user", "content": "Hello!"}
      ]
    }'
  ```

  ```bash CLI
  # Haz una solicitud con un token de Microsoft Entra ID. Reemplaza {resource} con el nombre de tu recurso
  # env -u elimina ANTHROPIC_API_KEY, que la CLI enviaría en lugar del token
  env -u ANTHROPIC_API_KEY \
    ANTHROPIC_AUTH_TOKEN="$(az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv)" \
    ant messages create \
      --base-url https://{resource}.services.ai.azure.com/anthropic \
      --model claude-opus-5-5 \
      --max-tokens 1024 \
      --message '{role: user, content: "Hello!"}'
  ```

  ```python Python
  from anthropic import AnthropicFoundry
  from azure.identity import DefaultAzureCredential, get_bearer_token_provider

  # Obtén el token de Microsoft Entra ID usando el patrón de proveedor de tokens
  token_provider = get_bearer_token_provider(
      DefaultAzureCredential(), "https://ai.azure.com/.default"
  )

  # Crea el cliente con autenticación de Entra ID
  client = AnthropicFoundry(
      resource="example-resource",  # your resource name
      azure_ad_token_provider=token_provider,  # Use token provider for Entra ID auth
  )

  # Realiza la solicitud
  message = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[{"role": "user", "content": "Hello!"}],
  )
  print(message.content)
  ```

  ```typescript TypeScript
  import AnthropicFoundry from "@anthropic-ai/foundry-sdk";
  import { DefaultAzureCredential, getBearerTokenProvider } from "@azure/identity";

  // Obtén el token de Entra ID usando el patrón de proveedor de tokens
  const credential = new DefaultAzureCredential();
  const tokenProvider = getBearerTokenProvider(credential, "https://ai.azure.com/.default");

  // Crea el cliente con autenticación de Entra ID
  const client = new AnthropicFoundry({
    resource: "example-resource", // your resource name
    azureADTokenProvider: tokenProvider // Use token provider for Entra ID auth
  });

  // Realiza la solicitud
  const message = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello!" }]
  });
  console.log(message.content);
  ```

  ```csharp C#
  using Anthropic.Foundry;
  using Anthropic.Models.Messages;
  using Azure.Identity;

  var client = new AnthropicFoundryClient(
      new AnthropicFoundryIdentityTokenCredentials(
          new DefaultAzureCredential(),
          "example-resource"
      )
  );

  var response = await client.Messages.Create(new MessageCreateParams
  {
      Model = "claude-opus-5-5",
      MaxTokens = 1024,
      Messages = [new UserMessageParam { Content = "Hello!" }],
  });

  Console.WriteLine(
      string.Join("", response.Content
          .Select(block => block.Value)
          .OfType<TextBlock>()
          .Select(textBlock => textBlock.Text)));
  ```

  ```go Go
  package main

  import (
  	"context"
  	"fmt"

  	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
  	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
  	"github.com/anthropics/anthropic-sdk-go/v2"
  	"github.com/anthropics/anthropic-sdk-go/v2/foundry"
  )

  func main() {
  	credential, err := azidentity.NewDefaultAzureCredential(nil)
  	if err != nil {
  		panic(err)
  	}

  	tokenProvider := func(ctx context.Context) (string, error) {
  		token, err := credential.GetToken(ctx, policy.TokenRequestOptions{
  			Scopes: []string{foundry.EntraIDScope},
  		})
  		return token.Token, err
  	}

  	client, err := foundry.NewClient(foundry.ClientConfig{
  		Resource:             "example-resource", // your resource name
  		AzureADTokenProvider: tokenProvider,
  	})
  	if err != nil {
  		panic(err)
  	}

  	message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
  		Model:     "claude-opus-5-5",
  		MaxTokens: 1024,
  		Messages: []anthropic.MessageParam{
  			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
  		},
  	})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(message.Content)
  }
  ```

  ```java Java
  import com.anthropic.client.AnthropicClient;
  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
  import com.anthropic.foundry.backends.FoundryBackend;
  import com.anthropic.models.messages.MessageCreateParams;
  import com.azure.identity.AuthenticationUtil;
  import com.azure.identity.DefaultAzureCredentialBuilder;
  import java.util.function.Supplier;

  void main() {
      Supplier<String> bearerTokenSupplier = AuthenticationUtil.getBearerTokenSupplier(
          new DefaultAzureCredentialBuilder().build(),
          "https://ai.azure.com/.default"
      );

      AnthropicClient client = AnthropicOkHttpClient.builder()
          .backend(FoundryBackend.builder()
              .bearerTokenSupplier(bearerTokenSupplier)
              .resource("example-resource")
              .build())
          .build();

      MessageCreateParams params = MessageCreateParams.builder()
          .model("claude-opus-5-5")
          .maxTokens(1024)
          .addUserMessage("Hello!")
          .build();

      client.messages().create(params).content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }
  ```

  ```php PHP
  use Anthropic\Foundry;

  // Obtén un token de acceso de Entra ID, por ejemplo con la CLI de Azure:
  //   az account get-access-token --resource https://ai.azure.com \
  //     --query accessToken -o tsv
  $token = getenv('AZURE_ACCESS_TOKEN');

  $client = Foundry\Client::withCredentials(
      authToken: $token,
      baseUrl: 'https://example-resource.services.ai.azure.com/anthropic',
  );

  $message = $client->messages->create(
      maxTokens: 1024,
      messages: [
          ['role' => 'user', 'content' => 'Hello!']
      ],
      model: 'claude-opus-5-5',
  );
  echo array_find($message->content, fn ($block) => $block->type === 'text')->text;
  ```

  ```ruby Ruby
  require "anthropic"

  # Obtén un token de Microsoft Entra ID desde la CLI de Azure. El cliente llama a esta
  # lambda en cada solicitud y reintento, así que en producción almacena el token en caché
  # hasta que esté cerca de expirar.
  token_provider = lambda do
    `az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv`
  end

  client = Anthropic::FoundryClient.new(
    resource: "example-resource", # your resource name
    azure_ad_token_provider: token_provider
  )

  message = client.messages.create(
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [{role: "user", content: "Hello!"}]
  )

  message.content.grep(Anthropic::Models::TextBlock).each { |block| puts block.text }
  ```
</CodeGroup>

## IDs de solicitud de correlación

Foundry incluye identificadores de solicitud en los encabezados de respuesta HTTP para depuración y seguimiento. Al contactar con soporte, proporciona tanto el valor de `request-id` como el de `apim-request-id` (Azure API Management) para ayudar a los equipos a localizar e investigar rápidamente tu solicitud en los sistemas de Anthropic y Azure.

## Compatibilidad de funciones

Claude en Microsoft Foundry admite la mayoría de las funciones de Claude. En la [descripción general de funciones](https://platform.claude.com/docs/es/build-with-claude/overview) se enumeran las funciones de Claude, y la sección **Disponibilidad** de la página de cada función indica si Foundry la admite y con qué opción de alojamiento.

### Ventana de contexto

Todos los [modelos disponibles](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry#api-model-ids-and-deployments) tienen una [ventana de contexto de 1M de tokens](https://platform.claude.com/docs/es/build-with-claude/context-windows) en Microsoft Foundry, excepto Claude Opus 4.5, Claude Sonnet 4.5 (deprecado) y Claude Haiku 4.5. Estos tres modelos tienen una ventana de contexto de 200k tokens.

### Funciones de Claude no admitidas para Claude en Microsoft Foundry

* Admin API
* Herramienta de asesor
* Claude Managed Agents
* Compliance API
* Models API
* Message Batches API
* Respaldo del lado del servidor (el [parámetro `fallbacks`](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback#server-side-fallback); en su lugar, usa el [patrón de respaldo del lado del cliente](https://platform.claude.com/docs/es/build-with-claude/refusals-and-fallback#client-side-fallback))
* Endpoints de perfiles de usuario (`/v1/user_profiles`; en su lugar, [crea perfiles en la API de Claude](https://platform.claude.com/docs/es/manage-claude/user-profiles#before-you-begin))

### Funciones adicionales no admitidas cuando se aloja en Azure

Las siguientes funciones están disponibles para implementaciones alojadas en Anthropic, pero no son compatibles con implementaciones alojadas en Azure:

* [Ejecución de código](https://platform.claude.com/docs/es/agents-and-tools/tool-use/code-execution-tool)
* Versiones de las herramientas de [búsqueda web](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-search-tool) y [obtención web](https://platform.claude.com/docs/es/agents-and-tools/tool-use/web-fetch-tool) posteriores a `web_search_20250305` y `web_fetch_20250910`. Las implementaciones alojadas en Azure solo admiten estas versiones básicas, por lo que el filtrado dinámico, la inclusión de respuestas y la omisión de caché no están disponibles.
* [Agent Skills](https://platform.claude.com/docs/es/agents-and-tools/agent-skills/overview)
* [Llamada programática de herramientas](https://platform.claude.com/docs/es/agents-and-tools/tool-use/programmatic-tool-calling)
* [Files API](https://platform.claude.com/docs/es/build-with-claude/files)

Las solicitudes que usan estas funciones contra una implementación alojada en Azure devuelven un error `400 Bad Request` por diseño. Claude Code detecta las implementaciones alojadas en Azure y adapta automáticamente su conjunto de funciones.

## Respuestas de la API

Las respuestas de la API de Claude en Microsoft Foundry siguen el [formato de respuesta estándar de la Claude API](https://platform.claude.com/docs/es/api/messages/create), incluido el objeto `usage`.

Para detalles sobre los encabezados de respuesta específicos de Foundry, consulta [IDs de solicitud de correlación](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry#correlation-request-ids).

## IDs de modelo de la API e implementaciones

Los términos del ciclo de vida (Deprecado, Retirado) se definen en [Obsolescencia de modelos](https://platform.claude.com/docs/es/about-claude/model-deprecations). Microsoft Foundry sigue el calendario de ciclo de vida de la Claude API.

Los siguientes modelos Claude están disponibles a través de Foundry:

| Model                                                                                                 | Default deployment name | Hosted on Azure | Hosted on Anthropic |
| :---------------------------------------------------------------------------------------------------- | :---------------------- | :-------------: | :-----------------: |
| Claude Fable 5.2                                                                                      | `claude-fable-5-2`      |                 |          ✓          |
| Claude Mythos 5.2 ([limited availability](https://support.claude.com/en/articles/14604842))           | `claude-mythos-5-2`     |                 |          ✓          |
| Claude Fable 5.1                                                                                      | `claude-fable-5-1`      |                 |          ✓          |
| Claude Mythos 5.1 ([limited availability](https://support.claude.com/en/articles/14604842))           | `claude-mythos-5-1`     |                 |          ✓          |
| Claude Fable 5                                                                                        | `claude-fable-5`        |                 |          ✓          |
| Claude Mythos 5 ([limited availability](https://support.claude.com/en/articles/14604842))             | `claude-mythos-5`       |                 |          ✓          |
| Claude Opus 5.5                                                                                       | `claude-opus-5-5`       |        ✓        |          ✓          |
| Claude Opus 5                                                                                         | `claude-opus-5`         |        ✓        |          ✓          |
| Claude Opus 4.8                                                                                       | `claude-opus-4-8`       |        ✓        |          ✓          |
| Claude Opus 4.7                                                                                       | `claude-opus-4-7`       |                 |          ✓          |
| Claude Opus 4.6                                                                                       | `claude-opus-4-6`       |                 |          ✓          |
| Claude Opus 4.5                                                                                       | `claude-opus-4-5`       |                 |          ✓          |
| Claude Sonnet 5.5                                                                                     | `claude-sonnet-5-5`     |        ✓        |          ✓          |
| Claude Sonnet 5                                                                                       | `claude-sonnet-5`       |        ✓        |          ✓          |
| Claude Sonnet 4.6                                                                                     | `claude-sonnet-4-6`     |                 |          ✓          |
| Claude Sonnet 4.5 ([deprecated](https://platform.claude.com/docs/es/about-claude/model-deprecations)) | `claude-sonnet-4-5`     |                 |          ✓          |
| Claude Haiku 5.5                                                                                      | `claude-haiku-5-5`      |        ✓        |          ✓          |
| Claude Haiku 4.5                                                                                      | `claude-haiku-4-5`      |        ✓        |          ✓          |

De forma predeterminada, los nombres de implementación coinciden con los IDs de modelo que se muestran en la tabla anterior. Sin embargo, puedes crear implementaciones personalizadas con nombres diferentes en el portal de Foundry para administrar distintas configuraciones, versiones o límites de velocidad. Usa el nombre de la implementación (no necesariamente el ID del modelo) en tus solicitudes a la API.

<Info>
  [Claude Mythos Preview](https://anthropic.com/glasswing) es una vista previa de investigación disponible para clientes invitados en Microsoft Foundry.
</Info>

Deja que Claude Code migre tu código a un modelo más reciente

```text
/claude-api migrate este proyecto al modelo Claude Opus más reciente
```

## Facturación

Claude en Microsoft Foundry se factura a través del [Azure Marketplace](https://azuremarketplace.microsoft.com/). El uso se denomina en Claude Consumption Units (CCUs), se mide por hora y se factura mensualmente a posteriori en tu factura de Azure. Las CCUs no son créditos prepagados. No existe un saldo ni un compromiso de CCUs.

Para conocer el precio de las CCUs, la mecánica de conversión y las tarifas de tokens por modelo, consulta [precios de Claude en Microsoft Foundry](https://platform.claude.com/docs/es/about-claude/pricing#claude-in-microsoft-foundry-pricing).

## Migración entre opciones de alojamiento

Para mover una implementación existente de una opción de alojamiento a la otra:

1. Crea una nueva implementación de la otra versión de alojamiento del modelo (Alojado en Azure o Alojado en Anthropic). Puede estar en el mismo recurso de Foundry o en uno nuevo.
2. Actualiza tu aplicación para pasar el nuevo nombre de implementación en el parámetro `model`.
3. Elimina la implementación anterior una vez que el tráfico se haya trasladado.

Si la nueva implementación está en el mismo recurso de Foundry, la URL de tu endpoint y la autenticación no cambian. Si creaste un nuevo recurso, actualiza el endpoint y las credenciales de tu aplicación para que apunten a él.

## Monitoreo y registro

Azure proporciona monitoreo y registro para tu uso de Claude a través de patrones estándar de Azure:

* **Azure Monitor:** Rastrea el uso de la API, la latencia y las tasas de error
* **Azure Log Analytics:** Consulta y analiza los registros de solicitudes/respuestas
* **Cost Management:** Monitorea y pronostica los costos asociados con el uso de Claude

Anthropic recomienda registrar tu actividad al menos de forma continua durante 30 días para comprender los patrones de uso e investigar cualquier posible problema.

<Note>
  Los servicios de registro de Azure se configuran dentro de tu suscripción de Azure. Habilitar el registro no proporciona a Microsoft ni a Anthropic acceso a tu contenido más allá de lo necesario para la facturación y la operación del servicio.
</Note>

## Solución de problemas

### Errores de autenticación

**Error:** `401 Unauthorized` o `Invalid API key`

* **Solución:** Verifica que tu clave de API sea correcta. Puedes encontrarla en el portal de Foundry en la pestaña **Details** de tu implementación (en **Build** > **Models**).
* **Solución:** Si usas Microsoft Entra ID, asegúrate de que tu token de acceso sea válido y no haya expirado. Los tokens normalmente expiran después de 1 hora.

**Error:** `403 Forbidden`

**Causa:** Es posible que tu cuenta de Azure no tenga los permisos necesarios.

* **Solución:** Asegúrate de tener asignado el rol de Azure RBAC adecuado (por ejemplo, **Foundry User** o **Cognitive Services User**).

### Limitación de velocidad

**Error:** `429 Too Many Requests`

* **Solución:** Has excedido tu límite de velocidad. Implementa lógica de retroceso exponencial y reintentos en tu aplicación.
* **Solución:** Considera solicitar aumentos del límite de velocidad a través del portal de Azure o del soporte de Azure.

#### Encabezados de límite de velocidad

Foundry no incluye los encabezados estándar de límite de velocidad de Anthropic (`anthropic-ratelimit-tokens-limit`, `anthropic-ratelimit-tokens-remaining`, `anthropic-ratelimit-tokens-reset`, `anthropic-ratelimit-input-tokens-limit`, `anthropic-ratelimit-input-tokens-remaining`, `anthropic-ratelimit-input-tokens-reset`, `anthropic-ratelimit-output-tokens-limit`, `anthropic-ratelimit-output-tokens-remaining` y `anthropic-ratelimit-output-tokens-reset`) en las respuestas. En su lugar, administra la limitación de velocidad a través de las herramientas de monitoreo de Azure.

### Errores de modelo e implementación

**Error:** `Model not found` o `Deployment not found`

* **Solución:** Verifica que estés usando el nombre de implementación correcto. Si no has creado una implementación personalizada, usa el ID de modelo predeterminado (por ejemplo, claude-opus-5-5).
* **Solución:** Asegúrate de que el modelo/implementación esté disponible en tu región de Azure.

**Error:** `Invalid model parameter`

* **Solución:** El parámetro `model` debe contener el nombre de tu implementación, que se puede personalizar en el portal de Foundry. Verifica que la implementación exista y esté configurada correctamente.

## Próximos pasos

<CardGroup cols={2}>
  <Card title="Descripción general de funciones" icon="stack" href="https://platform.claude.com/docs/es/build-with-claude/overview">
    Explora las funciones y capacidades avanzadas de Claude.
  </Card>

  <Card title="Precios" icon="chart" href="https://platform.claude.com/docs/es/about-claude/pricing#claude-in-microsoft-foundry-pricing">
    Conoce la estructura de precios de Anthropic para modelos y funciones.
  </Card>

  <Card title="Obsolescencia de modelos" icon="arrow-clockwise" href="https://platform.claude.com/docs/es/about-claude/model-deprecations">
    A medida que se lanzan modelos más seguros y capaces, Anthropic retira regularmente los más antiguos. Consulta todas las obsolescencias de la API, junto con los reemplazos recomendados.
  </Card>
</CardGroup>

## Recursos adicionales

<CardGroup cols={2}>
  <Card title="Catálogo de modelos de Foundry" icon="grid" href="https://ai.azure.com/catalog/publishers/anthropic">
    Explora los modelos de Anthropic en el catálogo de Foundry.
  </Card>

  <Card title="Precios de Microsoft Foundry" icon="calculator" href="https://azure.microsoft.com/en-us/pricing/details/ai-foundry/#pricing">
    Consulta los detalles de precios de Microsoft para Microsoft Foundry.
  </Card>

  <Card title="Precios de modelos" icon="table" href="https://platform.claude.com/docs/es/about-claude/pricing#model-pricing">
    Consulta los detalles de precios por modelo de Anthropic.
  </Card>

  <Card title="Portal de Azure" icon="cloud" href="https://portal.azure.com/">
    Administra tus recursos de Azure.
  </Card>
</CardGroup>
