---
title: Claude sur Amazon Bedrock (Opus 4.6 et versions antérieures)
url: https://platform.claude.com/docs/fr/build-with-claude/claude-on-amazon-bedrock-legacy
description: L'intégration Amazon Bedrock héritée pour les modèles Claude, utilisant les API InvokeModel et Converse avec des identifiants de modèle versionnés par ARN.
---

<Note>
  Cette page couvre l'intégration Amazon Bedrock héritée : les API `InvokeModel` et `Converse` avec des identifiants de modèle versionnés par ARN et l'encodage event-stream d'AWS. Pour les modèles disponibles sur le point de terminaison Bedrock de l'API Messages, consultez [Claude dans Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock), qui utilise l'API Messages à l'adresse `/anthropic/v1/messages` avec le streaming SSE. Pour une alternative exploitée par Anthropic avec facturation via AWS Marketplace et un accès aux fonctionnalités généralement le jour même, consultez [Claude Platform on AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws). Les utilisateurs actuels de Bedrock peuvent suivre le [guide de migration](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#migrating-from-amazon-bedrock).
</Note>

Appeler Claude via Bedrock diffère légèrement de la manière dont vous appelleriez Claude directement sur l'API Claude. Ce guide vous accompagne dans la réalisation d'un appel API à Claude sur Bedrock à l'aide de l'un des [SDK clients](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview) d'Anthropic.

Notez que ce guide suppose que vous avez déjà créé un [compte AWS](https://portal.aws.amazon.com/billing/signup) et configuré l'accès programmatique.

## Installer et configurer l'AWS CLI

1. [Installez une version de l'AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) égale ou supérieure à la version `2.13.23`.
2. Configurez vos identifiants AWS à l'aide de la commande AWS configure (consultez [Configurer l'AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)) ou trouvez vos identifiants en accédant à « Command line or programmatic access » dans votre tableau de bord AWS et en suivant les instructions de la fenêtre modale.
3. Vérifiez que vos identifiants fonctionnent :

```bash AWS CLI
aws sts get-caller-identity
```

## Installer un SDK pour accéder à Bedrock

Les [SDK clients](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview) d'Anthropic prennent en charge Bedrock. Vous pouvez également utiliser directement un SDK AWS comme `boto3`.

<Tabs>
  <Tab title="Python">
    ```bash
    pip install -U "anthropic[bedrock]"
    ```
  </Tab>

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

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

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

  <Tab title="Java">
    <CodeGroup>
      ```groovy Gradle
      implementation("com.anthropic:anthropic-java:2.73.0")
      implementation("com.anthropic:anthropic-java-bedrock:2.73.0")
      ```

      ```xml Maven
      <dependency>
          <groupId>com.anthropic</groupId>
          <artifactId>anthropic-java</artifactId>
          <version>2.73.0</version>
      </dependency>
      <dependency>
          <groupId>com.anthropic</groupId>
          <artifactId>anthropic-java-bedrock</artifactId>
          <version>2.73.0</version>
      </dependency>
      ```

      ```java Java
      import com.anthropic.client.AnthropicClient;
      import com.anthropic.client.okhttp.AnthropicOkHttpClient;
      import com.anthropic.bedrock.backends.BedrockBackend;
      import com.anthropic.models.messages.MessageCreateParams;
      import com.anthropic.models.messages.Message;
      import com.anthropic.models.messages.Model;

      public class BasicMessage {
          public static void main(String[] args) {
              AnthropicClient client = AnthropicOkHttpClient.builder()
                  .backend(BedrockBackend.fromEnv())
                  .build();

              MessageCreateParams params = MessageCreateParams.builder()
                  .model(Model.CLAUDE_OPUS_4_6)
                  .maxTokens(1024L)
                  .addUserMessage("What is the capital of France?")
                  .build();

              Message response = client.messages().create(params);
              response.content().stream()
                  .flatMap(block -> block.text().stream())
                  .forEach(textBlock -> System.out.println(textBlock.text()));
          }
      }
      ```
    </CodeGroup>
  </Tab>

  <Tab title="PHP">
    ```bash
    composer require anthropic-ai/sdk aws/aws-sdk-php
    ```
  </Tab>

  <Tab title="Ruby">
    ```bash
    # Gemfile
    gem "anthropic"
    gem "aws-sdk-bedrockruntime"
    ```
  </Tab>

  <Tab title="Boto3 (Python)">
    ```bash
    pip install "boto3>=1.28.59"
    ```
  </Tab>
</Tabs>

## Accéder à Bedrock

### S'abonner aux modèles Anthropic

Rendez-vous sur [AWS Console > Bedrock > Model Access](https://console.aws.amazon.com/bedrock/home?region=us-west-2#/modelaccess) et demandez l'accès aux modèles Anthropic. Notez que la disponibilité des modèles Anthropic varie selon la région. Consultez la [documentation AWS](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) pour obtenir les informations les plus récentes.

#### Identifiants de modèle de l'API

<Note>
  Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5, Claude Sonnet 5, Claude Haiku 5.5, Claude Opus 4.8 et Claude Opus 4.7 sont accessibles via `InvokeModel` sur `bedrock-runtime`. Ces requêtes sont traitées par la même infrastructure que le point de terminaison [Claude dans Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock). Pour la forme de requête native de l'API Messages et la parité complète des fonctionnalités, utilisez cette page. Ces modèles sont omis du tableau des modèles de cette page, car ils ne disposent pas d'identifiants de modèle versionnés par ARN.
</Note>

Les termes relatifs au cycle de vie (Déprécié, Retiré) sont définis dans [Dépréciations de modèles](https://platform.claude.com/docs/fr/about-claude/model-deprecations). Les dates du cycle de vie sur les plateformes exploitées par des partenaires sont fixées par le partenaire et peuvent différer du calendrier de l'API Claude. Pour connaître la date de retrait actuelle de tout modèle sur Amazon Bedrock, consultez la [page sur le cycle de vie des modèles d'Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/model-lifecycle.html).

AWS propose les modèles Claude plus récents via la « [cross-region inference](https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html) » (inférence interrégionale) plutôt qu'avec un débit à la demande. Pour ces modèles, une requête qui transmet l'identifiant du modèle de base échoue avec une erreur HTTP 400 comme la suivante :

```text wrap
Invocation of model ID anthropic.claude-sonnet-4-5-20250929-v1:0 with on-demand throughput isn't supported. Retry your request with the ID or ARN of an inference profile that contains this model.
```

Pour invoquer ces modèles, transmettez un « inference profile » (profil d'inférence) au lieu de l'identifiant du modèle de base. L'identifiant du profil d'inférence correspond à l'identifiant du modèle de base précédé d'un préfixe issu d'une colonne marquée « Oui » dans le tableau suivant, par exemple us.anthropic.claude-sonnet-4-5-20250929-v1:0. Vous pouvez également transmettre l'ARN complet du profil d'inférence, sous la forme `arn:aws:bedrock:{region}:{account-id}:inference-profile/{inference-profile-id}`. Pour la liste officielle d'AWS des profils d'inférence disponibles, consultez [Régions et modèles pris en charge pour les profils d'inférence](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html). Pour savoir comment les préfixes influent sur le routage et la tarification, consultez la section [Points de terminaison globaux et régionaux](https://platform.claude.com/docs/fr/build-with-claude/claude-on-amazon-bedrock-legacy#global-vs-regional-endpoints).

| Model                                                                                                 | Base Bedrock model ID                       | `global` | `us` | `eu` | `jp` | `apac` |
| :---------------------------------------------------------------------------------------------------- | :------------------------------------------ | :------- | :--- | :--- | :--- | :----- |
| Claude Opus 4.6                                                                                       | `anthropic.claude-opus-4-6-v1`              | Yes      | Yes  | Yes  | Yes  | Yes    |
| Claude Opus 4.5                                                                                       | `anthropic.claude-opus-4-5-20251101-v1:0`   | Yes      | Yes  | Yes  | No   | No     |
| Claude Opus 4.1 ([deprecated](https://platform.claude.com/docs/fr/about-claude/model-deprecations))   | `anthropic.claude-opus-4-1-20250805-v1:0`   | No       | Yes  | No   | No   | No     |
| Claude Sonnet 4.6                                                                                     | `anthropic.claude-sonnet-4-6`               | Yes      | Yes  | Yes  | Yes  | No     |
| Claude Sonnet 4.5 ([deprecated](https://platform.claude.com/docs/fr/about-claude/model-deprecations)) | `anthropic.claude-sonnet-4-5-20250929-v1:0` | Yes      | Yes  | Yes  | Yes  | No     |
| Claude Sonnet 4 ([deprecated](https://platform.claude.com/docs/fr/about-claude/model-deprecations))   | `anthropic.claude-sonnet-4-20250514-v1:0`   | Yes      | Yes  | Yes  | No   | Yes    |
| Claude Haiku 4.5                                                                                      | `anthropic.claude-haiku-4-5-20251001-v1:0`  | Yes      | Yes  | Yes  | No   | No     |

### Lister les modèles disponibles

Les exemples suivants montrent comment afficher la liste de tous les modèles Claude disponibles via Bedrock :

<CodeGroup>
  ```bash AWS CLI
  aws bedrock list-foundation-models --region=us-west-2 --by-provider anthropic --query "modelSummaries[*].modelId"
  ```

  ```python Boto3 (Python)
  import boto3

  bedrock = boto3.client(service_name="bedrock")
  response = bedrock.list_foundation_models(byProvider="anthropic")

  for summary in response["modelSummaries"]:
      print(summary["modelId"])
  ```

  ```typescript TypeScript
  import { BedrockClient, ListFoundationModelsCommand } from "@aws-sdk/client-bedrock";

  const client = new BedrockClient({ region: "us-west-2" });

  const command = new ListFoundationModelsCommand({ byProvider: "anthropic" });
  const response = await client.send(command);

  if (response.modelSummaries) {
    for (const summary of response.modelSummaries) {
      console.log(summary.modelId);
    }
  }
  ```

  ```csharp C#
  using Amazon;
  using Amazon.Bedrock;
  using Amazon.Bedrock.Model;

  var client = new AmazonBedrockClient(RegionEndpoint.USWest2);

  var request = new ListFoundationModelsRequest
  {
      ByProvider = "anthropic"
  };

  var response = await client.ListFoundationModelsAsync(request);

  foreach (var summary in response.ModelSummaries)
  {
      Console.WriteLine(summary.ModelId);
  }
  ```

  ```go Go
  import (
  	"context"
  	"fmt"
  	"log"

  	"github.com/aws/aws-sdk-go-v2/config"
  	"github.com/aws/aws-sdk-go-v2/service/bedrock"
  )
  // ...
  	cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion("us-west-2"))
  	if err != nil {
  		log.Fatal(err)
  	}

  	client := bedrock.NewFromConfig(cfg)

  	byProvider := "anthropic"
  	response, err := client.ListFoundationModels(context.TODO(), &bedrock.ListFoundationModelsInput{
  		ByProvider: &byProvider,
  	})
  	if err != nil {
  		log.Fatal(err)
  	}

  	for _, summary := range response.ModelSummaries {
  		fmt.Println(*summary.ModelId)
  	}
  ```

  ```java Java
  import software.amazon.awssdk.regions.Region;
  import software.amazon.awssdk.services.bedrock.BedrockClient;
  import software.amazon.awssdk.services.bedrock.model.ListFoundationModelsRequest;
  import software.amazon.awssdk.services.bedrock.model.ListFoundationModelsResponse;
  import software.amazon.awssdk.services.bedrock.model.FoundationModelSummary;

  public class ListAnthropicModels {
      public static void main(String[] args) {
          BedrockClient client = BedrockClient.builder()
              .region(Region.US_WEST_2)
              .build();

          ListFoundationModelsRequest request = ListFoundationModelsRequest.builder()
              .byProvider("anthropic")
              .build();

          ListFoundationModelsResponse response = client.listFoundationModels(request);

          for (FoundationModelSummary summary : response.modelSummaries()) {
              System.out.println(summary.modelId());
          }

          client.close();
      }
  }
  ```

  ```php PHP
  <?php

  use Aws\Bedrock\BedrockClient;

  $client = new BedrockClient([
      'region' => 'us-west-2',
      'version' => 'latest'
  ]);

  $result = $client->listFoundationModels([
      'byProvider' => 'anthropic'
  ]);

  foreach ($result['modelSummaries'] as $summary) {
      echo $summary['modelId'] . PHP_EOL;
  }
  ```

  ```ruby Ruby
  require "aws-sdk-bedrock"

  client = Aws::Bedrock::Client.new(region: "us-west-2")

  response = client.list_foundation_models({
    by_provider: "anthropic"
  })

  response.model_summaries.each do |summary|
    puts summary.model_id
  end
  ```
</CodeGroup>

### Effectuer des requêtes

Les exemples suivants montrent comment générer du texte avec Claude sur Bedrock :

<Tabs>
  <Tab title="cURL">
    <Note>
      L'appel de l'API `InvokeModel` avec des identifiants AWS nécessite la signature des requêtes SigV4, que les SDK des autres onglets gèrent automatiquement. Pour un point de terminaison Bedrock que vous pouvez appeler avec une commande cURL autonome, consultez [Claude dans Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock#making-your-first-request).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI `ant` ne prend pas en charge Amazon Bedrock. Utilisez plutôt l'un des exemples de SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    ```python
    from anthropic import AnthropicBedrock

    client = AnthropicBedrock(
        # Authentifiez-vous en fournissant les clés ci-dessous ou utilisez les fournisseurs d'identifiants AWS par défaut, par exemple
        # via ~/.aws/credentials ou les variables d'environnement "AWS_SECRET_ACCESS_KEY" et "AWS_ACCESS_KEY_ID".
        aws_access_key="<access key>",
        aws_secret_key="<secret key>",
        # Des identifiants temporaires peuvent être utilisés avec aws_session_token.
        # Pour en savoir plus : https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html.
        aws_session_token="<session_token>",
        # aws_region modifie la région AWS vers laquelle la requête est envoyée. Si elle n'est pas fournie, le SDK lit
        # AWS_REGION / AWS_DEFAULT_REGION, puis la région configurée pour votre session boto3 ou votre profil AWS
        # (y compris ~/.aws/config), et lève une ValueError si aucune région ne peut être résolue.
        aws_region="us-west-2",
    )

    message = client.messages.create(
        model="global.anthropic.claude-opus-4-6-v1",
        max_tokens=256,
        messages=[{"role": "user", "content": "Hello, world"}],
    )
    print(message.content)
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript
    import AnthropicBedrock from "@anthropic-ai/bedrock-sdk";

    const client = new AnthropicBedrock({
      // Authentifiez-vous en fournissant les clés ci-dessous ou utilisez
      // les fournisseurs d'identifiants AWS par défaut, tels que
      // ~/.aws/credentials ou les variables d'environnement
      // "AWS_SECRET_ACCESS_KEY" et "AWS_ACCESS_KEY_ID".
      awsAccessKey: "<access key>",
      awsSecretKey: "<secret key>",

      // Des identifiants temporaires peuvent être utilisés avec awsSessionToken.
      // En savoir plus : https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html.
      awsSessionToken: "<session_token>",

      // awsRegion modifie la région AWS vers laquelle la requête
      // est envoyée. Par défaut, le SDK lit AWS_REGION et, si
      // elle est absente, utilise us-east-1. Notez que
      // le SDK ne lit pas ~/.aws/config pour la région.
      awsRegion: "us-west-2"
    });

    const message = await client.messages.create({
      model: "global.anthropic.claude-opus-4-6-v1",
      max_tokens: 256,
      messages: [{ role: "user", content: "Hello, world" }]
    });
    console.log(message);
    ```
  </Tab>

  <Tab title="C#">
    ```csharp
    using Anthropic.Bedrock;
    using Anthropic.Models.Messages;

    AnthropicBedrockClient client = new(
        await AnthropicBedrockCredentialsHelper.FromEnv()
        ?? throw new InvalidOperationException("AWS credentials not configured.")
    );

    var response = await client.Messages.Create(new MessageCreateParams
    {
        Model = "global.anthropic.claude-opus-4-6-v1",
        MaxTokens = 256,
        Messages = [new() { Role = Role.User, Content = "Hello, world" }],
    });

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

  <Tab title="Go">
    ```go
    import (
    	"context"
    	"fmt"

    	"github.com/anthropics/anthropic-sdk-go"
    	"github.com/anthropics/anthropic-sdk-go/bedrock"
    )
    // ...
    	// Utilise la chaîne de fournisseurs d'identifiants AWS par défaut
    	client := anthropic.NewClient(
    		bedrock.WithLoadDefaultConfig(context.Background()),
    	)

    	message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
    		Model:     "global.anthropic.claude-opus-4-6-v1",
    		MaxTokens: 256,
    		Messages: []anthropic.MessageParam{
    			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, world")),
    		},
    	})
    	if err != nil {
    		panic(err)
    	}
    	fmt.Println(message.Content)
    ```
  </Tab>

  <Tab title="Java">
    ```java
    import com.anthropic.bedrock.backends.BedrockBackend;
    import com.anthropic.client.AnthropicClient;
    import com.anthropic.client.okhttp.AnthropicOkHttpClient;
    import com.anthropic.models.messages.Message;
    import com.anthropic.models.messages.MessageCreateParams;

    public class BedrockExample {

      public static void main(String[] args) {
        // Utilise la chaîne de fournisseurs d'identifiants AWS par défaut
        AnthropicClient client = AnthropicOkHttpClient.builder()
          .backend(BedrockBackend.fromEnv())
          .build();

        Message message = client
          .messages()
          .create(
            MessageCreateParams.builder()
              .model("global.anthropic.claude-opus-4-6-v1")
              .maxTokens(256)
              .addUserMessage("Hello, world")
              .build()
          );

        System.out.println(message.content());
      }
    }
    ```
  </Tab>

  <Tab title="PHP">
    ```php
    <?php

    use Anthropic\Bedrock;

    $client = Bedrock\Client::withCredentials(
        accessKeyId: getenv("AWS_ACCESS_KEY_ID"),
        secretAccessKey: getenv("AWS_SECRET_ACCESS_KEY"),
        region: 'us-west-2',
        securityToken: getenv("AWS_SESSION_TOKEN"),
    );

    $message = $client->messages->create(
        maxTokens: 256,
        messages: [
            ['role' => 'user', 'content' => 'Hello, world']
        ],
        model: 'global.anthropic.claude-opus-4-6-v1',
    );
    echo $message->content[0]->text;
    ```
  </Tab>

  <Tab title="Ruby">
    ```ruby
    require "anthropic"

    client = Anthropic::BedrockClient.new

    message = client.messages.create(
      model: "global.anthropic.claude-opus-4-6-v1",
      max_tokens: 256,
      messages: [{role: "user", content: "Hello, world"}]
    )

    puts message.content.first.text
    ```
  </Tab>

  <Tab title="Boto3 (Python)">
    ```python
    import boto3
    import json

    bedrock = boto3.client(service_name="bedrock-runtime")
    body = json.dumps(
        {
            "max_tokens": 256,
            "messages": [{"role": "user", "content": "Hello, world"}],
            "anthropic_version": "bedrock-2023-05-31",
        }
    )

    response = bedrock.invoke_model(
        body=body, modelId="global.anthropic.claude-opus-4-6-v1"
    )

    response_body = json.loads(response.get("body").read())
    print(response_body.get("content"))
    ```
  </Tab>
</Tabs>

Consultez les [SDK clients](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview) pour plus de détails, ainsi que la [documentation officielle de Bedrock](https://docs.aws.amazon.com/bedrock/).

### Authentification par jeton porteur

Vous pouvez vous authentifier auprès de Bedrock à l'aide de « bearer tokens » (jetons porteurs) au lieu d'identifiants AWS. Cela est utile dans les environnements d'entreprise où les équipes ont besoin d'accéder à Bedrock sans gérer d'identifiants AWS, de rôles IAM ou d'autorisations au niveau du compte.

L'approche la plus simple consiste à définir la variable d'environnement `AWS_BEARER_TOKEN_BEDROCK`, que le SDK détecte automatiquement lors de la résolution des identifiants à partir de l'environnement.

Pour fournir un jeton par programmation :

<Tabs>
  <Tab title="cURL">
    <Note>
      Cette section montre comment configurer un jeton porteur dans un client SDK, qui lit également le jeton à partir de la variable d'environnement `AWS_BEARER_TOKEN_BEDROCK`. Pour effectuer des requêtes HTTP directes avec un jeton porteur, consultez la [documentation d'Amazon Bedrock](https://docs.aws.amazon.com/bedrock/).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI `ant` ne prend pas en charge Amazon Bedrock. Utilisez plutôt l'un des exemples de SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    ```python
    from anthropic import AnthropicBedrock

    client = AnthropicBedrock(
        api_key="your-bearer-token",
        aws_region="us-west-2",
    )

    message = client.messages.create(
        model="us.anthropic.claude-sonnet-4-5-20250929-v1:0",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Hello!"}],
    )
    print(message.content)
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript
    import AnthropicBedrock from "@anthropic-ai/bedrock-sdk";

    const client = new AnthropicBedrock({
      apiKey: "your-bearer-token",
      awsRegion: "us-west-2"
    });

    const message = await client.messages.create({
      model: "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
      max_tokens: 1024,
      messages: [{ role: "user", content: "Hello!" }]
    });
    console.log(message);
    ```
  </Tab>

  <Tab title="C#">
    ```csharp
    using Anthropic.Bedrock;
    using Anthropic.Models.Messages;

    var client = new AnthropicBedrockClient(
        new AnthropicBedrockApiTokenCredentials
        {
            BearerToken = "your-bearer-token",
            Region = "us-west-2",
        }
    );

    var response = await client.Messages.Create(new MessageCreateParams
    {
        Model = "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
        MaxTokens = 1024,
        Messages = [new() { Role = Role.User, Content = "Hello!" }],
    });
    ```
  </Tab>

  <Tab title="Go">
    ```go
    import (
    	"context"
    	"fmt"

    	"github.com/anthropics/anthropic-sdk-go"
    	"github.com/anthropics/anthropic-sdk-go/bedrock"
    	"github.com/aws/aws-sdk-go-v2/aws"
    )
    // ...
    	cfg := aws.Config{
    		Region:                  "us-west-2",
    		BearerAuthTokenProvider: bedrock.NewStaticBearerTokenProvider("your-bearer-token"),
    	}
    	client := anthropic.NewClient(
    		bedrock.WithConfig(cfg),
    	)

    	message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
    		Model:     "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
    		MaxTokens: 1024,
    		Messages: []anthropic.MessageParam{
    			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
    		},
    	})
    	if err != nil {
    		panic(err)
    	}
    	fmt.Println(message.Content[0].Text)
    ```
  </Tab>

  <Tab title="Java">
    ```java
    import com.anthropic.bedrock.backends.BedrockBackend;
    import com.anthropic.client.AnthropicClient;
    import com.anthropic.client.okhttp.AnthropicOkHttpClient;
    import com.anthropic.models.messages.MessageCreateParams;

    // Option 1 : définissez la variable d'environnement AWS_BEARER_TOKEN_BEDROCK et utilisez fromEnv().
    AnthropicClient client = AnthropicOkHttpClient.builder()
      .backend(BedrockBackend.fromEnv())
      .build();

    // Option 2 : fournissez le jeton par programmation.
    client = AnthropicOkHttpClient.builder()
      .backend(BedrockBackend.builder()
        .apiKey("your-bearer-token")
        .build())
      .build();

    MessageCreateParams params = MessageCreateParams.builder()
      .model("us.anthropic.claude-sonnet-4-5-20250929-v1:0")
      .maxTokens(1024)
      .addUserMessage("Hello!")
      .build();

    client.messages().create(params).content().stream()
      .flatMap(block -> block.text().stream())
      .forEach(textBlock -> System.out.println(textBlock.text()));
    ```
  </Tab>

  <Tab title="PHP">
    ```php
    <?php

    use Anthropic\Bedrock;

    $client = Bedrock\Client::withApiKey('your-bearer-token', 'us-west-2');

    $message = $client->messages->create(
        maxTokens: 1024,
        messages: [
            ['role' => 'user', 'content' => 'Hello!']
        ],
        model: 'us.anthropic.claude-sonnet-4-5-20250929-v1:0',
    );
    echo $message->content[0]->text;
    ```
  </Tab>

  <Tab title="Ruby">
    ```ruby
    require "anthropic"

    client = Anthropic::BedrockClient.new(
      api_key: "your-bearer-token",
      aws_region: "us-west-2"
    )

    message = client.messages.create(
      model: "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
      max_tokens: 1024,
      messages: [{role: "user", content: "Hello!"}]
    )
    puts message.content.first.text
    ```
  </Tab>
</Tabs>

## Journalisation de l'activité

Bedrock fournit un [service de journalisation des invocations](https://docs.aws.amazon.com/bedrock/latest/userguide/model-invocation-logging.html) qui vous permet de journaliser les prompts et les complétions associés à votre utilisation.

Anthropic vous recommande de journaliser votre activité sur une période glissante d'au moins 30 jours afin de comprendre votre activité et d'enquêter sur toute utilisation abusive potentielle.

<Note>
  L'activation de ce service ne donne ni à AWS ni à Anthropic un quelconque accès à votre contenu.
</Note>

## Prise en charge des fonctionnalités

Pour la liste complète des fonctionnalités avec leur disponibilité sur Amazon Bedrock, consultez la [Vue d'ensemble des fonctionnalités](https://platform.claude.com/docs/fr/build-with-claude/overview).

### Principales fonctionnalités prises en charge

* [API Messages](https://platform.claude.com/docs/fr/api/messages/create)
* [Mise en cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching)
* [Réflexion](https://platform.claude.com/docs/fr/build-with-claude/thinking)
* [Utilisation d'outils](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/overview), y compris l'[outil Bash](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/bash-tool), l'[outil d'utilisation de l'ordinateur](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool), l'[outil de mémoire](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/memory-tool) et l'[outil d'édition de texte](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/text-editor-tool)
* [Citations](https://platform.claude.com/docs/fr/build-with-claude/citations)
* [Sorties structurées](https://platform.claude.com/docs/fr/build-with-claude/structured-outputs), pour les modèles mentionnés dans la note Amazon Bedrock de sa section [Compatibilité](https://platform.claude.com/docs/fr/build-with-claude/structured-outputs#compatibility)

### Fonctionnalités non prises en charge

* Sources d'entrée (sources URL pour les images et les documents, API Files)
* Outils côté serveur (exécution de code, recherche web, récupération web, advisor)
* Infrastructure d'agents (Agent Skills, connecteur MCP, appel d'outils programmatique)
* Points de terminaison d'API (Message Batches, Models, Admin, Compliance, Usage and Cost)
* Claude Managed Agents
* 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))
* Mise en cache automatique des prompts (le [champ `cache_control` de premier niveau](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching#automatic-caching) ; utilisez plutôt des [points d'arrêt de cache explicites](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching#explicit-cache-breakpoints))
* Ensembles d'outils d'[utilisation de l'ordinateur](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool) et d'[utilisation du navigateur](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/browser-use-tool) (`computer_toolset_20260801` et `browser_toolset_20260801` ne sont actuellement pas disponibles sur Amazon Bedrock ; les versions bêta de l'outil d'utilisation de l'ordinateur restent disponibles)

### Prise en charge des PDF sur Bedrock

La prise en charge des PDF est disponible sur Bedrock via l'API Converse et l'API InvokeModel. Pour des informations détaillées sur les capacités et les limites du traitement des PDF, consultez [Prise en charge des PDF sur Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/pdf-support#amazon-bedrock-pdf-support).

**Considérations importantes pour les utilisateurs de l'API Converse :**

* L'analyse visuelle des PDF (graphiques, images, mises en page) nécessite l'activation des citations
* Sans citations, seule l'extraction de texte basique est disponible
* Pour un contrôle total sans citations forcées, utilisez l'API InvokeModel

### Messages système en cours de conversation sur Bedrock

Les [messages système en cours de conversation](https://platform.claude.com/docs/fr/build-with-claude/mid-conversation-system-messages) sont disponibles via l'API InvokeModel pour Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Sonnet 5.5 et Claude Haiku 5.5. Comme décrit dans la note sous [Identifiants de modèle de l'API](https://platform.claude.com/docs/fr/build-with-claude/claude-on-amazon-bedrock-legacy#api-model-ids), ces requêtes sont traitées par la même infrastructure que le point de terminaison [Claude dans Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock). Aucun en-tête bêta n'est requis pour les messages système en cours de conversation. Cette fonctionnalité n'est pas disponible sur Claude Sonnet 5. Utilisez plutôt le champ `system` de premier niveau. Elle n'est pas disponible pour les modèles versionnés par ARN du tableau des modèles de cette page.

Un message `role: "system"` peut également définir `output_config.effort` pour [modifier l'effort en cours de conversation](https://platform.claude.com/docs/fr/build-with-claude/effort#change-effort-mid-conversation-beta) sur Claude Fable 5.1 et Claude Opus 5.5. Cette fonctionnalité est en bêta : ajoutez `mid-conversation-output-config-2026-07-01` au tableau `anthropic_beta` dans le corps de la requête. Sans cette valeur, ou sur Claude Fable 5, Claude Opus 5 ou Claude Opus 4.8, la requête renvoie une erreur 400 : `messages.N.output_config: Extra inputs are not permitted`. Dans l'erreur, `N` est l'index du message `system` dans `messages`.

**Pour les utilisateurs de l'API Converse :** l'API Converse accepte les instructions système via son [paramètre `system`](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) de premier niveau. Pour ajouter des instructions système en cours de conversation, utilisez l'API InvokeModel.

### Fenêtre de contexte

Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, Claude Sonnet 5.5, Claude Sonnet 5, Claude Sonnet 4.6 et Claude Haiku 5.5 disposent d'une « [context window](https://platform.claude.com/docs/fr/build-with-claude/context-windows) » (fenêtre de contexte) de 1M de tokens sur Amazon Bedrock. Les autres modèles Claude, y compris Sonnet 4.5 (déprécié) et Sonnet 4 (déprécié), disposent d'une fenêtre de contexte de 200k tokens.

Bedrock limite la taille des charges utiles des requêtes à 20 Mo. Lors de l'envoi de documents volumineux ou de nombreuses images, vous pouvez atteindre cette limite avant la limite de tokens.

## Points de terminaison globaux et régionaux

À partir de **Claude Sonnet 4.5 et de tous les modèles futurs**, Bedrock propose deux types de points de terminaison :

* **Points de terminaison globaux :** routage dynamique pour une disponibilité maximale
* **Points de terminaison régionaux :** routage des données garanti via des régions géographiques spécifiques

Les points de terminaison régionaux incluent un supplément tarifaire de 10 % par rapport aux points de terminaison globaux.

<Note>
  Cela s'applique uniquement à Claude Sonnet 4.5 (déprécié) et aux modèles futurs. Les modèles plus anciens (Claude Sonnet 4 (déprécié) et antérieurs) conservent leurs structures tarifaires existantes.
</Note>

### Quand utiliser chaque option

**Points de terminaison globaux (recommandés) :**

* Offrent une disponibilité et un temps de fonctionnement maximaux
* Acheminent dynamiquement les requêtes vers les régions disposant de capacité disponible
* Aucun supplément tarifaire
* Idéaux pour les applications où la résidence des données est flexible

**Points de terminaison régionaux (CRIS) :**

* Acheminent le trafic via des régions géographiques spécifiques
* Requis pour les exigences de résidence des données et de conformité
* Disponibles pour les États-Unis, l'UE, le Japon et l'Asie-Pacifique
* Le supplément tarifaire de 10 % reflète les coûts d'infrastructure liés à la capacité régionale dédiée

### Mise en œuvre

**Utilisation des points de terminaison globaux (par défaut pour Opus 4.6, Sonnet 4.6 et Sonnet 4.5 (déprécié)) :**

Les identifiants de modèle de Claude Opus 4.6, Sonnet 4.6 et Sonnet 4.5 (déprécié) incluent déjà le préfixe `global.` :

<Tabs>
  <Tab title="cURL">
    <Note>
      L'appel de l'API `InvokeModel` avec des identifiants AWS nécessite la signature des requêtes SigV4, que les SDK des autres onglets gèrent automatiquement. Pour un point de terminaison Bedrock que vous pouvez appeler avec une commande cURL autonome, consultez [Claude dans Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock#making-your-first-request).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI `ant` ne prend pas en charge Amazon Bedrock. Utilisez plutôt l'un des exemples de SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    ```python
    from anthropic import AnthropicBedrock

    client = AnthropicBedrock(aws_region="us-west-2")

    message = client.messages.create(
        model="global.anthropic.claude-opus-4-6-v1",
        max_tokens=256,
        messages=[{"role": "user", "content": "Hello, world"}],
    )
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript
    import AnthropicBedrock from "@anthropic-ai/bedrock-sdk";

    const client = new AnthropicBedrock({
      awsRegion: "us-west-2"
    });

    const message = await client.messages.create({
      model: "global.anthropic.claude-opus-4-6-v1",
      max_tokens: 256,
      messages: [{ role: "user", content: "Hello, world" }]
    });
    ```
  </Tab>

  <Tab title="C#">
    ```csharp
    using Anthropic.Bedrock;
    using Anthropic.Models.Messages;

    // Le client C# Bedrock utilise des ID de modèle avec un préfixe de région pour le routage global.
    AnthropicBedrockClient client = new(
        await AnthropicBedrockCredentialsHelper.FromEnv()
        ?? throw new InvalidOperationException("AWS credentials not configured.")
    );

    var response = await client.Messages.Create(new MessageCreateParams
    {
        // Utilisez le préfixe "global." pour l'inférence inter-régions globale.
        Model = "global.anthropic.claude-opus-4-6-v1",
        MaxTokens = 256,
        Messages = [new() { Role = Role.User, Content = "Hello, world" }],
    });
    ```
  </Tab>

  <Tab title="Go">
    ```go
    import (
    	"context"

    	"github.com/anthropics/anthropic-sdk-go"
    	"github.com/anthropics/anthropic-sdk-go/bedrock"
    )
    // ...
    	// Utilise la chaîne de fournisseurs d'identifiants AWS par défaut.
    	client := anthropic.NewClient(
    		bedrock.WithLoadDefaultConfig(context.Background()),
    	)

    	message, _ := client.Messages.New(context.Background(), anthropic.MessageNewParams{
    		Model:     "global.anthropic.claude-opus-4-6-v1",
    		MaxTokens: 256,
    		Messages: []anthropic.MessageParam{
    			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, world")),
    		},
    	})
    ```
  </Tab>

  <Tab title="Java">
    ```java
    import com.anthropic.bedrock.backends.BedrockBackend;
    import com.anthropic.client.AnthropicClient;
    import com.anthropic.client.okhttp.AnthropicOkHttpClient;
    import com.anthropic.models.messages.MessageCreateParams;

    // Utilise la chaîne de fournisseurs d'identifiants AWS par défaut.
    AnthropicClient client = AnthropicOkHttpClient.builder()
      .backend(BedrockBackend.fromEnv())
      .build();

    var message = client
      .messages()
      .create(
        MessageCreateParams.builder()
          .model("global.anthropic.claude-opus-4-6-v1")
          .maxTokens(256)
          .addUserMessage("Hello, world")
          .build()
      );
    ```
  </Tab>

  <Tab title="PHP">
    ```php
    <?php

    use Anthropic\Bedrock;

    $client = Bedrock\Client::fromEnvironment();

    $message = $client->messages->create(
        maxTokens: 256,
        messages: [
            ['role' => 'user', 'content' => 'Hello, world']
        ],
        model: 'global.anthropic.claude-opus-4-6-v1',
    );
    ```
  </Tab>

  <Tab title="Ruby">
    ```ruby
    require "anthropic"

    # Les identifiants par défaut déterminent la région via la variable d'environnement AWS_REGION.
    client = Anthropic::BedrockClient.new

    message = client.messages.create(
      # Utilisez le préfixe "global." pour l'inférence inter-régions globale.
      model: "global.anthropic.claude-opus-4-6-v1",
      max_tokens: 256,
      messages: [{role: "user", content: "Hello, world"}]
    )
    ```
  </Tab>
</Tabs>

**Utilisation des points de terminaison régionaux (CRIS) :**

Pour utiliser des points de terminaison régionaux, remplacez le préfixe `global.` par un préfixe régional tel que `us.` :

<Tabs>
  <Tab title="cURL">
    <Note>
      L'appel de l'API `InvokeModel` avec des identifiants AWS nécessite la signature des requêtes SigV4, que les SDK des autres onglets gèrent automatiquement. Pour un point de terminaison Bedrock que vous pouvez appeler avec une commande cURL autonome, consultez [Claude dans Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock#making-your-first-request).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI `ant` ne prend pas en charge Amazon Bedrock. Utilisez plutôt l'un des exemples de SDK.
    </Note>
  </Tab>

  <Tab title="Python">
    ```python
    from anthropic import AnthropicBedrock

    client = AnthropicBedrock(aws_region="us-west-2")

    # Utilisation du point de terminaison régional US (CRIS)
    message = client.messages.create(
        model="us.anthropic.claude-opus-4-6-v1",  # Regional prefix
        max_tokens=256,
        messages=[{"role": "user", "content": "Hello, world"}],
    )
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript
    import AnthropicBedrock from "@anthropic-ai/bedrock-sdk";

    const client = new AnthropicBedrock({
      awsRegion: "us-west-2"
    });

    // Utilisation du point de terminaison régional US (CRIS)
    const message = await client.messages.create({
      model: "us.anthropic.claude-opus-4-6-v1", // Regional prefix
      max_tokens: 256,
      messages: [{ role: "user", content: "Hello, world" }]
    });
    ```
  </Tab>

  <Tab title="C#">
    ```csharp
    using Anthropic.Bedrock;
    using Anthropic.Models.Messages;

    AnthropicBedrockClient client = new(
        new AnthropicBedrockPrivateKeyCredentials { Region = "us-west-2" }
    );

    // Utilisation du point de terminaison régional US (CRIS)
    var response = await client.Messages.Create(new MessageCreateParams
    {
        Model = "us.anthropic.claude-opus-4-6-v1", // Regional prefix
        MaxTokens = 256,
        Messages = [new() { Role = Role.User, Content = "Hello, world" }],
    });
    ```
  </Tab>

  <Tab title="Go">
    ```go
    import (
    	"context"

    	"github.com/anthropics/anthropic-sdk-go"
    	"github.com/anthropics/anthropic-sdk-go/bedrock"
    )
    // ...
    	// Utilise la chaîne de fournisseurs d'identifiants AWS par défaut.
    	client := anthropic.NewClient(
    		bedrock.WithLoadDefaultConfig(context.Background()),
    	)

    	// Utilisation du point de terminaison régional US (CRIS).
    	message, _ := client.Messages.New(context.Background(), anthropic.MessageNewParams{
    		Model:     "us.anthropic.claude-opus-4-6-v1", // Regional prefix
    		MaxTokens: 256,
    		Messages: []anthropic.MessageParam{
    			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, world")),
    		},
    	})
    ```
  </Tab>

  <Tab title="Java">
    ```java
    import com.anthropic.bedrock.backends.BedrockBackend;
    import com.anthropic.client.AnthropicClient;
    import com.anthropic.client.okhttp.AnthropicOkHttpClient;
    import com.anthropic.models.messages.MessageCreateParams;

    // Utilise la chaîne de fournisseurs d'identifiants AWS par défaut.
    AnthropicClient client = AnthropicOkHttpClient.builder()
      .backend(BedrockBackend.fromEnv())
      .build();

    // Utilisation du point de terminaison régional US (CRIS).
    var message = client
      .messages()
      .create(
        MessageCreateParams.builder()
          .model("us.anthropic.claude-opus-4-6-v1") // Regional prefix
          .maxTokens(256)
          .addUserMessage("Hello, world")
          .build()
      );
    ```
  </Tab>

  <Tab title="PHP">
    ```php
    <?php

    use Anthropic\Bedrock;

    $client = Bedrock\Client::fromEnvironment();

    $message = $client->messages->create(
        maxTokens: 256,
        messages: [
            ['role' => 'user', 'content' => 'Hello, world']
        ],
        model: 'us.anthropic.claude-opus-4-6-v1',
    );
    ```
  </Tab>

  <Tab title="Ruby">
    ```ruby
    require "anthropic"

    # Utilisation du point de terminaison régional US (CRIS)
    client = Anthropic::BedrockClient.new(aws_region: "us-west-2")

    message = client.messages.create(
      model: "us.anthropic.claude-opus-4-6-v1", # Regional prefix
      max_tokens: 256,
      messages: [{role: "user", content: "Hello, world"}]
    )
    ```
  </Tab>
</Tabs>

<Note>
  **Claude Mythos Preview** est un modèle en aperçu de recherche disponible pour les clients invités sur Amazon Bedrock. Pour plus d'informations, consultez [Project Glasswing](https://anthropic.com/glasswing).
</Note>

## Ressources supplémentaires

* **Tarification Bedrock :** [page de tarification d'Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/)
* **Documentation tarifaire AWS :** [guide de tarification Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-pricing.html)
* **Article de blog AWS :** [Présentation de Claude Sonnet 4.5 dans Amazon Bedrock](https://aws.amazon.com/blogs/aws/introducing-claude-sonnet-4-5-in-amazon-bedrock-anthropics-most-intelligent-model-best-for-coding-and-complex-agents/)
* **Détails de la tarification Anthropic :** [tarification des plateformes cloud](https://platform.claude.com/docs/fr/about-claude/pricing#cloud-platform-pricing)