> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Limiti ACU per utente

> Limita il consumo mensile di ACU di ciascun utente con tier, mappature di gruppi IdP e override per utente

<Note>
  I limiti per utente sono in versione beta e richiedono l'abilitazione della funzionalità per la tua Enterprise. Per abilitarla, contatta il tuo account team.
</Note>

Un limite per utente stabilisce un tetto all'utilizzo combinato di ACU **locali e cloud** dell'utente: le sessioni cloud di Devin, Devin Desktop, Windsurf JetBrains e Devin CLI contribuiscono allo stesso limite. Quando un utente raggiunge il proprio limite, non può avviare nuovo lavoro su queste funzionalità finché il limite non viene aumentato o l'utilizzo non si reimposta nella finestra mensile successiva.

Puoi gestire i tier e i limiti per utente dalla web app, in **Enterprise Settings** nella sezione **policy di utilizzo** (consulta la [guida alle policy di utilizzo](/it/enterprise/features/usage-policies)), oppure tramite gli [endpoint usage-policies](#tier-endpoints) riportati di seguito.

I limiti per utente sono gestiti tramite i **tier**. Un tier è un limite predefinito con nome, valido per l'intero account e condiviso dai relativi membri:

* Gli utenti possono essere inseriti nei tier in tre modi: un admin li **assegna esplicitamente**, una [**mappatura di gruppi IdP**](#idp-group-endpoints) li associa a un tier (un gruppo viene mappato a un tier e i suoi membri ereditano quel tier, salvo assegnazione esplicita a un altro tier), oppure ricadono nel **tier predefinito**. Ogni account può designare un tier come tier predefinito; tutti i membri dell'account non altrimenti assegnati vi appartengono. Non esiste un "limite utente predefinito" separato: configura invece il tier predefinito.
* I singoli utenti possono avere un **override**, **permanente** (non scade mai) o **temporaneo** (scade al termine della finestra mensile corrente). Gli override sono circoscritti all'utente: impostarne uno non modifica mai l'assegnazione del tier dell'utente.
* Il **limite effettivo** di un utente viene determinato in questo ordine: override permanente; in alternativa, override temporaneo attivo; quindi `cycle_acu_limit` del tier assegnato esplicitamente; quindi limite del tier mappato al gruppo IdP con la priorità più alta; infine, limite del tier predefinito. Un limite `null` indica l'assenza di limiti.
* Gli utenti possono richiedere un limite più alto; gli admin esaminano queste [**richieste di aumento del limite**](#limit-increase-request-endpoints) e il valore `policy` di ciascun tier determina se le richieste vengono approvate automaticamente o sottoposte a revisione manuale.

I limiti per utente sono indipendenti dai [limiti a livello di organizzazione](/it/admin/billing/org-acu-limits): una richiesta viene bloccata se è stato raggiunto uno dei due limiti. Consulta [Limiti ACU](/it/admin/billing/acu-limits) per informazioni su autenticazione, autorizzazioni e semantica di `PATCH` condivise da tutti gli endpoint in questa pagina.

<Warning>
  Gli endpoint precedenti all'introduzione dei tier, relativi ai limiti per utente e al limite utente predefinito, sono deprecati; consulta [Endpoint legacy dei limiti ACU per utente](/it/admin/billing/legacy-user-acu-limits).
</Warning>

<div id="tier-endpoints">
  ## Endpoint dei livelli
</div>

<div id="list-tiers">
  ### Elencare i tier
</div>

```http theme={null}
GET /v3beta1/enterprise/usage-policies/tiers
```

Restituisce un elenco paginato di tier in ordine di precedenza: prima la `priority` più alta, poi il tier più recente a parità di priorità. Ogni tier ha questa struttura:

```json theme={null}
{
  "tier_id": "tier-abc123",
  "name": "Engineers",
  "is_default": true,
  "cycle_acu_limit": 500,
  "policy": "manual",
  "max_limit": null,
  "priority": 0,
  "member_count": 42,
  "created_at": 1735689600
}
```

* `is_default`: indica se si tratta del tier predefinito dell'account.
* `cycle_acu_limit`: il limite ACU predefinito per ciclo per ogni membro; `null` indica che non è previsto alcun limite.
* `policy`: come vengono gestite le richieste di aumento del limite per il tier — `unconditional` e `conditional` approvano fino a `max_limit`, mentre `manual` richiede la revisione di un Admin. La policy `conditional` (approvazione automatica basata sull'efficienza) richiede un'abilitazione separata; contatta il tuo account team.
* `max_limit`: il limite massimo fino al quale vengono approvate le richieste di aumento; `null` approva senza un tetto massimo. È sempre `null` quando `cycle_acu_limit` è `null`.
* `priority`: determina la posizione del tier tra quelli di un utente mappati ai gruppi IdP — prevale il valore più alto; in caso di parità, prevale il tier più recente. La classificazione determina solo la precedenza: un tier con priorità più alta può avere un `cycle_acu_limit` inferiore. Un'assegnazione esplicita all'utente ha la precedenza sulla priorità e il tier predefinito non viene mai classificato.
* `member_count`: il numero di utenti attualmente nel tier — utenti assegnati esplicitamente più utenti inclusi tramite una mappatura di gruppo IdP. Per il tier predefinito, include tutti i membri dell'account che non appartengono a un altro tier.

<Note>
  Configura il tier predefinito e la priorità dei tier nella web app, in **Policy di utilizzo**.
</Note>

<div id="create-a-tier">
  ### Crea un livello
</div>

```http theme={null}
POST /v3beta1/enterprise/usage-policies/tiers
```

**Corpo della richiesta**

```json theme={null}
{
  "name": "Engineers",
  "cycle_acu_limit": 500,
  "policy": "manual"
}
```

Il primo livello dell'account diventa automaticamente quello predefinito. Restituisce HTTP `201` con il livello creato.

<div id="get-a-tier">
  ### Recuperare un livello
</div>

```http theme={null}
GET /v3beta1/enterprise/usage-policies/tiers/{tier_id}
```

<div id="update-a-tier">
  ### Aggiorna un livello
</div>

```http theme={null}
PATCH /v3beta1/enterprise/usage-policies/tiers/{tier_id}
```

Aggiornamento parziale; i campi omessi restano invariati. Per modificare il tier predefinito o la relativa priorità, usa la web app nella sezione **Policy di utilizzo**.

```json theme={null}
{
  "name": "Engineering",
  "cycle_acu_limit": 750
}
```

<div id="delete-a-tier">
  ### Elimina un tier
</div>

```http theme={null}
DELETE /v3beta1/enterprise/usage-policies/tiers/{tier_id}
```

Restituisce HTTP `204` in caso di successo. Il tier predefinito non può essere eliminato (promuovi prima un altro tier). Prima di eliminare un tier che contiene ancora utenti, devi spostarli e rimuovere eventuali mappature di gruppi IdP associate al tier.

<div id="tier-user-endpoints">
  ## Endpoint utente del tier
</div>

<div id="list-a-tiers-users">
  ### Elencare gli utenti di un livello
</div>

```http theme={null}
GET /v3beta1/enterprise/usage-policies/tiers/{tier_id}/users
```

Restituisce un elenco paginato degli utenti del tier con i relativi limiti determinati: utenti assegnati esplicitamente e utenti inclusi tramite la mappatura di un gruppo IdP. Per il tier predefinito, include tutti i membri dell'account che non appartengono a un altro tier:

```json theme={null}
{
  "user_id": "user_abc123",
  "name": "Ada Lovelace",
  "email": "ada@example.com",
  "cycle_acu_limit_override": null,
  "temporary_cycle_acu_limit": 800,
  "effective_cycle_acu_limit": 800,
  "limit_source": "temporary_override",
  "membership": "explicit"
}
```

* `cycle_acu_limit_override`: l'override permanente dell'utente, se presente.
* `temporary_cycle_acu_limit`: l'override temporaneo dell'utente, presente solo finché è attivo nella finestra di fatturazione mensile corrente.
* `effective_cycle_acu_limit`: il limite attualmente applicato all'utente; `null` indica che non è previsto alcun limite.
* `limit_source`: l'origine del limite effettivo — `override` (permanente), `temporary_override` o `tier`.
* `membership`: il motivo per cui l'utente appartiene al tier — `explicit` (assegnato direttamente), `idp_group` (tramite la mappatura del gruppo IdP prevalente) o `default` (fallback al tier predefinito).

<div id="assign-a-user-to-a-tier">
  ### Assegnare un utente a un livello
</div>

```http theme={null}
PUT /v3beta1/enterprise/usage-policies/tiers/{tier_id}/users/{user_id}
```

Idempotente. Restituisce HTTP `204` in caso di successo. Lo spostamento di un utente da un altro livello rimuove qualsiasi override per utente, pertanto l'utente erediterà il limite del livello di destinazione.

<div id="remove-a-user-from-a-tier">
  ### Rimuovere un utente da un livello
</div>

```http theme={null}
DELETE /v3beta1/enterprise/usage-policies/tiers/{tier_id}/users/{user_id}
```

Rimuove l'assegnazione esplicita del tier dell'utente (ed eventuali override), riportandolo al tier predefinito. Restituisce HTTP `204` in caso di successo.

<div id="user-override-endpoint">
  ## Endpoint di override dell'utente
</div>

<div id="set-or-clear-a-users-override">
  ### Impostare o rimuovere l'override di un utente
</div>

```http theme={null}
PATCH /v3beta1/enterprise/usage-policies/users/{user_id}
```

Ambito utente: il destinatario deve solo essere un membro dell'account; non è previsto alcun livello e l'assegnazione del livello dell'utente non viene mai modificata. Un utente con un solo override (senza un'assegnazione esplicita di livello) rimane nel livello predefinito.

**Corpo della richiesta — impostare un override temporaneo**

```json theme={null}
{
  "cycle_acu_limit": 800,
  "kind": "temporary"
}
```

`kind` è obbligatorio quando si imposta un valore: `permanent` non scade mai; `temporary` scade al termine dell'attuale periodo di fatturazione mensile.

**Corpo della richiesta — cancella tutti gli override**

```json theme={null}
{
  "cycle_acu_limit": null
}
```

L'endpoint restituisce HTTP `204` in caso di successo.

<div id="idp-group-endpoints">
  ## Endpoint dei gruppi IdP
</div>

Mappa un gruppo IdP a un tier affinché i suoi membri ereditino automaticamente quel tier. Le mappature vengono risolte in tempo reale in base all'appartenenza ai gruppi e non modificano mai l'assegnazione esplicita del tier di un utente: un'assegnazione esplicita ha sempre la precedenza. Per un utente che appartiene a più gruppi mappati, viene selezionato il tier mappato con priorità più alta (`priority` più alta; a parità, prevale il tier più recente).

<div id="list-idp-group-mappings">
  ### Elencare le mappature dei gruppi IdP
</div>

```http theme={null}
GET /v3beta1/enterprise/usage-policies/idp-groups
```

Restituisce un elenco paginato delle mappature gruppo-livello dell'account, dalla più vecchia alla più recente. Usa `?tier_id=` per elencare solo i gruppi mappati a un livello:

```json theme={null}
{
  "idp_group_id": "grp_abc123",
  "idp_group_name": "Engineering",
  "tier_id": "tier-abc123"
}
```

<div id="get-an-idp-groups-mapping">
  ### Ottieni la mappatura di un gruppo IdP
</div>

```http theme={null}
GET /v3beta1/enterprise/usage-policies/idp-groups/{idp_group_name}
```

Restituisce HTTP `404` se il gruppo non dispone di una mappatura.

<div id="map-an-idp-group-to-a-tier">
  ### Mappa un gruppo IdP a un tier
</div>

```http theme={null}
PUT /v3beta1/enterprise/usage-policies/idp-groups/{idp_group_name}
```

**Corpo della richiesta**

```json theme={null}
{
  "tier_id": "tier-abc123"
}
```

Upsert idempotente. Un gruppo può essere associato a un solo tier; associare un gruppo già associato lo sposta nel tier specificato.

<div id="unmap-an-idp-group">
  ### Annulla la mappatura di un gruppo IdP
</div>

```http theme={null}
DELETE /v3beta1/enterprise/usage-policies/idp-groups/{idp_group_name}
```

Restituisce HTTP `204` in caso di successo. Il tier mappato non si applica più ai membri del gruppo; gli utenti senza un'assegnazione esplicita né un altro tier mappato tornano al tier predefinito.

<div id="limit-increase-request-endpoints">
  ## Endpoint per le richieste di aumento del limite
</div>

Gli utenti possono richiedere un limite più alto per ciclo. La `policy` del tier del richiedente determina cosa accade: `unconditional` e `conditional` approvano automaticamente le richieste fino al valore `max_limit` del tier, mentre `manual` mantiene la richiesta in attesa della revisione di un admin tramite questi endpoint (o in **Criteri di utilizzo** nella web app).

<Note>
  A differenza degli altri endpoint in questa pagina, per leggere le richieste di aumento del limite è necessaria l'autorizzazione **ManageBilling**: le richieste contengono l'identità del membro e messaggi di testo libero, che costituiscono dati del flusso di lavoro dell'admin.
</Note>

<div id="list-limit-increase-requests">
  ### Elencare le richieste di aumento dei limiti
</div>

```http theme={null}
GET /v3beta1/enterprise/usage-policies/requests
```

Restituisce un elenco paginato, filtrabile tramite `?status=` (`pending`, `approved`, `denied`) e `?user_id=`:

```json theme={null}
{
  "request_id": 42,
  "user_id": "user_abc123",
  "name": "Ada Lovelace",
  "email": "ada@example.com",
  "tier_id": "tier-abc123",
  "tier_name": "Engineers",
  "current_cycle_acu_limit": 500,
  "requested_cycle_acu_limit": 800,
  "message": "Wrapping up a large migration this month",
  "status": "pending",
  "created_at": 1735689600,
  "reviewed_at": null,
  "reviewer": null
}
```

* `tier_id` / `tier_name`: il tier del richiedente (assegnazione esplicita, mappatura del gruppo IdP o tier predefinito); `null` quando l'account non dispone di tier.
* `current_cycle_acu_limit`: il limite attualmente applicato al richiedente; `null` indica l'assenza di limiti.
* `reviewer`: l'Admin che ha esaminato la richiesta; `null` finché la richiesta è in attesa.

<div id="get-a-limit-increase-request">
  ### Recupera una richiesta di aumento del limite
</div>

```http theme={null}
GET /v3beta1/enterprise/usage-policies/requests/{request_id}
```

<div id="approve-a-limit-increase-request">
  ### Approva una richiesta di aumento del limite
</div>

```http theme={null}
POST /v3beta1/enterprise/usage-policies/requests/{request_id}/approve
```

Concede il limite richiesto come **override temporaneo**, che scade al termine dell'attuale periodo di fatturazione mensile. Facoltativamente, concedi un limite diverso:

```json theme={null}
{
  "cycle_acu_limit": 700
}
```

Restituisce la richiesta aggiornata. Restituisce HTTP `409` se la richiesta è già stata esaminata o se il richiedente non è più membro dell'account.

<div id="deny-a-limit-increase-request">
  ### Rifiutare una richiesta di aumento del limite
</div>

```http theme={null}
POST /v3beta1/enterprise/usage-policies/requests/{request_id}/deny
```

Restituisce la richiesta aggiornata oppure HTTP `409` se era già stata esaminata.

<div id="example-workflows">
  ## Esempi di flussi di lavoro
</div>

<div id="set-up-tiers-with-a-default-limit">
  ### Configura i tier con un limite predefinito
</div>

Crea un tier predefinito affinché ogni utente disponga di un limite mensile di 500 ACU:

```bash theme={null}
curl -X POST "https://api.devin.ai/v3beta1/enterprise/usage-policies/tiers" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{"name": "Standard", "cycle_acu_limit": 500, "policy": "manual"}'
```

Crea un tier con un limite più alto e assegna un utente a quel tier:

```bash theme={null}
curl -X POST "https://api.devin.ai/v3beta1/enterprise/usage-policies/tiers" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{"name": "Power users", "cycle_acu_limit": 2000, "policy": "manual"}'

curl -X PUT "https://api.devin.ai/v3beta1/enterprise/usage-policies/tiers/tier-abc123/users/user_abc123" \
  -H "Authorization: Bearer <token>"
```

Concedi a un utente un aumento temporaneo per il resto del mese:

```bash theme={null}
curl -X PATCH "https://api.devin.ai/v3beta1/enterprise/usage-policies/users/user_abc123" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{"cycle_acu_limit": 800, "kind": "temporary"}'
```

Mappa un gruppo IdP al tier con il limite più alto ed esamina una richiesta di aumento del limite in attesa:

```bash theme={null}
curl -X PUT "https://api.devin.ai/v3beta1/enterprise/usage-policies/idp-groups/Engineering" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{"tier_id": "tier-abc123"}'

curl -X POST "https://api.devin.ai/v3beta1/enterprise/usage-policies/requests/42/approve" \
  -H "Authorization: Bearer <token>"
```

<div id="frequently-asked-questions">
  ## Domande frequenti
</div>

<AccordionGroup>
  <Accordion title="A quali prodotti si applicano i limiti per utente?">
    Utilizzo locale e cloud: le sessioni Devin nel cloud e l'utilizzo locale tramite CLI e IDE (Devin Desktop, Windsurf JetBrains e Devin CLI) concorrono a un unico limite.
  </Accordion>

  <Accordion title="Come viene determinato il limite effettivo di un utente?">
    Ha la precedenza un override permanente, seguito da un override temporaneo attivo, dal limite del tier assegnato esplicitamente all'utente, dal limite del tier con il ranking più alto mappato ai gruppi IdP dell'utente e infine dal limite del tier predefinito. Un limite `null` a ogni livello significa che l'utente non è soggetto a limiti.
  </Accordion>

  <Accordion title="Gli override utente si aggiungono al limite del tier?">
    No. Un override sostituisce il limite del tier per quell'utente. Se il limite del tier è di 500 ACU e un utente dispone di un override di 200 ACU, il limite effettivo di quell'utente è di 200 ACU.
  </Accordion>

  <Accordion title="Qual è la differenza tra un override permanente e uno temporaneo?">
    Un override permanente non scade mai. Un override temporaneo scade alla fine della finestra mensile corrente, dopodiché all'utente viene nuovamente applicato il limite del proprio tier. L'approvazione di una richiesta di aumento del limite concede un override temporaneo.
  </Accordion>

  <Accordion title="Esiste ancora un limite utente predefinito?">
    Non come impostazione autonoma. Configura invece il limite del tier predefinito: si applica a ogni membro dell'account non assegnato a un altro tier. Gli [endpoint legacy per il limite ACU utente predefinito](/it/admin/billing/legacy-user-acu-limits#default-user-limit-endpoints) ora leggono e scrivono il limite del tier predefinito.
  </Accordion>

  <Accordion title="Cosa succede quando qualcuno raggiunge il proprio limite?">
    I nuovi lavori vengono bloccati sia nelle funzionalità locali sia in quelle cloud. L'utente può contattare un amministratore Enterprise per modificare il limite o attendere l'inizio della prossima finestra mensile.
  </Accordion>
</AccordionGroup>