---
title: Limiti di velocità
url: https://platform.claude.com/docs/it/api/rate-limits
description: Per mitigare gli abusi e gestire la capacità dell'API, sono previsti dei limiti su quanto un'organizzazione può utilizzare la Claude API.
---

<Note>
  **[Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws):** I limiti di velocità descritti in questa pagina si applicano a Claude Platform on AWS, ma la fatturazione e la gestione dei limiti sono diverse. La fatturazione avviene tramite AWS Marketplace (non tramite l’acquisto di crediti Anthropic). Le nuove organizzazioni su Claude Platform on AWS vengono collocate nel livello Start. Possono passare automaticamente a un livello superiore man mano che accumulano uno storico di fatture AWS Marketplace pagate. La configurazione dei limiti di velocità per singolo workspace e la [“fast mode” (modalità veloce)](https://platform.claude.com/docs/it/build-with-claude/fast-mode) non sono disponibili su Claude Platform on AWS. Per i dettagli, consulta [Limiti di velocità e quote su Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#rate-limits-and-quotas).
</Note>

Esistono due tipi di limiti:

1. I **limiti di spesa** stabiliscono un costo mensile massimo che un’organizzazione può sostenere per l’utilizzo dell’API.
2. I **“rate limits” (limiti di velocità)** stabiliscono il numero massimo di richieste API che un’organizzazione può effettuare in un determinato periodo di tempo.

L’API applica i limiti configurati dal servizio a livello di organizzazione, ma puoi anche impostare limiti configurabili dall’utente per i workspace della tua organizzazione.

## Informazioni sui limiti di velocità

* I limiti sono progettati per prevenire l’abuso dell’API, riducendo al minimo l’impatto sui modelli di utilizzo più comuni dei clienti.
* I limiti sono definiti in base al **livello di utilizzo** (“usage tier”). Le organizzazioni vengono collocate automaticamente in un livello in base alla cronologia di utilizzo e allo stato dell’account, e possono passare a un livello superiore nel tempo man mano che utilizzano l’API.
* Le nuove organizzazioni e le organizzazioni con una cronologia di utilizzo limitata possono iniziare nel livello di valutazione, con limiti inferiori ai limiti standard mostrati in questa pagina mentre viene costruita la cronologia dell’account. Questi limiti iniziali fanno parte del modo in cui Anthropic previene frodi e abusi, e aumentano automaticamente man mano che la tua organizzazione accumula cronologia di utilizzo.
* I limiti sono impostati a livello di organizzazione. Puoi vedere il livello e i limiti attuali della tua organizzazione nella pagina [Limiti di richieste](https://platform.claude.com/usage/limits) (`platform.claude.com/usage/limits`) della [Claude Console](https://platform.claude.com/). Su Claude Models on Google Cloud (Anthropic managed) e Claude Platform on AWS, quella pagina mostra **Livello personalizzato** per ogni organizzazione, indipendentemente dal suo livello di utilizzo.
* Potresti raggiungere i limiti di velocità su intervalli di tempo più brevi. Ad esempio, una velocità di 60 richieste al minuto (RPM) potrebbe essere applicata come 1 richiesta al secondo. Brevi raffiche di richieste possono superare il limite e generare errori di limite di velocità.
* I limiti seguenti sono i limiti standard per ciascun livello. Se hai bisogno di limiti più elevati, consulta [Richiedere limiti più elevati](https://platform.claude.com/docs/it/api/rate-limits#requesting-higher-limits).
* L’API utilizza l’[algoritmo token bucket](https://en.wikipedia.org/wiki/Token_bucket) per applicare i limiti di velocità. Ciò significa che la tua capacità viene continuamente ripristinata fino al limite massimo, anziché essere azzerata a intervalli fissi.
* Tutti i limiti qui descritti rappresentano l’utilizzo massimo consentito, non minimi garantiti. Questi limiti hanno lo scopo di ridurre le spese eccessive involontarie e garantire una distribuzione equa delle risorse tra gli utenti.

## Limiti di spesa

<Note>
  **[Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws):** Si applicano gli stessi tetti di spesa mensili e le richieste si interrompono al raggiungimento del tetto nello stesso modo. La fatturazione e gli aumenti di livello funzionano in modo diverso; consulta [Limiti di spesa su Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#spend-limits).
</Note>

Ciascuno dei livelli Start, Build e Scale prevede un tetto di spesa mensile. Il tetto è l’importo massimo che la tua organizzazione può spendere per l’API in ogni mese solare. Puoi visualizzare il tetto di spesa mensile della tua organizzazione e impostare un tuo limite in [Limiti di spesa nella Claude Console](https://platform.claude.com/settings/spend-limits) (`platform.claude.com/settings/spend-limits`).

| Livello di utilizzo | Tetto di spesa mensile |
| ------------------- | ---------------------- |
| Start               | $500 USD               |
| Build               | $1.000 USD             |
| Scale               | $200.000 USD           |

Le organizzazioni nel livello personalizzato non hanno un tetto di spesa mensile; i limiti vengono concordati con il loro team di account.

### Raggiungimento del tetto di spesa

Una volta raggiunto il tetto di spesa del tuo livello, l’utilizzo dell’API viene sospeso fino alle 00:00 UTC del primo giorno del mese successivo, a meno che tu non richieda prima un limite più elevato. Mentre l’utilizzo è sospeso, le richieste API restituiscono HTTP 429:

```json
{
  "type": "error",
  "error": {
    "type": "rate_limit_error",
    "message": "You have reached your API usage limits: your organization has crossed its monthly API usage threshold, set based on your organization's API tier. You will regain access on 2026-09-01 at 00:00 UTC.",
    "details": { "error_code": "enforced_spend_limit_reached" }
  },
  "request_id": "req_018EeWyXxfu5pfWkrYcMdjWG"
}
```

* Il tipo di errore è `rate_limit_error`, lo stesso di un limite di velocità, ma la risposta non include l’header `retry-after`. I nuovi tentativi, inclusi quelli automatici dell’SDK, falliscono finché l’accesso non viene ripristinato.
* Nella Messages API, `error.details.error_code` è `enforced_spend_limit_reached`. Usalo per distinguere questa risposta da un limite di velocità.
* Il passaggio a un livello superiore ripristina l’accesso; consulta [Richiedere limiti più elevati](https://platform.claude.com/docs/it/api/rate-limits#requesting-higher-limits).

### Impostare un proprio limite di spesa

Puoi anche impostare un tuo limite di spesa inferiore al tetto del tuo livello per controllare i costi:

<Steps>
  <Step title="Vai ai tuoi limiti di spesa">
    Vai a [Limiti di spesa nella Claude Console](https://platform.claude.com/settings/spend-limits) (`platform.claude.com/settings/spend-limits`).
  </Step>

  <Step title="Apri l’editor del limite di spesa">
    Accanto al **Limite di spesa mensile** della tua organizzazione, fai clic su **Modifica limite** o **Imposta limite**.
  </Step>

  <Step title="Modifica il tuo limite di spesa">
    Inserisci un nuovo valore. Il tuo limite di spesa non può superare il tetto del tuo livello attuale.
  </Step>
</Steps>

Quando l’utilizzo raggiunge un limite di spesa da te impostato, le richieste restituiscono HTTP 400 con tipo di errore `invalid_request_error`. Il messaggio inizia con `You have reached your specified API usage limits`, oppure `You have reached your specified workspace API usage limits` per un limite di workspace, e indica quando l’accesso verrà ripristinato. Aumenta o rimuovi il limite per ripristinare l’accesso prima.

I limiti sul [workspace Claude Code](https://platform.claude.com/docs/it/manage-claude/workspaces#claude-code-workspace) vengono verificati separatamente: le richieste di Claude Code che superano il limite di quel workspace possono invece ricevere un 429 che include un header `retry-after`.

## Limiti di velocità

I limiti di velocità per la Messages API sono misurati in richieste al minuto (RPM), token di input al minuto (ITPM) e token di output al minuto (OTPM) per ciascuna classe di modelli. Se superi uno qualsiasi dei limiti di velocità, ricevi un [errore 429](https://platform.claude.com/docs/it/api/errors) che descrive quale limite di velocità è stato superato. Quando la risposta include un header `retry-after`, attendi quel numero di secondi prima di riprovare.

<Note>
  Un forte aumento dell’utilizzo può causare anche errori 429. Consulta [Limiti di crescita](https://platform.claude.com/docs/it/api/rate-limits#ramp-limits).
</Note>

### ITPM con riconoscimento della cache

**I limiti di velocità ITPM predefiniti dell’API conteggiano solo i token di input non in cache.** Questo rende i limiti di velocità effettivamente più alti di quanto possano sembrare inizialmente.

I limiti di velocità ITPM vengono stimati all’inizio di ogni richiesta e la stima viene adeguata durante la richiesta per riflettere il numero effettivo di token di input utilizzati.

Ecco cosa viene conteggiato ai fini dell’ITPM:

* `input_tokens` (token dopo l’ultimo breakpoint della cache) ✓ **Conteggiati ai fini dell’ITPM**
* `cache_creation_input_tokens` (token scritti nella cache) ✓ **Conteggiati ai fini dell’ITPM**
* `cache_read_input_tokens` (token letti dalla cache) ✗ **NON conteggiati ai fini dell’ITPM**

<Note>
  Il campo `input_tokens` rappresenta solo i token che compaiono **dopo il tuo ultimo breakpoint della cache**, non tutti i token di input della tua richiesta. Per calcolare il totale dei token di input:

  ```text wrap
  total_input_tokens = cache_read_input_tokens + cache_creation_input_tokens + input_tokens
  ```

  Ciò significa che quando hai contenuti in cache, `input_tokens` è in genere molto più piccolo del tuo input totale. Ad esempio, con un documento in cache di 200k token e una domanda dell’utente di 50 token, vedresti `input_tokens: 50` anche se l’input totale è di 200.050 token.

  Ai fini dei limiti di velocità, solo `input_tokens` + `cache_creation_input_tokens` vengono conteggiati nel tuo limite ITPM, rendendo la [“prompt caching” (cache dei prompt)](https://platform.claude.com/docs/it/build-with-claude/prompt-caching) un modo efficace per aumentare il tuo throughput.
</Note>

**Esempio:** con un limite di 2.000.000 ITPM e un tasso di cache hit dell’80 percento, potresti effettivamente elaborare 10.000.000 di token di input totali al minuto (2M non in cache + 8M in cache), perché i token in cache non vengono conteggiati ai fini del tuo limite di velocità. Questi token in cache sono fatturati alla [tariffa di lettura della cache](https://platform.claude.com/docs/it/build-with-claude/prompt-caching#pricing), una frazione del prezzo di input base.

Per ottenere il throughput più elevato entro i tuoi limiti di velocità, metti in cache i contenuti ripetuti come istruzioni di sistema e prompt, documenti di contesto di grandi dimensioni, definizioni degli strumenti e cronologia delle conversazioni; consulta la [cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/prompt-caching) per indicazioni. Con una cache efficace, puoi aumentare sostanzialmente il tuo throughput effettivo senza aumentare i limiti di velocità. Monitora il tuo tasso di cache hit nella pagina [Utilizzo](https://platform.claude.com/usage) della Claude Console per ottimizzare la tua strategia di cache.

I limiti di velocità OTPM vengono valutati in tempo reale man mano che i token di output vengono prodotti, conteggiando solo i token effettivamente generati. Il parametro `max_tokens` non rientra nei calcoli dei limiti di velocità OTPM, quindi impostare un valore di `max_tokens` più elevato non comporta svantaggi in termini di limiti di velocità.

Ogni riga nelle tabelle seguenti ha i propri limiti RPM, ITPM e OTPM. Alcune righe includono diversi modelli che condividono un unico limite; consulta le note che seguono le tabelle. Puoi controllare i tuoi attuali “rate limit” (limiti di velocità) e il relativo comportamento nella pagina [Limiti di richieste](https://platform.claude.com/usage/limits) nella Claude Console, oppure leggere i limiti configurati e impostare i limiti dei workspace in modo programmatico con l’[API Rate Limits](https://platform.claude.com/docs/it/manage-claude/rate-limits-api).

<Note>
  I limiti di velocità sono condivisi tra tutti i valori di `inference_geo`. Le richieste con `inference_geo: "us"` e `inference_geo: "global"` attingono allo stesso pool di limiti di velocità.
</Note>

<Tabs>
  <Tab title="Livello Start">
    | Modello                                       | Richieste massime al minuto (RPM) | Token di input massimi al minuto (ITPM) | Token di output massimi al minuto (OTPM) |
    | --------------------------------------------- | --------------------------------- | --------------------------------------- | ---------------------------------------- |
    | Claude Fable 5.2                              | 4.000                             | 500.000                                 | 100.000                                  |
    | Claude Fable 5.1 e Claude Fable 5<sup>1</sup> | 4.000                             | 500.000                                 | 100.000                                  |
    | Claude Opus 5.5                               | 4.000                             | 2.000.000                               | 400.000                                  |
    | Claude Opus 5                                 | 1.000                             | 2.000.000                               | 400.000                                  |
    | Claude Opus 4.x<sup>2</sup>                   | 1.000                             | 2.000.000                               | 400.000                                  |
    | Claude Sonnet 5.5                             | 4.000                             | 2.000.000                               | 400.000                                  |
    | Claude Sonnet 5                               | 1.000                             | 2.000.000                               | 400.000                                  |
    | Claude Sonnet 4.x<sup>3</sup>                 | 1.000                             | 2.000.000                               | 400.000                                  |
    | Claude Haiku 5.5                              | 4.000                             | 2.000.000                               | 400.000                                  |
    | Claude Haiku 4.5                              | 1.000                             | 2.000.000                               | 400.000                                  |
  </Tab>

  <Tab title="Livello Build">
    | Modello                                       | Richieste massime al minuto (RPM) | Token di input massimi al minuto (ITPM) | Token di output massimi al minuto (OTPM) |
    | --------------------------------------------- | --------------------------------- | --------------------------------------- | ---------------------------------------- |
    | Claude Fable 5.2                              | 10.000                            | 1.500.000                               | 300.000                                  |
    | Claude Fable 5.1 e Claude Fable 5<sup>1</sup> | 10.000                            | 1.500.000                               | 300.000                                  |
    | Claude Opus 5.5                               | 10.000                            | 5.000.000                               | 1.000.000                                |
    | Claude Opus 5                                 | 5.000                             | 5.000.000                               | 1.000.000                                |
    | Claude Opus 4.x<sup>2</sup>                   | 5.000                             | 5.000.000                               | 1.000.000                                |
    | Claude Sonnet 5.5                             | 10.000                            | 5.000.000                               | 1.000.000                                |
    | Claude Sonnet 5                               | 5.000                             | 5.000.000                               | 1.000.000                                |
    | Claude Sonnet 4.x<sup>3</sup>                 | 5.000                             | 5.000.000                               | 1.000.000                                |
    | Claude Haiku 5.5                              | 10.000                            | 5.000.000                               | 1.000.000                                |
    | Claude Haiku 4.5                              | 5.000                             | 5.000.000                               | 1.000.000                                |
  </Tab>

  <Tab title="Livello Scale">
    | Modello                                       | Richieste massime al minuto (RPM) | Token di input massimi al minuto (ITPM) | Token di output massimi al minuto (OTPM) |
    | --------------------------------------------- | --------------------------------- | --------------------------------------- | ---------------------------------------- |
    | Claude Fable 5.2                              | 13.000                            | 4.000.000                               | 800.000                                  |
    | Claude Fable 5.1 e Claude Fable 5<sup>1</sup> | 13.000                            | 4.000.000                               | 800.000                                  |
    | Claude Opus 5.5                               | 13.000                            | 10.000.000                              | 2.000.000                                |
    | Claude Opus 5                                 | 10.000                            | 10.000.000                              | 2.000.000                                |
    | Claude Opus 4.x<sup>2</sup>                   | 10.000                            | 10.000.000                              | 2.000.000                                |
    | Claude Sonnet 5.5                             | 13.000                            | 10.000.000                              | 2.000.000                                |
    | Claude Sonnet 5                               | 10.000                            | 10.000.000                              | 2.000.000                                |
    | Claude Sonnet 4.x<sup>3</sup>                 | 10.000                            | 10.000.000                              | 2.000.000                                |
    | Claude Haiku 5.5                              | 13.000                            | 10.000.000                              | 2.000.000                                |
    | Claude Haiku 4.5                              | 10.000                            | 10.000.000                              | 2.000.000                                |
  </Tab>

  <Tab title="Livello personalizzato">
    Se hai bisogno di limiti superiori a quelli del livello Scale, contatta il team commerciale tramite la pagina [Limiti di richieste](https://platform.claude.com/usage/limits) della Claude Console. Su Claude Models on Google Cloud (Anthropic managed) e Claude Platform on AWS, usa **Richiedi limiti più elevati** in quella pagina, se lo vedi.
  </Tab>
</Tabs>

*<sup>1 Il limite di velocità di Fable è un limite totale che si applica al traffico combinato di Claude Fable 5.1 e Claude Fable 5. Claude Fable 5.2 ha un limite di velocità separato e non fa parte di questo bucket combinato. Claude Mythos 5.2, Claude Mythos 5.1 e Claude Mythos 5 condividono un limite combinato separato.</sup>*

*<sup>2 Il limite di velocità di Opus è un limite totale che si applica al traffico combinato di Claude Opus 4.8, Opus 4.7, Opus 4.6 e Opus 4.5. Claude Opus 5.5 e Claude Opus 5 hanno ciascuno un limite di velocità separato e non fanno parte di questo bucket combinato.</sup>*

*<sup>3 Il limite di velocità di Sonnet 4.x è un limite totale che si applica al traffico combinato di Sonnet 4.6 e Sonnet 4.5 (deprecato; consulta [Deprecazioni dei modelli](https://platform.claude.com/docs/it/about-claude/model-deprecations)). Claude Sonnet 5.5 e Claude Sonnet 5 hanno ciascuno un limite di velocità separato e non fanno parte di questo bucket combinato.</sup>*

### Limiti di crescita

Un “ramp limit” (limite di crescita) stabilisce quanto velocemente può crescere l’utilizzo di token della tua organizzazione su un modello. Dopo un forte aumento dell’utilizzo, le richieste possono restituire un errore 429 anche se sei al di sotto dei tuoi limiti di velocità ITPM e OTPM. Anche una raffica di richieste nell’arco di pochi secondi può essere conteggiata come un forte aumento.

Il tuo limite di crescita è l’utilizzo al minuto più elevato del modello da parte della tua organizzazione nel passato recente, più un incremento. Ogni minuto puoi salire fino a un incremento oltre quel picco, quindi il limite aumenta man mano che cresce il tuo utilizzo andato a buon fine. Smette di aumentare al raggiungimento del tuo limite di velocità. Dopo un periodo di utilizzo inferiore, il limite di crescita torna a scendere. Il limite non scende mai al di sotto di una quantità iniziale, anche se non hai usato il modello di recente.

* I limiti di crescita possono applicarsi a qualsiasi modello.
* I token di input e i token di output vengono conteggiati separatamente.
* L’utilizzo della [modalità veloce](https://platform.claude.com/docs/it/api/rate-limits#fast-mode-rate-limits) ha i propri limiti di crescita, separati dall’utilizzo standard dello stesso modello.
* Come per l’[ITPM con riconoscimento della cache](https://platform.claude.com/docs/it/api/rate-limits#cache-aware-itpm), i token letti dalla cache non vengono conteggiati ai fini di un limite di crescita. I token di input non in cache e i token scritti nella cache invece sì.
* L’incremento e la quantità iniziale variano in base al modello e possono cambiare. Il messaggio di errore in genere indica il tuo attuale limite di crescita, l’incremento e il tuo limite di velocità.
* Il tipo di errore è `rate_limit_error`, lo stesso di un limite di velocità. Nella Messages API, `error.details.error_code` è `ramp_limit_exceeded`. Usalo per distinguere questa risposta da un limite di velocità.
* La [Message Batches API](https://platform.claude.com/docs/it/api/rate-limits#message-batches-api) non è soggetta ai limiti di crescita.

Se ricevi un 429 a causa di un limite di crescita:

* Attendi almeno il numero di secondi indicato nell’header `retry-after` prima di riprovare.
* Mantieni il traffico a un livello in cui le richieste vanno a buon fine, quindi aumentalo al massimo di un incremento al minuto.
* Avvia i job pianificati o massivi a una velocità bassa e distribuisci le richieste in modo uniforme, invece di inviare tutto in una volta.

### Message Batches API

La Message Batches API ha un proprio insieme di limiti di velocità, condivisi tra tutti i modelli. Questi includono un limite di richieste al minuto (RPM) per tutti gli endpoint dell’API e un limite sul numero di richieste batch che possono trovarsi contemporaneamente nella coda di elaborazione. Una “richiesta batch” qui si riferisce a una parte di un batch di messaggi. Puoi creare un batch di messaggi contenente migliaia di richieste batch, ciascuna delle quali viene conteggiata ai fini di questo limite. Una richiesta batch resta nella coda di elaborazione finché il modello non l’ha elaborata con successo.

<Tabs>
  <Tab title="Livello Start">
    | Richieste massime al minuto (RPM) | Richieste batch massime nella coda di elaborazione | Richieste batch massime per batch |
    | --------------------------------- | -------------------------------------------------- | --------------------------------- |
    | 1.000                             | 200.000                                            | 100.000                           |
  </Tab>

  <Tab title="Livello Build">
    | Richieste massime al minuto (RPM) | Richieste batch massime nella coda di elaborazione | Richieste batch massime per batch |
    | --------------------------------- | -------------------------------------------------- | --------------------------------- |
    | 2.000                             | 300.000                                            | 100.000                           |
  </Tab>

  <Tab title="Livello Scale">
    | Richieste massime al minuto (RPM) | Richieste batch massime nella coda di elaborazione | Richieste batch massime per batch |
    | --------------------------------- | -------------------------------------------------- | --------------------------------- |
    | 4.000                             | 500.000                                            | 100.000                           |
  </Tab>

  <Tab title="Livello personalizzato">
    Se hai bisogno di limiti superiori a quelli del livello Scale, contatta il team commerciale tramite la pagina [Limiti di richieste](https://platform.claude.com/usage/limits) della Claude Console. Su Claude Models on Google Cloud (Anthropic managed) e Claude Platform on AWS, usa **Richiedi limiti più elevati** in quella pagina, se lo vedi.
  </Tab>
</Tabs>

### Managed Agents

Gli endpoint di [Claude Managed Agents](https://platform.claude.com/docs/it/managed-agents/overview) hanno limiti di velocità per ciascuna organizzazione. Questi limiti sono separati dai limiti di velocità della Messages API descritti in precedenza in questa pagina.

| Operazione                                                     | Limite                    |
| -------------------------------------------------------------- | ------------------------- |
| Endpoint di creazione (ad esempio agenti, sessioni e ambienti) | 300 richieste al minuto   |
| Endpoint di lettura (ad esempio recupero, elenco e streaming)  | 1.200 richieste al minuto |

### Files API

Le richieste alla [Files API](https://platform.claude.com/docs/it/build-with-claude/files) hanno un proprio limite per organizzazione, condiviso tra le operazioni di caricamento, elenco, recupero, download ed eliminazione e separato dai limiti della Messages API descritti in precedenza in questa pagina. Consulta [Limiti di velocità della Files API](https://platform.claude.com/docs/it/build-with-claude/files#rate-limits) per il valore attuale.

### Limiti di velocità della modalità veloce

Quando utilizzi la [modalità veloce](https://platform.claude.com/docs/it/build-with-claude/fast-mode) con `speed: "fast"`, si applicano limiti di velocità dedicati, separati dai limiti di velocità standard. Si applicano su Claude Fable 5.2, Claude Mythos 5.2, Claude Opus 5.5, Claude Opus 5 e Claude Opus 4.8. La modalità veloce è in anteprima di ricerca per Claude Opus 5 ed è deprecata per Claude Opus 4.8.

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

Per vedere i tuoi limiti di velocità della modalità veloce, vai alla pagina [Limiti di richieste](https://platform.claude.com/usage/limits) della Claude Console. Quando superi i tuoi limiti di velocità della modalità veloce, l’API restituisce un errore `429` con un header `retry-after`.

La risposta include header `anthropic-fast-*` che indicano lo stato dei tuoi limiti di velocità della modalità veloce. Consulta [Limiti di velocità della modalità veloce](https://platform.claude.com/docs/it/build-with-claude/fast-mode#rate-limits) per i dettagli su questi header.

### Monitorare i limiti di velocità nella Console

Puoi monitorare l’utilizzo dei tuoi limiti di velocità nella pagina [Utilizzo](https://platform.claude.com/usage) della [Claude Console](https://platform.claude.com/).

Oltre a fornire grafici su token e richieste, la pagina **Utilizzo** fornisce due grafici separati sui limiti di velocità. Usa questi grafici per vedere quale margine di crescita hai, identificare quando potresti raggiungere i picchi di utilizzo, capire quali limiti di velocità richiedere e imparare a migliorare i tuoi tassi di cache. I grafici visualizzano una serie di metriche per un determinato limite di velocità (ad esempio, per ciascun modello):

* Il grafico **Rate Limit - Input Tokens** include:

  * Il massimo orario di token di input non in cache al minuto
  * Il tuo attuale limite di velocità di token di input al minuto
  * Il tasso di cache per i tuoi token di input (ovvero la percentuale di token di input letti dalla cache)

* Il grafico **Rate Limit - Output Tokens** include:

  * Il massimo orario di token di output al minuto
  * Il tuo attuale limite di velocità di token di output al minuto

## Richiedere limiti più elevati

Per richiedere limiti di velocità più elevati o un tetto di spesa mensile più alto, usa **Richiedi un livello superiore** nella pagina [Limiti di richieste](https://platform.claude.com/usage/limits) della Claude Console. Anche il supporto Anthropic può aumentare i limiti; per esigenze urgenti, contatta il [supporto Anthropic](https://support.claude.com).

<Note>
  **[Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws):** Nella pagina **Limiti di richieste**, il pulsante per i limiti di velocità e il tetto di spesa è **Richiedi limiti più elevati**. Per usarlo, hai bisogno del [ruolo Admin](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#signing-in) nella Claude Console e delle azioni IAM `ListAccountRateLimitIncreaseRequests` e `CreateAccountRateLimitIncreaseRequest`. Per sapere cosa includere, chi non può usare il pulsante e gli altri modi per fare richiesta, consulta [Limiti di velocità e quote su Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#rate-limits-and-quotas).
</Note>

## Impostare limiti inferiori per i workspace

Per maggiori informazioni sui workspace, consulta [Workspace](https://platform.claude.com/docs/it/manage-claude/workspaces).

Per proteggere i workspace della tua organizzazione da un potenziale utilizzo eccessivo, puoi impostare limiti di spesa e di velocità personalizzati per ciascun workspace.

Esempio: se il limite della tua organizzazione è di 40.000 token di input al minuto e 8.000 token di output al minuto, potresti limitare un workspace a 30.000 token di input al minuto. Questo protegge gli altri workspace da un potenziale utilizzo eccessivo e distribuisce le risorse in modo più equo all’interno della tua organizzazione. Gli altri 10.000 token di input al minuto, più quelli dei 30.000 che quel workspace non utilizza, restano disponibili per gli altri workspace.

Nota:

* Su [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed) e [Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws), non puoi impostare limiti di spesa sul workspace predefinito.
* Un limite di spesa sul workspace predefinito potrebbe non conteggiare o non bloccare parte dell’utilizzo in quel workspace. Ciò include l’utilizzo dalla Claude Console (ad esempio il playground) e dalle sessioni di Claude Managed Agents. Include anche l’utilizzo di Claude Code o Claude Desktop quando un membro accede con un account Claude Console e usa il workspace predefinito. Il [limite di spesa](https://platform.claude.com/docs/it/api/rate-limits#setting-your-own-spend-limit) della tua organizzazione si applica a tutto questo utilizzo.
* Se non impostati, i limiti del workspace corrispondono al limite dell’organizzazione.
* I limiti del workspace vengono impostati per ciascun tipo di limitatore (ad esempio richieste al minuto, token di input al minuto o token di output al minuto).
* I limiti a livello di organizzazione si applicano sempre, anche se la somma dei limiti dei workspace è superiore.

Per leggere gli attuali limiti di velocità della tua organizzazione e dei tuoi workspace o impostare i limiti di velocità dei workspace in modo programmatico, usa l’[API Rate Limits](https://platform.claude.com/docs/it/manage-claude/rate-limits-api).

## Header di risposta

La risposta dell’API include header che mostrano il limite di velocità applicato, l’utilizzo attuale e quando il limite si ripristina.

Vengono restituiti i seguenti header:

| Header                                        | Descrizione                                                                                                                                                                                                                                                                                                                 |
| --------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `retry-after`                                 | Il numero di secondi da attendere prima di poter ritentare la richiesta. I tentativi anticipati potrebbero fallire. Non tutti i 429 lo includono; il 429 del tetto di spesa non lo include mai (consulta [Raggiungimento del tetto di spesa](https://platform.claude.com/docs/it/api/rate-limits#reaching-your-spend-cap)). |
| `anthropic-ratelimit-requests-limit`          | Il numero massimo di richieste consentite in qualsiasi periodo di limite di velocità.                                                                                                                                                                                                                                       |
| `anthropic-ratelimit-requests-remaining`      | Il numero di richieste rimanenti prima di essere soggetti al limite di velocità.                                                                                                                                                                                                                                            |
| `anthropic-ratelimit-requests-reset`          | Il momento in cui il limite di velocità delle richieste è completamente ripristinato, fornito in formato RFC 3339.                                                                                                                                                                                                          |
| `anthropic-ratelimit-tokens-limit`            | Il numero massimo di token consentiti in qualsiasi periodo di limite di velocità.                                                                                                                                                                                                                                           |
| `anthropic-ratelimit-tokens-remaining`        | Il numero di token rimanenti (arrotondato al migliaio più vicino) prima di essere soggetti al limite di velocità.                                                                                                                                                                                                           |
| `anthropic-ratelimit-tokens-reset`            | Il momento in cui il limite di velocità dei token è completamente ripristinato, fornito in formato RFC 3339.                                                                                                                                                                                                                |
| `anthropic-ratelimit-input-tokens-limit`      | Il numero massimo di token di input consentiti in qualsiasi periodo di limite di velocità.                                                                                                                                                                                                                                  |
| `anthropic-ratelimit-input-tokens-remaining`  | Il numero di token di input rimanenti (arrotondato al migliaio più vicino) prima di essere soggetti al limite di velocità.                                                                                                                                                                                                  |
| `anthropic-ratelimit-input-tokens-reset`      | Il momento in cui il limite di velocità dei token di input è completamente ripristinato, fornito in formato RFC 3339.                                                                                                                                                                                                       |
| `anthropic-ratelimit-output-tokens-limit`     | Il numero massimo di token di output consentiti in qualsiasi periodo di limite di velocità.                                                                                                                                                                                                                                 |
| `anthropic-ratelimit-output-tokens-remaining` | Il numero di token di output rimanenti (arrotondato al migliaio più vicino) prima di essere soggetti al limite di velocità.                                                                                                                                                                                                 |
| `anthropic-ratelimit-output-tokens-reset`     | Il momento in cui il limite di velocità dei token di output è completamente ripristinato, fornito in formato RFC 3339.                                                                                                                                                                                                      |
| `anthropic-priority-input-tokens-limit`       | Il numero massimo di token di input Priority Tier consentiti in qualsiasi periodo di limite di velocità. (Solo Priority Tier)                                                                                                                                                                                               |
| `anthropic-priority-input-tokens-remaining`   | Il numero di token di input Priority Tier rimanenti (arrotondato al migliaio più vicino) prima di essere soggetti al limite di velocità. (Solo Priority Tier)                                                                                                                                                               |
| `anthropic-priority-input-tokens-reset`       | Il momento in cui il limite di velocità dei token di input Priority Tier è completamente ripristinato, fornito in formato RFC 3339. (Solo Priority Tier)                                                                                                                                                                    |
| `anthropic-priority-output-tokens-limit`      | Il numero massimo di token di output Priority Tier consentiti in qualsiasi periodo di limite di velocità. (Solo Priority Tier)                                                                                                                                                                                              |
| `anthropic-priority-output-tokens-remaining`  | Il numero di token di output Priority Tier rimanenti (arrotondato al migliaio più vicino) prima di essere soggetti al limite di velocità. (Solo Priority Tier)                                                                                                                                                              |
| `anthropic-priority-output-tokens-reset`      | Il momento in cui il limite di velocità dei token di output Priority Tier è completamente ripristinato, fornito in formato RFC 3339. (Solo Priority Tier)                                                                                                                                                                   |

Gli header `anthropic-ratelimit-tokens-*` mostrano i valori del limite più restrittivo attualmente in vigore. Ad esempio, se hai superato il limite di token al minuto del workspace, gli header contengono i valori del limite di velocità di token al minuto del workspace. Se i limiti del workspace non si applicano, gli header restituiscono i token totali rimanenti, dove il totale è la somma dei token di input e di output. Per vedere su quale workspace è stata conteggiata una richiesta, leggi l’[header di risposta](https://platform.claude.com/docs/it/api/overview#response-headers) `anthropic-workspace-id`, che contiene l’ID del workspace a cui la tua chiave API o il tuo token di accesso è stato risolto.
