---
title: Claude su Amazon Bedrock (Opus 4.6 e precedenti)
url: https://platform.claude.com/docs/it/build-with-claude/claude-on-amazon-bedrock-legacy
description: L'integrazione legacy di Amazon Bedrock per i modelli Claude, che utilizza le API InvokeModel e Converse con identificatori di modello versionati tramite ARN.
---

<Note>
  Questa pagina tratta l'integrazione legacy di Amazon Bedrock: le API `InvokeModel` e `Converse` con identificatori di modello versionati tramite ARN e codifica event-stream di AWS. Per i modelli disponibili sull'endpoint Bedrock della Messages API, consulta [Claude in Amazon Bedrock](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock), che utilizza la Messages API su `/anthropic/v1/messages` con streaming SSE. Per un'alternativa gestita da Anthropic con fatturazione tramite AWS Marketplace e accesso alle funzionalità tipicamente nello stesso giorno, consulta [Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws). Gli utenti Bedrock esistenti possono seguire la [guida alla migrazione](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#migrating-from-amazon-bedrock).
</Note>

Chiamare Claude tramite Bedrock differisce leggermente da come chiameresti Claude direttamente sulla Claude API. Questa guida ti accompagna nel completamento di una chiamata API a Claude su Bedrock utilizzando uno dei [client SDK](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) di Anthropic.

Nota che questa guida presuppone che tu abbia già registrato un [account AWS](https://portal.aws.amazon.com/billing/signup) e configurato l'accesso programmatico.

## Installa e configura la AWS CLI

1. [Installa una versione della AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) pari o successiva alla versione `2.13.23`.
2. Configura le tue credenziali AWS utilizzando il comando AWS configure (consulta [Configure the AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)) oppure trova le tue credenziali navigando su "Command line or programmatic access" all'interno della tua dashboard AWS e seguendo le indicazioni nella finestra modale.
3. Verifica che le tue credenziali funzionino:

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

## Installa un SDK per accedere a Bedrock

Gli [SDK client](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) di Anthropic supportano Bedrock. Puoi anche utilizzare direttamente un SDK AWS come `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>

## Accedere a Bedrock

### Sottoscrivi i modelli Anthropic

Vai su [AWS Console > Bedrock > Model Access](https://console.aws.amazon.com/bedrock/home?region=us-west-2#/modelaccess) e richiedi l'accesso ai modelli Anthropic. Nota che la disponibilità dei modelli Anthropic varia in base alla regione. Consulta la [documentazione AWS](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html) per le informazioni più aggiornate.

#### ID dei modelli 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 e Claude Opus 4.7 sono raggiungibili tramite `InvokeModel` su `bedrock-runtime`. Queste richieste sono servite dalla stessa infrastruttura dell'endpoint [Claude in Amazon Bedrock](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock). Per la struttura nativa delle richieste della Messages API e la piena parità di funzionalità, utilizza quella pagina. Questi modelli sono omessi dalla tabella dei modelli in questa pagina perché non hanno ID di modello versionati tramite ARN.
</Note>

I termini del ciclo di vita (Deprecato, Ritirato) sono definiti in [Deprecazioni dei modelli](https://platform.claude.com/docs/it/about-claude/model-deprecations). Le date del ciclo di vita sulle piattaforme gestite da partner sono stabilite dal partner e possono differire dal calendario della Claude API. Per la data di ritiro attuale di qualsiasi modello su Amazon Bedrock, consulta la [pagina sul ciclo di vita dei modelli di Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/model-lifecycle.html).

AWS offre i modelli Claude più recenti tramite la ["cross-region inference" (inferenza tra regioni)](https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html) anziché tramite throughput on-demand. Per questi modelli, una richiesta che passa l'ID del modello base fallisce con un errore HTTP 400 come il seguente:

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

Per invocare questi modelli, passa un "inference profile" (profilo di inferenza) invece dell'ID del modello base. L'ID del profilo di inferenza è l'ID del modello base con un prefisso tratto da una colonna contrassegnata con "Sì" nella tabella seguente, ad esempio us.anthropic.claude-sonnet-4-5-20250929-v1:0. Puoi anche passare l'ARN completo del profilo di inferenza, nella forma `arn:aws:bedrock:{region}:{account-id}:inference-profile/{inference-profile-id}`. Per l'elenco ufficiale di AWS dei profili di inferenza disponibili, consulta [Supported Regions and models for inference profiles](https://docs.aws.amazon.com/bedrock/latest/userguide/inference-profiles-support.html). Per scoprire come i prefissi influenzano l'instradamento e i prezzi, consulta la sezione [Endpoint globali e regionali](https://platform.claude.com/docs/it/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/it/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/it/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/it/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     |

### Elenca i modelli disponibili

Gli esempi seguenti mostrano come stampare un elenco di tutti i modelli Claude disponibili tramite 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>

### Effettuare richieste

Gli esempi seguenti mostrano come generare testo da Claude su Bedrock:

<Tabs>
  <Tab title="cURL">
    <Note>
      Chiamare l'API `InvokeModel` con credenziali AWS richiede la firma delle richieste SigV4, che gli SDK nelle altre schede gestiscono automaticamente. Per un endpoint Bedrock che puoi chiamare con un comando cURL autonomo, consulta [Claude in Amazon Bedrock](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock#making-your-first-request).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI `ant` non supporta Amazon Bedrock. Usa invece uno degli esempi SDK.
    </Note>
  </Tab>

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

    client = AnthropicBedrock(
        # Autenticati fornendo le chiavi qui sotto oppure usa i provider di credenziali AWS predefiniti, ad esempio
        # usando ~/.aws/credentials o le variabili d'ambiente "AWS_SECRET_ACCESS_KEY" e "AWS_ACCESS_KEY_ID".
        aws_access_key="<access key>",
        aws_secret_key="<secret key>",
        # Le credenziali temporanee possono essere usate con aws_session_token.
        # Maggiori informazioni su https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html.
        aws_session_token="<session_token>",
        # aws_region cambia la regione AWS a cui viene inviata la richiesta. Se non viene fornita, l'SDK legge
        # AWS_REGION / AWS_DEFAULT_REGION, poi la regione configurata per la sessione boto3 o il profilo AWS
        # (incluso ~/.aws/config), e solleva ValueError se non è possibile risolvere alcuna regione.
        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({
      // Autenticati fornendo le chiavi qui sotto oppure usa
      // i provider di credenziali AWS predefiniti, come
      // ~/.aws/credentials o le variabili d'ambiente "AWS_SECRET_ACCESS_KEY" e
      // "AWS_ACCESS_KEY_ID".
      awsAccessKey: "<access key>",
      awsSecretKey: "<secret key>",

      // Le credenziali temporanee possono essere usate con awsSessionToken.
      // Maggiori informazioni su https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html.
      awsSessionToken: "<session_token>",

      // awsRegion cambia la regione aws a cui viene inviata
      // la richiesta. Per impostazione predefinita, l'SDK legge AWS_REGION e, se
      // non è presente, usa us-east-1 come predefinita. Nota che
      // l'SDK non legge ~/.aws/config per la regione.
      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"
    )
    // ...
    	// Usa la catena predefinita di provider di credenziali AWS
    	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) {
        // Usa la catena predefinita di provider di credenziali AWS
        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>

Consulta i [client SDK](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) per maggiori dettagli e la [documentazione ufficiale di Bedrock](https://docs.aws.amazon.com/bedrock/).

### Autenticazione con bearer token

Puoi autenticarti con Bedrock utilizzando i "bearer token" (token al portatore) invece delle credenziali AWS. Questo è utile negli ambienti aziendali in cui i team hanno bisogno di accedere a Bedrock senza gestire credenziali AWS, ruoli IAM o autorizzazioni a livello di account.

L'approccio più semplice consiste nell'impostare la variabile d'ambiente `AWS_BEARER_TOKEN_BEDROCK`, che l'SDK rileva automaticamente quando risolve le credenziali dall'ambiente.

Per fornire un token in modo programmatico:

<Tabs>
  <Tab title="cURL">
    <Note>
      Questa sezione mostra come configurare un bearer token in un client SDK, che legge il token anche dalla variabile d'ambiente `AWS_BEARER_TOKEN_BEDROCK`. Per effettuare richieste HTTP dirette con un bearer token, consulta la [documentazione di Amazon Bedrock](https://docs.aws.amazon.com/bedrock/).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI `ant` non supporta Amazon Bedrock. Utilizza invece uno degli esempi 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;

    // Opzione 1: imposta la variabile d'ambiente AWS_BEARER_TOKEN_BEDROCK e usa fromEnv()
    AnthropicClient client = AnthropicOkHttpClient.builder()
      .backend(BedrockBackend.fromEnv())
      .build();

    // Opzione 2: fornisci il token a livello di codice
    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>

## Registrazione delle attività

Bedrock fornisce un [servizio di registrazione delle invocazioni](https://docs.aws.amazon.com/bedrock/latest/userguide/model-invocation-logging.html) che ti consente di registrare i prompt e i completamenti associati al tuo utilizzo.

Anthropic consiglia di registrare la tua attività almeno su base continuativa di 30 giorni per comprendere la tua attività e indagare su eventuali usi impropri.

<Note>
  L'attivazione di questo servizio non concede ad AWS o ad Anthropic alcun accesso ai tuoi contenuti.
</Note>

## Supporto delle funzionalità

Per l'elenco completo delle funzionalità con la disponibilità su Amazon Bedrock, consulta la [Panoramica delle funzionalità](https://platform.claude.com/docs/it/build-with-claude/overview).

### Principali funzionalità supportate

* [Messages API](https://platform.claude.com/docs/it/api/messages/create)
* [Prompt caching](https://platform.claude.com/docs/it/build-with-claude/prompt-caching) (cache dei prompt)
* [Thinking](https://platform.claude.com/docs/it/build-with-claude/thinking) (ragionamento)
* [Tool use](https://platform.claude.com/docs/it/agents-and-tools/tool-use/overview) (uso degli strumenti), inclusi lo [strumento Bash](https://platform.claude.com/docs/it/agents-and-tools/tool-use/bash-tool), lo [strumento Computer use](https://platform.claude.com/docs/it/agents-and-tools/tool-use/computer-use-tool), lo [strumento Memory](https://platform.claude.com/docs/it/agents-and-tools/tool-use/memory-tool) e lo [strumento Text editor](https://platform.claude.com/docs/it/agents-and-tools/tool-use/text-editor-tool)
* [Citazioni](https://platform.claude.com/docs/it/build-with-claude/citations)
* [Structured outputs](https://platform.claude.com/docs/it/build-with-claude/structured-outputs) (output strutturati), per i modelli indicati nella nota su Amazon Bedrock nella relativa sezione [Compatibilità](https://platform.claude.com/docs/it/build-with-claude/structured-outputs#compatibility)

### Funzionalità non supportate

* Sorgenti di input (sorgenti URL per immagini e documenti, Files API)
* Strumenti lato server (esecuzione di codice, ricerca web, web fetch, advisor)
* Infrastruttura per agenti (Agent Skills, connettore MCP, chiamata programmatica degli strumenti)
* Endpoint API (Message Batches, Models, Admin, Compliance, Usage and Cost)
* Claude Managed Agents
* 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))
* Cache dei prompt automatica (il [campo `cache_control` di primo livello](https://platform.claude.com/docs/it/build-with-claude/prompt-caching#automatic-caching); usa invece i [breakpoint di cache espliciti](https://platform.claude.com/docs/it/build-with-claude/prompt-caching#explicit-cache-breakpoints))
* Toolset [Computer use](https://platform.claude.com/docs/it/agents-and-tools/tool-use/computer-use-tool) e [browser use](https://platform.claude.com/docs/it/agents-and-tools/tool-use/browser-use-tool) (`computer_toolset_20260801` e `browser_toolset_20260801` non sono attualmente disponibili su Amazon Bedrock; le versioni beta dello strumento computer use rimangono disponibili)

### Supporto PDF su Bedrock

Il supporto PDF è disponibile su Bedrock sia tramite la Converse API sia tramite la InvokeModel API. Per informazioni dettagliate sulle capacità e le limitazioni dell'elaborazione dei PDF, consulta [Supporto PDF su Amazon Bedrock](https://platform.claude.com/docs/it/build-with-claude/pdf-support#amazon-bedrock-pdf-support).

**Considerazioni importanti per gli utenti della Converse API:**

* L'analisi visiva dei PDF (grafici, immagini, layout) richiede che le citazioni siano abilitate
* Senza citazioni, è disponibile solo l'estrazione di testo di base
* Per un controllo completo senza citazioni forzate, usa la InvokeModel API

### Messaggi di sistema a metà conversazione su Bedrock

I [messaggi di sistema a metà conversazione](https://platform.claude.com/docs/it/build-with-claude/mid-conversation-system-messages) sono disponibili tramite la InvokeModel API per Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Sonnet 5.5 e Claude Haiku 5.5. Come descritto nella nota in [ID dei modelli API](https://platform.claude.com/docs/it/build-with-claude/claude-on-amazon-bedrock-legacy#api-model-ids), queste richieste sono servite dalla stessa infrastruttura dell'endpoint [Claude in Amazon Bedrock](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock). Non è richiesto alcun header beta per i messaggi di sistema a metà conversazione. Questa funzionalità non è disponibile su Claude Sonnet 5. Utilizza invece il campo `system` di primo livello. Non è disponibile per i modelli versionati tramite ARN nella tabella dei modelli in questa pagina.

Un messaggio `role: "system"` può anche impostare `output_config.effort` per [modificare l'effort a metà conversazione](https://platform.claude.com/docs/it/build-with-claude/effort#change-effort-mid-conversation-beta) su Claude Fable 5.1 e Claude Opus 5.5. Questa funzionalità è in beta: aggiungi `mid-conversation-output-config-2026-07-01` all'array `anthropic_beta` nel corpo della richiesta. Senza quel valore, oppure su Claude Fable 5, Claude Opus 5 o Claude Opus 4.8, la richiesta restituisce un errore 400: `messages.N.output_config: Extra inputs are not permitted`. Nell'errore, `N` è l'indice del messaggio `system` in `messages`.

**Per gli utenti della Converse API:** la Converse API accetta istruzioni di sistema tramite il suo [parametro `system`](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) di primo livello. Per aggiungere istruzioni di sistema a metà conversazione, utilizza la InvokeModel API.

### Finestra di contesto

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 e Claude Haiku 5.5 hanno una ["context window" (finestra di contesto) da 1M di token](https://platform.claude.com/docs/it/build-with-claude/context-windows) su Amazon Bedrock. Gli altri modelli Claude, inclusi Sonnet 4.5 (deprecato) e Sonnet 4 (deprecato), hanno una finestra di contesto da 200k token.

Bedrock limita i payload delle richieste a 20 MB. Quando invii documenti di grandi dimensioni o molte immagini, potresti raggiungere questo limite prima del limite di token.

## Endpoint globali e regionali

A partire da **Claude Sonnet 4.5 e tutti i modelli futuri**, Bedrock offre due tipi di endpoint:

* **Endpoint globali:** instradamento dinamico per la massima disponibilità
* **Endpoint regionali:** instradamento dei dati garantito attraverso specifiche regioni geografiche

Gli endpoint regionali prevedono un sovrapprezzo del 10% rispetto agli endpoint globali.

<Note>
  Questo si applica solo a Claude Sonnet 4.5 (deprecato) e ai modelli futuri. I modelli precedenti (Claude Sonnet 4 (deprecato) e precedenti) mantengono le loro strutture di prezzo esistenti.
</Note>

### Quando usare ciascuna opzione

**Endpoint globali (consigliati):**

* Forniscono la massima disponibilità e uptime
* Instradano dinamicamente le richieste verso regioni con capacità disponibile
* Nessun sovrapprezzo
* Ideali per applicazioni in cui la residenza dei dati è flessibile

**Endpoint regionali (CRIS):**

* Instradano il traffico attraverso regioni geografiche specifiche
* Necessari per requisiti di residenza dei dati e conformità
* Disponibili per Stati Uniti, UE, Giappone e Asia-Pacifico
* Il sovrapprezzo del 10% riflette i costi infrastrutturali per la capacità regionale dedicata

### Implementazione

**Utilizzo degli endpoint globali (predefinito per Opus 4.6, Sonnet 4.6 e Sonnet 4.5 (deprecato)):**

Gli ID dei modelli per Claude Opus 4.6, Sonnet 4.6 e Sonnet 4.5 (deprecato) includono già il prefisso `global.`:

<Tabs>
  <Tab title="cURL">
    <Note>
      Chiamare l'API `InvokeModel` con credenziali AWS richiede la firma delle richieste SigV4, che gli SDK nelle altre schede gestiscono automaticamente. Per un endpoint Bedrock che puoi chiamare con un comando cURL autonomo, consulta [Claude in Amazon Bedrock](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock#making-your-first-request).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI `ant` non supporta Amazon Bedrock. Utilizza invece uno degli esempi 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;

    // Il client C# per Bedrock usa ID di modello con prefisso di regione per il routing globale
    AnthropicBedrockClient client = new(
        await AnthropicBedrockCredentialsHelper.FromEnv()
        ?? throw new InvalidOperationException("AWS credentials not configured.")
    );

    var response = await client.Messages.Create(new MessageCreateParams
    {
        // Usa il prefisso "global." per l'inferenza globale tra regioni
        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"
    )
    // ...
    	// Usa la catena predefinita dei provider di credenziali AWS
    	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;

    // Usa la catena predefinita di provider di credenziali AWS
    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"

    # Le credenziali predefinite ricavano la regione dalla variabile d'ambiente AWS_REGION
    client = Anthropic::BedrockClient.new

    message = client.messages.create(
      # Usa il prefisso "global." per l'inferenza cross-region globale
      model: "global.anthropic.claude-opus-4-6-v1",
      max_tokens: 256,
      messages: [{role: "user", content: "Hello, world"}]
    )
    ```
  </Tab>
</Tabs>

**Utilizzo degli endpoint regionali (CRIS):**

Per utilizzare gli endpoint regionali, sostituisci il prefisso `global.` con un prefisso regionale come `us.`:

<Tabs>
  <Tab title="cURL">
    <Note>
      Chiamare l'API `InvokeModel` con credenziali AWS richiede la firma delle richieste SigV4, che gli SDK nelle altre schede gestiscono automaticamente. Per un endpoint Bedrock che puoi chiamare con un comando cURL autonomo, consulta [Claude in Amazon Bedrock](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock#making-your-first-request).
    </Note>
  </Tab>

  <Tab title="CLI">
    <Note>
      La CLI `ant` non supporta Amazon Bedrock. Utilizza invece uno degli esempi SDK.
    </Note>
  </Tab>

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

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

    # Uso dell'endpoint regionale USA (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"
    });

    // Uso dell'endpoint regionale USA (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" }
    );

    // Uso dell'endpoint regionale USA (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"
    )
    // ...
    	// Usa la catena predefinita di provider di credenziali AWS
    	client := anthropic.NewClient(
    		bedrock.WithLoadDefaultConfig(context.Background()),
    	)

    	// Uso dell'endpoint regionale 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;

    // Usa la catena predefinita di provider di credenziali AWS
    AnthropicClient client = AnthropicOkHttpClient.builder()
      .backend(BedrockBackend.fromEnv())
      .build();

    // Uso dell'endpoint regionale 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"

    # Uso dell'endpoint regionale 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** è un modello in anteprima di ricerca disponibile per i clienti invitati su Amazon Bedrock. Per maggiori informazioni, consulta [Project Glasswing](https://anthropic.com/glasswing).
</Note>

## Risorse aggiuntive

* **Prezzi di Bedrock:** [pagina dei prezzi di Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/)
* **Documentazione sui prezzi AWS:** [guida ai prezzi di Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-pricing.html)
* **Post del blog AWS:** [Introducing Claude Sonnet 4.5 in 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/)
* **Dettagli sui prezzi Anthropic:** [prezzi delle piattaforme cloud](https://platform.claude.com/docs/it/about-claude/pricing#cloud-platform-pricing)