---
title: Modalità veloce
url: https://platform.claude.com/docs/it/build-with-claude/fast-mode
description: Ottieni fino a 2,5 volte più token di output al secondo dai modelli Claude supportati.
featureMetadata:
  betaHeader: fast-mode-2026-02-01
  zdr:
    eligibility: eligible
    note: Excludes [Covered Models](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements). Stesso endpoint della Messages API con inferenza più veloce. La ZDR si applica indipendentemente dall’impostazione della velocità.
  supportedModels:
    - claude-fable-5-2
    - claude-mythos-5-2
    - claude-opus-5-5
    - claude-opus-5
    - claude-opus-4-8
  supportedPlatforms:
    Claude API:
      availability: stable
      note: 'Data di rimozione: 30 novembre 2026. Dopo la rimozione, le richieste a `claude-opus-4-8` con `speed: "fast"` restituiranno un errore. Per continuare a usare la modalità veloce, esegui la migrazione a Claude Opus 5.5. Consulta [Migrazione a Claude Opus 5.5 da Claude Opus 4.8](https://platform.claude.com/docs/it/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8).'
    Claude Models on Google Cloud (Anthropic managed): stable
    Claude Models on Google Cloud (Google managed): stable
    Microsoft Foundry:
      availability: stable
      note: Su Microsoft Foundry, la modalità veloce ha i propri ID del modello, che terminano con `-fast`. Invia le richieste a un deployment del modello veloce e ometti `speed`.
  details:
    - La modalità veloce è in anteprima di ricerca su Claude Opus 5 e deprecata su Claude Opus 4.8, e richiede l'header beta `fast-mode-2026-02-01` su entrambi i modelli.
---

**Supporto API**: L’utilizzo varia in base al prodotto.

* **Messages API**: Imposta `speed: "fast"` nella richiesta.
* **Managed Agents**: Imposta `speed` nell’oggetto modello dell’agente, ad esempio `{"id": "claude-opus-5-5", "speed": "fast"}`.

La “fast mode” (modalità veloce) offre fino a 2,5 volte più token di output al secondo a un prezzo premium. Imposta `speed: "fast"` nella tua richiesta per attivarla. La modalità veloce è disponibile su Claude Fable 5.2, Claude Mythos 5.2 e Claude Opus 5.5. La modalità veloce è in anteprima di ricerca su Claude Opus 5 e deprecata su Claude Opus 4.8.

## Come funziona la modalità veloce

La modalità veloce esegue lo stesso modello con una configurazione di inferenza più rapida. Non ci sono cambiamenti nell’intelligenza o nelle capacità.

* Fino a 2,5 volte più token di output al secondo rispetto alla velocità standard
* I vantaggi in termini di velocità riguardano gli “output tokens per second” (token di output al secondo), o OTPS, e non il “time to first token” (tempo al primo token), o TTFT
* Compatibile con lo [streaming](https://platform.claude.com/docs/it/build-with-claude/streaming), dove il guadagno in OTPS è più visibile

## Utilizzo di base

La modalità veloce funziona solo sui modelli supportati. Consulta [Disponibilità](https://platform.claude.com/docs/it/build-with-claude/fast-mode#feature-availability) per i dettagli, inclusi i modelli che richiedono un header beta.

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 4096,
      "speed": "fast",
      "messages": [{
        "role": "user",
        "content": "Refactor this module to use dependency injection"
      }]
    }'
  ```

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-opus-5-5
  max_tokens: 4096
  speed: fast
  messages:
    - role: user
      content: Refactor this module to use dependency injection
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

  response = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=4096,
      speed="fast",
      messages=[
          {"role": "user", "content": "Refactor this module to use dependency injection"}
      ],
  )

  for block in response.content:
      if block.type == "text":
          print(block.text)
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 4096,
    speed: "fast",
    messages: [
      {
        role: "user",
        content: "Refactor this module to use dependency injection"
      }
    ]
  });

  const textBlock = response.content.find((block) => block.type === "text");
  console.log(textBlock?.text);
  ```

  ```csharp C#
  AnthropicClient client = new();

  var response = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 4096,
      Speed = Speed.Fast,
      Messages = [
          new UserMessageParam { Content = "Refactor this module to use dependency injection" }
      ],
  });

  foreach (var block in response.Content)
  {
      if (block.TryPickText(out var textBlock))
      {
          Console.WriteLine(textBlock.Text);
      }
  }
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 4096,
  	Speed:     anthropic.MessageNewParamsSpeedFast,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Refactor this module to use dependency injection")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  for _, block := range response.Content {
  	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
  		fmt.Println(textBlock.Text)
  	}
  }
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  Message response = client.messages().create(
      MessageCreateParams.builder()
          .model(Model.CLAUDE_OPUS_5_5)
          .maxTokens(4096L)
          .speed(MessageCreateParams.Speed.FAST)
          .addUserMessage("Refactor this module to use dependency injection")
          .build());

  response.content().stream()
      .flatMap(block -> block.text().stream())
      .forEach(textBlock -> IO.println(textBlock.text()));
  ```

  ```php PHP
  $client = new Client();

  $response = $client->messages->create(
      model: Model::CLAUDE_OPUS_5_5,
      maxTokens: 4096,
      speed: 'fast',
      messages: [
          ['role' => 'user', 'content' => 'Refactor this module to use dependency injection'],
      ],
  );

  foreach ($response->content as $block) {
      if ($block instanceof \Anthropic\Messages\TextBlock) {
          echo $block->text, PHP_EOL;
      }
  }
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 4096,
    speed: "fast",
    messages: [{ role: "user", content: "Refactor this module to use dependency injection" }]
  )

  response.content.each do |block|
    puts block.text if block.is_a?(Anthropic::Models::TextBlock)
  end
  ```
</CodeGroup>

Su [Claude in Microsoft Foundry](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry), la modalità veloce ha i propri ID del modello, ed è il deployment a impostare la velocità. Invia le richieste in modalità veloce a un deployment del modello veloce e ometti `speed`:

| Modello           | ID del modello veloce    |
| ----------------- | ------------------------ |
| Claude Fable 5.2  | `claude-fable-5-2-fast`  |
| Claude Mythos 5.2 | `claude-mythos-5-2-fast` |
| Claude Opus 5.5   | `claude-opus-5-5-fast`   |

Una richiesta che imposta `speed` su un deployment del modello standard, come `claude-opus-5-5`, restituisce un errore.

## Limiti di velocità

La modalità veloce ha un “rate limit” (limite di velocità) dedicato, separato dai limiti di velocità standard. Quando superi il limite di velocità della modalità veloce, l’API restituisce un errore `429` con un header `retry-after` che indica quando la capacità è disponibile. Su [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/google-managed#rate-limits), Google Cloud gestisce i limiti di velocità e le quote.

Claude Fable 5.2, Claude Mythos 5.2 e Claude Opus 5.5 hanno un limite di velocità predefinito per la modalità veloce. Il limite predefinito si applica nei [livelli di utilizzo](https://platform.claude.com/docs/it/api/rate-limits) Start, Build e Scale. Non è necessario richiedere l’accesso alla modalità veloce per questi modelli. Le organizzazioni nel livello di valutazione possono usare la modalità veloce con questi modelli una volta passate al livello Start, Build o Scale.

La risposta include header che indicano lo stato del limite di velocità della modalità veloce:

| Header                                   | Descrizione                                                                      |
| ---------------------------------------- | -------------------------------------------------------------------------------- |
| `anthropic-fast-input-tokens-limit`      | Numero massimo di token di input in modalità veloce al minuto                    |
| `anthropic-fast-input-tokens-remaining`  | Token di input rimanenti in modalità veloce                                      |
| `anthropic-fast-input-tokens-reset`      | Momento in cui il limite di token di input in modalità veloce viene reimpostato  |
| `anthropic-fast-output-tokens-limit`     | Numero massimo di token di output in modalità veloce al minuto                   |
| `anthropic-fast-output-tokens-remaining` | Token di output rimanenti in modalità veloce                                     |
| `anthropic-fast-output-tokens-reset`     | Momento in cui il limite di token di output in modalità veloce viene reimpostato |

Per visualizzare i limiti di velocità della modalità veloce, vai alla pagina [Limiti di richieste](https://platform.claude.com/usage/limits) nella Claude Console.

## Verificare quale velocità è stata utilizzata

L’oggetto `usage` della risposta include un campo `speed` che indica quale velocità è stata utilizzata, `"fast"` oppure `"standard"`. Richiedere `speed: "fast"` su un [modello che non supporta la modalità veloce](https://platform.claude.com/docs/it/build-with-claude/fast-mode#feature-availability) restituisce un errore, così come il superamento dei limiti di velocità o della capacità della modalità veloce (un `429` o un `529`). Quando una richiesta con `speed: "fast"` ha esito positivo, `usage.speed` è `"fast"`. Claude Opus 4.6 rappresenta un’eccezione: invece di restituire un errore, una richiesta con `speed: "fast"` e l’header beta `fast-mode-2026-02-01` ha esito positivo, ma viene eseguita a velocità standard. In questa situazione, `usage.speed` mostra `"standard"`. Su Claude Models on Google Cloud (Anthropic managed), una richiesta a Claude Opus 4.6 con `speed: "fast"` restituisce un errore `400` anche con l’header.

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

  ```bash CLI
  ant messages create <<'YAML'
  model: claude-opus-5-5
  max_tokens: 1024
  speed: fast
  messages:
    - role: user
      content: Hello
  YAML
  ```

  ```python Python
  client = anthropic.Anthropic()

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

  print(response.usage.speed)  # "fast" or "standard"
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const response = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    speed: "fast",
    messages: [{ role: "user", content: "Hello" }]
  });

  console.log(response.usage.speed); // "fast" or "standard"
  ```

  ```csharp C#
  AnthropicClient client = new();

  var response = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Speed = Speed.Fast,
      Messages = [new UserMessageParam { Content = "Hello" }],
  });

  Console.WriteLine(response.Usage.Speed);  // "fast" or "standard"
  ```

  ```go Go
  client := anthropic.NewClient()

  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus5_5,
  	MaxTokens: 1024,
  	Speed:     anthropic.MessageNewParamsSpeedFast,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Hello")),
  	},
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(response.Usage.Speed) // "fast" or "standard"
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_5_5)
      .maxTokens(1024L)
      .speed(MessageCreateParams.Speed.FAST)
      .addUserMessage("Hello")
      .build();

  Message response = client.messages().create(params);
  IO.println(response.usage().speed().orElseThrow());  // "fast" or "standard"
  ```

  ```php PHP
  $client = new Client();

  $response = $client->messages->create(
      model: Model::CLAUDE_OPUS_5_5,
      maxTokens: 1024,
      speed: 'fast',
      messages: [['role' => 'user', 'content' => 'Hello']],
  );

  echo $response->usage->speed;  // "fast" or "standard"
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  response = client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 1024,
    speed: "fast",
    messages: [{ role: "user", content: "Hello" }]
  )

  puts(response.usage.speed)  # "fast" or "standard"
  ```
</CodeGroup>

```json Output
{
  "id": "msg_01XFDUDYJgAACzvnptvVoYEL",
  "type": "message",
  "role": "assistant",
  // ...
  "usage": {
    "input_tokens": 8,
    "output_tokens": 12,
    "speed": "fast"
  }
}
```

Per monitorare l’utilizzo e i costi della modalità veloce in tutta la tua organizzazione, consulta l’[API Usage and Cost Analytics](https://platform.claude.com/docs/it/manage-claude/usage-cost-analytics-api).

## Nuovi tentativi e fallback

### Nuovi tentativi automatici

L’SDK ritenta automaticamente gli errori `429` della modalità veloce fino a due volte per impostazione predefinita (configurabile con `max_retries` (typescript, php: `maxRetries`; java: `.maxRetries()`; csharp: `MaxRetries`; go: `option.WithMaxRetries()`)), attendendo il ritardo indicato nell’header `retry-after` prima di ogni nuovo tentativo. Poiché la modalità veloce utilizza un reintegro continuo dei token, il ritardo `retry-after` è in genere breve e le richieste hanno esito positivo non appena la capacità è disponibile.

### Fallback alla velocità standard

Se preferisci ripiegare sulla velocità standard anziché attendere la capacità della modalità veloce, intercetta l’errore del limite di velocità e ritenta senza `speed: "fast"`. Su Claude in Microsoft Foundry, è il deployment a impostare la velocità, quindi ritenta invece su un deployment del modello standard. Imposta `max_retries` (typescript, php: `maxRetries`; java: `.maxRetries()`; csharp: `MaxRetries`; go: `option.WithMaxRetries()`) su `0` nella richiesta veloce iniziale per saltare i nuovi tentativi automatici e fallire immediatamente in caso di errori del limite di velocità.

<Note>
  Il fallback dalla velocità veloce a quella standard comporta un “cache miss” (mancato riscontro nella cache) nella [cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/prompt-caching). Le richieste a velocità diverse non condividono i prefissi memorizzati nella cache.
</Note>

Poiché impostare `max_retries` (typescript, php: `maxRetries`; java: `.maxRetries()`; csharp: `MaxRetries`; go: `option.WithMaxRetries()`) su `0` disabilita anche i nuovi tentativi per altri errori transitori (sovraccarico, errori interni del server), gli esempi seguenti inviano nuovamente la richiesta dopo questi errori.

<CodeGroup exclude="shell:cURL, shell:CLI">
  ```python Python
  client = anthropic.Anthropic()


  def create_message_with_fast_fallback(max_retries=0, max_attempts=3, **params):
      try:
          return client.with_options(max_retries=max_retries).messages.create(**params)
      except anthropic.RateLimitError:
          if params.get("speed") == "fast":
              del params["speed"]
              return create_message_with_fast_fallback(max_retries=max_retries, **params)
          raise
      except (
          anthropic.APIStatusError,
          anthropic.APIConnectionError,
      ) as error:
          if isinstance(error, anthropic.APIStatusError) and error.status_code < 500:
              raise
          if max_attempts > 1:
              return create_message_with_fast_fallback(
                  max_retries=max_retries, max_attempts=max_attempts - 1, **params
              )
          raise


  message = create_message_with_fast_fallback(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[{"role": "user", "content": "Hello"}],
      speed="fast",
      max_retries=0,
  )
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  async function createMessageWithFastFallback(
    params: Anthropic.MessageCreateParamsNonStreaming,
    requestOptions?: Anthropic.RequestOptions,
    maxAttempts: number = 3
  ): Promise<Anthropic.Message> {
    try {
      return await client.messages.create(params, requestOptions);
    } catch (e) {
      if (e instanceof Anthropic.RateLimitError && params.speed === "fast") {
        const { speed, ...rest } = params;
        return createMessageWithFastFallback(rest);
      }
      if (
        e instanceof Anthropic.InternalServerError ||
        e instanceof Anthropic.APIConnectionError
      ) {
        if (maxAttempts > 1) {
          return createMessageWithFastFallback(params, undefined, maxAttempts - 1);
        }
      }
      throw e;
    }
  }

  const message = await createMessageWithFastFallback(
    {
      model: "claude-opus-5-5",
      max_tokens: 1024,
      messages: [{ role: "user", content: "Hello" }],
      speed: "fast"
    },
    { maxRetries: 0 }
  );
  ```

  ```csharp C#
  AnthropicClient client = new();

  async Task<Message> CreateMessageWithFastFallback(
      MessageCreateParams parameters,
      int? maxRetries = null,
      int maxAttempts = 3)
  {
      try
      {
          var requestClient = maxRetries is int retries
              ? client.WithOptions(options => options with { MaxRetries = retries })
              : client;
          return await requestClient.Messages.Create(parameters);
      }
      catch (AnthropicRateLimitException)
      {
          if (parameters.Speed is not null)
          {
              return await CreateMessageWithFastFallback(
                  parameters with { Speed = null });
          }
          throw;
      }
      catch (Anthropic5xxException)
      {
          if (maxAttempts > 1)
          {
              return await CreateMessageWithFastFallback(
                  parameters, maxAttempts: maxAttempts - 1);
          }
          throw;
      }
  }

  var message = await CreateMessageWithFastFallback(
      new MessageCreateParams
      {
          Model = Model.ClaudeOpus5_5,
          MaxTokens = 1024,
          Messages = [new UserMessageParam { Content = "Hello" }],
          Speed = Speed.Fast,
      },
      maxRetries: 0);
  ```

  ```go Go
  func createMessageWithFastFallback(
  	ctx context.Context,
  	client *anthropic.Client,
  	params anthropic.MessageNewParams,
  	maxAttempts int,
  	opts ...option.RequestOption,
  ) (*anthropic.Message, error) {
  	message, err := client.Messages.New(ctx, params, opts...)
  	if err != nil {
  		var apierr *anthropic.Error
  		if errors.As(err, &apierr) && apierr.StatusCode == 429 && params.Speed != "" {
  			params.Speed = ""
  			return createMessageWithFastFallback(ctx, client, params, maxAttempts)
  		}
  		if (errors.As(err, &apierr) && apierr.StatusCode >= 500) || !errors.As(err, &apierr) {
  			if maxAttempts > 1 {
  				return createMessageWithFastFallback(ctx, client, params, maxAttempts-1)
  			}
  		}
  		return nil, err
  	}
  	return message, nil
  }

  func main() {
  	client := anthropic.NewClient()
  	message, err := createMessageWithFastFallback(
  		context.TODO(),
  		&client,
  		anthropic.MessageNewParams{
  			Model:     anthropic.ModelClaudeOpus5_5,
  			MaxTokens: 1024,
  			Messages: []anthropic.MessageParam{
  				anthropic.NewUserMessage(anthropic.NewTextBlock("Hello")),
  			},
  			Speed: anthropic.MessageNewParamsSpeedFast,
  		},
  		3,
  		option.WithMaxRetries(0),
  	)
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(message)
  }
  ```

  ```java Java
  import com.anthropic.errors.InternalServerException;
  import com.anthropic.errors.RateLimitException;
  // ...
  // Disattiva il retry automatico dell'SDK affinché lo gestisca la logica di fallback seguente
  AnthropicClient client =
      AnthropicOkHttpClient.builder()
          .fromEnv()
          .maxRetries(0)
          .build();

  Message createMessageWithFastFallback(
          MessageCreateParams params, int maxAttempts) {
      try {
          return client.messages().create(params);
      } catch (RateLimitException e) {
          if (params.speed().isPresent()) {
              MessageCreateParams retryParams = params.toBuilder()
                  .speed(Optional.empty())
                  .build();
              return createMessageWithFastFallback(retryParams, maxAttempts);
          }
          throw e;
      } catch (InternalServerException e) {
          if (maxAttempts > 1) {
              return createMessageWithFastFallback(params, maxAttempts - 1);
          }
          throw e;
      }
  }

  void main() {
      Message message = createMessageWithFastFallback(
          MessageCreateParams.builder()
              .model(Model.CLAUDE_OPUS_5_5)
              .maxTokens(1024L)
              .addUserMessage("Hello")
              .speed(MessageCreateParams.Speed.FAST)
              .build(),
          3);
      message.content().stream()
          .flatMap(block -> block.text().stream())
          .forEach(textBlock -> IO.println(textBlock.text()));
  }
  ```

  ```php PHP
  use Anthropic\Core\Exceptions\APIConnectionException;
  use Anthropic\Core\Exceptions\InternalServerException;
  use Anthropic\Core\Exceptions\RateLimitException;
  use Anthropic\Messages\Model;
  use Anthropic\RequestOptions;

  $client = new Client();

  function createMessageWithFastFallback(
      Client $client,
      array $params,
      ?RequestOptions $requestOptions = null,
      int $maxAttempts = 3,
  ) {
      try {
          return $client->messages->create(
              ...$params,
              requestOptions: $requestOptions,
          );
      } catch (RateLimitException $e) {
          if (isset($params['speed'])) {
              unset($params['speed']);
              return createMessageWithFastFallback($client, $params);
          }
          throw $e;
      } catch (InternalServerException | APIConnectionException $e) {
          if ($maxAttempts > 1) {
              return createMessageWithFastFallback(
                  $client, $params, maxAttempts: $maxAttempts - 1
              );
          }
          throw $e;
      }
  }

  $message = createMessageWithFastFallback(
      $client,
      [
          'model' => Model::CLAUDE_OPUS_5_5,
          'maxTokens' => 1024,
          'messages' => [['role' => 'user', 'content' => 'Hello']],
          'speed' => 'fast',
      ],
      RequestOptions::with(maxRetries: 0),
  );
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  def create_message_with_fast_fallback(client, request_options: {}, max_attempts: 3, **params)
    client.messages.create(**params, request_options: request_options)
  rescue Anthropic::Errors::RateLimitError
    raise unless params[:speed] == "fast"
    params.delete(:speed)
    create_message_with_fast_fallback(client, **params)
  rescue Anthropic::Errors::InternalServerError, Anthropic::Errors::APIConnectionError
    raise unless max_attempts > 1
    create_message_with_fast_fallback(client, max_attempts: max_attempts - 1, **params)
  end

  message = create_message_with_fast_fallback(
    client,
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello" }],
    speed: "fast",
    request_options: { max_retries: 0 }
  )
  ```
</CodeGroup>

## Considerazioni

* **Batch API:** La modalità veloce non è disponibile con la [Batch API](https://platform.claude.com/docs/it/build-with-claude/batch-processing).
* **Priority Tier:** La modalità veloce non è disponibile con un impegno [Priority Tier](https://platform.claude.com/docs/it/api/service-tiers).

## Prezzi

La modalità veloce ha un prezzo pari a un moltiplicatore sulle tariffe standard sull’intera finestra di contesto, incluse le richieste con oltre 200k token di input. Su Claude Models on Google Cloud (Google managed), è Google Cloud a stabilire i prezzi della modalità veloce. Consulta [Prezzi delle piattaforme cloud](https://platform.claude.com/docs/it/about-claude/pricing#cloud-platform-pricing).

| Modello                         | Input          | Output         |
| ------------------------------- | -------------- | -------------- |
| Claude Fable 5.2                | $16 USD / MTok | $80 USD / MTok |
| Claude Mythos 5.2               | $16 USD / MTok | $80 USD / MTok |
| Claude Opus 5.5                 | $8 USD / MTok  | $40 USD / MTok |
| Claude Opus 5 / Claude Opus 4.8 | $10 USD / MTok | $50 USD / MTok |

I prezzi della modalità veloce si sommano ad altri modificatori di prezzo:

* I [moltiplicatori della cache dei prompt](https://platform.claude.com/docs/it/about-claude/pricing#prompt-caching) si applicano in aggiunta ai prezzi della modalità veloce.
* I moltiplicatori di [residenza dei dati](https://platform.claude.com/docs/it/manage-claude/data-residency) si applicano in aggiunta ai prezzi della modalità veloce.

Per i dettagli completi sui prezzi, consulta la pagina [Prezzi](https://platform.claude.com/docs/it/about-claude/pricing#fast-mode-pricing).

## Disponibilità

La funzionalità Modalità veloce è disponibile o in anteprima di ricerca o deprecata su alcuni modelli e idonea per conservazione zero dei dati e preparazione HIPAA.

### Supporto API

La modalità veloce è disponibile solo sui seguenti modelli. Se utilizzavi la modalità veloce su un modello precedente, [esegui la migrazione a un modello che supporta la modalità veloce](https://platform.claude.com/docs/it/models/opus-5-5/migration-guide).

Per accedere alla modalità veloce su Claude Opus 5, contatta il tuo account manager o [iscriviti alla lista d’attesa](https://claude.com/fast-mode).

#### [Messages API](https://platform.claude.com/docs/it/build-with-claude/working-with-messages)

* Disponibilità: Disponibile
* Utilizzo: Imposta `speed: "fast"` nella richiesta.

| Stato                   | Piattaforme cloud                                                                                                                                                                                                                                                                                                            | Modelli                                                                                                                                                                |
| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Disponibile             | Claude API, [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed), [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/google-managed) | [Claude Fable 5.2](https://platform.claude.com/docs/it/models/fable-5-2/overview), [Claude Mythos 5.2](https://platform.claude.com/docs/it/models/mythos-5-2/overview) |
| Disponibile<sup>1</sup> | [Microsoft Foundry (hosted on Anthropic)](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry)                                                                                                                                                                                                 | [Claude Fable 5.2](https://platform.claude.com/docs/it/models/fable-5-2/overview), [Claude Mythos 5.2](https://platform.claude.com/docs/it/models/mythos-5-2/overview) |
| Disponibile             | Claude API, [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed)                                                                                                                                                       | [Claude Opus 5.5](https://platform.claude.com/docs/it/models/opus-5-5/overview)                                                                                        |
| Disponibile<sup>1</sup> | [Microsoft Foundry (hosted on Azure)](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry)                                                                                                                                                                                                     | [Claude Opus 5.5](https://platform.claude.com/docs/it/models/opus-5-5/overview)                                                                                        |
| Anteprima di ricerca    | Claude API                                                                                                                                                                                                                                                                                                                   | [Claude Opus 5](https://platform.claude.com/docs/it/models/opus-5/overview)                                                                                            |
| Deprecato<sup>2</sup>   | Claude API                                                                                                                                                                                                                                                                                                                   | [Claude Opus 4.8](https://platform.claude.com/docs/it/models/opus-4-8/overview)                                                                                        |

1. Su Microsoft Foundry, la modalità veloce ha i propri ID del modello, che terminano con `-fast`. Invia le richieste a un deployment del modello veloce e ometti `speed`.
2. Data di rimozione: 30 novembre 2026. Dopo la rimozione, le richieste a `claude-opus-4-8` con `speed: "fast"` restituiranno un errore. Per continuare a usare la modalità veloce, esegui la migrazione a Claude Opus 5.5. Consulta [Migrazione a Claude Opus 5.5 da Claude Opus 4.8](https://platform.claude.com/docs/it/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8).

#### [Managed Agents](https://platform.claude.com/docs/it/managed-agents/overview)

* Disponibilità: Disponibile
* Utilizzo: Imposta `speed` nell’oggetto modello dell’agente, ad esempio `{"id": "claude-opus-5-5", "speed": "fast"}`.

| Stato                 | Piattaforme cloud                                                                                                                                                      | Modelli                                                                         |
| --------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| Disponibile           | Claude API, [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed) | [Claude Opus 5.5](https://platform.claude.com/docs/it/models/opus-5-5/overview) |
| Anteprima di ricerca  | Claude API                                                                                                                                                             | [Claude Opus 5](https://platform.claude.com/docs/it/models/opus-5/overview)     |
| Deprecato<sup>1</sup> | Claude API                                                                                                                                                             | [Claude Opus 4.8](https://platform.claude.com/docs/it/models/opus-4-8/overview) |

1. Data di rimozione: 30 novembre 2026. Dopo la rimozione, le richieste a `claude-opus-4-8` con `speed: "fast"` restituiranno un errore. Per continuare a usare la modalità veloce, esegui la migrazione a Claude Opus 5.5. Consulta [Migrazione a Claude Opus 5.5 da Claude Opus 4.8](https://platform.claude.com/docs/it/models/opus-5-5/migration-guide#migrating-from-claude-opus-4-8).

### Header beta richiesti

[Panoramica degli header beta](https://platform.claude.com/docs/it/api/beta-headers)

Gli header beta consentono di accedere a funzionalità sperimentali e a nuove capacità dei modelli prima che entrino a far parte dell’API standard.

| Header                 | Modelli                                                                                                                                                      |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `fast-mode-2026-02-01` | [Claude Opus 5](https://platform.claude.com/docs/it/models/opus-5/overview), [Claude Opus 4.8](https://platform.claude.com/docs/it/models/opus-4-8/overview) |

### Gestione dei dati

[Panoramica sulla gestione dei dati](https://platform.claude.com/docs/it/manage-claude/api-and-data-retention#feature-eligibility)

| Elemento | Conservazione zero dei dati                                                                                                                             | HIPAA  |
| -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | ------ |
| Stato    | Idoneo (esclude [Modelli coperti](https://platform.claude.com/docs/it/manage-claude/api-and-data-retention#model-specific-data-retention-requirements)) | Idoneo |
| Dettagli | Stesso endpoint della Messages API con inferenza più veloce. La ZDR si applica indipendentemente dall’impostazione della velocità.                      | —      |

Endpoint applicabili:

* `/v1/messages` con `speed: "fast"`

## Passaggi successivi

<CardGroup cols={2}>
  <Card title="Output strutturati" icon="code-brackets" href="https://platform.claude.com/docs/it/build-with-claude/structured-outputs">
    Ottieni risultati JSON convalidati dai flussi di lavoro degli agenti.
  </Card>

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

  <Card title="Effort" icon="gauge" href="https://platform.claude.com/docs/it/build-with-claude/effort">
    Controlla quanti token Claude utilizza nel rispondere tramite il parametro effort, bilanciando la completezza della risposta e l’efficienza dei token.
  </Card>

  <Card title="Streaming dei messaggi" icon="arrow-right" href="https://platform.claude.com/docs/it/build-with-claude/streaming">
    Trasmetti in streaming le risposte della Messages API in modo incrementale con i server-sent events, inclusi i delta di testo, uso degli strumenti e ragionamento esteso.
  </Card>
</CardGroup>
