---
title: Claude dans Microsoft Foundry
url: https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry
description: Accédez aux modèles Claude via Microsoft Foundry avec des points de terminaison et une authentification natifs Azure.
---

Ce guide vous montre comment configurer Claude dans Microsoft Foundry et lui envoyer des appels API. Vous pouvez utiliser l’un des SDK clients d’Anthropic ou des requêtes HTTP directes. Lorsque vous accédez à Claude dans Microsoft Foundry, vous payez l’utilisation de Claude via l’Azure Marketplace. La section [ID de modèle API et déploiements](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry#api-model-ids-and-deployments) répertorie les modèles disponibles. Des fonctionnalités telles que la [« context window » (fenêtre de contexte) de 1M de tokens](https://platform.claude.com/docs/fr/build-with-claude/context-windows) sont également disponibles. Vous gérez les coûts via votre abonnement Azure.

Claude est disponible dans les types de déploiement Global Standard et US Data Zone Standard des ressources Foundry, facturé en Claude Consumption Units via l’Azure Marketplace. Consultez la [tarification de Claude dans Microsoft Foundry](https://platform.claude.com/docs/fr/about-claude/pricing#claude-in-microsoft-foundry-pricing) pour plus de détails.

## Options d’hébergement

Les modèles Claude dans Microsoft Foundry sont disponibles selon deux options d’hébergement. Vous choisissez l’option d’hébergement lorsque vous configurez le déploiement.

|                           | Hébergé sur Azure                                                                                                                                         | Hébergé sur Anthropic                                                                                                                                                                                                                                                                                                                                                                                                                |
| ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Où s’exécute l’inférence  | Service exploité par Anthropic s’exécutant sur l’infrastructure Azure                                                                                     | Service exploité par Anthropic s’exécutant sur l’infrastructure Anthropic                                                                                                                                                                                                                                                                                                                                                            |
| Disponibilité des modèles | [Certains modèles Opus, Sonnet et Haiku](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry#api-model-ids-and-deployments) | [Tous les modèles Claude disponibles sur Microsoft Foundry](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry#api-model-ids-and-deployments)                                                                                                                                                                                                                                                         |
| Types de déploiement      | Global Standard, US Data Zone Standard                                                                                                                    | Global Standard                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Recommandé pour           | La plupart des charges de travail                                                                                                                         | Les charges de travail qui nécessitent des [modèles hébergés uniquement sur Anthropic](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry#api-model-ids-and-deployments) ou des [fonctionnalités disponibles uniquement en cas d’hébergement sur Anthropic](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry#additional-features-not-supported-when-hosted-on-azure) |

Pour les déploiements hébergés sur Azure, Anthropic traite les prompts et les complétions sur l’infrastructure Azure et y stocke le contenu conservé. Le contenu conservé inclut le contenu signalé par les systèmes de sécurité d’Anthropic pour examen par Anthropic. Les données opérationnelles qui ne contiennent ni prompts ni complétions sont stockées sur les systèmes d’Anthropic en dehors d’Azure. Il s’agit par exemple des scores des classificateurs de sécurité, des ID, ainsi que des données d’utilisation et de facturation.

<Note>
  Anthropic agit en tant que sous-traitant indépendant pour Microsoft. Les clients utilisant Claude via Microsoft Foundry sont soumis aux [conditions d’utilisation des données](https://www.anthropic.com/legal) d’Anthropic. Anthropic respecte ses engagements en matière de sécurité et de données.
</Note>

## Prérequis

Avant de commencer, assurez-vous de disposer de :

* Un abonnement Azure actif
* Un accès au [portail Foundry](https://ai.azure.com/)
* Un rôle de contrôle d’accès en fonction du rôle Azure (RBAC), tel que **Foundry User** ou **Cognitive Services User**, pour la ressource Foundry que vous créez dans [Provisionnement](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry#provisioning)
* Facultatif : l’[Azure CLI](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli) pour obtenir des jetons [Microsoft Entra ID](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry#microsoft-entra-authentication) avec `az account get-access-token`

## Installer un SDK

Les [SDK clients](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview) d’Anthropic prennent en charge Foundry via un package ou une classe client spécifique à la plateforme. Les exemples de cette page montrent également des requêtes avec cURL et la CLI `ant`. Pour configurer la CLI, consultez le [démarrage rapide de la CLI](https://platform.claude.com/docs/fr/cli-sdks-libraries/cli/quickstart).

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

    # Pour l'authentification Entra ID, installez également la bibliothèque Azure Identity.
    pip install azure-identity
    ```
  </Tab>

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

    # Pour l'authentification Entra ID, installez également la bibliothèque 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

    # Pour l'authentification Entra ID, installez également la bibliothèque 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.11.0")
        implementation("com.anthropic:anthropic-java-foundry:3.11.0")
        ```
      </Tab>

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

    Pour l’authentification Entra ID, ajoutez également la bibliothèque Azure Identity (`com.azure:azure-identity`) à votre build, dans sa dernière version sur [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
    ```

    Pour l’authentification Entra ID, vous transmettez au client un fournisseur de jetons. Le fournisseur présenté dans [Authentification Microsoft Entra](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry#microsoft-entra-authentication) obtient ses jetons à partir de l’[Azure CLI](https://learn.microsoft.com/en-us/cli/azure/install-azure-cli) ; installez donc l’Azure CLI pour utiliser ce fournisseur.
  </Tab>
</Tabs>

## Provisionnement

Foundry utilise une hiérarchie à deux niveaux : les **ressources** contiennent votre configuration de sécurité et de facturation, tandis que les **déploiements** sont les instances de modèle que vous appelez via l’API. Vous allez d’abord créer une ressource Foundry, puis créer un ou plusieurs déploiements Claude au sein de celle-ci.

### Provisionnement des ressources Foundry

Pour provisionner votre ressource :

1. Accédez au [portail Foundry](https://ai.azure.com/).
2. Créez ou sélectionnez une ressource Foundry dans une [région Azure où votre modèle est disponible](https://learn.microsoft.com/en-us/azure/foundry/foundry-models/how-to/use-foundry-models-claude). Vous pouvez suivre les [instructions de Microsoft pour créer une ressource Foundry](https://learn.microsoft.com/en-us/azure/ai-services/multi-service-resource?pivots=azportal) ou [créer un projet Foundry](https://learn.microsoft.com/en-us/azure/foundry/how-to/create-projects), ce qui crée une ressource pour vous.
3. Notez le nom de votre ressource, qui correspond à `{resource}` dans les points de terminaison de l’API tels que `https://{resource}.services.ai.azure.com/anthropic/v1/*`.

Pour restreindre l’accès réseau, vous pouvez [ajouter votre ressource à un réseau privé](https://learn.microsoft.com/en-us/azure/foundry/how-to/configure-private-link) (Azure Virtual Network).

### Création de déploiements Foundry

Après avoir créé votre ressource, déployez un modèle Claude pour le rendre disponible pour les appels API. Ces étapes décrivent le nouveau portail Foundry (le bouton **New Foundry** est activé) :

1. Connectez-vous au portail Foundry. Depuis la page d’accueil du portail, sélectionnez **Discover** dans la navigation en haut à droite, puis **Models** dans le volet de gauche pour ouvrir le catalogue de modèles.

2. Recherchez et sélectionnez un modèle Claude (par exemple, claude-opus-5-5). Chaque modèle apparaît une seule fois dans le catalogue, quel que soit le nombre d’options d’hébergement qu’il prend en charge.

3. Sur la fiche du modèle, sélectionnez **Deploy**, puis **Custom settings** pour ouvrir le volet des paramètres de déploiement. Si vous sélectionnez plutôt **Default settings**, le déploiement est automatiquement configuré comme Hébergé sur Azure pour les modèles disponibles dans les deux options d’hébergement.

4. Lors de votre premier déploiement Claude, consultez les conditions de l’Azure Marketplace, sélectionnez un secteur d’activité, puis sélectionnez **Agree and Proceed** pour accepter les conditions et vous abonner à l’offre de l’Azure Marketplace.

5. Configurez le déploiement :

   * **Deployment name :** par défaut, il s’agit de l’ID du modèle, mais vous pouvez le personnaliser (par exemple, `my-claude-deployment`). Le nom du déploiement ne peut pas être modifié après sa création.
   * **Model version :** ce paramètre détermine l’[option d’hébergement](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry#hosting-options). Développez **Model version settings**, ouvrez le menu déroulant **Model version** et sélectionnez la version portant l’étiquette de l’option d’hébergement souhaitée.
   * **Region scope :** sélectionnez **Global**, ou **Data Zone** si le déploiement est hébergé sur Azure. **Data Zone** crée un déploiement US Data Zone Standard, qui maintient l’inférence aux États-Unis. Pour la tarification, consultez [Géographie d’inférence](https://platform.claude.com/docs/fr/about-claude/pricing#foundry-inference-geography).

6. Sélectionnez **Deploy** et attendez la fin du provisionnement.

7. Une fois le déploiement effectué, sélectionnez **Build** dans la navigation en haut à droite, puis **Models** dans le volet de gauche, et ouvrez votre déploiement. L’onglet **Details** affiche le **Target URI** (l’URL de votre point de terminaison) et la **Key** (votre clé API).

Si le bouton **New Foundry** est désactivé, vous êtes dans la disposition classique du portail. Dans ce cas, ouvrez **Model catalog** dans le volet de gauche pour trouver et déployer un modèle, et ouvrez **Models + endpoints** (sous **My assets**) pour afficher vos déploiements et les détails de leurs points de terminaison.

<Note>
  Le nom de déploiement que vous choisissez devient la valeur que vous transmettez dans le paramètre `model` de vos requêtes API. Vous pouvez créer plusieurs déploiements du même modèle avec des noms différents pour gérer des configurations ou des « rate limits » (limites de débit) distinctes.
</Note>

## Authentification

Claude dans Microsoft Foundry prend en charge deux méthodes d’authentification : les clés API et les jetons Entra ID. Les deux méthodes utilisent des points de terminaison au format `https://{resource}.services.ai.azure.com/anthropic/v1/*`. Pour les [modèles Claude Mythos](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry#api-model-ids-and-deployments), utilisez des [jetons Entra ID](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry#microsoft-entra-authentication).

### Authentification par clé API

Après avoir provisionné votre ressource Claude Foundry, vous pouvez obtenir une clé API depuis le portail Foundry :

1. Dans le portail Foundry, sélectionnez **Build** dans la navigation en haut à droite, puis **Models** dans le volet de gauche.
2. Ouvrez votre déploiement Claude et sélectionnez l’onglet **Details**.
3. Copiez la valeur **Key** (et notez le **Target URI** de votre point de terminaison).
4. Utilisez l’en-tête `api-key` ou `x-api-key` dans vos requêtes, ou fournissez-la au SDK.

Le client Foundry du SDK nécessite une clé API ainsi qu’un nom de ressource ou une URL de base, et les lit automatiquement à partir des variables d’environnement suivantes si elles sont définies :

* `ANTHROPIC_FOUNDRY_API_KEY` - Votre clé API
* `ANTHROPIC_FOUNDRY_RESOURCE` - Le nom de votre ressource (par exemple, `example-resource`)
* `ANTHROPIC_FOUNDRY_BASE_URL` - Alternative au nom de ressource dans tous les SDK sauf C# : l’URL de base complète (par exemple, `https://example-resource.services.ai.azure.com/anthropic/`)

<Note>
  Les paramètres `resource` et `base_url` s’excluent mutuellement. Fournissez soit le nom de la ressource (que le SDK utilise pour construire l’URL sous la forme `https://{resource}.services.ai.azure.com/anthropic/`), soit directement l’URL de base complète.
</Note>

**Exemple utilisant une clé 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 lit 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;

  // Le client C# construit toujours l'URL de base à partir du nom de la ressource.
  // Il ne lit pas 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() {
      // Nécessite les variables d'environnement : 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>
  Protégez vos clés API. Ne les validez jamais dans un système de contrôle de version et ne les partagez jamais publiquement. Toute personne ayant accès à votre clé API peut effectuer des requêtes vers Claude via votre ressource Foundry.
</Warning>

### Authentification Microsoft Entra

L’authentification Entra ID vous permet de gérer les accès avec Azure RBAC, de vous intégrer à la gestion des identités de votre organisation et d’éviter de manipuler manuellement des clés API. Pour utiliser des jetons Entra ID :

1. Activez l’[authentification Microsoft Entra ID](https://learn.microsoft.com/en-us/azure/ai-foundry/model-inference/how-to/configure-entra-id) pour votre ressource Foundry.
2. Obtenez un jeton d’accès auprès d’Entra ID.
3. Utilisez le jeton dans l’en-tête `Authorization: Bearer {TOKEN}`.

**Exemple utilisant Entra ID :**

<CodeGroup>
  ```bash cURL
  # Effectuez une requête avec un jeton Microsoft Entra ID. Remplacez {resource} par le nom de votre ressource.
  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
  # Effectuer une requête avec un jeton Microsoft Entra ID. Remplacez {resource} par le nom de votre ressource.
  # env -u supprime ANTHROPIC_API_KEY, que la CLI enverrait à la place du jeton.
  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

  # Obtenir un jeton Microsoft Entra ID via le modèle de fournisseur de jetons.
  token_provider = get_bearer_token_provider(
      DefaultAzureCredential(), "https://ai.azure.com/.default"
  )

  # Créer le client avec l'authentification Entra ID.
  client = AnthropicFoundry(
      resource="example-resource",  # your resource name
      azure_ad_token_provider=token_provider,  # Use token provider for Entra ID auth
  )

  # Effectuer la requête.
  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";

  // Obtenir un jeton Entra ID via le modèle de fournisseur de jetons.
  const credential = new DefaultAzureCredential();
  const tokenProvider = getBearerTokenProvider(credential, "https://ai.azure.com/.default");

  // Créer le client avec l'authentification Entra ID.
  const client = new AnthropicFoundry({
    resource: "example-resource", // your resource name
    azureADTokenProvider: tokenProvider // Use token provider for Entra ID auth
  });

  // Effectuer la requête.
  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;

  // Obtenez un jeton d'accès Entra ID, par exemple avec l'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"

  # Obtenez un jeton Microsoft Entra ID depuis l'Azure CLI. Le client appelle cette
  # lambda à chaque requête et nouvelle tentative ; en production, mettez donc le jeton en cache
  # jusqu'à ce qu'il soit proche de son expiration.
  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 de requête de corrélation

Foundry inclut des identifiants de requête dans les en-têtes de réponse HTTP à des fins de débogage et de traçage. Lorsque vous contactez le support, fournissez les valeurs `request-id` et `apim-request-id` (Azure API Management) pour aider les équipes à localiser et examiner rapidement votre requête dans les systèmes Anthropic et Azure.

## Prise en charge des fonctionnalités

Claude dans Microsoft Foundry prend en charge la plupart des fonctionnalités de Claude. La [vue d’ensemble des fonctionnalités](https://platform.claude.com/docs/fr/build-with-claude/overview) répertorie les fonctionnalités de Claude, et la section **Disponibilité** de la page d’une fonctionnalité indique si Foundry la prend en charge et avec quelle option d’hébergement.

### Fenêtre de contexte

Tous les [modèles disponibles](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry#api-model-ids-and-deployments) disposent d’une [fenêtre de contexte de 1M de tokens](https://platform.claude.com/docs/fr/build-with-claude/context-windows) sur Microsoft Foundry, à l’exception de Claude Opus 4.5, Claude Sonnet 4.5 (déprécié) et Claude Haiku 4.5. Ces trois modèles disposent d’une fenêtre de contexte de 200k tokens.

### Fonctionnalités Claude non prises en charge pour Claude dans Microsoft Foundry

* Admin API
* Outil conseiller
* Claude Managed Agents
* Compliance API
* Models API
* Message Batches API
* Repli côté serveur (le [paramètre `fallbacks`](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback#server-side-fallback) ; utilisez plutôt le [modèle de repli côté client](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback#client-side-fallback))
* Points de terminaison des profils utilisateur (`/v1/user_profiles` ; [créez plutôt les profils sur l’API Claude](https://platform.claude.com/docs/fr/manage-claude/user-profiles#before-you-begin))

### Fonctionnalités supplémentaires non prises en charge en cas d’hébergement sur Azure

Les fonctionnalités suivantes sont disponibles pour les déploiements hébergés sur Anthropic, mais ne sont pas prises en charge pour les déploiements hébergés sur Azure :

* [Exécution de code](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool)
* Versions des outils de [recherche web](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/web-search-tool) et de [récupération web](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/web-fetch-tool) ultérieures à `web_search_20250305` et `web_fetch_20250910`. Les déploiements hébergés sur Azure ne prennent en charge que ces versions de base ; le filtrage dynamique, l’inclusion de réponse et le contournement du cache ne sont donc pas disponibles.
* [Agent Skills](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/overview)
* [Appel d’outils programmatique](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/programmatic-tool-calling)
* [Files API](https://platform.claude.com/docs/fr/build-with-claude/files)

Les requêtes qui utilisent ces fonctionnalités sur un déploiement hébergé sur Azure renvoient, par conception, une erreur `400 Bad Request`. Claude Code détecte les déploiements hébergés sur Azure et adapte automatiquement son ensemble de fonctionnalités.

## Réponses de l’API

Les réponses de l’API de Claude dans Microsoft Foundry suivent le [format de réponse standard de la Claude API](https://platform.claude.com/docs/fr/api/messages/create), y compris l’objet `usage`.

Pour plus de détails sur les en-têtes de réponse spécifiques à Foundry, consultez [ID de requête de corrélation](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry#correlation-request-ids).

## ID de modèle API et déploiements

Les termes du cycle de vie (« Deprecated » (déprécié), « Retired » (retiré)) sont définis dans [Dépréciations de modèles](https://platform.claude.com/docs/fr/about-claude/model-deprecations). Microsoft Foundry suit le calendrier du cycle de vie de la Claude API.

Les modèles Claude suivants sont disponibles via 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/fr/about-claude/model-deprecations)) | `claude-sonnet-4-5`     |                 |          ✓          |
| Claude Haiku 5.5                                                                                      | `claude-haiku-5-5`      |        ✓        |          ✓          |
| Claude Haiku 4.5                                                                                      | `claude-haiku-4-5`      |        ✓        |          ✓          |

Par défaut, les noms de déploiement correspondent aux ID de modèle indiqués dans le tableau précédent. Cependant, vous pouvez créer des déploiements personnalisés avec des noms différents dans le portail Foundry pour gérer différentes configurations, versions ou limites de débit. Utilisez le nom du déploiement (pas nécessairement l’ID du modèle) dans vos requêtes API.

<Info>
  [Claude Mythos Preview](https://anthropic.com/glasswing) est un aperçu de recherche disponible pour les clients invités sur Microsoft Foundry.
</Info>

Laissez Claude Code migrer votre code vers un modèle plus récent

```text
/claude-api migrate ce projet vers le dernier modèle Claude Opus
```

## Facturation

Claude dans Microsoft Foundry est facturé via l’[Azure Marketplace](https://azuremarketplace.microsoft.com/). L’utilisation est exprimée en « Claude Consumption Units » (unités de consommation Claude), ou CCU, mesurée toutes les heures et facturée mensuellement à terme échu sur votre facture Azure. Les CCU ne sont pas des crédits prépayés. Il n’existe ni solde ni engagement de CCU.

Pour connaître le prix des CCU, les mécanismes de conversion et les tarifs de tokens par modèle, consultez la [tarification de Claude dans Microsoft Foundry](https://platform.claude.com/docs/fr/about-claude/pricing#claude-in-microsoft-foundry-pricing).

## Migration entre les options d’hébergement

Pour déplacer un déploiement existant d’une option d’hébergement à l’autre :

1. Créez un nouveau déploiement de l’autre version d’hébergement du modèle (Hébergé sur Azure ou Hébergé sur Anthropic). Celui-ci peut se trouver dans la même ressource Foundry ou dans une nouvelle.
2. Mettez à jour votre application pour transmettre le nouveau nom de déploiement dans le paramètre `model`.
3. Supprimez l’ancien déploiement une fois le trafic basculé.

Si le nouveau déploiement se trouve dans la même ressource Foundry, l’URL de votre point de terminaison et votre authentification restent inchangées. Si vous avez créé une nouvelle ressource, mettez à jour le point de terminaison et les identifiants de votre application pour qu’ils pointent vers celle-ci.

## Surveillance et journalisation

Azure fournit la surveillance et la journalisation de votre utilisation de Claude via les modèles Azure standard :

* **Azure Monitor :** suivez l’utilisation de l’API, la latence et les taux d’erreur
* **Azure Log Analytics :** interrogez et analysez les journaux de requêtes/réponses
* **Cost Management :** surveillez et prévoyez les coûts associés à l’utilisation de Claude

Anthropic recommande de journaliser votre activité sur une période glissante d’au moins 30 jours afin de comprendre les modèles d’utilisation et d’examiner tout problème potentiel.

<Note>
  Les services de journalisation d’Azure sont configurés au sein de votre abonnement Azure. L’activation de la journalisation ne donne pas à Microsoft ni à Anthropic accès à votre contenu au-delà de ce qui est nécessaire à la facturation et au fonctionnement du service.
</Note>

## Dépannage

### Erreurs d’authentification

**Erreur :** `401 Unauthorized` ou `Invalid API key`

* **Solution :** vérifiez que votre clé API est correcte. Vous la trouverez dans le portail Foundry, dans l’onglet **Details** de votre déploiement (sous **Build** > **Models**).
* **Solution :** si vous utilisez Microsoft Entra ID, assurez-vous que votre jeton d’accès est valide et n’a pas expiré. Les jetons expirent généralement après 1 heure.

**Erreur :** `403 Forbidden`

**Cause :** il se peut que votre compte Azure ne dispose pas des autorisations nécessaires.

* **Solution :** assurez-vous que le rôle Azure RBAC approprié vous est attribué (par exemple, **Foundry User** ou **Cognitive Services User**).

### Limitation de débit

**Erreur :** `429 Too Many Requests`

* **Solution :** vous avez dépassé votre « rate limit » (limite de débit). Implémentez une logique de temporisation exponentielle et de nouvelle tentative dans votre application.
* **Solution :** envisagez de demander une augmentation des limites de débit via le portail Azure ou le support Azure.

#### En-têtes de limite de débit

Foundry n’inclut pas les en-têtes de limite de débit standard d’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` et `anthropic-ratelimit-output-tokens-reset`) dans les réponses. Gérez plutôt la limitation de débit via les outils de surveillance d’Azure.

### Erreurs de modèle et de déploiement

**Erreur :** `Model not found` ou `Deployment not found`

* **Solution :** vérifiez que vous utilisez le bon nom de déploiement. Si vous n’avez pas créé de déploiement personnalisé, utilisez l’ID de modèle par défaut (par exemple, claude-opus-5-5).
* **Solution :** assurez-vous que le modèle/déploiement est disponible dans votre région Azure.

**Erreur :** `Invalid model parameter`

* **Solution :** Le paramètre `model` doit contenir le nom de votre déploiement, qui peut être personnalisé dans le portail Foundry. Vérifiez que le déploiement existe et qu’il est correctement configuré.

## Étapes suivantes

<CardGroup cols={2}>
  <Card title="Vue d’ensemble des fonctionnalités" icon="stack" href="https://platform.claude.com/docs/fr/build-with-claude/overview">
    Explorez les fonctionnalités et capacités avancées de Claude.
  </Card>

  <Card title="Tarification" icon="chart" href="https://platform.claude.com/docs/fr/about-claude/pricing#claude-in-microsoft-foundry-pricing">
    Découvrez la structure tarifaire d’Anthropic pour les modèles et les fonctionnalités.
  </Card>

  <Card title="Dépréciations de modèles" icon="arrow-clockwise" href="https://platform.claude.com/docs/fr/about-claude/model-deprecations">
    À mesure que des modèles plus sûrs et plus performants sont lancés, Anthropic retire régulièrement les plus anciens. Consultez toutes les dépréciations de l’API, ainsi que les remplacements recommandés.
  </Card>
</CardGroup>

## Ressources supplémentaires

<CardGroup cols={2}>
  <Card title="Catalogue de modèles Foundry" icon="grid" href="https://ai.azure.com/catalog/publishers/anthropic">
    Parcourez les modèles Anthropic dans le catalogue Foundry.
  </Card>

  <Card title="Tarification Microsoft Foundry" icon="calculator" href="https://azure.microsoft.com/en-us/pricing/details/ai-foundry/#pricing">
    Consultez les détails de la tarification de Microsoft pour Microsoft Foundry.
  </Card>

  <Card title="Tarification des modèles" icon="table" href="https://platform.claude.com/docs/fr/about-claude/pricing#model-pricing">
    Consultez les détails de la tarification par modèle d’Anthropic.
  </Card>

  <Card title="Portail Azure" icon="cloud" href="https://portal.azure.com/">
    Gérez vos ressources Azure.
  </Card>
</CardGroup>
