---
title: Livelli di servizio
url: https://platform.claude.com/docs/it/api/service-tiers
description: Diversi livelli di servizio ti consentono di bilanciare disponibilità, prestazioni e costi prevedibili in base alle esigenze della tua applicazione.
---

<Warning>
  Gli impegni di capacità Priority Tier non sono più disponibili per l'acquisto. Le organizzazioni con un impegno esistente possono continuare a utilizzare Priority Tier fino alla data di scadenza del contratto, e questa pagina rimane disponibile come riferimento per loro. Se hai bisogno di capacità garantita, [contatta il team vendite](https://claude.com/contact-sales).
</Warning>

Anthropic offre tre "service tiers" (livelli di servizio):

* **Priority Tier:** Disponibile solo per le organizzazioni con un impegno di capacità esistente
* **Standard:** Livello predefinito sia per la sperimentazione che per la scalabilità dei casi d'uso quotidiani
* **Batch:** Ideale per flussi di lavoro asincroni che possono attendere o trarre vantaggio dall'essere al di fuori della tua capacità normale

## Livello standard

Lo standard tier (livello standard) è il livello di servizio predefinito per tutte le richieste API. L'API dà priorità a queste richieste insieme a tutte le altre richieste con disponibilità best-effort.

## Priority Tier

L'API dà priorità alle richieste in questo livello rispetto a tutte le altre richieste. Questa prioritizzazione aiuta a ridurre al minimo gli [errori "server overloaded"](https://platform.claude.com/docs/it/api/errors#http-errors), anche durante i periodi di picco.

Per maggiori informazioni, consulta [Impegni Priority Tier esistenti](https://platform.claude.com/docs/it/api/service-tiers#existing-priority-tier-commitments).

## Come vengono assegnati i livelli alle richieste

Quando gestisce una richiesta, Anthropic decide di assegnare una richiesta a Priority Tier nei seguenti scenari:

* La tua organizzazione dispone di sufficiente capacità Priority Tier di token di **input** al minuto
* La tua organizzazione dispone di sufficiente capacità Priority Tier di token di **output** al minuto

Anthropic conteggia l'utilizzo rispetto alla capacità Priority Tier come segue:

**Token di input**

* Letture dalla cache come 0,1 token per ogni token letto dalla cache
* Scritture nella cache come 1,25 token per ogni token scritto nella cache con un TTL di 5 minuti
* Scritture nella cache come 2,00 token per ogni token scritto nella cache con un TTL di 1 ora
* Per le richieste con [inferenza solo negli Stati Uniti](https://platform.claude.com/docs/it/manage-claude/data-residency) (`inference_geo: "us"`) sui modelli Claude 4.6 e successivi, i token di input valgono 1,1 token per token
* Tutti gli altri token di input valgono 1 token per token

**Token di output**

* Per le richieste con [inferenza solo negli Stati Uniti](https://platform.claude.com/docs/it/manage-claude/data-residency) (`inference_geo: "us"`) sui modelli Claude 4.6 e successivi, i token di output valgono 1,1 token per token
* Tutti gli altri token di output valgono 1 token per token

Altrimenti, le richieste procedono allo standard tier.

<Note>
  Questi tassi di consumo riflettono il prezzo relativo di ciascun tipo di token. Ad esempio, l'inferenza solo negli Stati Uniti ha un prezzo di 1,1x sui modelli Claude 4.6 e successivi, quindi ogni token consumato con `inference_geo: "us"` sottrae 1,1 token dalla tua capacità Priority Tier.
</Note>

<Note>
  Le richieste assegnate a Priority Tier attingono sia dalla capacità Priority Tier sia dai normali "rate limits" (limiti di velocità). Se servire la richiesta comportasse il superamento dei limiti di velocità, la richiesta viene rifiutata.
</Note>

## Utilizzo dei livelli di servizio

Puoi controllare quali livelli di servizio possono essere utilizzati per una richiesta impostando il parametro `service_tier`:

<CodeGroup>
  ```bash cURL
  curl https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-4-8",
      "max_tokens": 1024,
      "messages": [{"role": "user", "content": "Hello, Claude!"}],
      "service_tier": "auto"
    }'
  ```

  ```bash CLI
  ant messages create --transform usage.service_tier --raw-output <<'YAML'
  model: claude-opus-4-8
  max_tokens: 1024
  messages:
    - role: user
      content: Hello, Claude!
  service_tier: auto  # Automatically use Priority Tier when available, fallback to standard
  YAML
  ```

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

  message = client.messages.create(
      model="claude-opus-4-8",
      max_tokens=1024,
      messages=[{"role": "user", "content": "Hello, Claude!"}],
      service_tier="auto",  # Automatically use Priority Tier when available, fallback to standard
  )
  print(message.usage.service_tier)
  ```

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

  const message = await client.messages.create({
    model: "claude-opus-4-8",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude!" }],
    service_tier: "auto" // Automatically use Priority Tier when available, fallback to standard
  });
  console.log(message.usage.service_tier);
  ```

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

  var message = await client.Messages.Create(new MessageCreateParams
  {
      Model = Model.ClaudeOpus4_8,
      MaxTokens = 1024,
      Messages = [new() { Role = Role.User, Content = "Hello, Claude!" }],
      ServiceTier = ServiceTier.Auto, // Automatically use Priority Tier when available, fallback to standard
  });
  Console.WriteLine(message.Usage.ServiceTier);
  ```

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

  message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
  	Model:     anthropic.ModelClaudeOpus4_8,
  	MaxTokens: 1024,
  	Messages: []anthropic.MessageParam{
  		anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude!")),
  	},
  	// Usa automaticamente Priority Tier quando disponibile, altrimenti passa a standard
  	ServiceTier: anthropic.MessageNewParamsServiceTierAuto,
  })
  if err != nil {
  	log.Fatal(err)
  }
  fmt.Println(message.Usage.ServiceTier)
  ```

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

  MessageCreateParams params = MessageCreateParams.builder()
      .model(Model.CLAUDE_OPUS_4_8)
      .maxTokens(1024L)
      .addUserMessage("Hello, Claude!")
      // Usa automaticamente il Priority Tier quando disponibile, altrimenti passa allo standard
      .serviceTier(MessageCreateParams.ServiceTier.AUTO)
      .build();

  Message message = client.messages().create(params);
  IO.println(message.usage().serviceTier().orElseThrow());
  ```

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

  $message = $client->messages->create(
      model: 'claude-opus-4-8',
      maxTokens: 1024,
      messages: [['role' => 'user', 'content' => 'Hello, Claude!']],
      serviceTier: 'auto', // Automatically use Priority Tier when available, fallback to standard
  );
  echo $message->usage->serviceTier;
  ```

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

  message = client.messages.create(
    model: "claude-opus-4-8",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude!" }],
    service_tier: :auto # Automatically use Priority Tier when available, fallback to standard
  )
  puts(message.usage.service_tier)
  ```
</CodeGroup>

Il parametro `service_tier` accetta i seguenti valori:

* `"auto"` (predefinito) - Utilizza la capacità Priority Tier se disponibile, ripiegando sull'altra tua capacità in caso contrario
* `"standard_only"` - Utilizza solo la capacità dello standard tier, utile se non vuoi utilizzare la tua capacità Priority Tier

L'oggetto `usage` della risposta include anche il livello di servizio assegnato alla richiesta:

```json
{
  "usage": {
    "input_tokens": 410,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0,
    "output_tokens": 585,
    "service_tier": "priority"
  }
}
```

Questo ti consente di determinare quale livello di servizio è stato assegnato alla richiesta.

Quando richiedi `service_tier="auto"` con un modello con un impegno Priority Tier, queste intestazioni di risposta forniscono informazioni utili:

```text wrap
anthropic-priority-input-tokens-limit: 10000
anthropic-priority-input-tokens-remaining: 9618
anthropic-priority-input-tokens-reset: 2025-01-12T23:11:59Z
anthropic-priority-output-tokens-limit: 10000
anthropic-priority-output-tokens-remaining: 6000
anthropic-priority-output-tokens-reset: 2025-01-12T23:12:21Z
```

Puoi utilizzare la presenza di queste intestazioni per rilevare se la tua richiesta era idonea per Priority Tier, anche se superava il limite.

## Impegni Priority Tier esistenti

Un impegno Priority Tier è composto da:

* Un numero di token di input al minuto
* Un numero di token di output al minuto
* Una durata dell'impegno (1, 3, 6 o 12 mesi)
* Una versione specifica del modello

Priority Tier punta a un uptime del 99,5% con risorse computazionali prioritarie. Le richieste che superano la capacità impegnata ripiegano automaticamente sullo standard tier.

### Modelli supportati

Priority Tier è supportato su tutti i modelli Claude disponibili tranne Claude Fable 5.1, Claude Haiku 5.5, Claude Mythos 5.1, Claude Mythos 5, [Claude Mythos Preview](https://anthropic.com/glasswing), Claude Opus 5.5, Claude Opus 5, Claude Sonnet 5.5 e Claude Sonnet 5.

Consulta la [panoramica dei modelli](https://platform.claude.com/docs/it/models/overview) per maggiori dettagli sui modelli disponibili.