---
title: API de Límites de Gasto
url: https://platform.claude.com/docs/es/manage-claude/spend-limits-api
description: Establece un límite de gasto para cada miembro de Claude Enterprise, consulta de dónde se hereda el límite de gasto de cada miembro y revisa o actúa sobre las solicitudes de los miembros para obtener un límite más alto.
---
La API de Límites de Gasto (Spend Limits API) te permite establecer un límite de gasto para cada miembro de Claude Enterprise, ver de dónde se hereda el límite de gasto de cada miembro y revisar o actuar sobre las solicitudes de los miembros para obtener un límite más alto.
Para *informes* de uso y costos por usuario y agrupados por intervalos de tiempo, consulta las [API de Analytics](https://platform.claude.com/docs/es/manage-claude/analytics-api).
**Se requiere una clave de API de administrador con alcance**
Estos endpoints requieren una clave de API de administrador con el alcance `read:spend_limits` (para los endpoints `GET`) o el alcance `write:spend_limits` (para los endpoints `POST` y `DELETE`). Consulta [Crear una clave de API de administrador](https://platform.claude.com/docs/es/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization) para saber dónde la crea tu propietario principal y qué alcances debe seleccionar. Pasa la clave en el encabezado `x-api-key` en cada solicitud, junto con el encabezado [`anthropic-version`](https://platform.claude.com/docs/es/api/versioning).
La API de Límites de Gasto está disponible únicamente para organizaciones de Claude Enterprise. No está disponible para organizaciones de Claude Platform (Claude Console).
## Descripción general
La API expone ocho endpoints distribuidos en dos recursos:
| Recurso | Endpoints | Úsalo para |
| ---------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Límites de gasto** | `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}` | Leer el límite de gasto efectivo de cada miembro y su gasto acumulado en el período; establecer o eliminar una anulación por usuario. |
| **Solicitudes de aumento del límite de gasto** | `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 las solicitudes de los miembros para obtener un límite de gasto más alto, con el contexto necesario para decidir; aprobar o denegar cada solicitud. |
Usa los endpoints de **límites de gasto** para responder "¿qué límite de gasto se aplica a cada miembro, de dónde proviene y qué tan cerca están de alcanzarlo?" y para establecer una anulación por usuario. Usa los endpoints de **solicitudes de aumento del límite de gasto** para procesar la cola de solicitudes enviadas por los miembros.
## Requisitos previos
* Tu organización debe tener un plan Claude Enterprise.
* Los créditos de uso deben estar activados para tu organización. Tu propietario principal puede activarlos en la configuración de facturación de claude.ai.
El SDK expone estos endpoints en `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`), y la CLI `ant` en `ant beta:organization:spend-limits`. Ambos envían el encabezado `anthropic-version` por ti. Los ejemplos leen la clave de API de administrador de la variable de entorno `ANTHROPIC_API_KEY`. El SDK y la CLI obtienen más páginas por ti a medida que recorres los resultados, por lo que `limit` establece el tamaño de página, no el total (consulta [Paginación](https://platform.claude.com/docs/es/manage-claude/spend-limits-api#pagination)).
## Inicio rápido
Lista el límite de gasto mensual efectivo de cada miembro y su gasto acumulado en el período:
```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
```
## Conceptos clave
### La jerarquía de límites de gasto
Un **límite de gasto efectivo** (effective spend limit) se aplica al gasto de cada miembro y se resuelve a partir de una jerarquía de niveles de alcance. Cuando un miembro no tiene una anulación por usuario, hereda el límite de gasto configurado para su grupo (si tu organización usa límites basados en grupos), su nivel de asiento o el valor predeterminado de toda la organización. Un límite de gasto de grupo es un valor predeterminado por miembro: cada miembro que lo hereda se controla en función de su propio gasto, no de un presupuesto grupal compartido.
Leer `GET /v1/organizations/spend_limits/effective` devuelve todos los miembros actuales con su límite de gasto efectivo resuelto, de dónde se resolvió ese límite (`source`) y su gasto acumulado en el período. Establecer una anulación por usuario con `POST /v1/organizations/spend_limits` fija a un miembro a un límite de gasto específico independientemente de lo que heredaría de otro modo. Eliminar la anulación lo devuelve al límite de gasto heredado (o lo deja sin límite si no existe ninguno).
El campo `source` en la fila de cada miembro te indica desde qué nivel se resolvió su límite de gasto: `user` (una anulación por usuario), `seat_tier`, `rbac_group` u `organization`. Trata los tipos de alcance como un conjunto abierto; ignora los valores desconocidos en lugar de fallar.
### Período
`period` es la ventana recurrente durante la cual se aplica el límite de gasto y se reinicia el gasto. Un límite de gasto se identifica por su par `(scope, period)`. Actualmente `monthly` es el único período admitido; el gasto mensual se reinicia a las 00:00 UTC del primer día de cada mes calendario. Trata `period` como un conjunto abierto.
### Montos y moneda
Todos los valores monetarios son cadenas en **unidades menores de la moneda de facturación de la organización** (centavos, para USD). Por ejemplo, `"50000"` representa 500.00 USD. Analízalo como decimal y divídelo por 100 para mostrar dólares; evita el punto flotante binario para valores grandes.
`amount` **admite valores nulos**. En la fila efectiva de un miembro, `null` significa **ilimitado** (sin límite de gasto) y `"0"` significa que el miembro no puede usar Claude más allá del uso incluido en su plan. En una fila de límite de gasto configurado (como la que devuelve `GET /v1/organizations/spend_limits/{id}`), `null` solo significa que no hay un límite de gasto numérico establecido; lee la fila efectiva del miembro para distinguir entre ilimitado y solo uso incluido.
`period_to_date_spend` es el gasto del miembro acumulado desde el inicio del `period` actual, en el mismo formato de unidades menores; puede incluir una parte fraccionaria (por ejemplo, `"41280.125"`). Puede aparecer como `"0"` si la lectura del gasto no está disponible temporalmente; trátalo como informativo, no transaccional.
### Ciclo de vida de las solicitudes de aumento
Una **solicitud de aumento del límite de gasto** (spend limit increase request) se crea cuando un miembro hace clic en **Request more usage** (Solicitar más uso) en claude.ai. Las solicitudes no se crean a través de esta API. El `status` de una solicitud es uno de los siguientes:
| Estado | Significado |
| ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `pending` | En espera de la acción de un administrador. La solicitud normalmente incluye un `spend_summary` en vivo para que puedas ver el límite de gasto efectivo actual del miembro y su gasto acumulado en el período mientras decides; `spend_summary` puede ser `null` si no se pudo calcular. |
| `approved` | La solicitud se resolvió con aprobación: ya sea porque un administrador la aprobó explícitamente, porque otra acción de un administrador aumentó el límite de gasto del miembro, o porque el soporte de Anthropic aumentó un límite de gasto en nombre de la organización. `spend_summary` es `null`. |
| `denied` | Un administrador la rechazó. `spend_summary` es `null`. El miembro puede enviar una nueva solicitud de inmediato; solo una solicitud `pending` impide crear una nueva. Un administrador aún puede aumentar el límite de gasto del miembro directamente en cualquier momento. |
Tanto `approved` como `denied` son estados terminales. Un miembro tiene como máximo una solicitud `pending` a la vez.
Aprobar con `POST /v1/organizations/spend_limit_increase_requests/{id}/approve` escribe la misma fila de límite de gasto por usuario que escribe `POST /v1/organizations/spend_limits`. Establecer un límite de gasto directamente **no** cambia el estado de una solicitud pendiente; usa el endpoint de aprobación para resolver una solicitud.
De forma predeterminada, Anthropic envía un correo electrónico al miembro cuando su solicitud es aprobada o denegada. Pasa `suppress_notification: true` al aprobar o denegar para suprimir ese correo (por ejemplo, cuando tu propio sistema notifica al miembro).
## Control de versiones
Envía el encabezado `anthropic-version` en cada solicitud; consulta [Versiones de la API](https://platform.claude.com/docs/es/api/versioning) para ver las versiones disponibles.
## Límite de velocidad
Los ocho endpoints comparten un único "rate limit" (límite de velocidad) por organización de **60 solicitudes por minuto**. Las solicitudes que superen el límite devuelven **429 Too Many Requests**.
## Paginación
`GET /v1/organizations/spend_limits/effective` y `GET /v1/organizations/spend_limit_increase_requests` se paginan con un **cursor opaco**. La primera solicitud devuelve hasta `limit` filas más un cursor `next_page`; pasa ese cursor sin modificar como el parámetro `page` en la siguiente solicitud, y repite hasta que `next_page` sea `null`.
**No cambies los parámetros de consulta a mitad de la secuencia.** Los cursores están vinculados a los filtros que los emitieron. Si cambias `user_ids[]`, `period[]`, `status[]` o `actor_ids[]` y pasas un cursor antiguo, obtendrás un 400 con *"cursor does not match current query parameters"*. En su lugar, inicia una nueva secuencia desde la primera página.
## Serialización de parámetros de lista
Los parámetros de lista usan notación de corchetes: repite el nombre del parámetro con `[]` para cada valor.
```text wrap
user_ids[]=user_01AbCdEfGh&user_ids[]=user_01JkLmNoPq
```
## Respuestas de error
Las respuestas de error siguen la forma estándar documentada en [Errores](https://platform.claude.com/docs/es/api/errors). Cita el `request_id` del cuerpo de la respuesta cuando contactes al soporte.
## Límites de gasto
### Listar el límite de gasto efectivo de cada miembro
`GET /v1/organizations/spend_limits/effective` devuelve una fila por cada miembro actual, que refleja el límite de gasto efectivo de cada miembro, su `source` en la jerarquía de alcances y su `period_to_date_spend`. Requiere el alcance `read:spend_limits`.
Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta [Listar límites de gasto efectivos](https://platform.claude.com/docs/es/api/beta/organization/spend_limits/effective/list) en la referencia de la 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_..."
}
```
### Obtener un único límite de gasto
`GET /v1/organizations/spend_limits/{spend_limit_id}` devuelve un límite de gasto configurado por ID. Úsalo para inspeccionar la fila a la que hacía referencia un campo `spend_limit_id`. Requiere el alcance `read:spend_limits`.
Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta [Recuperar un límite de gasto](https://platform.claude.com/docs/es/api/beta/organization/spend_limits/retrieve) en la referencia de la 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}"
```
### Establecer una anulación por usuario
`POST /v1/organizations/spend_limits` establece una anulación del límite de gasto por usuario. Se trata de un upsert con clave `(scope, period)`: establecer un límite para un usuario y período que ya tiene uno lo sobrescribe en su lugar. Este endpoint solo acepta `scope.type: "user"`; los valores predeterminados a nivel de nivel de asiento, grupo y organización se configuran en la configuración de claude.ai. Requiere el alcance `write:spend_limits`.
Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta [Crear un límite de gasto](https://platform.claude.com/docs/es/api/beta/organization/spend_limits/set) en la referencia de la 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"
}
```
### Eliminar una anulación por usuario
`DELETE /v1/organizations/spend_limits/{spend_limit_id}` elimina una anulación por usuario, tras lo cual el miembro vuelve a cualquier valor predeterminado heredado de nivel de asiento, grupo u organización. Las filas a nivel de nivel de asiento, grupo y organización no se pueden eliminar a través de este endpoint. Requiere el alcance `write:spend_limits`.
Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta [Eliminar un límite de gasto](https://platform.claude.com/docs/es/api/beta/organization/spend_limits/delete) en la referencia de la 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}"
```
## Solicitudes de aumento del límite de gasto
### Listar solicitudes de aumento
`GET /v1/organizations/spend_limit_increase_requests` lista las solicitudes, las más recientes primero. Filtra por `status[]` (`pending`, `approved`, `denied`) y `actor_ids[]`. La lista excluye las solicitudes cuyo solicitante ya no es miembro de la organización. Requiere el alcance `read:spend_limits`.
Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta [Listar solicitudes de aumento del límite de gasto](https://platform.claude.com/docs/es/api/beta/organization/spend_limits/increase_requests/list) en la referencia de la 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 solicitud pendiente incluye un `spend_summary` en vivo que muestra el límite de gasto efectivo actual del solicitante y su gasto acumulado en el período, suficiente para decidir sin una consulta adicional.
### Obtener una única solicitud de aumento
`GET /v1/organizations/spend_limit_increase_requests/{id}` devuelve una solicitud por ID. Requiere el alcance `read:spend_limits`.
Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta [Recuperar una solicitud de aumento del límite de gasto](https://platform.claude.com/docs/es/api/beta/organization/spend_limits/increase_requests/retrieve) en la referencia de la 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}"
```
### Aprobar una solicitud de aumento
`POST /v1/organizations/spend_limit_increase_requests/{id}/approve` aprueba una solicitud pendiente: escribe un límite de gasto por usuario con el `amount` proporcionado por el administrador para el solicitante y cambia la solicitud a `approved`. La solicitud no incluye un monto solicitado; tú proporcionas el nuevo límite de gasto al aprobar. Requiere el alcance `write:spend_limits`.
Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta [Aprobar una solicitud de aumento del límite de gasto](https://platform.claude.com/docs/es/api/beta/organization/spend_limits/increase_requests/approve) en la referencia de la 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}"
```
### Denegar una solicitud de aumento
`POST /v1/organizations/spend_limit_increase_requests/{id}/deny` deniega una solicitud pendiente. Es idempotente sobre `denied`: denegar una solicitud ya denegada devuelve 200 con el recurso existente. El endpoint rechaza un intento de denegar una solicitud ya aprobada para que la automatización pueda distinguir un reintento de una decisión contradictoria. Requiere el alcance `write:spend_limits`.
Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta [Denegar una solicitud de aumento del límite de gasto](https://platform.claude.com/docs/es/api/beta/organization/spend_limits/increase_requests/deny) en la referencia de la 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}"
```
## Flujos de trabajo de ejemplo
Algunos de estos flujos de trabajo combinan la API de Límites de Gasto con los endpoints de costo de las [API de Analytics](https://platform.claude.com/docs/es/manage-claude/analytics-api). Los endpoints de costo de Analytics están diseñados para informes de gasto de toda la organización a lo largo de un rango de fechas. `GET /spend_limits/effective` devuelve el tope que se aplica actualmente a cada miembro. Comienza un barrido con Analytics para descubrir qué miembros revisar y luego lee sus topes actuales con `/effective`.
Los endpoints de Límites de Gasto requieren los alcances `spend_limits` y los endpoints de costo de Analytics requieren `read:analytics`; consulta las [API de Analytics](https://platform.claude.com/docs/es/manage-claude/analytics-api) para saber cómo aprovisionar el acceso. Los ejemplos usan una sola clave de API de administrador que tiene los alcances de todas las API que llaman. Un propietario principal [selecciona estos alcances al crear la clave](https://platform.claude.com/docs/es/manage-claude/admin-api-keys#choose-scopes-for-a-claude-enterprise-key). Todos los valores monetarios en ambas son cadenas decimales en unidades menores (centavos). Ambas API paginan con un cursor opaco. Establece un `limit` explícito y recorre las páginas mediante `next_page` hasta que sea `null` para cubrir toda la organización.
### Automatizar el flujo de revisión de solicitudes de aumento
Ejecuta un trabajo programado que obtenga las solicitudes pendientes, aplique la política de aprobación de tu organización y resuelva cada una.
1. Lista las solicitudes pendientes:
```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 solicitud incluye el `actor.user_id` del solicitante y un `spend_summary` en vivo con su `amount` efectivo actual y su `period_to_date_spend`, suficiente para decidir sin una consulta adicional.
2. Aplica tu política. Por ejemplo, aprueba automáticamente cuando el `amount` actual del miembro esté por debajo de un umbral y deriva los topes más grandes a revisión manual.
3. Resuelve cada solicitud. Para aprobar, proporciona el nuevo tope:
```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 denegar, llama en su lugar al [endpoint de denegación](https://platform.claude.com/docs/es/manage-claude/spend-limits-api#deny-an-increase-request) con el mismo ID. Pasa `suppress_notification: true` cuando tu propio sistema notifique al solicitante.
### Identificar miembros cercanos a su límite de gasto
Encuentra a los miembros que se acercan a su tope para poder aumentarlo antes de que queden bloqueados.
1. Obtén el gasto acumulado del mes de cada miembro desde la API de Analytics (una fila por miembro, el gasto más alto primero de forma predeterminada):
```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 fila contiene `actor.user_id`, `actor.email_address` y `amount` (el gasto del miembro en centavos). Recorre las páginas mediante `next_page` para cubrir toda la organización.
2. Para los miembros con mayor gasto (o todos los que superen un umbral en dólares), obtén los topes efectivos en 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 fila devuelve el tope como `amount` (`null` = ilimitado, `"0"` = solo uso incluido) junto con `period_to_date_spend`.
3. Para cada miembro con un tope positivo, calcula `period_to_date_spend / amount` y marca a aquellos que estén en tu umbral o por encima de él (por ejemplo, 80 por ciento). Trata un tope de `"0"` como si ya estuviera en el límite. No existe un filtro del lado del servidor para esta proporción.
4. Actúa sobre los miembros marcados: aumenta el tope con `POST /v1/organizations/spend_limits`, aprueba una solicitud de aumento pendiente si existe, o comunícate con el miembro.
### Encontrar miembros con uso que cambia rápidamente
Identifica a los miembros cuyo gasto ha aumentado bruscamente de una semana a otra.
1. Obtén el costo diario por miembro de las últimas dos semanas desde la 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
```
Con `bucket_width` establecido, cada miembro abarca una fila por cada día con uso. Recorre las páginas mediante `next_page` para recopilar la serie completa de cada miembro.
2. Agrupa las filas por `actor.user_id`. Para cada miembro, suma los siete días más recientes y los siete días anteriores. Marca a los miembros cuya semana reciente supere la semana anterior por el múltiplo que elijas (por ejemplo, tres). El costo de los días recientes es provisional y puede revisarse al alza; para comparaciones repetibles, establece `ending_at` en o antes de un `data_refreshed_at` devuelto previamente (consulta [Disponibilidad y actualización de los datos](https://platform.claude.com/docs/es/manage-claude/analytics-api#data-availability-and-freshness)).
3. Actúa sobre los miembros marcados: ajusta el tope con `POST /v1/organizations/spend_limits`, o comunícate con ellos.
### Aumentar temporalmente el límite de gasto de un miembro durante un incidente
Dale margen de trabajo a quien responde a un incidente mientras este esté abierto: aumenta su tope de gasto cuando comience el incidente y reviértelo después de que el incidente se cierre. Condiciona el aumento a tu sistema de gestión de incidentes, por ejemplo, exigiendo un ID de incidente activo con el miembro asignado a él.
1. Lee el tope actual del miembro y regístralo para la reversión:
```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 el tope:
```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. Si quienes responden necesitan un acceso más amplio durante un incidente, aprovisiona previamente un grupo de respuesta a incidentes cuyo [rol personalizado](https://platform.claude.com/docs/es/manage-claude/user-management#custom-roles) lo otorgue, y agrega al miembro durante ese tiempo:
```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 [Gestión de usuarios](https://platform.claude.com/docs/es/manage-claude/user-management#groups) para ver los endpoints de grupos.
4. Cuando tu sistema de incidentes marque el incidente como cerrado, revierte ambos cambios: restaura el límite de gasto que registraste en el paso 1 (o elimina la anulación con `DELETE /v1/organizations/spend_limits/{spend_limit_id}` si el miembro no tenía ninguna) y quita al miembro del grupo con `DELETE /v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}`.
## Preguntas frecuentes
### ¿Establecer un límite de gasto directamente resuelve la solicitud de aumento pendiente de un miembro?
No. `POST /v1/organizations/spend_limits` escribe la anulación pero deja intacta la solicitud pendiente. Usa `POST /v1/organizations/spend_limit_increase_requests/{id}/approve` para resolver la solicitud y escribir la anulación en una sola llamada.
### ¿Qué sucede cuando elimino una anulación por usuario?
El miembro vuelve a lo que heredaría de la jerarquía: el valor predeterminado de su grupo, nivel de asiento u organización. Si no existe ningún valor predeterminado en ningún nivel, el miembro queda sin límite.
### ¿Puedo establecer un valor predeterminado de nivel de asiento o de toda la organización a través de esta API?
No. Solo las anulaciones por usuario se pueden escribir a través de esta API. Los valores predeterminados a nivel de nivel de asiento, grupo y organización se configuran en la configuración de la organización en claude.ai.
### ¿Por qué `period_to_date_spend` a veces aparece como `"0"` para un miembro activo?
La lectura del gasto puede no estar disponible temporalmente, en cuyo caso el campo muestra `"0"` en lugar de generar un error. Trátalo como informativo.
## Ver también
Esquemas de solicitud y respuesta generados para cada endpoint de la API de Límites de Gasto.
Esquemas de solicitud y respuesta generados para los endpoints de solicitudes de aumento.
Informes de uso y costo por usuario y agrupados por intervalos de tiempo para Claude Enterprise.