---
title: Claude in Microsoft Foundry
url: https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry
description: Accedi ai modelli Claude tramite Microsoft Foundry con endpoint e autenticazione nativi di Azure.
---

Questa guida ti mostra come configurare Claude in Microsoft Foundry ed effettuare chiamate API a esso. Puoi utilizzare uno degli SDK client di Anthropic o richieste HTTP dirette. Quando accedi a Claude in Microsoft Foundry, paghi l’utilizzo di Claude tramite l’Azure Marketplace. La sezione [ID dei modelli API e deployment](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry#api-model-ids-and-deployments) elenca i modelli disponibili. Sono disponibili anche funzionalità come la [“context window” (finestra di contesto) da 1M di token](https://platform.claude.com/docs/it/build-with-claude/context-windows). Gestisci i costi tramite la tua sottoscrizione Azure.

Claude è disponibile nei tipi di deployment Global Standard e US Data Zone Standard nelle risorse Foundry, fatturato in Claude Consumption Units tramite l’Azure Marketplace. Visita [prezzi di Claude in Microsoft Foundry](https://platform.claude.com/docs/it/about-claude/pricing#claude-in-microsoft-foundry-pricing) per i dettagli.

## Opzioni di hosting

I modelli Claude in Microsoft Foundry sono disponibili in due opzioni di hosting. Scegli l’opzione di hosting quando configuri il deployment.

|                                 | Ospitato su Azure                                                                                                                                      | Ospitato su Anthropic                                                                                                                                                                                                                                                                                                                                                                                     |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Dove viene eseguita l’inferenza | Servizio gestito da Anthropic in esecuzione sull’infrastruttura Azure                                                                                  | Servizio gestito da Anthropic in esecuzione sull’infrastruttura Anthropic                                                                                                                                                                                                                                                                                                                                 |
| Disponibilità dei modelli       | [Alcuni modelli Opus, Sonnet e Haiku](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry#api-model-ids-and-deployments) | [Tutti i modelli Claude disponibili su Microsoft Foundry](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry#api-model-ids-and-deployments)                                                                                                                                                                                                                                |
| Tipi di deployment              | Global Standard, US Data Zone Standard                                                                                                                 | Global Standard                                                                                                                                                                                                                                                                                                                                                                                           |
| Consigliato per                 | La maggior parte dei carichi di lavoro                                                                                                                 | Carichi di lavoro che richiedono [modelli ospitati solo su Anthropic](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry#api-model-ids-and-deployments) o [funzionalità disponibili solo per i deployment ospitati su Anthropic](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry#additional-features-not-supported-when-hosted-on-azure) |

Per i deployment ospitati su Azure, Anthropic elabora i prompt e i completamenti sull’infrastruttura Azure e vi archivia i contenuti conservati. I contenuti conservati includono i contenuti segnalati dai sistemi di sicurezza di Anthropic per la revisione da parte di Anthropic. I dati operativi che non contengono prompt o completamenti vengono archiviati sui sistemi di Anthropic al di fuori di Azure. Alcuni esempi sono i punteggi dei classificatori di sicurezza, gli identificatori e i dati di utilizzo e fatturazione.

<Note>
  Anthropic agisce come responsabile del trattamento indipendente per Microsoft. I clienti che utilizzano Claude tramite Microsoft Foundry sono soggetti ai [termini di utilizzo dei dati](https://www.anthropic.com/legal) di Anthropic. Anthropic garantisce i propri impegni in materia di sicurezza e dati.
</Note>

## Prerequisiti

Prima di iniziare, assicurati di avere:

* Una sottoscrizione Azure attiva
* Accesso al [portale Foundry](https://ai.azure.com/)
* Un ruolo di “role-based access control” (controllo degli accessi basato sui ruoli), o RBAC, di Azure, come **Foundry User** o **Cognitive Services User**, per la risorsa Foundry che crei in [Provisioning](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry#provisioning)
* Facoltativo: la [Azure CLI](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli) per ottenere token [Microsoft Entra ID](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry#microsoft-entra-authentication) con `az account get-access-token`

## Installa un SDK

Gli [SDK client](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) di Anthropic supportano Foundry tramite un pacchetto o una classe client specifici della piattaforma. Gli esempi in questa pagina mostrano anche richieste con cURL e la CLI `ant`. Per configurare la CLI, consulta la [guida rapida della CLI](https://platform.claude.com/docs/it/cli-sdks-libraries/cli/quickstart).

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

    # Per l'autenticazione con Entra ID, installa anche la libreria Azure Identity
    pip install azure-identity
    ```
  </Tab>

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

    # Per l'autenticazione con Entra ID, installa anche la libreria 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

    # Per l'autenticazione con Entra ID, installa anche la libreria 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.10.0")
        implementation("com.anthropic:anthropic-java-foundry:3.10.0")
        ```
      </Tab>

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

    Per l’autenticazione con Entra ID, aggiungi anche la libreria Azure Identity (`com.azure:azure-identity`) alla tua build, all’ultima versione disponibile su [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
    ```

    Per l’autenticazione con Entra ID, passi al client un provider di token. Il provider in [Autenticazione Microsoft Entra](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry#microsoft-entra-authentication) ottiene i propri token dalla [Azure CLI](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli), quindi installa la Azure CLI per usare quel provider.
  </Tab>
</Tabs>

## Provisioning

Foundry utilizza una gerarchia a due livelli: le **risorse** contengono la configurazione di sicurezza e fatturazione, mentre i **deployment** sono le istanze del modello che chiami tramite l’API. Prima creerai una risorsa Foundry, poi creerai uno o più deployment Claude al suo interno.

### Provisioning delle risorse Foundry

Per effettuare il provisioning della tua risorsa:

1. Vai al [portale Foundry](https://ai.azure.com/).
2. Crea o seleziona una risorsa Foundry in una [regione Azure in cui il tuo modello è disponibile](https://learn.microsoft.com/en-us/azure/foundry/foundry-models/how-to/use-foundry-models-claude). Puoi seguire le [istruzioni di Microsoft per creare una risorsa Foundry](https://learn.microsoft.com/en-us/azure/ai-services/multi-service-resource?pivots=azportal) oppure [creare un progetto Foundry](https://learn.microsoft.com/en-us/azure/foundry/how-to/create-projects), che crea una risorsa per te.
3. Annota il nome della tua risorsa, che corrisponde a `{resource}` negli endpoint API come `https://{resource}.services.ai.azure.com/anthropic/v1/*`.

Per limitare l’accesso di rete, puoi [aggiungere la tua risorsa a una rete privata](https://learn.microsoft.com/en-us/azure/foundry/how-to/configure-private-link) (Azure Virtual Network).

### Creazione dei deployment Foundry

Dopo aver creato la risorsa, esegui il deployment di un modello Claude per renderlo disponibile per le chiamate API. Questi passaggi descrivono il nuovo portale Foundry (l’interruttore **New Foundry** è attivo):

1. Accedi al portale Foundry. Dalla home page del portale, seleziona **Discover** nella navigazione in alto a destra, quindi **Models** nel riquadro a sinistra per aprire il catalogo dei modelli.

2. Cerca e seleziona un modello Claude (ad esempio, claude-opus-5-5). Ogni modello compare una sola volta nel catalogo, indipendentemente da quante opzioni di hosting supporta.

3. Nella scheda del modello, seleziona **Deploy**, poi **Custom settings** per aprire il riquadro delle impostazioni del deployment. Se invece selezioni **Default settings**, il deployment viene configurato automaticamente come ospitato su Azure per i modelli disponibili in entrambe le opzioni di hosting.

4. Al tuo primo deployment di Claude, esamina i termini dell’Azure Marketplace, seleziona un settore e seleziona **Agree and Proceed** per accettare i termini e sottoscrivere l’offerta dell’Azure Marketplace.

5. Configura il deployment:

   * **Deployment name:** Il valore predefinito è l’ID del modello, ma puoi personalizzarlo (ad esempio, `my-claude-deployment`). Il nome del deployment non può essere modificato dopo la creazione.
   * **Model version:** Questa impostazione determina l’[opzione di hosting](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry#hosting-options). Espandi **Model version settings**, apri il menu a discesa **Model version** e seleziona la versione etichettata con l’opzione di hosting desiderata.
   * **Region scope:** Seleziona **Global**, oppure **Data Zone** se il deployment è ospitato su Azure. **Data Zone** crea un deployment US Data Zone Standard, che mantiene l’inferenza all’interno degli Stati Uniti. Per i prezzi, consulta [Area geografica dell’inferenza](https://platform.claude.com/docs/it/about-claude/pricing#foundry-inference-geography).

6. Seleziona **Deploy** e attendi il completamento del provisioning.

7. Una volta completato il deployment, seleziona **Build** nella navigazione in alto a destra, quindi **Models** nel riquadro a sinistra, e apri il tuo deployment. La scheda **Details** mostra il **Target URI** (l’URL del tuo endpoint) e la **Key** (la tua chiave API).

Se l’interruttore **New Foundry** è disattivato, ti trovi nel layout classico del portale. Lì, apri **Model catalog** nel riquadro a sinistra per trovare un modello ed eseguirne il deployment, e apri **Models + endpoints** (sotto **My assets**) per visualizzare i tuoi deployment e i dettagli dei relativi endpoint.

<Note>
  Il nome del deployment che scegli diventa il valore da passare nel parametro `model` delle tue richieste API. Puoi creare più deployment dello stesso modello con nomi diversi per gestire configurazioni o “rate limit” (limiti di velocità) separati.
</Note>

## Autenticazione

Claude in Microsoft Foundry supporta due metodi di autenticazione: chiavi API e token Entra ID. Entrambi i metodi utilizzano endpoint nel formato `https://{resource}.services.ai.azure.com/anthropic/v1/*`. Per i [modelli Claude Mythos](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry#api-model-ids-and-deployments), usa i [token Entra ID](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry#microsoft-entra-authentication).

### Autenticazione con chiave API

Dopo aver effettuato il provisioning della tua risorsa Claude in Foundry, puoi ottenere una chiave API dal portale Foundry:

1. Nel portale Foundry, seleziona **Build** nella navigazione in alto a destra, quindi **Models** nel riquadro a sinistra.
2. Apri il tuo deployment di Claude e seleziona la scheda **Details**.
3. Copia il valore **Key** (e annota il **Target URI** del tuo endpoint).
4. Utilizza l’header `api-key` o `x-api-key` nelle tue richieste, oppure forniscila all’SDK.

Il client Foundry dell’SDK richiede una chiave API e un nome di risorsa o un URL di base, e li legge automaticamente dalle seguenti variabili d’ambiente, se definite:

* `ANTHROPIC_FOUNDRY_API_KEY` - La tua chiave API
* `ANTHROPIC_FOUNDRY_RESOURCE` - Il nome della tua risorsa (ad esempio, `example-resource`)
* `ANTHROPIC_FOUNDRY_BASE_URL` - Alternativa al nome della risorsa in tutti gli SDK tranne C#: l’URL di base completo (ad esempio, `https://example-resource.services.ai.azure.com/anthropic/`)

<Note>
  I parametri `resource` e `base_url` si escludono a vicenda. Fornisci il nome della risorsa (che l’SDK utilizza per costruire l’URL come `https://{resource}.services.ai.azure.com/anthropic/`) oppure direttamente l’URL di base completo.
</Note>

**Esempio con chiave 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 legge 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;

  // Il client C# costruisce sempre l'URL di base a partire dal nome della risorsa.
  // Non legge 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() {
      // Richiede le variabili d'ambiente: 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>
  Mantieni al sicuro le tue chiavi API. Non eseguirne mai il commit nel controllo di versione e non condividerle pubblicamente. Chiunque abbia accesso alla tua chiave API può effettuare richieste a Claude tramite la tua risorsa Foundry.
</Warning>

### Autenticazione Microsoft Entra

L’autenticazione Entra ID ti consente di gestire l’accesso con Azure RBAC, integrarti con la gestione delle identità della tua organizzazione ed evitare di gestire manualmente le chiavi API. Per utilizzare i token Entra ID:

1. Abilita l’[autenticazione Microsoft Entra ID](https://learn.microsoft.com/en-us/azure/ai-foundry/model-inference/how-to/configure-entra-id) per la tua risorsa Foundry.
2. Ottieni un token di accesso da Entra ID.
3. Utilizza il token nell’header `Authorization: Bearer {TOKEN}`.

**Esempio con Entra ID:**

<CodeGroup>
  ```bash cURL
  # Esegui una richiesta con un token di Microsoft Entra ID. Sostituisci {resource} con il nome della tua risorsa
  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
  # Esegui una richiesta con un token di Microsoft Entra ID. Sostituisci {resource} con il nome della tua risorsa
  # env -u rimuove ANTHROPIC_API_KEY, che la CLI invierebbe al posto 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

  # Ottieni il token di Microsoft Entra ID usando il pattern del token provider
  token_provider = get_bearer_token_provider(
      DefaultAzureCredential(), "https://ai.azure.com/.default"
  )

  # Crea il client con autenticazione Entra ID
  client = AnthropicFoundry(
      resource="example-resource",  # your resource name
      azure_ad_token_provider=token_provider,  # Use token provider for Entra ID auth
  )

  # Esegui la richiesta
  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";

  // Ottieni il token Entra ID usando il pattern del token provider
  const credential = new DefaultAzureCredential();
  const tokenProvider = getBearerTokenProvider(credential, "https://ai.azure.com/.default");

  // Crea il client con autenticazione Entra ID
  const client = new AnthropicFoundry({
    resource: "example-resource", // your resource name
    azureADTokenProvider: tokenProvider // Use token provider for Entra ID auth
  });

  // Esegui la richiesta
  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;

  // Ottieni un token di accesso Entra ID, ad esempio usando la Azure CLI:
  //   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"

  # Ottieni un token Microsoft Entra ID dall'Azure CLI. Il client chiama questa
  # lambda per ogni richiesta e nuovo tentativo, quindi in produzione metti in cache il token
  # finché non è prossimo alla scadenza.
  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>

## ID di correlazione delle richieste

Foundry include identificatori di richiesta negli header di risposta HTTP per il debug e il tracciamento. Quando contatti il supporto, fornisci sia il valore `request-id` sia il valore `apim-request-id` (Azure API Management) per aiutare i team a individuare e analizzare rapidamente la tua richiesta nei sistemi sia di Anthropic sia di Azure.

## Supporto delle funzionalità

Claude in Microsoft Foundry supporta la maggior parte delle funzionalità di Claude. La [panoramica delle funzionalità](https://platform.claude.com/docs/it/build-with-claude/overview) elenca le funzionalità di Claude e la sezione **Disponibilità** della pagina di ciascuna funzionalità indica se Foundry la supporta e con quale opzione di hosting.

### Finestra di contesto

Tutti i [modelli disponibili](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry#api-model-ids-and-deployments) hanno una [finestra di contesto da 1M di token](https://platform.claude.com/docs/it/build-with-claude/context-windows) su Microsoft Foundry, tranne Claude Opus 4.5, Claude Sonnet 4.5 (deprecato) e Claude Haiku 4.5. Questi tre modelli hanno una finestra di contesto da 200k token.

### Funzionalità di Claude non supportate per Claude in Microsoft Foundry

* Admin API
* Strumento advisor
* Claude Managed Agents
* Compliance API
* Models API
* Message Batches API
* Fallback lato server (il [parametro `fallbacks`](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback#server-side-fallback); usa invece il [pattern di fallback lato client](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback#client-side-fallback))
* Endpoint dei profili utente (`/v1/user_profiles`; [crea invece i profili sulla Claude API](https://platform.claude.com/docs/it/manage-claude/user-profiles#before-you-begin))

### Funzionalità aggiuntive non supportate quando ospitato su Azure

Le seguenti funzionalità sono disponibili per i deployment ospitati su Anthropic ma non sono supportate per i deployment ospitati su Azure:

* [Esecuzione di codice](https://platform.claude.com/docs/it/agents-and-tools/tool-use/code-execution-tool)
* Versioni degli strumenti [ricerca web](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-search-tool) e [web fetch](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-fetch-tool) successive a `web_search_20250305` e `web_fetch_20250910`. I deployment ospitati su Azure supportano solo queste versioni di base, quindi il filtraggio dinamico, l’inclusione delle risposte e il bypass della cache non sono disponibili.
* [Agent Skills](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/overview)
* [Chiamata programmatica degli strumenti](https://platform.claude.com/docs/it/agents-and-tools/tool-use/programmatic-tool-calling)
* [Files API](https://platform.claude.com/docs/it/build-with-claude/files)

Le richieste che utilizzano queste funzionalità su un deployment ospitato su Azure restituiscono intenzionalmente un errore `400 Bad Request`. Claude Code rileva i deployment ospitati su Azure e adatta automaticamente il proprio set di funzionalità.

## Risposte API

Le risposte API di Claude in Microsoft Foundry seguono il [formato di risposta standard della Claude API](https://platform.claude.com/docs/it/api/messages/create), incluso l’oggetto `usage`.

Per i dettagli sugli header di risposta specifici di Foundry, consulta [ID di correlazione delle richieste](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry#correlation-request-ids).

## ID dei modelli API e deployment

I termini del ciclo di vita (Deprecato, Ritirato) sono definiti in [Deprecazioni dei modelli](https://platform.claude.com/docs/it/about-claude/model-deprecations). Microsoft Foundry segue il calendario del ciclo di vita della Claude API.

I seguenti modelli Claude sono disponibili tramite 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/it/about-claude/model-deprecations)) | `claude-sonnet-4-5`     |                 |          ✓          |
| Claude Haiku 5.5                                                                                      | `claude-haiku-5-5`      |        ✓        |          ✓          |
| Claude Haiku 4.5                                                                                      | `claude-haiku-4-5`      |        ✓        |          ✓          |

Per impostazione predefinita, i nomi dei deployment corrispondono agli ID dei modelli mostrati nella tabella precedente. Tuttavia, puoi creare deployment personalizzati con nomi diversi nel portale Foundry per gestire configurazioni, versioni o limiti di velocità differenti. Usa il nome del deployment (non necessariamente l’ID del modello) nelle tue richieste API.

<Info>
  [Claude Mythos Preview](https://anthropic.com/glasswing) è un’anteprima di ricerca disponibile per i clienti invitati su Microsoft Foundry.
</Info>

Lascia che Claude Code migri il tuo codice a un modello più recente

```text
/claude-api migrate questo progetto all'ultimo modello Claude Opus
```

## Fatturazione

Claude in Microsoft Foundry viene fatturato tramite l’[Azure Marketplace](https://azuremarketplace.microsoft.com/). L’utilizzo è espresso in Claude Consumption Units (CCU), misurato su base oraria e fatturato mensilmente in via posticipata sulla tua fattura Azure. Le CCU non sono crediti prepagati. Non esiste alcun saldo o impegno in CCU.

Per il prezzo delle CCU, i meccanismi di conversione e le tariffe per token di ciascun modello, consulta [Prezzi di Claude in Microsoft Foundry](https://platform.claude.com/docs/it/about-claude/pricing#claude-in-microsoft-foundry-pricing).

## Migrazione tra opzioni di hosting

Per spostare un deployment esistente da un’opzione di hosting all’altra:

1. Crea un nuovo deployment dell’altra versione di hosting del modello (Hosted on Azure o Hosted on Anthropic). Può trovarsi nella stessa risorsa Foundry o in una nuova.
2. Aggiorna la tua applicazione in modo che passi il nuovo nome del deployment nel parametro `model`.
3. Elimina il vecchio deployment una volta che il traffico è stato spostato.

Se il nuovo deployment si trova nella stessa risorsa Foundry, l’URL dell’endpoint e l’autenticazione restano invariati. Se hai creato una nuova risorsa, aggiorna l’endpoint e le credenziali della tua applicazione in modo che puntino a essa.

## Monitoraggio e logging

Azure fornisce monitoraggio e logging per il tuo utilizzo di Claude tramite i pattern standard di Azure:

* **Azure Monitor:** monitora l’utilizzo dell’API, la latenza e i tassi di errore
* **Azure Log Analytics:** interroga e analizza i log di richieste/risposte
* **Cost Management:** monitora e prevedi i costi associati all’utilizzo di Claude

Anthropic consiglia di registrare la tua attività su una base mobile di almeno 30 giorni per comprendere i pattern di utilizzo e indagare eventuali problemi.

<Note>
  I servizi di logging di Azure sono configurati all’interno della tua sottoscrizione Azure. L’abilitazione del logging non fornisce a Microsoft o ad Anthropic accesso ai tuoi contenuti oltre a quanto necessario per la fatturazione e il funzionamento del servizio.
</Note>

## Risoluzione dei problemi

### Errori di autenticazione

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

* **Soluzione:** verifica che la tua chiave API sia corretta. Puoi trovarla nel portale Foundry nella scheda **Details** del tuo deployment (sotto **Build** > **Models**).
* **Soluzione:** se usi Microsoft Entra ID, assicurati che il tuo token di accesso sia valido e non sia scaduto. I token in genere scadono dopo 1 ora.

**Errore:** `403 Forbidden`

**Causa:** il tuo account Azure potrebbe non disporre delle autorizzazioni necessarie.

* **Soluzione:** assicurati che ti sia stato assegnato il ruolo Azure RBAC appropriato (ad esempio, **Foundry User** o **Cognitive Services User**).

### Limitazione della velocità

**Errore:** `429 Too Many Requests`

* **Soluzione:** hai superato il tuo limite di velocità. Implementa una logica di backoff esponenziale e di ripetizione dei tentativi nella tua applicazione.
* **Soluzione:** valuta la possibilità di richiedere un aumento dei limiti di velocità tramite il portale Azure o il supporto Azure.

#### Header dei limiti di velocità

Foundry non include nelle risposte gli header standard dei limiti di velocità di 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` e `anthropic-ratelimit-output-tokens-reset`). Gestisci invece la limitazione della velocità tramite gli strumenti di monitoraggio di Azure.

### Errori di modello e deployment

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

* **Soluzione:** verifica di usare il nome del deployment corretto. Se non hai creato un deployment personalizzato, usa l’ID del modello predefinito (ad esempio, claude-opus-5-5).
* **Soluzione:** assicurati che il modello/deployment sia disponibile nella tua regione Azure.

**Errore:** `Invalid model parameter`

* **Soluzione:** Il parametro `model` deve contenere il nome del tuo deployment, che può essere personalizzato nel portale Foundry. Verifica che il deployment esista e sia configurato correttamente.

## Passaggi successivi

<CardGroup cols={2}>
  <Card title="Panoramica delle funzionalità" icon="stack" href="https://platform.claude.com/docs/it/build-with-claude/overview">
    Esplora le funzionalità e le capacità avanzate di Claude.
  </Card>

  <Card title="Prezzi" icon="chart" href="https://platform.claude.com/docs/it/about-claude/pricing#claude-in-microsoft-foundry-pricing">
    Scopri la struttura dei prezzi di Anthropic per modelli e funzionalità.
  </Card>

  <Card title="Deprecazioni dei modelli" icon="arrow-clockwise" href="https://platform.claude.com/docs/it/about-claude/model-deprecations">
    Con il lancio di modelli più sicuri e capaci, Anthropic ritira regolarmente quelli più vecchi. Consulta tutte le deprecazioni dell’API, insieme alle sostituzioni consigliate.
  </Card>
</CardGroup>

## Risorse aggiuntive

<CardGroup cols={2}>
  <Card title="Catalogo dei modelli Foundry" icon="grid" href="https://ai.azure.com/catalog/publishers/anthropic">
    Sfoglia i modelli Anthropic nel catalogo Foundry.
  </Card>

  <Card title="Prezzi di Microsoft Foundry" icon="calculator" href="https://azure.microsoft.com/en-us/pricing/details/ai-foundry/#pricing">
    Visualizza i dettagli dei prezzi di Microsoft per Microsoft Foundry.
  </Card>

  <Card title="Prezzi dei modelli" icon="table" href="https://platform.claude.com/docs/it/about-claude/pricing#model-pricing">
    Visualizza i dettagli dei prezzi per modello di Anthropic.
  </Card>

  <Card title="Portale Azure" icon="cloud" href="https://portal.azure.com/">
    Gestisci le tue risorse Azure.
  </Card>
</CardGroup>
