---
title: API de Limites de Gastos
url: https://platform.claude.com/docs/pt-BR/manage-claude/spend-limits-api
description: Defina um limite de gastos para cada membro do Claude Enterprise, veja de onde o limite de gastos de cada membro é herdado e revise ou tome ações sobre as solicitações dos membros por um limite maior.
---
A Spend Limits API (API de Limites de Gastos) permite que você defina um limite de gastos para cada membro do Claude Enterprise, veja de onde o limite de gastos de cada membro é herdado e revise ou tome ações sobre as solicitações dos membros por um limite maior.
Para *relatórios* de uso e custo por usuário e agrupados por intervalos de tempo, consulte [APIs de Analytics](https://platform.claude.com/docs/pt-BR/manage-claude/analytics-api).
**Chave de Admin API com escopo obrigatória**
Esses endpoints exigem uma chave de API de Admin com o escopo `read:spend_limits` (para endpoints `GET`) ou o escopo `write:spend_limits` (para endpoints `POST` e `DELETE`). Consulte [Criar uma chave de API de Admin](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization) para saber onde o proprietário principal da sua organização cria uma e quais escopos selecionar. Passe a chave no cabeçalho `x-api-key` em todas as solicitações, junto com o cabeçalho [`anthropic-version`](https://platform.claude.com/docs/pt-BR/api/versioning).
A Spend Limits API está disponível apenas para organizações Claude Enterprise. Ela não está disponível para organizações da Claude Platform (Claude Console).
## Visão geral
A API expõe oito endpoints em dois recursos:
| Recurso | Endpoints | Use para |
| ----------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| **Limites de gastos** | `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}` | Ler o limite de gastos efetivo de cada membro e o gasto acumulado no período; definir ou remover uma substituição por usuário. |
| **Solicitações de aumento de limite de gastos** | `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` | Listar as solicitações dos membros por um limite de gastos maior, com o contexto necessário para decidir; aprovar ou negar cada solicitação. |
Use os endpoints de **limites de gastos** para responder "qual limite de gastos se aplica a cada membro, de onde ele vem e quão perto eles estão dele?" e para definir uma substituição por usuário. Use os endpoints de **solicitações de aumento de limite de gastos** para processar a fila de solicitações enviadas pelos membros.
## Pré-requisitos
* Sua organização deve estar em um plano Claude Enterprise.
* Os créditos de uso devem estar ativados para sua organização. Seu proprietário principal pode ativá-los nas configurações de faturamento do claude.ai.
O SDK expõe esses endpoints em `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 a CLI `ant` em `ant beta:organization:spend-limits`. Ambos enviam o cabeçalho `anthropic-version` para você. Os exemplos leem a chave de API de Admin da variável de ambiente `ANTHROPIC_API_KEY`. O SDK e a CLI buscam mais páginas para você à medida que você percorre os resultados, então `limit` define o tamanho da página, não o total (consulte [Paginação](https://platform.claude.com/docs/pt-BR/manage-claude/spend-limits-api#pagination)).
## Início rápido
Liste o limite de gastos mensal efetivo e o gasto acumulado no período de cada 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
```
## Conceitos principais
### A hierarquia de limites de gastos
Um **effective spend limit** (limite de gastos efetivo) se aplica ao gasto de cada membro, resolvido a partir de uma hierarquia de níveis de escopo. Quando um membro não tem uma substituição por usuário, ele herda o limite de gastos configurado para seu grupo (se sua organização usa limites baseados em grupos), seu nível de assento ou o padrão de toda a organização. Um limite de gastos de grupo é um padrão por membro: cada membro que o herda é controlado em relação ao seu próprio gasto, não a um orçamento compartilhado do grupo.
Ler `GET /v1/organizations/spend_limits/effective` retorna todos os membros atuais com seu limite de gastos efetivo resolvido, de onde esse limite foi resolvido (`source`) e seu gasto acumulado no período. Definir uma substituição por usuário com `POST /v1/organizations/spend_limits` fixa um membro em um limite de gastos específico, independentemente do que ele herdaria de outra forma. Excluir a substituição o retorna ao limite de gastos herdado (ou o deixa ilimitado se nenhum existir).
O campo `source` na linha de cada membro informa de qual nível seu limite de gastos foi resolvido: `user` (uma substituição por usuário), `seat_tier`, `rbac_group` ou `organization`. Trate os tipos de escopo como um conjunto aberto; ignore valores desconhecidos em vez de falhar.
### Período
`period` é a janela recorrente durante a qual o limite de gastos é aplicado e o gasto é redefinido. Um limite de gastos é identificado pelo seu par `(scope, period)`. Atualmente, `monthly` é o único período suportado; o gasto mensal é redefinido às 00:00 UTC no primeiro dia de cada mês do calendário. Trate `period` como um conjunto aberto.
### Valores e moeda
Todos os valores monetários são strings em **unidades menores da moeda de faturamento da organização** (centavos, para USD). Por exemplo, `"50000"` representa 500,00 USD. Faça o parse como decimal e divida por 100 para exibir em dólares; evite ponto flutuante binário para valores grandes.
`amount` é **anulável**. Na linha efetiva de um membro, `null` significa **ilimitado** (sem limite de gastos) e `"0"` significa que o membro não pode usar o Claude além do uso incluído em seu plano. Em uma linha de limite de gastos configurada (como retornada por `GET /v1/organizations/spend_limits/{id}`), `null` significa apenas que nenhum limite de gastos numérico está definido; leia a linha efetiva do membro para distinguir ilimitado de apenas uso incluído.
`period_to_date_spend` é o gasto do membro acumulado desde o início do `period` atual, no mesmo formato de unidades menores; ele pode incluir uma parte fracionária (por exemplo, `"41280.125"`). Ele pode aparecer como `"0"` se a leitura de gastos estiver temporariamente indisponível; trate-o como informativo, não transacional.
### Ciclo de vida da solicitação de aumento
Uma **spend limit increase request** (solicitação de aumento de limite de gastos) é criada quando um membro clica em **Request more usage** no claude.ai. As solicitações não são criadas por meio desta API. O `status` de uma solicitação é um dos seguintes:
| Status | Significado |
| ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `pending` | Aguardando ação do administrador. A solicitação normalmente carrega um `spend_summary` em tempo real para que você possa ver o limite de gastos efetivo atual do membro e o gasto acumulado no período enquanto decide; `spend_summary` pode ser `null` se não puder ser calculado. |
| `approved` | A solicitação foi resolvida com aprovação: um administrador a aprovou explicitamente, outra ação de administrador aumentou o limite de gastos do membro ou o suporte da Anthropic aumentou um limite de gastos em nome da organização. `spend_summary` é `null`. |
| `denied` | Um administrador recusou. `spend_summary` é `null`. O membro pode enviar uma nova solicitação imediatamente; apenas uma solicitação `pending` impede uma nova. Um administrador ainda pode aumentar o limite de gastos do membro diretamente a qualquer momento. |
Tanto `approved` quanto `denied` são terminais. Um membro tem no máximo uma solicitação `pending` por vez.
Aprovar com `POST /v1/organizations/spend_limit_increase_requests/{id}/approve` grava a mesma linha de limite de gastos por usuário que `POST /v1/organizations/spend_limits` grava. Definir um limite de gastos diretamente **não** faz a transição de uma solicitação pendente; use o endpoint de aprovação para resolver uma solicitação.
Por padrão, a Anthropic envia um e-mail ao membro quando sua solicitação é aprovada ou negada. Passe `suppress_notification: true` ao aprovar ou negar para suprimir esse e-mail (por exemplo, quando seu próprio sistema notifica o membro).
## Versionamento
Envie o cabeçalho `anthropic-version` em todas as solicitações; consulte [Versões da API](https://platform.claude.com/docs/pt-BR/api/versioning) para ver as versões disponíveis.
## Limite de taxa
Todos os oito endpoints compartilham um único "rate limit" (limite de taxa) por organização de **60 requisições por minuto**. Requisições acima do limite retornam **429 Too Many Requests**.
## Paginação
`GET /v1/organizations/spend_limits/effective` e `GET /v1/organizations/spend_limit_increase_requests` são paginados com um **cursor opaco**. A primeira requisição retorna até `limit` linhas mais um cursor `next_page`; passe esse cursor inalterado como o parâmetro `page` na próxima requisição e repita até que `next_page` seja `null`.
**Não altere os parâmetros de consulta no meio da sequência.** Os cursores estão vinculados aos filtros que os emitiram. Se você alterar `user_ids[]`, `period[]`, `status[]` ou `actor_ids[]` e passar um cursor antigo, você receberá um 400 com *"cursor does not match current query parameters"*. Em vez disso, inicie uma nova sequência a partir da primeira página.
## Serializando parâmetros de lista
Parâmetros de lista usam notação de colchetes: repita o nome do parâmetro com `[]` para cada valor.
```text wrap
user_ids[]=user_01AbCdEfGh&user_ids[]=user_01JkLmNoPq
```
## Respostas de erro
As respostas de erro seguem o formato padrão documentado em [Erros](https://platform.claude.com/docs/pt-BR/api/errors). Cite o `request_id` do corpo da resposta ao entrar em contato com o suporte.
## Limites de gastos
### Listar o limite de gastos efetivo de cada membro
`GET /v1/organizations/spend_limits/effective` retorna uma linha por membro atual, refletindo o limite de gastos efetivo de cada membro, seu `source` na hierarquia de escopo e seu `period_to_date_spend`. Requer o escopo `read:spend_limits`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Listar limites de gastos efetivos](https://platform.claude.com/docs/pt-BR/api/beta/organization/spend_limits/effective/list) na referência da 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_..."
}
```
### Obter um único limite de gastos
`GET /v1/organizations/spend_limits/{spend_limit_id}` retorna um limite de gastos configurado por ID. Use-o para inspecionar a linha que um campo `spend_limit_id` referenciou. Requer o escopo `read:spend_limits`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Recuperar um limite de gastos](https://platform.claude.com/docs/pt-BR/api/beta/organization/spend_limits/retrieve) na referência da 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}"
```
### Definir uma substituição por usuário
`POST /v1/organizations/spend_limits` define uma substituição de limite de gastos por usuário. Este é um upsert com chave em `(scope, period)`: definir um limite para um usuário e período que já possui um o sobrescreve no lugar. Este endpoint aceita apenas `scope.type: "user"`; os padrões de nível de assento, grupo e organização são configurados nas configurações do claude.ai. Requer o escopo `write:spend_limits`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Criar um limite de gastos](https://platform.claude.com/docs/pt-BR/api/beta/organization/spend_limits/set) na referência da 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"
}
```
### Remover uma substituição por usuário
`DELETE /v1/organizations/spend_limits/{spend_limit_id}` remove uma substituição por usuário, após o que o membro retorna a qualquer padrão herdado de nível de assento, grupo ou organização. Linhas de nível de assento, grupo e organização não podem ser excluídas por meio deste endpoint. Requer o escopo `write:spend_limits`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Excluir um limite de gastos](https://platform.claude.com/docs/pt-BR/api/beta/organization/spend_limits/delete) na referência da 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}"
```
## Solicitações de aumento de limite de gastos
### Listar solicitações de aumento
`GET /v1/organizations/spend_limit_increase_requests` lista as solicitações, da mais recente para a mais antiga. Filtre por `status[]` (`pending`, `approved`, `denied`) e `actor_ids[]`. A lista exclui solicitações cujo solicitante não é mais membro da organização. Requer o escopo `read:spend_limits`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Listar solicitações de aumento de limite de gastos](https://platform.claude.com/docs/pt-BR/api/beta/organization/spend_limits/increase_requests/list) na referência da 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
```
Cada solicitação pendente carrega um `spend_summary` em tempo real mostrando o limite de gastos efetivo atual do solicitante e o gasto acumulado no período, o suficiente para decidir sem uma consulta separada.
### Obter uma única solicitação de aumento
`GET /v1/organizations/spend_limit_increase_requests/{id}` retorna uma solicitação por ID. Requer o escopo `read:spend_limits`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Recuperar uma solicitação de aumento de limite de gastos](https://platform.claude.com/docs/pt-BR/api/beta/organization/spend_limits/increase_requests/retrieve) na referência da 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}"
```
### Aprovar uma solicitação de aumento
`POST /v1/organizations/spend_limit_increase_requests/{id}/approve` aprova uma solicitação pendente: grava um limite de gastos por usuário no `amount` fornecido pelo administrador para o solicitante e faz a transição da solicitação para `approved`. A solicitação não carrega um valor solicitado; você fornece o novo limite de gastos na aprovação. Requer o escopo `write:spend_limits`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Aprovar uma solicitação de aumento de limite de gastos](https://platform.claude.com/docs/pt-BR/api/beta/organization/spend_limits/increase_requests/approve) na referência da 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}"
```
### Negar uma solicitação de aumento
`POST /v1/organizations/spend_limit_increase_requests/{id}/deny` nega uma solicitação pendente. Idempotente em `denied`: negar uma solicitação já negada retorna 200 com o recurso existente. O endpoint rejeita uma tentativa de negar uma solicitação já aprovada para que a automação possa distinguir uma nova tentativa de uma decisão conflitante. Requer o escopo `write:spend_limits`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Negar uma solicitação de aumento de limite de gastos](https://platform.claude.com/docs/pt-BR/api/beta/organization/spend_limits/increase_requests/deny) na referência da 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}"
```
## Exemplos de fluxos de trabalho
Alguns desses fluxos de trabalho combinam a Spend Limits API com os endpoints de custo das [APIs de Analytics](https://platform.claude.com/docs/pt-BR/manage-claude/analytics-api). Os endpoints de custo de Analytics são projetados para relatórios de gastos de toda a organização em um intervalo de datas. `GET /spend_limits/effective` retorna o teto que se aplica atualmente a cada membro. Inicie uma varredura com Analytics para descobrir quais membros analisar e, em seguida, leia seus tetos atuais com `/effective`.
Os endpoints de Spend Limits exigem os escopos `spend_limits` e os endpoints de custo de Analytics exigem `read:analytics`; consulte [APIs de Analytics](https://platform.claude.com/docs/pt-BR/manage-claude/analytics-api) para saber como provisionar o acesso. Os exemplos usam uma única chave de API de Admin que possui os escopos de todas as APIs que eles chamam. Um proprietário principal [seleciona esses escopos ao criar a chave](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api-keys#choose-scopes-for-a-claude-enterprise-key). Todos os valores monetários em ambas são strings decimais em unidades menores (centavos). Ambas as APIs paginam com um cursor opaco. Defina um `limit` explícito e percorra `next_page` até que seja `null` para cobrir toda a organização.
### Automatizar o fluxo de revisão de solicitações de aumento
Execute um job agendado que busca solicitações pendentes, aplica a política de aprovação da sua organização e resolve cada uma.
1. Liste as solicitações pendentes:
```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
```
Cada solicitação carrega o `actor.user_id` do solicitante e um `spend_summary` em tempo real com seu `amount` efetivo atual e `period_to_date_spend`, o suficiente para decidir sem uma consulta separada.
2. Aplique sua política. Por exemplo, aprove automaticamente quando o `amount` atual do membro estiver abaixo de um limite e encaminhe tetos maiores para revisão manual.
3. Resolva cada solicitação. Para aprovar, forneça o novo teto:
```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}"
```
Para negar, chame o [endpoint de negação](https://platform.claude.com/docs/pt-BR/manage-claude/spend-limits-api#deny-an-increase-request) com o mesmo ID. Passe `suppress_notification: true` quando seu próprio sistema notificar o solicitante.
### Identificar membros próximos do seu limite de gastos
Encontre membros que estão se aproximando do seu teto para que você possa aumentá-lo antes que sejam bloqueados.
1. Obtenha o gasto acumulado no mês de cada membro a partir da API de Analytics (uma linha por membro, maior gasto primeiro por padrão):
```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
```
Cada linha contém `actor.user_id`, `actor.email_address` e `amount` (os gastos do membro em centavos). Percorra `next_page` para cobrir toda a organização.
2. Para os maiores gastadores (ou todos acima de um limite em dólares), busque os tetos efetivos em lotes:
```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
```
Cada linha retorna o teto como `amount` (`null` = ilimitado, `"0"` = apenas uso incluído) junto com `period_to_date_spend`.
3. Para cada membro com um teto positivo, calcule `period_to_date_spend / amount` e sinalize aqueles que estão no seu limite ou acima dele (por exemplo, 80 por cento). Trate um teto `"0"` como já no limite. Não há filtro do lado do servidor para essa proporção.
4. Tome ações sobre os membros sinalizados: aumente o teto com `POST /v1/organizations/spend_limits`, aprove uma solicitação de aumento pendente se existir uma ou entre em contato com o membro.
### Encontrar membros com uso mudando rapidamente
Identifique membros cujo gasto aumentou de uma semana para outra.
1. Obtenha o custo diário por membro das últimas duas semanas a partir da API de 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
```
Com `bucket_width` definido, cada membro abrange uma linha por dia com uso. Percorra `next_page` para coletar a série completa de cada membro.
2. Agrupe as linhas por `actor.user_id`. Para cada membro, some os sete dias mais recentes e os sete dias anteriores. Sinalize os membros cuja semana recente excede a semana anterior pelo múltiplo escolhido por você (por exemplo, três). O custo dos dias recentes é provisório e pode ser revisado para cima; para comparações repetíveis, defina `ending_at` em ou antes de um `data_refreshed_at` retornado anteriormente (consulte [Disponibilidade e atualização dos dados](https://platform.claude.com/docs/pt-BR/manage-claude/analytics-api#data-availability-and-freshness)).
3. Tome ações sobre os membros sinalizados: ajuste o teto com `POST /v1/organizations/spend_limits` ou entre em contato.
### Aumentar temporariamente o limite de gastos de um membro durante um incidente
Dê a um respondente de incidentes espaço para trabalhar enquanto um incidente está aberto: aumente seu teto de gastos quando o incidente começar e reverta-o após o encerramento do incidente. Condicione o aumento ao seu sistema de gerenciamento de incidentes, por exemplo, exigindo um ID de incidente ativo com o membro atribuído a ele.
1. Leia o teto atual do membro e registre-o para a reversão:
```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. Aumente o teto:
```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 os respondentes precisarem de acesso mais amplo durante um incidente, pré-provisione um grupo de respondentes de incidentes cuja [função personalizada](https://platform.claude.com/docs/pt-BR/manage-claude/user-management#custom-roles) o conceda e adicione o membro pela duração:
```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}"
```
Consulte [Gerenciamento de usuários](https://platform.claude.com/docs/pt-BR/manage-claude/user-management#groups) para os endpoints de grupo.
4. Quando seu sistema de incidentes marcar o incidente como encerrado, reverta ambas as alterações: restaure o limite de gastos que você registrou na etapa 1 (ou exclua a substituição com `DELETE /v1/organizations/spend_limits/{spend_limit_id}` se o membro não tinha nenhuma) e remova o membro do grupo com `DELETE /v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}`.
## Perguntas frequentes
### Definir um limite de gastos diretamente resolve a solicitação de aumento pendente de um membro?
Não. `POST /v1/organizations/spend_limits` grava a substituição, mas deixa a solicitação pendente intacta. Use `POST /v1/organizations/spend_limit_increase_requests/{id}/approve` para resolver a solicitação e gravar a substituição em uma única chamada.
### O que acontece quando eu excluo uma substituição por usuário?
O membro retorna ao que herdaria da hierarquia: o padrão do seu grupo, nível de assento ou organização. Se não existir nenhum padrão em nenhum nível, o membro fica ilimitado.
### Posso definir um padrão de nível de assento ou de toda a organização por meio desta API?
Não. Apenas substituições por usuário podem ser gravadas por meio desta API. Os padrões de nível de assento, grupo e organização são configurados nas configurações da Organização no claude.ai.
### Por que `period_to_date_spend` às vezes aparece como `"0"` para um membro ativo?
A leitura de gastos pode estar temporariamente indisponível, caso em que o campo aparece como `"0"` em vez de gerar erro. Trate-o como informativo.
## Veja também
Esquemas de requisição e resposta gerados para cada endpoint da Spend Limits API.
Esquemas de requisição e resposta gerados para os endpoints de solicitação de aumento.
Relatórios de uso e custo por usuário e agrupados por intervalo de tempo para o Claude Enterprise.