---
title: API Spend Limits
url: https://platform.claude.com/docs/it/manage-claude/spend-limits-api
description: Imposta un limite di spesa per ciascun membro di Claude Enterprise, visualizza da dove viene ereditato il limite di spesa di ciascun membro e rivedi o gestisci le richieste dei membri per un limite più alto.
---
L'API Spend Limits ti consente di impostare uno "spend limit" (limite di spesa) per ciascun membro di Claude Enterprise, vedere da dove viene ereditato il limite di spesa di ciascun membro e rivedere o gestire le richieste dei membri per un limite più alto.
Per il *reporting* di utilizzo e costi per utente e suddiviso in intervalli di tempo, consulta le [API Analytics](https://platform.claude.com/docs/it/manage-claude/analytics-api).
**È richiesta una chiave Admin API con scope**
Questi endpoint richiedono una chiave API Admin con l'ambito `read:spend_limits` (per gli endpoint `GET`) o l'ambito `write:spend_limits` (per gli endpoint `POST` e `DELETE`). Consulta [Creare una chiave API Admin](https://platform.claude.com/docs/it/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization) per sapere dove il tuo proprietario principale ne crea una e quali ambiti selezionare. Passa la chiave nell'header `x-api-key` in ogni richiesta, insieme all'header [`anthropic-version`](https://platform.claude.com/docs/it/api/versioning).
L'API Spend Limits è disponibile solo per le organizzazioni Claude Enterprise. Non è disponibile per le organizzazioni Claude Platform (Claude Console).
## Panoramica
L'API espone otto endpoint su due risorse:
| Risorsa | Endpoint | Da usare per |
| -------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Limiti di spesa** | `GET /v1/organizations/spend_limits/effective`
`GET /v1/organizations/spend_limits/{spend_limit_id}`
`POST /v1/organizations/spend_limits`
`DELETE /v1/organizations/spend_limits/{spend_limit_id}` | Leggere il limite di spesa effettivo di ciascun membro e la spesa accumulata nel periodo; impostare o rimuovere un override per utente. |
| **Richieste di aumento del limite di spesa** | `GET /v1/organizations/spend_limit_increase_requests`
`GET /v1/organizations/spend_limit_increase_requests/{id}`
`POST /v1/organizations/spend_limit_increase_requests/{id}/approve`
`POST /v1/organizations/spend_limit_increase_requests/{id}/deny` | Elencare le richieste dei membri per un limite di spesa più alto, con il contesto necessario per decidere; approvare o rifiutare ciascuna richiesta. |
Usa gli endpoint dei **limiti di spesa** per rispondere a "quale limite di spesa si applica a ciascun membro, da dove proviene e quanto ci sono vicini?" e per impostare un override per utente. Usa gli endpoint delle **richieste di aumento del limite di spesa** per gestire la coda delle richieste inviate dai membri.
## Prerequisiti
* La tua organizzazione deve avere un piano Claude Enterprise.
* I crediti di utilizzo devono essere attivati per la tua organizzazione. Il tuo proprietario principale può attivarli nelle impostazioni di fatturazione di claude.ai.
L'SDK espone questi endpoint in `client.beta.organization.spend_limits` (typescript: `client.beta.organization.spendLimits`; csharp, go: `client.Beta.Organization.SpendLimits`; java: `client.beta().organization().spendLimits()`; php: `$client->beta->organization->spendLimits`), e la CLI `ant` in `ant beta:organization:spend-limits`. Entrambi inviano l'header `anthropic-version` per te. Gli esempi leggono la chiave Admin API dalla variabile d'ambiente `ANTHROPIC_API_KEY`. L'SDK e la CLI recuperano automaticamente altre pagine man mano che scorri i risultati, quindi `limit` imposta la dimensione della pagina, non il totale (consulta [Paginazione](https://platform.claude.com/docs/it/manage-claude/spend-limits-api#pagination)).
## Avvio rapido
Elenca il limite di spesa mensile effettivo e la spesa accumulata nel periodo di ogni membro:
```bash cURL
curl "https://api.anthropic.com/v1/organizations/spend_limits/effective?limit=20" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01"
```
```bash CLI
ant beta:organization:spend-limits:effective list --limit 20
```
```python Python
client = anthropic.Anthropic()
effective_limits = client.beta.organization.spend_limits.effective.list(limit=20)
for effective_limit in effective_limits:
scope = effective_limit.scope
if scope.type == "user":
amount = effective_limit.amount or "unlimited"
print(f"{scope.user_id}: {effective_limit.period_to_date_spend} of {amount}")
```
```typescript TypeScript
const client = new Anthropic();
const effectiveLimits = await client.beta.organization.spendLimits.effective.list({
limit: 20
});
for await (const effectiveLimit of effectiveLimits) {
const { scope } = effectiveLimit;
if (scope.type === "user") {
const amount = effectiveLimit.amount ?? "unlimited";
console.log(`${scope.user_id}: ${effectiveLimit.period_to_date_spend} of ${amount}`);
}
}
```
```csharp C#
AnthropicClient client = new();
var page = await client.Beta.Organization.SpendLimits.Effective.List(
new() { Limit = 20 }
);
await foreach (var effectiveLimit in page.Paginate())
{
if (effectiveLimit.Scope.TryPickBetaSpendLimitUser(out var userScope))
{
var amount = effectiveLimit.Amount ?? "unlimited";
Console.WriteLine($"{userScope.UserID}: {effectiveLimit.PeriodToDateSpend} of {amount}");
}
}
```
```go Go
client := anthropic.NewClient()
effectiveLimits := client.Beta.Organization.SpendLimits.Effective.ListAutoPaging(context.Background(), anthropic.BetaOrganizationSpendLimitEffectiveListParams{
Limit: anthropic.Int(20),
})
for effectiveLimits.Next() {
effectiveLimit := effectiveLimits.Current()
if userScope, ok := effectiveLimit.Scope.AsAny().(anthropic.BetaSpendLimitUserScope); ok {
amount := effectiveLimit.Amount
if !effectiveLimit.JSON.Amount.Valid() {
amount = "unlimited"
}
fmt.Printf("%s: %s of %s\n", userScope.UserID, effectiveLimit.PeriodToDateSpend, amount)
}
}
if err := effectiveLimits.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
import com.anthropic.models.beta.organization.spendlimits.effective.EffectiveListParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = EffectiveListParams.builder()
.limit(20)
.build();
var effectiveLimits = client.beta().organization().spendLimits().effective().list(params);
for (var effectiveLimit : effectiveLimits.autoPager()) {
var amount = effectiveLimit.amount().orElse("unlimited");
effectiveLimit.scope().user().ifPresent(userScope ->
IO.println(userScope.userId() + ": " + effectiveLimit.periodToDateSpend() + " of " + amount)
);
}
}
```
```php PHP
use Anthropic\Beta\Organization\SpendLimits\SpendLimitUserScope;
// ...
$client = new Client();
$effectiveLimits = $client->beta->organization->spendLimits->effective->list(limit: 20);
foreach ($effectiveLimits->pagingEachItem() as $effectiveLimit) {
$scope = $effectiveLimit->scope;
if ($scope instanceof SpendLimitUserScope) {
$amount = $effectiveLimit->amount ?? 'unlimited';
echo "{$scope->userID}: {$effectiveLimit->periodToDateSpend} of {$amount}\n";
}
}
```
```ruby Ruby
client = Anthropic::Client.new
page = client.beta.organization.spend_limits.effective.list(limit: 20)
page.auto_paging_each do |effective_limit|
scope = effective_limit.scope
if scope.is_a?(Anthropic::Models::Beta::Organization::BetaSpendLimitUserScope)
amount = effective_limit.amount || "unlimited"
puts "#{scope.user_id}: #{effective_limit.period_to_date_spend} of #{amount}"
end
end
```
## Concetti chiave
### La gerarchia dei limiti di spesa
Un **limite di spesa effettivo** si applica alla spesa di ciascun membro, risolto a partire da una gerarchia di livelli di scope. Quando un membro non ha un override per utente, eredita il limite di spesa configurato per il suo gruppo (se la tua organizzazione usa limiti basati sui gruppi), il suo livello di seat o il valore predefinito a livello di organizzazione. Un limite di spesa di gruppo è un valore predefinito per membro: ogni membro che lo eredita è vincolato rispetto alla propria spesa, non a un budget di gruppo condiviso.
La lettura di `GET /v1/organizations/spend_limits/effective` restituisce ogni membro attuale con il suo limite di spesa effettivo risolto, da dove quel limite è stato risolto (`source`) e la sua spesa accumulata nel periodo. Impostare un override per utente con `POST /v1/organizations/spend_limits` vincola un membro a un limite di spesa specifico indipendentemente da ciò che altrimenti erediterebbe. Eliminare l'override lo riporta al limite di spesa ereditato (o lo lascia illimitato se non ne esiste alcuno).
Il campo `source` nella riga di ciascun membro ti indica da quale livello è stato risolto il suo limite di spesa: `user` (un override per utente), `seat_tier`, `rbac_group` o `organization`. Tratta i tipi di scope come un insieme aperto; gestisci i valori sconosciuti con un comportamento di fallback anziché fallire.
### Periodo
`period` è la finestra ricorrente su cui il limite di spesa viene applicato e la spesa si azzera. Un limite di spesa è identificato dalla sua coppia `(scope, period)`. Attualmente `monthly` è l'unico periodo supportato; la spesa mensile si azzera alle 00:00 UTC del primo giorno di ogni mese di calendario. Tratta `period` come un insieme aperto.
### Importi e valuta
Tutti i valori monetari sono stringhe in **unità minori della valuta di fatturazione dell'organizzazione** (centesimi, per USD). Ad esempio, `"50000"` rappresenta 500,00 USD. Analizza il valore come decimale e dividi per 100 per visualizzare i dollari; evita la virgola mobile binaria per valori grandi.
`amount` è **nullable**. Nella riga effettiva di un membro, `null` significa **illimitato** (nessun limite di spesa) e `"0"` significa che il membro non può usare Claude oltre l'utilizzo incluso nel suo piano. In una riga di limite di spesa configurato (come restituita da `GET /v1/organizations/spend_limits/{id}`), `null` significa solo che non è impostato alcun limite di spesa numerico; leggi la riga effettiva del membro per distinguere tra illimitato e solo utilizzo incluso.
`period_to_date_spend` è la spesa del membro accumulata dall'inizio del `period` corrente, nello stesso formato in unità minori; può includere una parte frazionaria (ad esempio, `"41280.125"`). Può risultare `"0"` se la lettura della spesa è temporaneamente non disponibile; trattalo come informativo, non transazionale.
### Ciclo di vita delle richieste di aumento
Una **richiesta di aumento del limite di spesa** viene creata quando un membro fa clic su **Request more usage** in claude.ai. Le richieste non vengono create tramite questa API. Lo `status` di una richiesta è uno tra:
| Stato | Significato |
| ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `pending` | In attesa di azione da parte di un amministratore. La richiesta normalmente include uno `spend_summary` aggiornato in tempo reale, così puoi vedere il limite di spesa effettivo corrente del membro e la spesa accumulata nel periodo mentre decidi; `spend_summary` può essere `null` se non è stato possibile calcolarlo. |
| `approved` | La richiesta è stata risolta con approvazione: un amministratore l'ha approvata esplicitamente, un'altra azione amministrativa ha aumentato il limite di spesa del membro, oppure il supporto Anthropic ha aumentato un limite di spesa per conto dell'organizzazione. `spend_summary` è `null`. |
| `denied` | Un amministratore l'ha rifiutata. `spend_summary` è `null`. Il membro può inviare subito una nuova richiesta; solo una richiesta `pending` ne blocca una nuova. Un amministratore può comunque aumentare direttamente il limite di spesa del membro in qualsiasi momento. |
Sia `approved` che `denied` sono stati terminali. Un membro ha al massimo una richiesta `pending` alla volta.
L'approvazione con `POST /v1/organizations/spend_limit_increase_requests/{id}/approve` scrive la stessa riga di limite di spesa per utente che scrive `POST /v1/organizations/spend_limits`. Impostare direttamente un limite di spesa **non** fa transitare una richiesta in sospeso; usa l'endpoint di approvazione per risolvere una richiesta.
Per impostazione predefinita, Anthropic invia un'email al membro quando la sua richiesta viene approvata o rifiutata. Passa `suppress_notification: true` nell'approvazione o nel rifiuto per sopprimere quell'email (ad esempio, quando il tuo sistema notifica il membro autonomamente).
## Controllo delle versioni
Invia l'header `anthropic-version` in ogni richiesta; consulta [Versioni dell'API](https://platform.claude.com/docs/it/api/versioning) per le versioni disponibili.
## Limitazione della velocità
Tutti gli otto endpoint condividono un unico "rate limit" (limite di velocità) per organizzazione di **60 richieste al minuto**. Le richieste oltre il limite restituiscono **429 Too Many Requests**.
## Paginazione
`GET /v1/organizations/spend_limits/effective` e `GET /v1/organizations/spend_limit_increase_requests` sono paginati con un **cursore opaco**. La prima richiesta restituisce fino a `limit` righe più un cursore `next_page`; passa quel cursore invariato come parametro `page` nella richiesta successiva e ripeti finché `next_page` non è `null`.
**Non modificare i parametri di query a metà sequenza.** I cursori sono legati ai filtri che li hanno emessi. Se modifichi `user_ids[]`, `period[]`, `status[]` o `actor_ids[]` e passi un vecchio cursore, otterrai un 400 con *"cursor does not match current query parameters"*. Avvia invece una nuova sequenza dalla prima pagina.
## Serializzazione dei parametri lista
I parametri lista usano la notazione con parentesi quadre: ripeti il nome del parametro con `[]` per ogni valore.
```text wrap
user_ids[]=user_01AbCdEfGh&user_ids[]=user_01JkLmNoPq
```
## Risposte di errore
Le risposte di errore seguono la forma standard documentata in [Errori](https://platform.claude.com/docs/it/api/errors). Cita il `request_id` dal corpo della risposta quando contatti il supporto.
## Limiti di spesa
### Elencare il limite di spesa effettivo di ciascun membro
`GET /v1/organizations/spend_limits/effective` restituisce una riga per ogni membro attuale, che riflette il limite di spesa effettivo di ciascun membro, la sua `source` nella gerarchia degli scope e il suo `period_to_date_spend`. Richiede lo scope `read:spend_limits`.
Per i dettagli completi sui parametri e gli schemi di risposta, consulta [Elencare i limiti di spesa effettivi](https://platform.claude.com/docs/it/api/beta/organization/spend_limits/effective/list) nel riferimento API.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/spend_limits/effective?limit=20" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01"
```
```bash CLI
ant beta:organization:spend-limits:effective list --limit 20
```
```python Python
client = anthropic.Anthropic()
effective_limits = client.beta.organization.spend_limits.effective.list(limit=20)
for effective_limit in effective_limits:
scope = effective_limit.scope
if scope.type == "user":
amount = effective_limit.amount or "unlimited"
print(f"{scope.user_id}: {effective_limit.period_to_date_spend} of {amount}")
```
```typescript TypeScript
const client = new Anthropic();
const effectiveLimits = await client.beta.organization.spendLimits.effective.list({
limit: 20
});
for await (const effectiveLimit of effectiveLimits) {
const { scope } = effectiveLimit;
if (scope.type === "user") {
const amount = effectiveLimit.amount ?? "unlimited";
console.log(`${scope.user_id}: ${effectiveLimit.period_to_date_spend} of ${amount}`);
}
}
```
```csharp C#
AnthropicClient client = new();
var page = await client.Beta.Organization.SpendLimits.Effective.List(
new() { Limit = 20 }
);
await foreach (var effectiveLimit in page.Paginate())
{
if (effectiveLimit.Scope.TryPickBetaSpendLimitUser(out var userScope))
{
var amount = effectiveLimit.Amount ?? "unlimited";
Console.WriteLine($"{userScope.UserID}: {effectiveLimit.PeriodToDateSpend} of {amount}");
}
}
```
```go Go
client := anthropic.NewClient()
effectiveLimits := client.Beta.Organization.SpendLimits.Effective.ListAutoPaging(context.Background(), anthropic.BetaOrganizationSpendLimitEffectiveListParams{
Limit: anthropic.Int(20),
})
for effectiveLimits.Next() {
effectiveLimit := effectiveLimits.Current()
if userScope, ok := effectiveLimit.Scope.AsAny().(anthropic.BetaSpendLimitUserScope); ok {
amount := effectiveLimit.Amount
if !effectiveLimit.JSON.Amount.Valid() {
amount = "unlimited"
}
fmt.Printf("%s: %s of %s\n", userScope.UserID, effectiveLimit.PeriodToDateSpend, amount)
}
}
if err := effectiveLimits.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
import com.anthropic.models.beta.organization.spendlimits.effective.EffectiveListParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = EffectiveListParams.builder()
.limit(20)
.build();
var effectiveLimits = client.beta().organization().spendLimits().effective().list(params);
for (var effectiveLimit : effectiveLimits.autoPager()) {
var amount = effectiveLimit.amount().orElse("unlimited");
effectiveLimit.scope().user().ifPresent(userScope ->
IO.println(userScope.userId() + ": " + effectiveLimit.periodToDateSpend() + " of " + amount)
);
}
}
```
```php PHP
use Anthropic\Beta\Organization\SpendLimits\SpendLimitUserScope;
// ...
$client = new Client();
$effectiveLimits = $client->beta->organization->spendLimits->effective->list(limit: 20);
foreach ($effectiveLimits->pagingEachItem() as $effectiveLimit) {
$scope = $effectiveLimit->scope;
if ($scope instanceof SpendLimitUserScope) {
$amount = $effectiveLimit->amount ?? 'unlimited';
echo "{$scope->userID}: {$effectiveLimit->periodToDateSpend} of {$amount}\n";
}
}
```
```ruby Ruby
client = Anthropic::Client.new
page = client.beta.organization.spend_limits.effective.list(limit: 20)
page.auto_paging_each do |effective_limit|
scope = effective_limit.scope
if scope.is_a?(Anthropic::Models::Beta::Organization::BetaSpendLimitUserScope)
amount = effective_limit.amount || "unlimited"
puts "#{scope.user_id}: #{effective_limit.period_to_date_spend} of #{amount}"
end
end
```
```json
{
"data": [
{
"scope": { "type": "user", "user_id": "user_01AbCdEfGh" },
"actor": {
"type": "user_actor",
"user_id": "user_01AbCdEfGh",
"name": "Jane Smith",
"email_address": "jane@example.com",
"deleted": false
},
"amount": "50000",
"currency": "USD",
"period": "monthly",
"source": { "type": "seat_tier", "seat_tier": "enterprise_standard" },
"spend_limit_id": "spl_01XyZaBcDeFgHiJkLmNoPq",
"period_to_date_spend": "31402.5"
}
],
"next_page": "page_..."
}
```
### Ottenere un singolo limite di spesa
`GET /v1/organizations/spend_limits/{spend_limit_id}` restituisce un limite di spesa configurato tramite ID. Usalo per ispezionare la riga a cui faceva riferimento un campo `spend_limit_id`. Richiede lo scope `read:spend_limits`.
Per i dettagli completi dei parametri e gli schemi di risposta, consulta [Recuperare un limite di spesa](https://platform.claude.com/docs/it/api/beta/organization/spend_limits/retrieve) nel riferimento API.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/spend_limits/spl_01AbCdEfGhIjKlMnOpQrSt" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01"
```
```bash CLI
ant beta:organization:spend-limits retrieve \
--spend-limit-id spl_01AbCdEfGhIjKlMnOpQrSt
```
```python Python
client = anthropic.Anthropic()
spend_limit = client.beta.organization.spend_limits.retrieve(
"spl_01AbCdEfGhIjKlMnOpQrSt"
)
amount = spend_limit.amount or "none"
print(f"id: {spend_limit.id}")
print(f"amount: {amount}")
```
```typescript TypeScript
const client = new Anthropic();
const spendLimit = await client.beta.organization.spendLimits.retrieve(
"spl_01AbCdEfGhIjKlMnOpQrSt"
);
const amount = spendLimit.amount ?? "none";
console.log(`id: ${spendLimit.id}`);
console.log(`amount: ${amount}`);
```
```csharp C#
AnthropicClient client = new();
var spendLimit = await client.Beta.Organization.SpendLimits.Retrieve(
"spl_01AbCdEfGhIjKlMnOpQrSt"
);
var amount = spendLimit.Amount ?? "none";
Console.WriteLine($"id: {spendLimit.ID}");
Console.WriteLine($"amount: {amount}");
```
```go Go
client := anthropic.NewClient()
spendLimit, err := client.Beta.Organization.SpendLimits.Get(context.Background(), "spl_01AbCdEfGhIjKlMnOpQrSt")
if err != nil {
log.Fatal(err)
}
amount := spendLimit.Amount
if !spendLimit.JSON.Amount.Valid() {
amount = "none"
}
fmt.Printf("id: %s\n", spendLimit.ID)
fmt.Printf("amount: %s\n", amount)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var spendLimit = client.beta().organization().spendLimits()
.retrieve("spl_01AbCdEfGhIjKlMnOpQrSt");
var amount = spendLimit.amount().orElse("none");
IO.println("id: " + spendLimit.id());
IO.println("amount: " + amount);
```
```php PHP
$client = new Client();
$spendLimit = $client->beta->organization->spendLimits->retrieve('spl_01AbCdEfGhIjKlMnOpQrSt');
$amount = $spendLimit->amount ?? 'none';
echo "id: {$spendLimit->id}\n";
echo "amount: {$amount}\n";
```
```ruby Ruby
client = Anthropic::Client.new
spend_limit = client.beta.organization.spend_limits.retrieve("spl_01AbCdEfGhIjKlMnOpQrSt")
amount = spend_limit.amount || "none"
puts "id: #{spend_limit.id}"
puts "amount: #{amount}"
```
### Impostare un override per utente
`POST /v1/organizations/spend_limits` imposta un override del limite di spesa per utente. Si tratta di un upsert con chiave `(scope, period)`: impostare un limite per un utente e un periodo che ne ha già uno lo sovrascrive sul posto. Questo endpoint accetta solo `scope.type: "user"`; i valori predefiniti a livello di seat, gruppo e organizzazione si configurano nelle impostazioni di claude.ai. Richiede lo scope `write:spend_limits`.
Per i dettagli completi sui parametri e gli schemi di risposta, consulta [Creare un limite di spesa](https://platform.claude.com/docs/it/api/beta/organization/spend_limits/set) nel riferimento API.
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/spend_limits" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-d '{"scope": {"type": "user", "user_id": "user_01AbCdEfGh"}, "amount": "75000"}'
```
```bash CLI
ant beta:organization:spend-limits set \
--scope '{type: user, user_id: user_01AbCdEfGh}' \
--amount 75000
```
```python Python
client = anthropic.Anthropic()
spend_limit = client.beta.organization.spend_limits.set(
scope={"type": "user", "user_id": "user_01AbCdEfGh"}, amount="75000"
)
print(f"id: {spend_limit.id}")
print(f"amount: {spend_limit.amount}")
```
```typescript TypeScript
const client = new Anthropic();
const spendLimit = await client.beta.organization.spendLimits.set({
scope: { type: "user", user_id: "user_01AbCdEfGh" },
amount: "75000"
});
console.log(`id: ${spendLimit.id}`);
console.log(`amount: ${spendLimit.amount}`);
```
```csharp C#
using Anthropic.Models.Beta.Organization.SpendLimits;
AnthropicClient client = new();
var spendLimit = await client.Beta.Organization.SpendLimits.Set(
new()
{
Scope = new BetaSpendLimitUserScope("user_01AbCdEfGh"),
Amount = "75000",
}
);
Console.WriteLine($"id: {spendLimit.ID}");
Console.WriteLine($"amount: {spendLimit.Amount}");
```
```go Go
client := anthropic.NewClient()
spendLimit, err := client.Beta.Organization.SpendLimits.Set(context.Background(), anthropic.BetaOrganizationSpendLimitSetParams{
Scope: anthropic.BetaOrganizationSpendLimitSetParamsScopeUnion{
OfUser: &anthropic.BetaSpendLimitUserScopeParam{UserID: "user_01AbCdEfGh"},
},
Amount: anthropic.String("75000"),
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("id: %s\n", spendLimit.ID)
fmt.Printf("amount: %s\n", spendLimit.Amount)
```
```java Java
import com.anthropic.models.beta.organization.spendlimits.SpendLimitSetParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SpendLimitSetParams.builder()
.userScope("user_01AbCdEfGh")
.amount("75000")
.build();
var spendLimit = client.beta().organization().spendLimits().set(params);
IO.println("id: " + spendLimit.id());
IO.println("amount: " + spendLimit.amount().orElseThrow());
}
```
```php PHP
use Anthropic\Beta\Organization\SpendLimits\SpendLimitUserScope;
// ...
$client = new Client();
$spendLimit = $client->beta->organization->spendLimits->set(
scope: SpendLimitUserScope::with(userID: 'user_01AbCdEfGh'),
amount: '75000',
);
echo "id: {$spendLimit->id}\n";
echo "amount: {$spendLimit->amount}\n";
```
```ruby Ruby
client = Anthropic::Client.new
spend_limit = client.beta.organization.spend_limits.set(
scope: { type: :user, user_id: "user_01AbCdEfGh" },
amount: "75000"
)
puts "id: #{spend_limit.id}"
puts "amount: #{spend_limit.amount}"
```
```json
{
"type": "spend_limit",
"id": "spl_01RsTuVwXyZaBcDeFgHiJk",
"created_at": "2026-05-11T10:02:44Z",
"updated_at": "2026-05-11T10:02:44Z",
"scope": { "type": "user", "user_id": "user_01AbCdEfGh" },
"amount": "75000",
"currency": "USD",
"period": "monthly"
}
```
### Rimuovere un override per utente
`DELETE /v1/organizations/spend_limits/{spend_limit_id}` rimuove un override per utente, dopodiché il membro torna a qualsiasi valore predefinito ereditato a livello di seat, gruppo o organizzazione. Le righe a livello di seat, gruppo e organizzazione non possono essere eliminate tramite questo endpoint. Richiede lo scope `write:spend_limits`.
Per i dettagli completi dei parametri e gli schemi di risposta, consulta [Eliminare un limite di spesa](https://platform.claude.com/docs/it/api/beta/organization/spend_limits/delete) nel riferimento API.
```bash cURL
curl -X DELETE "https://api.anthropic.com/v1/organizations/spend_limits/spl_01RsTuVwXyZaBcDeFgHiJk" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01"
```
```bash CLI
ant beta:organization:spend-limits delete \
--spend-limit-id spl_01RsTuVwXyZaBcDeFgHiJk
```
```python Python
client = anthropic.Anthropic()
deleted_spend_limit = client.beta.organization.spend_limits.delete(
"spl_01RsTuVwXyZaBcDeFgHiJk"
)
print(f"id: {deleted_spend_limit.id}")
```
```typescript TypeScript
const client = new Anthropic();
const deletedSpendLimit = await client.beta.organization.spendLimits.delete(
"spl_01RsTuVwXyZaBcDeFgHiJk"
);
console.log(`id: ${deletedSpendLimit.id}`);
```
```csharp C#
AnthropicClient client = new();
var deletedSpendLimit = await client.Beta.Organization.SpendLimits.Delete(
"spl_01RsTuVwXyZaBcDeFgHiJk"
);
Console.WriteLine($"id: {deletedSpendLimit.ID}");
```
```go Go
client := anthropic.NewClient()
deletedSpendLimit, err := client.Beta.Organization.SpendLimits.Delete(context.Background(), "spl_01RsTuVwXyZaBcDeFgHiJk")
if err != nil {
log.Fatal(err)
}
fmt.Printf("id: %s\n", deletedSpendLimit.ID)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var deletedSpendLimit = client.beta().organization().spendLimits()
.delete("spl_01RsTuVwXyZaBcDeFgHiJk");
IO.println("id: " + deletedSpendLimit.id());
```
```php PHP
$client = new Client();
$deletedSpendLimit = $client->beta->organization->spendLimits->delete('spl_01RsTuVwXyZaBcDeFgHiJk');
echo "id: {$deletedSpendLimit->id}\n";
```
```ruby Ruby
client = Anthropic::Client.new
deleted_spend_limit = client.beta.organization.spend_limits.delete("spl_01RsTuVwXyZaBcDeFgHiJk")
puts "id: #{deleted_spend_limit.id}"
```
## Richieste di aumento del limite di spesa
### Elencare le richieste di aumento
`GET /v1/organizations/spend_limit_increase_requests` elenca le richieste, dalla più recente. Filtra per `status[]` (`pending`, `approved`, `denied`) e `actor_ids[]`. L'elenco esclude le richieste il cui richiedente non è più membro dell'organizzazione. Richiede lo scope `read:spend_limits`.
Per i dettagli completi dei parametri e gli schemi di risposta, consulta [Elencare le richieste di aumento del limite di spesa](https://platform.claude.com/docs/it/api/beta/organization/spend_limits/increase_requests/list) nel riferimento API.
```bash cURL
curl -g "https://api.anthropic.com/v1/organizations/spend_limit_increase_requests?status[]=pending&limit=50" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01"
```
```bash CLI
ant beta:organization:spend-limits:increase-requests list \
--status pending \
--limit 50
```
```python Python
client = anthropic.Anthropic()
increase_requests = client.beta.organization.spend_limits.increase_requests.list(
status=["pending"], limit=50
)
for increase_request in increase_requests:
print(f"{increase_request.id}: {increase_request.status}")
```
```typescript TypeScript
const client = new Anthropic();
const increaseRequests = await client.beta.organization.spendLimits.increaseRequests.list({
status: ["pending"],
limit: 50
});
for await (const increaseRequest of increaseRequests) {
console.log(`${increaseRequest.id}: ${increaseRequest.status}`);
}
```
```csharp C#
using Anthropic.Models.Beta.Organization.SpendLimits.IncreaseRequests;
AnthropicClient client = new();
var page = await client.Beta.Organization.SpendLimits.IncreaseRequests.List(
new() { Status = [BetaSpendLimitIncreaseRequestStatus.Pending], Limit = 50 }
);
await foreach (var increaseRequest in page.Paginate())
{
Console.WriteLine($"{increaseRequest.ID}: {increaseRequest.Status.Raw()}");
}
```
```go Go
client := anthropic.NewClient()
increaseRequests := client.Beta.Organization.SpendLimits.IncreaseRequests.ListAutoPaging(context.Background(), anthropic.BetaOrganizationSpendLimitIncreaseRequestListParams{
Status: []anthropic.BetaSpendLimitIncreaseRequestStatus{anthropic.BetaSpendLimitIncreaseRequestStatusPending},
Limit: anthropic.Int(50),
})
for increaseRequests.Next() {
increaseRequest := increaseRequests.Current()
fmt.Printf("%s: %s\n", increaseRequest.ID, increaseRequest.Status)
}
if err := increaseRequests.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
import com.anthropic.models.beta.organization.spendlimits.increaserequests.BetaSpendLimitIncreaseRequestStatus;
import com.anthropic.models.beta.organization.spendlimits.increaserequests.IncreaseRequestListParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = IncreaseRequestListParams.builder()
.addStatus(BetaSpendLimitIncreaseRequestStatus.PENDING)
.limit(50)
.build();
var increaseRequests = client.beta().organization().spendLimits().increaseRequests().list(params);
for (var increaseRequest : increaseRequests.autoPager()) {
IO.println(increaseRequest.id() + ": " + increaseRequest.status().asString());
}
}
```
```php PHP
$client = new Client();
$increaseRequests = $client->beta->organization->spendLimits->increaseRequests->list(
status: ['pending'],
limit: 50,
);
foreach ($increaseRequests->pagingEachItem() as $increaseRequest) {
echo "{$increaseRequest->id}: {$increaseRequest->status}\n";
}
```
```ruby Ruby
client = Anthropic::Client.new
page = client.beta.organization.spend_limits.increase_requests.list(status: [:pending], limit: 50)
page.auto_paging_each do |increase_request|
puts "#{increase_request.id}: #{increase_request.status}"
end
```
Ogni richiesta in sospeso include uno `spend_summary` aggiornato in tempo reale che mostra il limite di spesa effettivo corrente del richiedente e la spesa accumulata nel periodo, sufficiente per decidere senza una ricerca separata.
### Ottenere una singola richiesta di aumento
`GET /v1/organizations/spend_limit_increase_requests/{id}` restituisce una richiesta tramite ID. Richiede lo scope `read:spend_limits`.
Per i dettagli completi dei parametri e gli schemi di risposta, consulta [Recuperare una richiesta di aumento del limite di spesa](https://platform.claude.com/docs/it/api/beta/organization/spend_limits/increase_requests/retrieve) nel riferimento API.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/spend_limit_increase_requests/slir_01AbCdEfGhIjKlMnOpQrSt" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01"
```
```bash CLI
ant beta:organization:spend-limits:increase-requests retrieve \
--spend-limit-increase-request-id slir_01AbCdEfGhIjKlMnOpQrSt
```
```python Python
client = anthropic.Anthropic()
increase_request = client.beta.organization.spend_limits.increase_requests.retrieve(
"slir_01AbCdEfGhIjKlMnOpQrSt"
)
print(f"id: {increase_request.id}")
print(f"status: {increase_request.status}")
```
```typescript TypeScript
const client = new Anthropic();
const increaseRequest = await client.beta.organization.spendLimits.increaseRequests.retrieve(
"slir_01AbCdEfGhIjKlMnOpQrSt"
);
console.log(`id: ${increaseRequest.id}`);
console.log(`status: ${increaseRequest.status}`);
```
```csharp C#
AnthropicClient client = new();
var increaseRequest = await client.Beta.Organization.SpendLimits.IncreaseRequests.Retrieve(
"slir_01AbCdEfGhIjKlMnOpQrSt"
);
Console.WriteLine($"id: {increaseRequest.ID}");
Console.WriteLine($"status: {increaseRequest.Status.Raw()}");
```
```go Go
client := anthropic.NewClient()
increaseRequest, err := client.Beta.Organization.SpendLimits.IncreaseRequests.Get(context.Background(), "slir_01AbCdEfGhIjKlMnOpQrSt")
if err != nil {
log.Fatal(err)
}
fmt.Printf("id: %s\n", increaseRequest.ID)
fmt.Printf("status: %s\n", increaseRequest.Status)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var increaseRequest = client.beta().organization().spendLimits().increaseRequests()
.retrieve("slir_01AbCdEfGhIjKlMnOpQrSt");
IO.println("id: " + increaseRequest.id());
IO.println("status: " + increaseRequest.status().asString());
```
```php PHP
$client = new Client();
$increaseRequest = $client->beta->organization->spendLimits->increaseRequests->retrieve(
'slir_01AbCdEfGhIjKlMnOpQrSt',
);
echo "id: {$increaseRequest->id}\n";
echo "status: {$increaseRequest->status}\n";
```
```ruby Ruby
client = Anthropic::Client.new
increase_request = client.beta.organization.spend_limits.increase_requests.retrieve(
"slir_01AbCdEfGhIjKlMnOpQrSt"
)
puts "id: #{increase_request.id}"
puts "status: #{increase_request.status}"
```
### Approvare una richiesta di aumento
`POST /v1/organizations/spend_limit_increase_requests/{id}/approve` approva una richiesta in sospeso: scrive un limite di spesa per utente all'`amount` fornito dall'amministratore per il richiedente e fa transitare la richiesta a `approved`. La richiesta non include un importo richiesto; fornisci tu il nuovo limite di spesa al momento dell'approvazione. Richiede lo scope `write:spend_limits`.
Per i dettagli completi dei parametri e gli schemi di risposta, consulta [Approvare una richiesta di aumento del limite di spesa](https://platform.claude.com/docs/it/api/beta/organization/spend_limits/increase_requests/approve) nel riferimento API.
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/spend_limit_increase_requests/slir_01AbCdEfGhIjKlMnOpQrSt/approve" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-d '{"amount": "75000", "suppress_notification": true}'
```
```bash CLI
ant beta:organization:spend-limits:increase-requests approve \
--spend-limit-increase-request-id slir_01AbCdEfGhIjKlMnOpQrSt \
--amount 75000 \
--suppress-notification
```
```python Python
client = anthropic.Anthropic()
increase_request = client.beta.organization.spend_limits.increase_requests.approve(
"slir_01AbCdEfGhIjKlMnOpQrSt", amount="75000", suppress_notification=True
)
print(f"id: {increase_request.id}")
print(f"status: {increase_request.status}")
```
```typescript TypeScript
const client = new Anthropic();
const increaseRequest = await client.beta.organization.spendLimits.increaseRequests.approve(
"slir_01AbCdEfGhIjKlMnOpQrSt",
{
amount: "75000",
suppress_notification: true
}
);
console.log(`id: ${increaseRequest.id}`);
console.log(`status: ${increaseRequest.status}`);
```
```csharp C#
AnthropicClient client = new();
var increaseRequest = await client.Beta.Organization.SpendLimits.IncreaseRequests.Approve(
"slir_01AbCdEfGhIjKlMnOpQrSt",
new() { Amount = "75000", SuppressNotification = true }
);
Console.WriteLine($"id: {increaseRequest.ID}");
Console.WriteLine($"status: {increaseRequest.Status.Raw()}");
```
```go Go
client := anthropic.NewClient()
increaseRequest, err := client.Beta.Organization.SpendLimits.IncreaseRequests.Approve(
context.Background(),
"slir_01AbCdEfGhIjKlMnOpQrSt",
anthropic.BetaOrganizationSpendLimitIncreaseRequestApproveParams{
Amount: "75000",
SuppressNotification: anthropic.Bool(true),
},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("id: %s\n", increaseRequest.ID)
fmt.Printf("status: %s\n", increaseRequest.Status)
```
```java Java
import com.anthropic.models.beta.organization.spendlimits.increaserequests.IncreaseRequestApproveParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = IncreaseRequestApproveParams.builder()
.amount("75000")
.suppressNotification(true)
.build();
var increaseRequest = client.beta().organization().spendLimits().increaseRequests()
.approve("slir_01AbCdEfGhIjKlMnOpQrSt", params);
IO.println("id: " + increaseRequest.id());
IO.println("status: " + increaseRequest.status().asString());
}
```
```php PHP
$client = new Client();
$increaseRequest = $client->beta->organization->spendLimits->increaseRequests->approve(
'slir_01AbCdEfGhIjKlMnOpQrSt',
amount: '75000',
suppressNotification: true,
);
echo "id: {$increaseRequest->id}\n";
echo "status: {$increaseRequest->status}\n";
```
```ruby Ruby
client = Anthropic::Client.new
increase_request = client.beta.organization.spend_limits.increase_requests.approve(
"slir_01AbCdEfGhIjKlMnOpQrSt",
amount: "75000",
suppress_notification: true
)
puts "id: #{increase_request.id}"
puts "status: #{increase_request.status}"
```
### Rifiutare una richiesta di aumento
`POST /v1/organizations/spend_limit_increase_requests/{id}/deny` rifiuta una richiesta in sospeso. Idempotente su `denied`: rifiutare una richiesta già rifiutata restituisce 200 con la risorsa esistente. L'endpoint respinge un tentativo di rifiutare una richiesta già approvata, in modo che l'automazione possa distinguere un nuovo tentativo da una decisione in conflitto. Richiede lo scope `write:spend_limits`.
Per i dettagli completi dei parametri e gli schemi di risposta, consulta [Rifiutare una richiesta di aumento del limite di spesa](https://platform.claude.com/docs/it/api/beta/organization/spend_limits/increase_requests/deny) nel riferimento API.
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/spend_limit_increase_requests/slir_01AbCdEfGhIjKlMnOpQrSt/deny" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-d '{"suppress_notification": true}'
```
```bash CLI
ant beta:organization:spend-limits:increase-requests deny \
--spend-limit-increase-request-id slir_01AbCdEfGhIjKlMnOpQrSt \
--suppress-notification
```
```python Python
client = anthropic.Anthropic()
increase_request = client.beta.organization.spend_limits.increase_requests.deny(
"slir_01AbCdEfGhIjKlMnOpQrSt", suppress_notification=True
)
print(f"id: {increase_request.id}")
print(f"status: {increase_request.status}")
```
```typescript TypeScript
const client = new Anthropic();
const increaseRequest = await client.beta.organization.spendLimits.increaseRequests.deny(
"slir_01AbCdEfGhIjKlMnOpQrSt",
{
suppress_notification: true
}
);
console.log(`id: ${increaseRequest.id}`);
console.log(`status: ${increaseRequest.status}`);
```
```csharp C#
AnthropicClient client = new();
var increaseRequest = await client.Beta.Organization.SpendLimits.IncreaseRequests.Deny(
"slir_01AbCdEfGhIjKlMnOpQrSt",
new() { SuppressNotification = true }
);
Console.WriteLine($"id: {increaseRequest.ID}");
Console.WriteLine($"status: {increaseRequest.Status.Raw()}");
```
```go Go
client := anthropic.NewClient()
increaseRequest, err := client.Beta.Organization.SpendLimits.IncreaseRequests.Deny(
context.Background(),
"slir_01AbCdEfGhIjKlMnOpQrSt",
anthropic.BetaOrganizationSpendLimitIncreaseRequestDenyParams{
SuppressNotification: anthropic.Bool(true),
},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("id: %s\n", increaseRequest.ID)
fmt.Printf("status: %s\n", increaseRequest.Status)
```
```java Java
import com.anthropic.models.beta.organization.spendlimits.increaserequests.IncreaseRequestDenyParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = IncreaseRequestDenyParams.builder()
.suppressNotification(true)
.build();
var increaseRequest = client.beta().organization().spendLimits().increaseRequests()
.deny("slir_01AbCdEfGhIjKlMnOpQrSt", params);
IO.println("id: " + increaseRequest.id());
IO.println("status: " + increaseRequest.status().asString());
}
```
```php PHP
$client = new Client();
$increaseRequest = $client->beta->organization->spendLimits->increaseRequests->deny(
'slir_01AbCdEfGhIjKlMnOpQrSt',
suppressNotification: true,
);
echo "id: {$increaseRequest->id}\n";
echo "status: {$increaseRequest->status}\n";
```
```ruby Ruby
client = Anthropic::Client.new
increase_request = client.beta.organization.spend_limits.increase_requests.deny(
"slir_01AbCdEfGhIjKlMnOpQrSt",
suppress_notification: true
)
puts "id: #{increase_request.id}"
puts "status: #{increase_request.status}"
```
## Flussi di lavoro di esempio
Alcuni di questi flussi di lavoro combinano l'API Spend Limits con gli endpoint di costo delle [API Analytics](https://platform.claude.com/docs/it/manage-claude/analytics-api). Gli endpoint di costo di Analytics sono progettati per il reporting della spesa a livello di organizzazione su un intervallo di date. `GET /spend_limits/effective` restituisce il tetto che si applica attualmente a ciascun membro. Avvia una scansione con Analytics per scoprire quali membri esaminare, quindi leggi i loro tetti attuali con `/effective`.
Gli endpoint di Spend Limits richiedono gli scope `spend_limits` e gli endpoint di costo di Analytics richiedono `read:analytics`; consulta le [API Analytics](https://platform.claude.com/docs/it/manage-claude/analytics-api) per sapere come concedere l'accesso. Gli esempi usano un'unica chiave Admin API che dispone degli scope di tutte le API che chiamano. Un proprietario principale [seleziona questi scope durante la creazione della chiave](https://platform.claude.com/docs/it/manage-claude/admin-api-keys#choose-scopes-for-a-claude-enterprise-key). Tutti i valori monetari in entrambe sono stringhe decimali in unità minori (centesimi). Entrambe le API paginano con un cursore opaco. Imposta un `limit` esplicito e scorri le pagine tramite `next_page` finché non è `null` per coprire l'intera organizzazione.
### Automatizzare il flusso di revisione delle richieste di aumento
Esegui un job pianificato che recupera le richieste in sospeso, applica la policy di approvazione della tua organizzazione e risolve ciascuna di esse.
1. Elenca le richieste in sospeso:
```bash cURL
curl -g "https://api.anthropic.com/v1/organizations/spend_limit_increase_requests?status[]=pending&limit=100" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01"
```
```bash CLI
ant beta:organization:spend-limits:increase-requests list \
--status pending \
--limit 100
```
```python Python
client = anthropic.Anthropic()
increase_requests = client.beta.organization.spend_limits.increase_requests.list(
status=["pending"], limit=100
)
for increase_request in increase_requests:
print(f"{increase_request.id}: {increase_request.status}")
```
```typescript TypeScript
const client = new Anthropic();
const increaseRequests = await client.beta.organization.spendLimits.increaseRequests.list({
status: ["pending"],
limit: 100
});
for await (const increaseRequest of increaseRequests) {
console.log(`${increaseRequest.id}: ${increaseRequest.status}`);
}
```
```csharp C#
using Anthropic.Models.Beta.Organization.SpendLimits.IncreaseRequests;
AnthropicClient client = new();
var page = await client.Beta.Organization.SpendLimits.IncreaseRequests.List(
new() { Status = [BetaSpendLimitIncreaseRequestStatus.Pending], Limit = 100 }
);
await foreach (var increaseRequest in page.Paginate())
{
Console.WriteLine($"{increaseRequest.ID}: {increaseRequest.Status.Raw()}");
}
```
```go Go
client := anthropic.NewClient()
increaseRequests := client.Beta.Organization.SpendLimits.IncreaseRequests.ListAutoPaging(context.Background(), anthropic.BetaOrganizationSpendLimitIncreaseRequestListParams{
Status: []anthropic.BetaSpendLimitIncreaseRequestStatus{anthropic.BetaSpendLimitIncreaseRequestStatusPending},
Limit: anthropic.Int(100),
})
for increaseRequests.Next() {
increaseRequest := increaseRequests.Current()
fmt.Printf("%s: %s\n", increaseRequest.ID, increaseRequest.Status)
}
if err := increaseRequests.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
import com.anthropic.models.beta.organization.spendlimits.increaserequests.BetaSpendLimitIncreaseRequestStatus;
import com.anthropic.models.beta.organization.spendlimits.increaserequests.IncreaseRequestListParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = IncreaseRequestListParams.builder()
.addStatus(BetaSpendLimitIncreaseRequestStatus.PENDING)
.limit(100)
.build();
var increaseRequests = client.beta().organization().spendLimits().increaseRequests().list(params);
for (var increaseRequest : increaseRequests.autoPager()) {
IO.println(increaseRequest.id() + ": " + increaseRequest.status().asString());
}
}
```
```php PHP
$client = new Client();
$increaseRequests = $client->beta->organization->spendLimits->increaseRequests->list(
status: ['pending'],
limit: 100,
);
foreach ($increaseRequests->pagingEachItem() as $increaseRequest) {
echo "{$increaseRequest->id}: {$increaseRequest->status}\n";
}
```
```ruby Ruby
client = Anthropic::Client.new
page = client.beta.organization.spend_limits.increase_requests.list(status: [:pending], limit: 100)
page.auto_paging_each do |increase_request|
puts "#{increase_request.id}: #{increase_request.status}"
end
```
Ogni richiesta include l'`actor.user_id` del richiedente e uno `spend_summary` aggiornato in tempo reale con il suo `amount` effettivo corrente e `period_to_date_spend`, sufficiente per decidere senza una ricerca separata.
2. Applica la tua policy. Ad esempio, approva automaticamente quando l'`amount` corrente del membro è al di sotto di una soglia e indirizza i tetti più alti alla revisione manuale.
3. Risolvi ciascuna richiesta. Per approvare, fornisci il nuovo tetto:
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/spend_limit_increase_requests/slir_01AbCdEfGhIjKlMnOpQrSt/approve" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-d '{"amount": "75000", "suppress_notification": true}'
```
```bash CLI
ant beta:organization:spend-limits:increase-requests approve \
--spend-limit-increase-request-id slir_01AbCdEfGhIjKlMnOpQrSt \
--amount 75000 \
--suppress-notification
```
```python Python
client = anthropic.Anthropic()
increase_request = client.beta.organization.spend_limits.increase_requests.approve(
"slir_01AbCdEfGhIjKlMnOpQrSt", amount="75000", suppress_notification=True
)
print(f"id: {increase_request.id}")
print(f"status: {increase_request.status}")
```
```typescript TypeScript
const client = new Anthropic();
const increaseRequest = await client.beta.organization.spendLimits.increaseRequests.approve(
"slir_01AbCdEfGhIjKlMnOpQrSt",
{
amount: "75000",
suppress_notification: true
}
);
console.log(`id: ${increaseRequest.id}`);
console.log(`status: ${increaseRequest.status}`);
```
```csharp C#
AnthropicClient client = new();
var increaseRequest = await client.Beta.Organization.SpendLimits.IncreaseRequests.Approve(
"slir_01AbCdEfGhIjKlMnOpQrSt",
new() { Amount = "75000", SuppressNotification = true }
);
Console.WriteLine($"id: {increaseRequest.ID}");
Console.WriteLine($"status: {increaseRequest.Status.Raw()}");
```
```go Go
client := anthropic.NewClient()
increaseRequest, err := client.Beta.Organization.SpendLimits.IncreaseRequests.Approve(
context.Background(),
"slir_01AbCdEfGhIjKlMnOpQrSt",
anthropic.BetaOrganizationSpendLimitIncreaseRequestApproveParams{
Amount: "75000",
SuppressNotification: anthropic.Bool(true),
},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("id: %s\n", increaseRequest.ID)
fmt.Printf("status: %s\n", increaseRequest.Status)
```
```java Java
import com.anthropic.models.beta.organization.spendlimits.increaserequests.IncreaseRequestApproveParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = IncreaseRequestApproveParams.builder()
.amount("75000")
.suppressNotification(true)
.build();
var increaseRequest = client.beta().organization().spendLimits().increaseRequests()
.approve("slir_01AbCdEfGhIjKlMnOpQrSt", params);
IO.println("id: " + increaseRequest.id());
IO.println("status: " + increaseRequest.status().asString());
}
```
```php PHP
$client = new Client();
$increaseRequest = $client->beta->organization->spendLimits->increaseRequests->approve(
'slir_01AbCdEfGhIjKlMnOpQrSt',
amount: '75000',
suppressNotification: true,
);
echo "id: {$increaseRequest->id}\n";
echo "status: {$increaseRequest->status}\n";
```
```ruby Ruby
client = Anthropic::Client.new
increase_request = client.beta.organization.spend_limits.increase_requests.approve(
"slir_01AbCdEfGhIjKlMnOpQrSt",
amount: "75000",
suppress_notification: true
)
puts "id: #{increase_request.id}"
puts "status: #{increase_request.status}"
```
Per rifiutare, chiama invece l'[endpoint di rifiuto](https://platform.claude.com/docs/it/manage-claude/spend-limits-api#deny-an-increase-request) con lo stesso ID. Passa `suppress_notification: true` quando è il tuo sistema a notificare il richiedente.
### Identificare i membri vicini al loro limite di spesa
Trova i membri che si avvicinano al loro tetto in modo da poterlo aumentare prima che vengano bloccati.
1. Recupera la spesa del mese in corso di ciascun membro dall'API Analytics (una riga per membro, per impostazione predefinita dalla spesa più alta):
```bash cURL
curl "https://api.anthropic.com/v1/organizations/analytics/user_cost_report?starting_at=2026-06-01T00:00:00Z&limit=1000" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01"
```
```bash CLI
ant beta:organization:analytics:user-cost-report list \
--starting-at 2026-06-01T00:00:00Z \
--limit 1000
```
```python Python
client = anthropic.Anthropic()
cost_rows = client.beta.organization.analytics.user_cost_report.list(
starting_at="2026-06-01T00:00:00Z", limit=1000
)
for cost_row in cost_rows:
print(f"{cost_row.actor.user_id}: {cost_row.amount}")
```
```typescript TypeScript
const client = new Anthropic();
const costRows = await client.beta.organization.analytics.userCostReport.list({
starting_at: "2026-06-01T00:00:00Z",
limit: 1000
});
for await (const costRow of costRows) {
console.log(`${costRow.actor.user_id}: ${costRow.amount}`);
}
```
```csharp C#
AnthropicClient client = new();
var page = await client.Beta.Organization.Analytics.UserCostReport.List(
new()
{
StartingAt = DateTimeOffset.Parse("2026-06-01T00:00:00Z"),
Limit = 1000,
}
);
await foreach (var costRow in page.Paginate())
{
Console.WriteLine($"{costRow.Actor.UserID}: {costRow.Amount}");
}
```
```go Go
client := anthropic.NewClient()
costRows := client.Beta.Organization.Analytics.UserCostReport.ListAutoPaging(context.Background(), anthropic.BetaOrganizationAnalyticsUserCostReportListParams{
StartingAt: time.Date(2026, time.June, 1, 0, 0, 0, 0, time.UTC),
Limit: anthropic.Int(1000),
})
for costRows.Next() {
costRow := costRows.Current()
fmt.Printf("%s: %s\n", costRow.Actor.UserID, costRow.Amount)
}
if err := costRows.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
import com.anthropic.models.beta.organization.analytics.usercostreport.UserCostReportListParams;
import java.time.OffsetDateTime;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = UserCostReportListParams.builder()
.startingAt(OffsetDateTime.parse("2026-06-01T00:00:00Z"))
.limit(1000)
.build();
var costRows = client.beta().organization().analytics().userCostReport().list(params);
for (var costRow : costRows.autoPager()) {
IO.println(costRow.actor().userId() + ": " + costRow.amount());
}
}
```
```php PHP
$client = new Client();
$costRows = $client->beta->organization->analytics->userCostReport->list(
startingAt: new \DateTimeImmutable('2026-06-01T00:00:00Z'),
limit: 1000,
);
foreach ($costRows->pagingEachItem() as $costRow) {
echo "{$costRow->actor->userID}: {$costRow->amount}\n";
}
```
```ruby Ruby
client = Anthropic::Client.new
page = client.beta.organization.analytics.user_cost_report.list(
starting_at: Time.utc(2026, 6, 1),
limit: 1000
)
page.auto_paging_each do |cost_row|
puts "#{cost_row.actor.user_id}: #{cost_row.amount}"
end
```
Ogni riga contiene `actor.user_id`, `actor.email_address` e `amount` (la spesa del membro in centesimi). Scorri le pagine tramite `next_page` per coprire l'intera organizzazione.
2. Per i membri con la spesa più alta (o tutti quelli al di sopra di una soglia in dollari), recupera i tetti effettivi in batch:
```bash cURL
curl -g "https://api.anthropic.com/v1/organizations/spend_limits/effective?user_ids[]=user_01AbCdEfGh&user_ids[]=user_01JkLmNoPq&limit=100" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01"
```
```bash CLI
ant beta:organization:spend-limits:effective list \
--user-id user_01AbCdEfGh \
--user-id user_01JkLmNoPq \
--limit 100
```
```python Python
client = anthropic.Anthropic()
effective_limits = client.beta.organization.spend_limits.effective.list(
user_ids=["user_01AbCdEfGh", "user_01JkLmNoPq"], limit=100
)
for effective_limit in effective_limits:
scope = effective_limit.scope
if scope.type == "user":
amount = effective_limit.amount or "unlimited"
print(f"{scope.user_id}: {effective_limit.period_to_date_spend} of {amount}")
```
```typescript TypeScript
const client = new Anthropic();
const effectiveLimits = await client.beta.organization.spendLimits.effective.list({
user_ids: ["user_01AbCdEfGh", "user_01JkLmNoPq"],
limit: 100
});
for await (const effectiveLimit of effectiveLimits) {
const { scope } = effectiveLimit;
if (scope.type === "user") {
const amount = effectiveLimit.amount ?? "unlimited";
console.log(`${scope.user_id}: ${effectiveLimit.period_to_date_spend} of ${amount}`);
}
}
```
```csharp C#
AnthropicClient client = new();
var page = await client.Beta.Organization.SpendLimits.Effective.List(
new() { UserIds = ["user_01AbCdEfGh", "user_01JkLmNoPq"], Limit = 100 }
);
await foreach (var effectiveLimit in page.Paginate())
{
if (effectiveLimit.Scope.TryPickBetaSpendLimitUser(out var userScope))
{
var amount = effectiveLimit.Amount ?? "unlimited";
Console.WriteLine($"{userScope.UserID}: {effectiveLimit.PeriodToDateSpend} of {amount}");
}
}
```
```go Go
client := anthropic.NewClient()
effectiveLimits := client.Beta.Organization.SpendLimits.Effective.ListAutoPaging(context.Background(), anthropic.BetaOrganizationSpendLimitEffectiveListParams{
UserIDs: []string{"user_01AbCdEfGh", "user_01JkLmNoPq"},
Limit: anthropic.Int(100),
})
for effectiveLimits.Next() {
effectiveLimit := effectiveLimits.Current()
if userScope, ok := effectiveLimit.Scope.AsAny().(anthropic.BetaSpendLimitUserScope); ok {
amount := effectiveLimit.Amount
if !effectiveLimit.JSON.Amount.Valid() {
amount = "unlimited"
}
fmt.Printf("%s: %s of %s\n", userScope.UserID, effectiveLimit.PeriodToDateSpend, amount)
}
}
if err := effectiveLimits.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
import com.anthropic.models.beta.organization.spendlimits.effective.EffectiveListParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = EffectiveListParams.builder()
.addUserId("user_01AbCdEfGh")
.addUserId("user_01JkLmNoPq")
.limit(100)
.build();
var effectiveLimits = client.beta().organization().spendLimits().effective().list(params);
for (var effectiveLimit : effectiveLimits.autoPager()) {
var amount = effectiveLimit.amount().orElse("unlimited");
effectiveLimit.scope().user().ifPresent(userScope ->
IO.println(userScope.userId() + ": " + effectiveLimit.periodToDateSpend() + " of " + amount)
);
}
}
```
```php PHP
use Anthropic\Beta\Organization\SpendLimits\SpendLimitUserScope;
// ...
$client = new Client();
$effectiveLimits = $client->beta->organization->spendLimits->effective->list(
userIDs: ['user_01AbCdEfGh', 'user_01JkLmNoPq'],
limit: 100,
);
foreach ($effectiveLimits->pagingEachItem() as $effectiveLimit) {
$scope = $effectiveLimit->scope;
if ($scope instanceof SpendLimitUserScope) {
$amount = $effectiveLimit->amount ?? 'unlimited';
echo "{$scope->userID}: {$effectiveLimit->periodToDateSpend} of {$amount}\n";
}
}
```
```ruby Ruby
client = Anthropic::Client.new
page = client.beta.organization.spend_limits.effective.list(
user_ids: ["user_01AbCdEfGh", "user_01JkLmNoPq"],
limit: 100
)
page.auto_paging_each do |effective_limit|
scope = effective_limit.scope
if scope.is_a?(Anthropic::Models::Beta::Organization::BetaSpendLimitUserScope)
amount = effective_limit.amount || "unlimited"
puts "#{scope.user_id}: #{effective_limit.period_to_date_spend} of #{amount}"
end
end
```
Ogni riga restituisce il tetto come `amount` (`null` = illimitato, `"0"` = solo utilizzo incluso) insieme a `period_to_date_spend`.
3. Per ogni membro con un tetto positivo, calcola `period_to_date_spend / amount` e segnala quelli pari o superiori alla tua soglia (ad esempio, l'80 percento). Tratta un tetto `"0"` come già al limite. Non esiste un filtro lato server per questo rapporto.
4. Agisci sui membri segnalati: aumenta il tetto con `POST /v1/organizations/spend_limits`, approva una richiesta di aumento in sospeso se ne esiste una, oppure contatta il membro.
### Trovare i membri con utilizzo in rapido cambiamento
Individua i membri la cui spesa è aumentata bruscamente di settimana in settimana.
1. Recupera il costo giornaliero per membro delle ultime due settimane dall'API Analytics:
```bash cURL
curl "https://api.anthropic.com/v1/organizations/analytics/user_cost_report?starting_at=2026-06-09T00:00:00Z&ending_at=2026-06-23T00:00:00Z&bucket_width=1d&limit=1000" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01"
```
```bash CLI
ant beta:organization:analytics:user-cost-report list \
--starting-at 2026-06-09T00:00:00Z \
--ending-at 2026-06-23T00:00:00Z \
--bucket-width 1d \
--limit 1000
```
```python Python
client = anthropic.Anthropic()
cost_rows = client.beta.organization.analytics.user_cost_report.list(
starting_at="2026-06-09T00:00:00Z",
ending_at="2026-06-23T00:00:00Z",
bucket_width="1d",
limit=1000,
)
for cost_row in cost_rows:
print(f"{cost_row.actor.user_id} {cost_row.starting_at}: {cost_row.amount}")
```
```typescript TypeScript
const client = new Anthropic();
const costRows = await client.beta.organization.analytics.userCostReport.list({
starting_at: "2026-06-09T00:00:00Z",
ending_at: "2026-06-23T00:00:00Z",
bucket_width: "1d",
limit: 1000
});
for await (const costRow of costRows) {
console.log(`${costRow.actor.user_id} ${costRow.starting_at}: ${costRow.amount}`);
}
```
```csharp C#
using Anthropic.Models.Beta.Organization.Analytics.UserCostReport;
AnthropicClient client = new();
var page = await client.Beta.Organization.Analytics.UserCostReport.List(
new()
{
StartingAt = DateTimeOffset.Parse("2026-06-09T00:00:00Z"),
EndingAt = DateTimeOffset.Parse("2026-06-23T00:00:00Z"),
BucketWidth = BucketWidth.Day,
Limit = 1000,
}
);
await foreach (var costRow in page.Paginate())
{
Console.WriteLine($"{costRow.Actor.UserID} {costRow.StartingAt}: {costRow.Amount}");
}
```
```go Go
client := anthropic.NewClient()
costRows := client.Beta.Organization.Analytics.UserCostReport.ListAutoPaging(context.Background(), anthropic.BetaOrganizationAnalyticsUserCostReportListParams{
StartingAt: time.Date(2026, time.June, 9, 0, 0, 0, 0, time.UTC),
EndingAt: anthropic.Time(time.Date(2026, time.June, 23, 0, 0, 0, 0, time.UTC)),
BucketWidth: anthropic.BetaOrganizationAnalyticsUserCostReportListParamsBucketWidthDay,
Limit: anthropic.Int(1000),
})
for costRows.Next() {
costRow := costRows.Current()
fmt.Printf("%s %s: %s\n", costRow.Actor.UserID, costRow.StartingAt, costRow.Amount)
}
if err := costRows.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
import com.anthropic.models.beta.organization.analytics.usercostreport.UserCostReportListParams;
import java.time.OffsetDateTime;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = UserCostReportListParams.builder()
.startingAt(OffsetDateTime.parse("2026-06-09T00:00:00Z"))
.endingAt(OffsetDateTime.parse("2026-06-23T00:00:00Z"))
.bucketWidth(UserCostReportListParams.BucketWidth.DAY)
.limit(1000)
.build();
var costRows = client.beta().organization().analytics().userCostReport().list(params);
for (var costRow : costRows.autoPager()) {
IO.println(costRow.actor().userId() + " " + costRow.startingAt().orElseThrow() + ": " + costRow.amount());
}
}
```
```php PHP
$client = new Client();
$costRows = $client->beta->organization->analytics->userCostReport->list(
startingAt: new \DateTimeImmutable('2026-06-09T00:00:00Z'),
endingAt: new \DateTimeImmutable('2026-06-23T00:00:00Z'),
bucketWidth: '1d',
limit: 1000,
);
foreach ($costRows->pagingEachItem() as $costRow) {
$startingAt = $costRow->startingAt?->format(\DateTimeInterface::ATOM);
echo "{$costRow->actor->userID} {$startingAt}: {$costRow->amount}\n";
}
```
```ruby Ruby
client = Anthropic::Client.new
page = client.beta.organization.analytics.user_cost_report.list(
starting_at: Time.utc(2026, 6, 9),
ending_at: Time.utc(2026, 6, 23),
bucket_width: :"1d",
limit: 1000
)
page.auto_paging_each do |cost_row|
puts "#{cost_row.actor.user_id} #{cost_row.starting_at}: #{cost_row.amount}"
end
```
Con `bucket_width` impostato, ogni membro occupa una riga per ogni giorno con utilizzo. Scorri le pagine tramite `next_page` per raccogliere la serie completa di ogni membro.
2. Raggruppa le righe per `actor.user_id`. Per ogni membro, somma i sette giorni più recenti e i sette giorni precedenti. Segnala i membri la cui settimana recente supera la settimana precedente del multiplo da te scelto (ad esempio, tre). Il costo dei giorni recenti è provvisorio e può essere rivisto al rialzo; per confronti ripetibili, imposta `ending_at` a un valore pari o precedente a un `data_refreshed_at` restituito in precedenza (consulta [Disponibilità e aggiornamento dei dati](https://platform.claude.com/docs/it/manage-claude/analytics-api#data-availability-and-freshness)).
3. Agisci sui membri segnalati: regola il tetto con `POST /v1/organizations/spend_limits`, oppure contattali.
### Aumentare temporaneamente il limite di spesa di un membro durante un incidente
Dai a chi risponde a un incidente margine per lavorare mentre l'incidente è aperto: aumenta il suo tetto di spesa quando l'incidente inizia e ripristinalo dopo la chiusura dell'incidente. Vincola l'aumento al tuo sistema di gestione degli incidenti, ad esempio richiedendo un ID di incidente attivo con il membro assegnato ad esso.
1. Leggi il tetto attuale del membro e registralo per il ripristino:
```bash cURL
curl -g "https://api.anthropic.com/v1/organizations/spend_limits/effective?user_ids[]=user_01AbCdEfGh&period[]=monthly" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01"
```
```bash CLI
ant beta:organization:spend-limits:effective list \
--user-id user_01AbCdEfGh \
--period monthly
```
```python Python
client = anthropic.Anthropic()
effective_limits = client.beta.organization.spend_limits.effective.list(
user_ids=["user_01AbCdEfGh"], period=["monthly"]
)
for effective_limit in effective_limits:
scope = effective_limit.scope
if scope.type == "user":
amount = effective_limit.amount or "unlimited"
print(f"{scope.user_id}: {effective_limit.period_to_date_spend} of {amount}")
```
```typescript TypeScript
const client = new Anthropic();
const effectiveLimits = await client.beta.organization.spendLimits.effective.list({
user_ids: ["user_01AbCdEfGh"],
period: ["monthly"]
});
for await (const effectiveLimit of effectiveLimits) {
const { scope } = effectiveLimit;
if (scope.type === "user") {
const amount = effectiveLimit.amount ?? "unlimited";
console.log(`${scope.user_id}: ${effectiveLimit.period_to_date_spend} of ${amount}`);
}
}
```
```csharp C#
using Anthropic.Models.Beta.Organization.SpendLimits.Effective;
AnthropicClient client = new();
var page = await client.Beta.Organization.SpendLimits.Effective.List(
new() { UserIds = ["user_01AbCdEfGh"], Period = [Period.Monthly] }
);
await foreach (var effectiveLimit in page.Paginate())
{
if (effectiveLimit.Scope.TryPickBetaSpendLimitUser(out var userScope))
{
var amount = effectiveLimit.Amount ?? "unlimited";
Console.WriteLine($"{userScope.UserID}: {effectiveLimit.PeriodToDateSpend} of {amount}");
}
}
```
```go Go
client := anthropic.NewClient()
effectiveLimits := client.Beta.Organization.SpendLimits.Effective.ListAutoPaging(context.Background(), anthropic.BetaOrganizationSpendLimitEffectiveListParams{
UserIDs: []string{"user_01AbCdEfGh"},
Period: []string{"monthly"},
})
for effectiveLimits.Next() {
effectiveLimit := effectiveLimits.Current()
if userScope, ok := effectiveLimit.Scope.AsAny().(anthropic.BetaSpendLimitUserScope); ok {
amount := effectiveLimit.Amount
if !effectiveLimit.JSON.Amount.Valid() {
amount = "unlimited"
}
fmt.Printf("%s: %s of %s\n", userScope.UserID, effectiveLimit.PeriodToDateSpend, amount)
}
}
if err := effectiveLimits.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
import com.anthropic.models.beta.organization.spendlimits.effective.EffectiveListParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = EffectiveListParams.builder()
.addUserId("user_01AbCdEfGh")
.addPeriod(EffectiveListParams.Period.MONTHLY)
.build();
var effectiveLimits = client.beta().organization().spendLimits().effective().list(params);
for (var effectiveLimit : effectiveLimits.autoPager()) {
var amount = effectiveLimit.amount().orElse("unlimited");
effectiveLimit.scope().user().ifPresent(userScope ->
IO.println(userScope.userId() + ": " + effectiveLimit.periodToDateSpend() + " of " + amount)
);
}
}
```
```php PHP
use Anthropic\Beta\Organization\SpendLimits\SpendLimitUserScope;
// ...
$client = new Client();
$effectiveLimits = $client->beta->organization->spendLimits->effective->list(
userIDs: ['user_01AbCdEfGh'],
period: ['monthly'],
);
foreach ($effectiveLimits->pagingEachItem() as $effectiveLimit) {
$scope = $effectiveLimit->scope;
if ($scope instanceof SpendLimitUserScope) {
$amount = $effectiveLimit->amount ?? 'unlimited';
echo "{$scope->userID}: {$effectiveLimit->periodToDateSpend} of {$amount}\n";
}
}
```
```ruby Ruby
client = Anthropic::Client.new
page = client.beta.organization.spend_limits.effective.list(
user_ids: ["user_01AbCdEfGh"],
period: [:monthly]
)
page.auto_paging_each do |effective_limit|
scope = effective_limit.scope
if scope.is_a?(Anthropic::Models::Beta::Organization::BetaSpendLimitUserScope)
amount = effective_limit.amount || "unlimited"
puts "#{scope.user_id}: #{effective_limit.period_to_date_spend} of #{amount}"
end
end
```
2. Aumenta il tetto:
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/spend_limits" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-d '{"scope": {"type": "user", "user_id": "user_01AbCdEfGh"}, "amount": "500000", "period": "monthly"}'
```
```bash CLI
ant beta:organization:spend-limits set \
--scope '{type: user, user_id: user_01AbCdEfGh}' \
--amount 500000 \
--period monthly
```
```python Python
client = anthropic.Anthropic()
spend_limit = client.beta.organization.spend_limits.set(
scope={"type": "user", "user_id": "user_01AbCdEfGh"},
amount="500000",
period="monthly",
)
print(f"id: {spend_limit.id}")
print(f"amount: {spend_limit.amount}")
```
```typescript TypeScript
const client = new Anthropic();
const spendLimit = await client.beta.organization.spendLimits.set({
scope: { type: "user", user_id: "user_01AbCdEfGh" },
amount: "500000",
period: "monthly"
});
console.log(`id: ${spendLimit.id}`);
console.log(`amount: ${spendLimit.amount}`);
```
```csharp C#
using Anthropic.Models.Beta.Organization.SpendLimits;
AnthropicClient client = new();
var spendLimit = await client.Beta.Organization.SpendLimits.Set(
new()
{
Scope = new BetaSpendLimitUserScope("user_01AbCdEfGh"),
Amount = "500000",
Period = BetaSpendLimitPeriod.Monthly,
}
);
Console.WriteLine($"id: {spendLimit.ID}");
Console.WriteLine($"amount: {spendLimit.Amount}");
```
```go Go
client := anthropic.NewClient()
spendLimit, err := client.Beta.Organization.SpendLimits.Set(context.Background(), anthropic.BetaOrganizationSpendLimitSetParams{
Scope: anthropic.BetaOrganizationSpendLimitSetParamsScopeUnion{
OfUser: &anthropic.BetaSpendLimitUserScopeParam{UserID: "user_01AbCdEfGh"},
},
Amount: anthropic.String("500000"),
Period: anthropic.BetaSpendLimitPeriodMonthly,
})
if err != nil {
log.Fatal(err)
}
fmt.Printf("id: %s\n", spendLimit.ID)
fmt.Printf("amount: %s\n", spendLimit.Amount)
```
```java Java
import com.anthropic.models.beta.organization.spendlimits.BetaSpendLimitPeriod;
import com.anthropic.models.beta.organization.spendlimits.SpendLimitSetParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SpendLimitSetParams.builder()
.userScope("user_01AbCdEfGh")
.amount("500000")
.period(BetaSpendLimitPeriod.MONTHLY)
.build();
var spendLimit = client.beta().organization().spendLimits().set(params);
IO.println("id: " + spendLimit.id());
IO.println("amount: " + spendLimit.amount().orElseThrow());
}
```
```php PHP
use Anthropic\Beta\Organization\SpendLimits\SpendLimitUserScope;
// ...
$client = new Client();
$spendLimit = $client->beta->organization->spendLimits->set(
scope: SpendLimitUserScope::with(userID: 'user_01AbCdEfGh'),
amount: '500000',
period: 'monthly',
);
echo "id: {$spendLimit->id}\n";
echo "amount: {$spendLimit->amount}\n";
```
```ruby Ruby
client = Anthropic::Client.new
spend_limit = client.beta.organization.spend_limits.set(
scope: { type: :user, user_id: "user_01AbCdEfGh" },
amount: "500000",
period: :monthly
)
puts "id: #{spend_limit.id}"
puts "amount: #{spend_limit.amount}"
```
3. Se chi risponde agli incidenti necessita di un accesso più ampio durante un incidente, predisponi in anticipo un gruppo incident-responders il cui [ruolo personalizzato](https://platform.claude.com/docs/it/manage-claude/user-management#custom-roles) lo conceda, e aggiungi il membro per la durata dell'incidente:
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/rbac_groups/rbac_group_01UvWxYzAbCdEfGhIjKlMn/members" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-d '{"user_id": "user_01AbCdEfGh"}'
```
```bash CLI
ant beta:organization:rbac-groups:members add \
--rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn \
--user-id user_01AbCdEfGh
```
```python Python
client = anthropic.Anthropic()
member = client.beta.organization.rbac_groups.members.add(
"rbac_group_01UvWxYzAbCdEfGhIjKlMn", user_id="user_01AbCdEfGh"
)
print(f"user_id: {member.user_id}")
print(f"rbac_group_id: {member.rbac_group_id}")
```
```typescript TypeScript
const client = new Anthropic();
const member = await client.beta.organization.rbacGroups.members.add(
"rbac_group_01UvWxYzAbCdEfGhIjKlMn",
{
user_id: "user_01AbCdEfGh"
}
);
console.log(`user_id: ${member.user_id}`);
console.log(`rbac_group_id: ${member.rbac_group_id}`);
```
```csharp C#
AnthropicClient client = new();
var member = await client.Beta.Organization.RbacGroups.Members.Add(
"rbac_group_01UvWxYzAbCdEfGhIjKlMn",
new() { UserID = "user_01AbCdEfGh" }
);
Console.WriteLine($"user_id: {member.UserID}");
Console.WriteLine($"rbac_group_id: {member.RbacGroupID}");
```
```go Go
client := anthropic.NewClient()
member, err := client.Beta.Organization.RBACGroups.Members.Add(
context.Background(),
"rbac_group_01UvWxYzAbCdEfGhIjKlMn",
anthropic.BetaOrganizationRBACGroupMemberAddParams{
UserID: "user_01AbCdEfGh",
},
)
if err != nil {
log.Fatal(err)
}
fmt.Printf("user_id: %s\n", member.UserID)
fmt.Printf("rbac_group_id: %s\n", member.RBACGroupID)
```
```java Java
import com.anthropic.models.beta.organization.rbacgroups.members.MemberAddParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = MemberAddParams.builder()
.userId("user_01AbCdEfGh")
.build();
var member = client.beta().organization().rbacGroups().members()
.add("rbac_group_01UvWxYzAbCdEfGhIjKlMn", params);
IO.println("user_id: " + member.userId());
IO.println("rbac_group_id: " + member.rbacGroupId());
}
```
```php PHP
$client = new Client();
$member = $client->beta->organization->rbacGroups->members->add(
'rbac_group_01UvWxYzAbCdEfGhIjKlMn',
userID: 'user_01AbCdEfGh',
);
echo "user_id: {$member->userID}\n";
echo "rbac_group_id: {$member->rbacGroupID}\n";
```
```ruby Ruby
client = Anthropic::Client.new
member = client.beta.organization.rbac_groups.members.add(
"rbac_group_01UvWxYzAbCdEfGhIjKlMn",
user_id: "user_01AbCdEfGh"
)
puts "user_id: #{member.user_id}"
puts "rbac_group_id: #{member.rbac_group_id}"
```
Consulta [Gestione utenti](https://platform.claude.com/docs/it/manage-claude/user-management#groups) per gli endpoint dei gruppi.
4. Quando il tuo sistema di gestione degli incidenti contrassegna l'incidente come chiuso, annulla entrambe le modifiche: ripristina il limite di spesa registrato al passaggio 1 (oppure elimina l'override con `DELETE /v1/organizations/spend_limits/{spend_limit_id}` se il membro non ne aveva uno) e rimuovi il membro dal gruppo con `DELETE /v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}`.
## Domande frequenti
### Impostare direttamente un limite di spesa risolve la richiesta di aumento in sospeso di un membro?
No. `POST /v1/organizations/spend_limits` scrive l'override ma lascia intatta la richiesta in sospeso. Usa `POST /v1/organizations/spend_limit_increase_requests/{id}/approve` per risolvere la richiesta e scrivere l'override in un'unica chiamata.
### Cosa succede quando elimino un override per utente?
Il membro torna a qualsiasi valore erediterebbe dalla gerarchia: il valore predefinito del suo gruppo, del suo livello di seat o dell'organizzazione. Se non esiste alcun valore predefinito a nessun livello, il membro è illimitato.
### Posso impostare un valore predefinito a livello di seat o di organizzazione tramite questa API?
No. Solo gli override per utente possono essere scritti tramite questa API. I valori predefiniti a livello di seat, gruppo e organizzazione si configurano nelle impostazioni dell'organizzazione di claude.ai.
### Perché `period_to_date_spend` a volte risulta `"0"` per un membro attivo?
La lettura della spesa può essere temporaneamente non disponibile, nel qual caso il campo risulta `"0"` anziché generare un errore. Trattalo come informativo.
## Vedi anche
Schemi di richiesta e risposta generati per ogni endpoint dell'API Spend Limits.
Schemi di richiesta e risposta generati per gli endpoint delle richieste di aumento.
Reporting di utilizzo e costi per utente e per intervalli temporali per Claude Enterprise.