--- title: Gestión de usuarios url: https://platform.claude.com/docs/es/manage-claude/user-management description: "Gestiona a las personas de tu organización de Claude Enterprise con la Admin API: lista miembros y cambia roles, envía y retira invitaciones, gestiona grupos y lee roles personalizados." --- Esta página cubre la gestión programática de las personas de tu organización de **Claude Enterprise** (claude.ai), usando la [Admin API](https://platform.claude.com/docs/es/api/beta/organization): listar miembros y buscarlos por dirección de correo electrónico, cambiar el rol de un miembro, eliminar miembros, enviar y retirar invitaciones, gestionar los grupos de tu empresa y su membresía, y leer los roles personalizados de tu organización. Para organizaciones de Claude Console (Claude Platform), consulta la [guía de la Admin API para Claude Console](https://platform.claude.com/docs/es/manage-claude/admin-api). Las solicitudes de grupos y roles personalizados no requieren el [encabezado beta](https://platform.claude.com/docs/es/api/beta-headers) `anthropic-beta: ce-user-management-2026-07-13`. Las solicitudes que aún lo envían se aceptan y se comportan de forma idéntica. ## ¿Qué endpoints puede usar tu organización? La Admin API es un único conjunto de endpoints bajo `https://api.anthropic.com/v1/organizations/`. Las organizaciones de Claude Console y Claude Enterprise se autentican con [claves diferentes](https://platform.claude.com/docs/es/manage-claude/admin-api-keys) y cada una tiene acceso a un subconjunto diferente de los endpoints: | Endpoints | Claude Console (Claude Platform) | Claude Enterprise (claude.ai) | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | [Miembros](https://platform.claude.com/docs/es/manage-claude/user-management#members) e [invitaciones](https://platform.claude.com/docs/es/manage-claude/user-management#invites) | Disponible; consulta la [guía de la Admin API](https://platform.claude.com/docs/es/manage-claude/admin-api) | Disponible (esta página) | | [Grupos](https://platform.claude.com/docs/es/manage-claude/user-management#groups) | No disponible | Disponible (esta página) | | [Roles personalizados](https://platform.claude.com/docs/es/manage-claude/user-management#custom-roles) | No disponible | Disponible, solo lectura (esta página) | | [Límites de gasto](https://platform.claude.com/docs/es/manage-claude/spend-limits-api) | No disponible | Disponible | | Informes de uso y costos | Disponible; consulta la [API de uso y costos](https://platform.claude.com/docs/es/manage-claude/usage-cost-api) | Disponible a través de la [Claude Enterprise Analytics API](https://platform.claude.com/docs/es/manage-claude/analytics-api#get-access-to-the-claude-enterprise-analytics-api) | | [Espacios de trabajo](https://platform.claude.com/docs/es/manage-claude/workspaces), [claves de API](https://platform.claude.com/docs/es/manage-claude/admin-api#api-keys), [límites de velocidad](https://platform.claude.com/docs/es/manage-claude/rate-limits-api) y los demás endpoints de la [guía de la Admin API](https://platform.claude.com/docs/es/manage-claude/admin-api) | Disponible | No disponible | Los miembros y las invitaciones son los mismos endpoints para ambos tipos de organización; esta página documenta su comportamiento en Claude Enterprise, incluidos los [roles de organización](https://platform.claude.com/docs/es/manage-claude/user-management#organization-roles) de Claude Enterprise. Los endpoints de grupos y roles personalizados existen solo para Claude Enterprise. **Se requiere una clave de Admin API con alcance** Estos endpoints requieren una clave de Admin API con el "scope" (alcance) `read:members` (endpoints `GET` de miembros e invitaciones, y todos los endpoints de roles personalizados; no existe un alcance de roles independiente), el alcance `write:members` (endpoints `POST` y `DELETE` de miembros e invitaciones), el alcance `read:rbac_groups` (endpoints `GET` de grupos) o el alcance `write:rbac_groups` (endpoints `POST` y `DELETE` de grupos). Asignar el rol `managed`, o asignar grupos en una invitación, requiere `write:rbac_groups` además de `write:members`. Una clave con el alcance `read:org_audit` (un alcance de solo lectura para integraciones de auditoría de seguridad) también puede llamar a todos los endpoints `GET` de esta página y a los endpoints de lectura de la [Compliance API](https://platform.claude.com/docs/es/manage-claude/compliance-api). Consulta [Crear una clave de Admin API](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 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). ## Descripción general Esta página cubre cinco recursos: | Recurso | Endpoints | Úsalo para | | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------ | | **Miembros** | `GET /v1/organizations/users`
`GET /v1/organizations/users/{user_id}`
`POST /v1/organizations/users/{user_id}`
`DELETE /v1/organizations/users/{user_id}` | Listar los miembros de la organización o buscar uno por correo electrónico; cambiar el rol de un miembro; eliminar un miembro. | | **Invitaciones** | `POST /v1/organizations/invites`
`GET /v1/organizations/invites`
`GET /v1/organizations/invites/{invite_id}`
`DELETE /v1/organizations/invites/{invite_id}` | Invitar a una persona a la organización, hacer seguimiento del estado de la invitación y retirarla antes de que se acepte. | | **Grupos** | `GET /v1/organizations/rbac_groups`
`GET /v1/organizations/rbac_groups/{rbac_group_id}`
`POST /v1/organizations/rbac_groups`
`POST /v1/organizations/rbac_groups/{rbac_group_id}`
`DELETE /v1/organizations/rbac_groups/{rbac_group_id}` | Consultar los grupos de tu empresa y los roles personalizados asociados a cada uno; crear, renombrar y eliminar grupos. | | **Miembros de grupos** | `GET /v1/organizations/rbac_groups/{rbac_group_id}/members`
`POST /v1/organizations/rbac_groups/{rbac_group_id}/members`
`DELETE /v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}` | Consultar los miembros de un grupo; agregar y eliminar miembros. | | **Roles personalizados** | `GET /v1/organizations/rbac_roles`
`GET /v1/organizations/rbac_roles/{rbac_role_id}`
`GET /v1/organizations/rbac_roles/{rbac_role_id}/permissions` | Consultar los roles personalizados de tu organización y los permisos que otorga cada rol. | Los roles personalizados y sus asociaciones a grupos se gestionan en la [configuración de la organización de claude.ai](https://claude.ai/admin-settings); la API los lee pero no puede cambiarlos. ## Inicio rápido Establece la variable de entorno `ANTHROPIC_API_KEY` con tu clave de Admin API. Los ejemplos de esta página leen la clave desde ella. El SDK y la CLI `ant` envían los encabezados `x-api-key` y `anthropic-version` por ti. Lista los miembros de la organización, los más recientes primero: ```bash cURL curl "https://api.anthropic.com/v1/organizations/users?limit=20" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant organization:users list --limit 20 ``` ```python Python client = anthropic.Anthropic() users = client.organization.users.list(limit=20) for user in users: print(f"{user.id}: {user.email} ({user.role})") ``` ```typescript TypeScript const client = new Anthropic(); const users = await client.organization.users.list({ limit: 20 }); for await (const user of users) { console.log(`${user.id}: ${user.email} (${user.role})`); } ``` ```csharp C# AnthropicClient client = new(); var page = await client.Organization.Users.List(new() { Limit = 20 }); await foreach (var user in page.Paginate()) { Console.WriteLine($"{user.ID}: {user.Email} ({user.Role.Raw()})"); } ``` ```go Go client := anthropic.NewClient() users := client.Organization.Users.ListAutoPaging(context.Background(), anthropic.OrganizationUserListParams{ Limit: anthropic.Int(20), }) for users.Next() { user := users.Current() fmt.Printf("%s: %s (%s)\n", user.ID, user.Email, user.Role) } if err := users.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.organization.users.UserListParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = UserListParams.builder() .limit(20) .build(); var users = client.organization().users().list(params); for (var user : users.autoPager()) { IO.println(user.id() + ": " + user.email() + " (" + user.role().asString() + ")"); } } ``` ```php PHP $client = new Client(); $users = $client->organization->users->list(limit: 20); foreach ($users->pagingEachItem() as $user) { echo "{$user->id}: {$user->email} ({$user->role})\n"; } ``` ```ruby Ruby client = Anthropic::Client.new users = client.organization.users.list(limit: 20) users.auto_paging_each do |user| puts "#{user.id}: #{user.email} (#{user.role})" end ``` ```json { "data": [ { "type": "user", "id": "user_01AbCdEfGhIjKlMnOpQrSt", "email": "jane@example.com", "name": "Jane Smith", "role": "user", "added_at": "2026-06-12T09:14:03Z" } ], "has_more": false, "first_id": "user_01AbCdEfGhIjKlMnOpQrSt", "last_id": "user_01AbCdEfGhIjKlMnOpQrSt" } ``` ## Conceptos clave ### Roles de organización Cada miembro tiene exactamente un rol de organización. Las lecturas devuelven el rol del miembro como uno de cinco valores: | Rol | Significado | | ------------------ | ------------------------------------------------------------------------------------------------- | | `user` | Un miembro estándar. | | `managed` | Un miembro cuyos permisos se otorgan a través de los roles personalizados asociados a sus grupos. | | `owner` | Un propietario de la organización. | | `membership_admin` | Un miembro que puede gestionar los miembros de la organización. | | `primary_owner` | El propietario principal de la organización. Hay exactamente uno. | La API solo puede asignar los roles `user` y `managed`, al crear invitaciones y al actualizar roles. Asignar `managed` requiere el alcance `write:rbac_groups` además de `write:members`, porque los permisos de un miembro gestionado provienen de los roles personalizados asociados a sus grupos. Los roles administrativos (`owner`, `membership_admin` y `primary_owner`) se asignan en la configuración de la organización de claude.ai, y los miembros que los tienen no pueden modificarse ni eliminarse a través de esta API. ### Miembros e invitaciones Una persona se convierte en miembro al aceptar una invitación (o a través del "single sign-on" (inicio de sesión único) de tu organización, donde esté configurado). Crear una invitación envía un correo electrónico de invitación; la invitación se lee entonces como `pending` hasta que el destinatario acepta (`accepted`) o pasa su `expires_at` asignado por el servidor (`expired`). Solo una invitación `pending` puede retirarse. Para cambiar la dirección de correo electrónico o el rol de una invitación pendiente, retírala y crea una nueva. Si el plan de tu organización toma miembros de un conjunto finito de asientos comprados, una invitación pendiente consume un asiento. El endpoint de creación de invitaciones no acepta un parámetro de asiento o nivel: el asiento se asigna automáticamente desde el nivel más bajo que tenga disponibilidad. Crear una invitación cuando no hay ningún asiento libre falla con un error 400 en lugar de comprar un asiento. Retirar la invitación, dejar que expire o eliminar al miembro más tarde devuelve el asiento al conjunto. ### Grupos y roles Los grupos conectan a los miembros con roles personalizados ("role-based access control" (control de acceso basado en roles), el `rbac` de las rutas de los endpoints y de los nombres de los alcances). Los grupos pertenecen a tu empresa en su conjunto (la organización principal junto con todas las organizaciones que dependen de ella) y no a una sola organización, por lo que los alcances de grupos (`read:rbac_groups` y `write:rbac_groups`) requieren una clave creada para todas las organizaciones vinculadas. Cada grupo tiene un `source_type`: `direct` para los grupos creados en claude.ai, `scim` para los grupos aprovisionados por tu proveedor de identidad. El campo `role_ids` de un grupo enumera los ID de los roles personalizados asociados a él; resuélvelos en nombres y permisos con los [endpoints de roles personalizados](https://platform.claude.com/docs/es/manage-claude/user-management#custom-roles), teniendo en cuenta que el catálogo de roles es por organización mientras que los grupos abarcan toda la empresa, por lo que obtener un rol que pertenece a otra organización de tu empresa devuelve 404 para tu clave. El campo es `null` (en lugar de `[]`) cuando los datos de roles no estaban disponibles temporalmente, así que vuelve a intentarlo para distinguir una lectura degradada de un grupo sin roles. Todavía se devuelven dos campos obsoletos: `roles` en los grupos, siempre igual a `role_ids`, y `group_id` en los miembros de grupos, siempre igual a `rbac_group_id`. ## 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ímites de velocidad Los endpoints de la Admin API comparten un "rate limit" (límite de velocidad) por organización de **100 solicitudes por minuto**; la creación de invitaciones tiene en su lugar su propio límite de **1,200 solicitudes por hora**. Las solicitudes que superan un límite devuelven **429 Too Many Requests**. ## Paginación Las listas de miembros e invitaciones usan paginación basada en ID: pasa `limit` (predeterminado 20, máximo 1000) más como máximo uno de `before_id` o `after_id`, y pagina usando los campos `first_id` y `last_id` de cada respuesta hasta que `has_more` sea `false`. Las listas de grupos y roles personalizados usan en su lugar un **cursor opaco**: el valor `next_page` de la respuesta se pasa sin cambios como el parámetro `page` en la siguiente solicitud, hasta que `next_page` sea `null`. Cuando iteras sobre los resultados, el SDK obtiene más páginas por ti, por lo que `limit` establece el tamaño de página, no el total. En la CLI, `--limit` establece el número total de resultados para las listas de miembros e invitaciones. Para las listas de grupos y roles, establece el tamaño de página. ## Respuestas de error Las respuestas de error siguen la forma estándar documentada en [Errores](https://platform.claude.com/docs/es/api/errors). ## Miembros ### Listar miembros `GET /v1/organizations/users` devuelve los miembros de la organización, los agregados más recientemente primero. Filtra por `email` para buscar un miembro específico; la coincidencia no distingue mayúsculas de minúsculas y tolera variantes comunes de la misma dirección (por ejemplo, `jane+hiring@example.com` coincide con `jane@example.com`). Requiere el alcance `read:members`. Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta [Listar usuarios](https://platform.claude.com/docs/es/api/organization/users/list) en la referencia de la API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/users?email=jane@example.com" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant organization:users list --email jane@example.com ``` ```python Python client = anthropic.Anthropic() users = client.organization.users.list(email="jane@example.com") for user in users: print(f"{user.id}: {user.email} ({user.role})") ``` ```typescript TypeScript const client = new Anthropic(); const users = await client.organization.users.list({ email: "jane@example.com" }); for await (const user of users) { console.log(`${user.id}: ${user.email} (${user.role})`); } ``` ```csharp C# AnthropicClient client = new(); var page = await client.Organization.Users.List(new() { Email = "jane@example.com" }); await foreach (var user in page.Paginate()) { Console.WriteLine($"{user.ID}: {user.Email} ({user.Role.Raw()})"); } ``` ```go Go client := anthropic.NewClient() users := client.Organization.Users.ListAutoPaging(context.Background(), anthropic.OrganizationUserListParams{ Email: anthropic.String("jane@example.com"), }) for users.Next() { user := users.Current() fmt.Printf("%s: %s (%s)\n", user.ID, user.Email, user.Role) } if err := users.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.organization.users.UserListParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = UserListParams.builder() .email("jane@example.com") .build(); var users = client.organization().users().list(params); for (var user : users.autoPager()) { IO.println(user.id() + ": " + user.email() + " (" + user.role().asString() + ")"); } } ``` ```php PHP $client = new Client(); $users = $client->organization->users->list(email: 'jane@example.com'); foreach ($users->pagingEachItem() as $user) { echo "{$user->id}: {$user->email} ({$user->role})\n"; } ``` ```ruby Ruby client = Anthropic::Client.new users = client.organization.users.list(email: "jane@example.com") users.auto_paging_each do |user| puts "#{user.id}: #{user.email} (#{user.role})" end ``` ### Obtener un miembro `GET /v1/organizations/users/{user_id}` devuelve un miembro por ID. Requiere el alcance `read:members`. Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta [Obtener usuario](https://platform.claude.com/docs/es/api/organization/users/retrieve) en la referencia de la API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/users/user_01AbCdEfGhIjKlMnOpQrSt" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant organization:users retrieve --user-id user_01AbCdEfGhIjKlMnOpQrSt ``` ```python Python client = anthropic.Anthropic() user = client.organization.users.retrieve("user_01AbCdEfGhIjKlMnOpQrSt") print(f"id: {user.id}") print(f"email: {user.email}") print(f"role: {user.role}") ``` ```typescript TypeScript const client = new Anthropic(); const user = await client.organization.users.retrieve("user_01AbCdEfGhIjKlMnOpQrSt"); console.log(`id: ${user.id}`); console.log(`email: ${user.email}`); console.log(`role: ${user.role}`); ``` ```csharp C# AnthropicClient client = new(); var user = await client.Organization.Users.Retrieve("user_01AbCdEfGhIjKlMnOpQrSt"); Console.WriteLine($"id: {user.ID}"); Console.WriteLine($"email: {user.Email}"); Console.WriteLine($"role: {user.Role.Raw()}"); ``` ```go Go client := anthropic.NewClient() user, err := client.Organization.Users.Get(context.Background(), "user_01AbCdEfGhIjKlMnOpQrSt") if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", user.ID) fmt.Printf("email: %s\n", user.Email) fmt.Printf("role: %s\n", user.Role) ``` ```java Java AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var user = client.organization().users() .retrieve("user_01AbCdEfGhIjKlMnOpQrSt"); IO.println("id: " + user.id()); IO.println("email: " + user.email()); IO.println("role: " + user.role().asString()); ``` ```php PHP $client = new Client(); $user = $client->organization->users->retrieve( userID: 'user_01AbCdEfGhIjKlMnOpQrSt', ); echo "id: {$user->id}\n"; echo "email: {$user->email}\n"; echo "role: {$user->role}\n"; ``` ```ruby Ruby client = Anthropic::Client.new user = client.organization.users.retrieve("user_01AbCdEfGhIjKlMnOpQrSt") puts "id: #{user.id}" puts "email: #{user.email}" puts "role: #{user.role}" ``` ### Cambiar el rol de un miembro `POST /v1/organizations/users/{user_id}` establece el rol del miembro en `user` o `managed`. Los miembros que tienen un rol administrativo (`owner`, `membership_admin` o `primary_owner`) no pueden modificarse a través de este endpoint, y los roles administrativos no pueden asignarse; ambos casos devuelven 400 y se gestionan en la configuración de la organización de claude.ai. Si el proveedor de identidad de tu organización gestiona los roles (SSO avanzado o aprovisionamiento SCIM avanzado), las actualizaciones de roles devuelven 400. Requiere el alcance `write:members`, más `write:rbac_groups` al cambiar el rol a `managed`. Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta [Actualizar usuario](https://platform.claude.com/docs/es/api/organization/users/update) en la referencia de la API. ```bash cURL curl -X POST "https://api.anthropic.com/v1/organizations/users/user_01AbCdEfGhIjKlMnOpQrSt" \ -H "content-type: application/json" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -d '{"role": "managed"}' ``` ```bash CLI ant organization:users update \ --user-id user_01AbCdEfGhIjKlMnOpQrSt \ --role managed ``` ```python Python client = anthropic.Anthropic() user = client.organization.users.update("user_01AbCdEfGhIjKlMnOpQrSt", role="managed") print(f"id: {user.id}") print(f"role: {user.role}") ``` ```typescript TypeScript const client = new Anthropic(); const user = await client.organization.users.update("user_01AbCdEfGhIjKlMnOpQrSt", { role: "managed" }); console.log(`id: ${user.id}`); console.log(`role: ${user.role}`); ``` ```csharp C# using Anthropic.Models.Organization.Users; // ... AnthropicClient client = new(); var user = await client.Organization.Users.Update( "user_01AbCdEfGhIjKlMnOpQrSt", new() { Role = Role.Managed } ); Console.WriteLine($"id: {user.ID}"); Console.WriteLine($"role: {user.Role.Raw()}"); ``` ```go Go client := anthropic.NewClient() user, err := client.Organization.Users.Update( context.Background(), "user_01AbCdEfGhIjKlMnOpQrSt", anthropic.OrganizationUserUpdateParams{ Role: anthropic.OrganizationUserUpdateParamsRoleManaged, }, ) if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", user.ID) fmt.Printf("role: %s\n", user.Role) ``` ```java Java import com.anthropic.models.organization.users.UserUpdateParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = UserUpdateParams.builder() .role(UserUpdateParams.Role.MANAGED) .build(); var user = client.organization().users() .update("user_01AbCdEfGhIjKlMnOpQrSt", params); IO.println("id: " + user.id()); IO.println("role: " + user.role().asString()); } ``` ```php PHP use Anthropic\Organization\Users\UserUpdateParams\Role; // ... $client = new Client(); $user = $client->organization->users->update( userID: 'user_01AbCdEfGhIjKlMnOpQrSt', role: Role::MANAGED, ); echo "id: {$user->id}\n"; echo "role: {$user->role}\n"; ``` ```ruby Ruby client = Anthropic::Client.new user_id = "user_01AbCdEfGhIjKlMnOpQrSt" user = client.organization.users.update(user_id, role: :managed) puts "id: #{user.id}" puts "role: #{user.role}" ``` ### Eliminar un miembro `DELETE /v1/organizations/users/{user_id}` elimina al miembro de la organización, devolviendo cualquier asiento comprado que ocupara al conjunto de la organización. Los miembros que tienen un rol administrativo no pueden eliminarse a través de este endpoint, y si tu proveedor de identidad gestiona la membresía (SCIM), las eliminaciones devuelven 400. Requiere el alcance `write:members`. Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta [Eliminar usuario](https://platform.claude.com/docs/es/api/organization/users/remove) en la referencia de la API. ```bash cURL curl -X DELETE "https://api.anthropic.com/v1/organizations/users/user_01AbCdEfGhIjKlMnOpQrSt" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant organization:users remove --user-id user_01AbCdEfGhIjKlMnOpQrSt ``` ```python Python client = anthropic.Anthropic() removed_user = client.organization.users.remove("user_01AbCdEfGhIjKlMnOpQrSt") print(f"id: {removed_user.id}") ``` ```typescript TypeScript const client = new Anthropic(); const removedUser = await client.organization.users.remove("user_01AbCdEfGhIjKlMnOpQrSt"); console.log(`id: ${removedUser.id}`); ``` ```csharp C# AnthropicClient client = new(); var removedUser = await client.Organization.Users.Remove("user_01AbCdEfGhIjKlMnOpQrSt"); Console.WriteLine($"id: {removedUser.ID}"); ``` ```go Go client := anthropic.NewClient() removedUser, err := client.Organization.Users.Remove(context.Background(), "user_01AbCdEfGhIjKlMnOpQrSt") if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", removedUser.ID) ``` ```java Java AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var removedUser = client.organization().users() .remove("user_01AbCdEfGhIjKlMnOpQrSt"); IO.println("id: " + removedUser.id()); ``` ```php PHP $client = new Client(); $removedUser = $client->organization->users->remove( userID: 'user_01AbCdEfGhIjKlMnOpQrSt', ); echo "id: {$removedUser->id}\n"; ``` ```ruby Ruby client = Anthropic::Client.new user_id = "user_01AbCdEfGhIjKlMnOpQrSt" removed_user = client.organization.users.remove(user_id) puts "id: #{removed_user.id}" ``` ```json { "type": "user_deleted", "id": "user_01AbCdEfGhIjKlMnOpQrSt" } ``` ## Invitaciones ### Crear una invitación `POST /v1/organizations/invites` envía un correo electrónico de invitación y devuelve la invitación con un `expires_at` asignado por el servidor. `role` debe ser `user` o `managed`. Si ya existe una invitación pendiente para la dirección de correo electrónico, o la dirección ya pertenece a un miembro, la solicitud devuelve 400 indicando el recurso existente. Las organizaciones cuyo proveedor de identidad aprovisiona usuarios automáticamente (JIT o SCIM) no pueden crear invitaciones a través de la API. Requiere el alcance `write:members`, más `write:rbac_groups` cuando `role` es `managed`. En planes que toman miembros de un conjunto finito de asientos, la invitación toma automáticamente un asiento del nivel más bajo que tenga disponibilidad. La API no acepta un parámetro de nivel. Si no hay ningún asiento libre, la solicitud falla con un error 400 en lugar de comprar un asiento. Agrega asientos a través de la gestión del plan de la organización y reintenta. El campo opcional `rbac_group_ids` lista los grupos (por ID con prefijo `rbac_group_`) que se asignarán al miembro cuando acepte. Pasar un `rbac_group_ids` no vacío requiere además que la clave tenga el alcance `write:rbac_groups`, porque la asignación de grupos puede otorgar los permisos asociados a los roles del grupo. Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta [Crear invitación](https://platform.claude.com/docs/es/api/organization/invites/create) en la referencia de la API. ```bash cURL curl -X POST "https://api.anthropic.com/v1/organizations/invites" \ -H "content-type: application/json" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -d '{ "email": "newhire@example.com", "role": "managed", "rbac_group_ids": ["rbac_group_01UvWxYzAbCdEfGhIjKlMn"] }' ``` ```bash CLI ant organization:invites create \ --email newhire@example.com \ --role managed \ --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn ``` ```python Python client = anthropic.Anthropic() invite = client.organization.invites.create( email="newhire@example.com", role="managed", rbac_group_ids=["rbac_group_01UvWxYzAbCdEfGhIjKlMn"], ) print(f"id: {invite.id}") print(f"email: {invite.email}") print(f"status: {invite.status}") print(f"expires_at: {invite.expires_at}") ``` ```typescript TypeScript const client = new Anthropic(); const invite = await client.organization.invites.create({ email: "newhire@example.com", role: "managed", rbac_group_ids: ["rbac_group_01UvWxYzAbCdEfGhIjKlMn"] }); console.log(`id: ${invite.id}`); console.log(`email: ${invite.email}`); console.log(`status: ${invite.status}`); console.log(`expires_at: ${invite.expires_at}`); ``` ```csharp C# using Anthropic.Models.Organization.Invites; // ... AnthropicClient client = new(); var invite = await client.Organization.Invites.Create(new() { Email = "newhire@example.com", Role = Role.Managed, RbacGroupIds = ["rbac_group_01UvWxYzAbCdEfGhIjKlMn"] }); Console.WriteLine($"id: {invite.ID}"); Console.WriteLine($"email: {invite.Email}"); Console.WriteLine($"status: {invite.Status.Raw()}"); Console.WriteLine($"expires_at: {invite.ExpiresAt:O}"); ``` ```go Go client := anthropic.NewClient() invite, err := client.Organization.Invites.New(context.Background(), anthropic.OrganizationInviteNewParams{ Email: "newhire@example.com", Role: anthropic.OrganizationInviteNewParamsRoleManaged, RBACGroupIDs: []string{"rbac_group_01UvWxYzAbCdEfGhIjKlMn"}, }) if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", invite.ID) fmt.Printf("email: %s\n", invite.Email) fmt.Printf("status: %s\n", invite.Status) fmt.Printf("expires_at: %s\n", invite.ExpiresAt.Format(time.RFC3339)) ``` ```java Java import com.anthropic.models.organization.invites.InviteCreateParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = InviteCreateParams.builder() .email("newhire@example.com") .role(InviteCreateParams.Role.MANAGED) .addRbacGroupId("rbac_group_01UvWxYzAbCdEfGhIjKlMn") .build(); var invite = client.organization().invites().create(params); IO.println("id: " + invite.id()); IO.println("email: " + invite.email()); IO.println("status: " + invite.status().asString()); IO.println("expires_at: " + invite.expiresAt()); } ``` ```php PHP use Anthropic\Organization\Invites\InviteCreateParams\Role; // ... $client = new Client(); $invite = $client->organization->invites->create( email: 'newhire@example.com', role: Role::MANAGED, rbacGroupIDs: ['rbac_group_01UvWxYzAbCdEfGhIjKlMn'], ); echo "id: {$invite->id}\n"; echo "email: {$invite->email}\n"; echo "status: {$invite->status}\n"; echo "expires_at: {$invite->expiresAt->format(DATE_ATOM)}\n"; ``` ```ruby Ruby client = Anthropic::Client.new invite = client.organization.invites.create( email: "newhire@example.com", role: :managed, rbac_group_ids: ["rbac_group_01UvWxYzAbCdEfGhIjKlMn"] ) puts "id: #{invite.id}" puts "email: #{invite.email}" puts "status: #{invite.status}" puts "expires_at: #{invite.expires_at.iso8601}" ``` ```json { "type": "invite", "id": "invite_01QrStUvWxYzAbCdEfGhIj", "email": "newhire@example.com", "role": "managed", "invited_at": "2026-07-06T16:20:11Z", "expires_at": "2026-07-27T16:20:11Z", "accepted_at": null, "status": "pending", "rbac_group_ids": ["rbac_group_01UvWxYzAbCdEfGhIjKlMn"] } ``` ### Listar invitaciones `GET /v1/organizations/invites` devuelve las invitaciones de la organización, las más recientes primero, en los estados `pending`, `accepted` y `expired`; no hay filtro de estado. Requiere el alcance `read:members`. Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta [Listar invitaciones](https://platform.claude.com/docs/es/api/organization/invites/list) en la referencia de la API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/invites?limit=20" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant organization:invites list --limit 20 ``` ```python Python client = anthropic.Anthropic() invites = client.organization.invites.list(limit=20) for invite in invites: print(f"{invite.id}: {invite.email} ({invite.status})") ``` ```typescript TypeScript const client = new Anthropic(); const invites = await client.organization.invites.list({ limit: 20 }); for await (const invite of invites) { console.log(`${invite.id}: ${invite.email} (${invite.status})`); } ``` ```csharp C# AnthropicClient client = new(); var page = await client.Organization.Invites.List(new() { Limit = 20 }); await foreach (var invite in page.Paginate()) { Console.WriteLine($"{invite.ID}: {invite.Email} ({invite.Status.Raw()})"); } ``` ```go Go client := anthropic.NewClient() invites := client.Organization.Invites.ListAutoPaging(context.Background(), anthropic.OrganizationInviteListParams{ Limit: anthropic.Int(20), }) for invites.Next() { invite := invites.Current() fmt.Printf("%s: %s (%s)\n", invite.ID, invite.Email, invite.Status) } if err := invites.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.organization.invites.InviteListParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = InviteListParams.builder() .limit(20) .build(); var invites = client.organization().invites().list(params); for (var invite : invites.autoPager()) { IO.println(invite.id() + ": " + invite.email() + " (" + invite.status().asString() + ")"); } } ``` ```php PHP $client = new Client(); $invites = $client->organization->invites->list(limit: 20); foreach ($invites->pagingEachItem() as $invite) { echo "{$invite->id}: {$invite->email} ({$invite->status})\n"; } ``` ```ruby Ruby client = Anthropic::Client.new invites = client.organization.invites.list(limit: 20) invites.auto_paging_each do |invite| puts "#{invite.id}: #{invite.email} (#{invite.status})" end ``` ### Obtener una invitación `GET /v1/organizations/invites/{invite_id}` devuelve una invitación por ID. Requiere el alcance `read:members`. Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta [Obtener invitación](https://platform.claude.com/docs/es/api/organization/invites/retrieve) en la referencia de la API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/invites/invite_01QrStUvWxYzAbCdEfGhIj" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant organization:invites retrieve --invite-id invite_01QrStUvWxYzAbCdEfGhIj ``` ```python Python client = anthropic.Anthropic() invite = client.organization.invites.retrieve("invite_01QrStUvWxYzAbCdEfGhIj") print(f"id: {invite.id}") print(f"email: {invite.email}") print(f"status: {invite.status}") ``` ```typescript TypeScript const client = new Anthropic(); const invite = await client.organization.invites.retrieve("invite_01QrStUvWxYzAbCdEfGhIj"); console.log(`id: ${invite.id}`); console.log(`email: ${invite.email}`); console.log(`status: ${invite.status}`); ``` ```csharp C# AnthropicClient client = new(); var invite = await client.Organization.Invites.Retrieve("invite_01QrStUvWxYzAbCdEfGhIj"); Console.WriteLine($"id: {invite.ID}"); Console.WriteLine($"email: {invite.Email}"); Console.WriteLine($"status: {invite.Status.Raw()}"); ``` ```go Go client := anthropic.NewClient() invite, err := client.Organization.Invites.Get(context.Background(), "invite_01QrStUvWxYzAbCdEfGhIj") if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", invite.ID) fmt.Printf("email: %s\n", invite.Email) fmt.Printf("status: %s\n", invite.Status) ``` ```java Java AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var invite = client.organization().invites() .retrieve("invite_01QrStUvWxYzAbCdEfGhIj"); IO.println("id: " + invite.id()); IO.println("email: " + invite.email()); IO.println("status: " + invite.status().asString()); ``` ```php PHP $client = new Client(); $invite = $client->organization->invites->retrieve( inviteID: 'invite_01QrStUvWxYzAbCdEfGhIj', ); echo "id: {$invite->id}\n"; echo "email: {$invite->email}\n"; echo "status: {$invite->status}\n"; ``` ```ruby Ruby client = Anthropic::Client.new invite = client.organization.invites.retrieve("invite_01QrStUvWxYzAbCdEfGhIj") puts "id: #{invite.id}" puts "email: #{invite.email}" puts "status: #{invite.status}" ``` ### Retirar una invitación `DELETE /v1/organizations/invites/{invite_id}` retira una invitación `pending`, desactivando el enlace del correo electrónico de invitación. Retirar una invitación `accepted` devuelve 400 (elimina al miembro en su lugar); retirar una invitación `expired` devuelve 400. Requiere el alcance `write:members`. Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta [Eliminar invitación](https://platform.claude.com/docs/es/api/organization/invites/delete) en la referencia de la API. ```bash cURL curl -X DELETE "https://api.anthropic.com/v1/organizations/invites/invite_01QrStUvWxYzAbCdEfGhIj" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant organization:invites delete --invite-id invite_01QrStUvWxYzAbCdEfGhIj ``` ```python Python client = anthropic.Anthropic() deleted_invite = client.organization.invites.delete("invite_01QrStUvWxYzAbCdEfGhIj") print(f"id: {deleted_invite.id}") ``` ```typescript TypeScript const client = new Anthropic(); const deletedInvite = await client.organization.invites.delete( "invite_01QrStUvWxYzAbCdEfGhIj" ); console.log(`id: ${deletedInvite.id}`); ``` ```csharp C# AnthropicClient client = new(); var deletedInvite = await client.Organization.Invites.Delete("invite_01QrStUvWxYzAbCdEfGhIj"); Console.WriteLine($"id: {deletedInvite.ID}"); ``` ```go Go client := anthropic.NewClient() deletedInvite, err := client.Organization.Invites.Delete(context.Background(), "invite_01QrStUvWxYzAbCdEfGhIj") if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", deletedInvite.ID) ``` ```java Java AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var deletedInvite = client.organization().invites() .delete("invite_01QrStUvWxYzAbCdEfGhIj"); IO.println("id: " + deletedInvite.id()); ``` ```php PHP $client = new Client(); $deletedInvite = $client->organization->invites->delete( inviteID: 'invite_01QrStUvWxYzAbCdEfGhIj', ); echo "id: {$deletedInvite->id}\n"; ``` ```ruby Ruby client = Anthropic::Client.new invite_id = "invite_01QrStUvWxYzAbCdEfGhIj" deleted_invite = client.organization.invites.delete(invite_id) puts "id: #{deleted_invite.id}" ``` ## Grupos Los grupos que tu empresa crea directamente, en la [configuración de la organización de claude.ai](https://claude.ai/admin-settings) o mediante esta API (`source_type: "direct"`), admiten todos los endpoints de esta sección. Los grupos aprovisionados por tu proveedor de identidad (`source_type: "scim"`) se pueden leer, pero no modificar: renombrar o eliminar un grupo SCIM, o cambiar su membresía, devuelve 400, porque pertenece a tu proveedor de identidad. ### Listar grupos `GET /v1/organizations/rbac_groups` devuelve los grupos de tu empresa, incluidos los grupos gestionados por el proveedor de identidad (`scim`). Requiere el alcance `read:rbac_groups`. Para obtener detalles completos de los parámetros y esquemas de respuesta, consulta [Listar grupos](https://platform.claude.com/docs/es/api/beta/organization/rbac_groups/list) en la referencia de la API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/rbac_groups?limit=20" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant beta:organization:rbac-groups list --limit 20 ``` ```python Python client = anthropic.Anthropic() groups = client.beta.organization.rbac_groups.list(limit=20) for group in groups: print(f"{group.id}: {group.name} ({group.source_type})") ``` ```typescript TypeScript const client = new Anthropic(); const groups = await client.beta.organization.rbacGroups.list({ limit: 20 }); for await (const group of groups) { console.log(`${group.id}: ${group.name} (${group.source_type})`); } ``` ```csharp C# AnthropicClient client = new(); var page = await client.Beta.Organization.RbacGroups.List(new() { Limit = 20 }); await foreach (var group in page.Paginate()) { Console.WriteLine($"{group.ID}: {group.Name} ({group.SourceType.Raw()})"); } ``` ```go Go client := anthropic.NewClient() groups := client.Beta.Organization.RBACGroups.ListAutoPaging(context.Background(), anthropic.BetaOrganizationRBACGroupListParams{ Limit: anthropic.Int(20), }) for groups.Next() { group := groups.Current() fmt.Printf("%s: %s (%s)\n", group.ID, group.Name, group.SourceType) } if err := groups.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.beta.organization.rbacgroups.RbacGroupListParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = RbacGroupListParams.builder() .limit(20) .build(); var groups = client.beta().organization().rbacGroups().list(params); for (var group : groups.autoPager()) { IO.println(group.id() + ": " + group.name() + " (" + group.sourceType().asString() + ")"); } } ``` ```php PHP $client = new Client(); $groups = $client->beta->organization->rbacGroups->list(limit: 20); foreach ($groups->pagingEachItem() as $group) { echo "{$group->id}: {$group->name} ({$group->sourceType})\n"; } ``` ```ruby Ruby client = Anthropic::Client.new groups = client.beta.organization.rbac_groups.list(limit: 20) groups.auto_paging_each do |group| puts "#{group.id}: #{group.name} (#{group.source_type})" end ``` ```json { "data": [ { "type": "rbac_group", "id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn", "name": "Engineering", "source_type": "direct", "role_ids": ["rbac_role_01CdEfGhIjKlMnOpQrStUv"], "roles": ["rbac_role_01CdEfGhIjKlMnOpQrStUv"], "created_at": "2026-03-18T10:01:42Z", "updated_at": "2026-05-02T08:55:09Z" } ], "has_more": false, "next_page": null } ``` ### Obtener un grupo `GET /v1/organizations/rbac_groups/{rbac_group_id}` devuelve un grupo por ID. Requiere el alcance `read:rbac_groups`. Para obtener detalles completos de los parámetros y esquemas de respuesta, consulta [Obtener grupo](https://platform.claude.com/docs/es/api/beta/organization/rbac_groups/retrieve) en la referencia de la API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/rbac_groups/rbac_group_01UvWxYzAbCdEfGhIjKlMn" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant beta:organization:rbac-groups retrieve \ --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn ``` ```python Python client = anthropic.Anthropic() group = client.beta.organization.rbac_groups.retrieve( "rbac_group_01UvWxYzAbCdEfGhIjKlMn" ) print(f"id: {group.id}") print(f"name: {group.name}") print(f"source_type: {group.source_type}") ``` ```typescript TypeScript const client = new Anthropic(); const group = await client.beta.organization.rbacGroups.retrieve( "rbac_group_01UvWxYzAbCdEfGhIjKlMn" ); console.log(`id: ${group.id}`); console.log(`name: ${group.name}`); console.log(`source_type: ${group.source_type}`); ``` ```csharp C# AnthropicClient client = new(); var group = await client.Beta.Organization.RbacGroups.Retrieve("rbac_group_01UvWxYzAbCdEfGhIjKlMn"); Console.WriteLine($"id: {group.ID}"); Console.WriteLine($"name: {group.Name}"); Console.WriteLine($"source_type: {group.SourceType.Raw()}"); ``` ```go Go client := anthropic.NewClient() group, err := client.Beta.Organization.RBACGroups.Get(context.Background(), "rbac_group_01UvWxYzAbCdEfGhIjKlMn") if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", group.ID) fmt.Printf("name: %s\n", group.Name) fmt.Printf("source_type: %s\n", group.SourceType) ``` ```java Java AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var group = client.beta().organization().rbacGroups() .retrieve("rbac_group_01UvWxYzAbCdEfGhIjKlMn"); IO.println("id: " + group.id()); IO.println("name: " + group.name()); IO.println("source_type: " + group.sourceType().asString()); ``` ```php PHP $client = new Client(); $group = $client->beta->organization->rbacGroups->retrieve( rbacGroupID: 'rbac_group_01UvWxYzAbCdEfGhIjKlMn', ); echo "id: {$group->id}\n"; echo "name: {$group->name}\n"; echo "source_type: {$group->sourceType}\n"; ``` ```ruby Ruby client = Anthropic::Client.new rbac_group_id = "rbac_group_01UvWxYzAbCdEfGhIjKlMn" group = client.beta.organization.rbac_groups.retrieve(rbac_group_id) puts "id: #{group.id}" puts "name: #{group.name}" puts "source_type: #{group.source_type}" ``` ### Crear un grupo `POST /v1/organizations/rbac_groups` crea un grupo con el `name` dado (1–255 caracteres) y sin roles ni miembros. Requiere el alcance `write:rbac_groups`. Para obtener detalles completos de los parámetros y esquemas de respuesta, consulta [Crear grupo](https://platform.claude.com/docs/es/api/beta/organization/rbac_groups/create) en la referencia de la API. ```bash cURL curl -X POST "https://api.anthropic.com/v1/organizations/rbac_groups" \ -H "content-type: application/json" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -d '{"name": "Engineering"}' ``` ```bash CLI ant beta:organization:rbac-groups create --name Engineering ``` ```python Python client = anthropic.Anthropic() group = client.beta.organization.rbac_groups.create(name="Engineering") print(f"id: {group.id}") print(f"name: {group.name}") ``` ```typescript TypeScript const client = new Anthropic(); const group = await client.beta.organization.rbacGroups.create({ name: "Engineering" }); console.log(`id: ${group.id}`); console.log(`name: ${group.name}`); ``` ```csharp C# AnthropicClient client = new(); var group = await client.Beta.Organization.RbacGroups.Create(new() { Name = "Engineering" }); Console.WriteLine($"id: {group.ID}"); Console.WriteLine($"name: {group.Name}"); ``` ```go Go client := anthropic.NewClient() group, err := client.Beta.Organization.RBACGroups.New(context.Background(), anthropic.BetaOrganizationRBACGroupNewParams{ Name: "Engineering", }) if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", group.ID) fmt.Printf("name: %s\n", group.Name) ``` ```java Java import com.anthropic.models.beta.organization.rbacgroups.RbacGroupCreateParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = RbacGroupCreateParams.builder() .name("Engineering") .build(); var group = client.beta().organization().rbacGroups().create(params); IO.println("id: " + group.id()); IO.println("name: " + group.name()); } ``` ```php PHP $client = new Client(); $group = $client->beta->organization->rbacGroups->create( name: 'Engineering', ); echo "id: {$group->id}\n"; echo "name: {$group->name}\n"; ``` ```ruby Ruby client = Anthropic::Client.new group = client.beta.organization.rbac_groups.create(name: "Engineering") puts "id: #{group.id}" puts "name: #{group.name}" ``` ```json { "type": "rbac_group", "id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn", "name": "Engineering", "source_type": "direct", "role_ids": [], "roles": [], "created_at": "2026-07-09T18:00:00Z", "updated_at": "2026-07-09T18:00:00Z" } ``` ### Renombrar un grupo `POST /v1/organizations/rbac_groups/{rbac_group_id}` actualiza el grupo. `name` es el único campo que este endpoint puede cambiar. Requiere el alcance `write:rbac_groups`. Para obtener detalles completos de los parámetros y esquemas de respuesta, consulta [Actualizar grupo](https://platform.claude.com/docs/es/api/beta/organization/rbac_groups/update) en la referencia de la API. ```bash cURL curl -X POST "https://api.anthropic.com/v1/organizations/rbac_groups/rbac_group_01UvWxYzAbCdEfGhIjKlMn" \ -H "content-type: application/json" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -d '{"name": "Platform Engineering"}' ``` ```bash CLI ant beta:organization:rbac-groups update \ --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn \ --name "Platform Engineering" ``` ```python Python client = anthropic.Anthropic() group = client.beta.organization.rbac_groups.update( "rbac_group_01UvWxYzAbCdEfGhIjKlMn", name="Platform Engineering" ) print(f"id: {group.id}") print(f"name: {group.name}") ``` ```typescript TypeScript const client = new Anthropic(); const group = await client.beta.organization.rbacGroups.update( "rbac_group_01UvWxYzAbCdEfGhIjKlMn", { name: "Platform Engineering" } ); console.log(`id: ${group.id}`); console.log(`name: ${group.name}`); ``` ```csharp C# AnthropicClient client = new(); var group = await client.Beta.Organization.RbacGroups.Update( "rbac_group_01UvWxYzAbCdEfGhIjKlMn", new() { Name = "Platform Engineering" } ); Console.WriteLine($"id: {group.ID}"); Console.WriteLine($"name: {group.Name}"); ``` ```go Go client := anthropic.NewClient() group, err := client.Beta.Organization.RBACGroups.Update( context.Background(), "rbac_group_01UvWxYzAbCdEfGhIjKlMn", anthropic.BetaOrganizationRBACGroupUpdateParams{ Name: anthropic.String("Platform Engineering"), }, ) if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", group.ID) fmt.Printf("name: %s\n", group.Name) ``` ```java Java import com.anthropic.models.beta.organization.rbacgroups.RbacGroupUpdateParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = RbacGroupUpdateParams.builder() .name("Platform Engineering") .build(); var group = client.beta().organization().rbacGroups() .update("rbac_group_01UvWxYzAbCdEfGhIjKlMn", params); IO.println("id: " + group.id()); IO.println("name: " + group.name()); } ``` ```php PHP $client = new Client(); $group = $client->beta->organization->rbacGroups->update( rbacGroupID: 'rbac_group_01UvWxYzAbCdEfGhIjKlMn', name: 'Platform Engineering', ); echo "id: {$group->id}\n"; echo "name: {$group->name}\n"; ``` ```ruby Ruby client = Anthropic::Client.new rbac_group_id = "rbac_group_01UvWxYzAbCdEfGhIjKlMn" group = client.beta.organization.rbac_groups.update(rbac_group_id, name: "Platform Engineering") puts "id: #{group.id}" puts "name: #{group.name}" ``` ### Eliminar un grupo `DELETE /v1/organizations/rbac_groups/{rbac_group_id}` elimina el grupo. Sus miembros siguen siendo miembros de sus organizaciones, pero pierden los permisos de los roles asociados, y el [límite de gasto](https://platform.claude.com/docs/es/manage-claude/spend-limits-api) del grupo, si existía, deja de aplicárseles. Requiere el alcance `write:rbac_groups`. Para obtener detalles completos de los parámetros y esquemas de respuesta, consulta [Eliminar grupo](https://platform.claude.com/docs/es/api/beta/organization/rbac_groups/delete) en la referencia de la API. ```bash cURL curl -X DELETE "https://api.anthropic.com/v1/organizations/rbac_groups/rbac_group_01UvWxYzAbCdEfGhIjKlMn" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant beta:organization:rbac-groups delete \ --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn ``` ```python Python client = anthropic.Anthropic() deleted_group = client.beta.organization.rbac_groups.delete( "rbac_group_01UvWxYzAbCdEfGhIjKlMn" ) print(f"id: {deleted_group.id}") ``` ```typescript TypeScript const client = new Anthropic(); const deletedGroup = await client.beta.organization.rbacGroups.delete( "rbac_group_01UvWxYzAbCdEfGhIjKlMn" ); console.log(`id: ${deletedGroup.id}`); ``` ```csharp C# AnthropicClient client = new(); var deletedGroup = await client.Beta.Organization.RbacGroups.Delete( "rbac_group_01UvWxYzAbCdEfGhIjKlMn" ); Console.WriteLine($"id: {deletedGroup.ID}"); ``` ```go Go client := anthropic.NewClient() deletedGroup, err := client.Beta.Organization.RBACGroups.Delete(context.Background(), "rbac_group_01UvWxYzAbCdEfGhIjKlMn") if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", deletedGroup.ID) ``` ```java Java AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var deletedGroup = client.beta().organization().rbacGroups() .delete("rbac_group_01UvWxYzAbCdEfGhIjKlMn"); IO.println("id: " + deletedGroup.id()); ``` ```php PHP $client = new Client(); $deletedGroup = $client->beta->organization->rbacGroups->delete( rbacGroupID: 'rbac_group_01UvWxYzAbCdEfGhIjKlMn', ); echo "id: {$deletedGroup->id}\n"; ``` ```ruby Ruby client = Anthropic::Client.new rbac_group_id = "rbac_group_01UvWxYzAbCdEfGhIjKlMn" deleted_group = client.beta.organization.rbac_groups.delete(rbac_group_id) puts "id: #{deleted_group.id}" ``` ```json { "id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn", "type": "rbac_group_deleted" } ``` ### Listar los miembros de un grupo `GET /v1/organizations/rbac_groups/{rbac_group_id}/members` devuelve los miembros del grupo (cada uno con su `user_id` y correo electrónico), empezando por los más antiguos. Solo se devuelven los miembros actuales de las organizaciones de tu empresa, por lo que una página puede contener menos de `limit` entradas mientras `has_more` es `true`. Requiere el alcance `read:rbac_groups`. Para obtener detalles completos de los parámetros y esquemas de respuesta, consulta [Listar miembros del grupo](https://platform.claude.com/docs/es/api/beta/organization/rbac_groups/members/list) en la referencia de la API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/rbac_groups/rbac_group_01UvWxYzAbCdEfGhIjKlMn/members?limit=100" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant beta:organization:rbac-groups:members list \ --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn \ --limit 100 ``` ```python Python client = anthropic.Anthropic() members = client.beta.organization.rbac_groups.members.list( "rbac_group_01UvWxYzAbCdEfGhIjKlMn", limit=100 ) for member in members: print(f"{member.user_id}: {member.email}") ``` ```typescript TypeScript const client = new Anthropic(); const members = await client.beta.organization.rbacGroups.members.list( "rbac_group_01UvWxYzAbCdEfGhIjKlMn", { limit: 100 } ); for await (const member of members) { console.log(`${member.user_id}: ${member.email}`); } ``` ```csharp C# AnthropicClient client = new(); var page = await client.Beta.Organization.RbacGroups.Members.List( "rbac_group_01UvWxYzAbCdEfGhIjKlMn", new() { Limit = 100 } ); await foreach (var member in page.Paginate()) { Console.WriteLine($"{member.UserID}: {member.Email}"); } ``` ```go Go client := anthropic.NewClient() members := client.Beta.Organization.RBACGroups.Members.ListAutoPaging( context.Background(), "rbac_group_01UvWxYzAbCdEfGhIjKlMn", anthropic.BetaOrganizationRBACGroupMemberListParams{ Limit: anthropic.Int(100), }, ) for members.Next() { member := members.Current() fmt.Printf("%s: %s\n", member.UserID, member.Email) } if err := members.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.beta.organization.rbacgroups.members.MemberListParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = MemberListParams.builder() .limit(100) .build(); var members = client.beta().organization().rbacGroups().members() .list("rbac_group_01UvWxYzAbCdEfGhIjKlMn", params); for (var member : members.autoPager()) { IO.println(member.userId() + ": " + member.email()); } } ``` ```php PHP $client = new Client(); $members = $client->beta->organization->rbacGroups->members->list( rbacGroupID: 'rbac_group_01UvWxYzAbCdEfGhIjKlMn', limit: 100, ); foreach ($members->pagingEachItem() as $member) { echo "{$member->userID}: {$member->email}\n"; } ``` ```ruby Ruby client = Anthropic::Client.new rbac_group_id = "rbac_group_01UvWxYzAbCdEfGhIjKlMn" members = client.beta.organization.rbac_groups.members.list(rbac_group_id, limit: 100) members.auto_paging_each do |member| puts "#{member.user_id}: #{member.email}" end ``` ```json { "data": [ { "type": "rbac_group_member", "rbac_group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn", "group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn", "user_id": "user_01AbCdEfGhIjKlMnOpQrSt", "email": "jane@example.com", "created_at": "2026-04-07T12:30:00Z" } ], "has_more": false, "next_page": null } ``` ### Agregar un miembro a un grupo `POST /v1/organizations/rbac_groups/{rbac_group_id}/members` agrega un miembro de la organización al grupo por `user_id`. El usuario ya debe ser miembro de una de las organizaciones de tu empresa (de lo contrario, la solicitud devuelve 404), y agregar a alguien que ya está en el grupo devuelve 400. En los grupos `scim`, la membresía se gestiona en tu proveedor de identidad y esta solicitud devuelve 400. Para asignar grupos a una persona que aún no se ha unido, usa en su lugar `rbac_group_ids` al [crear la invitación](https://platform.claude.com/docs/es/manage-claude/user-management#create-an-invite). Requiere el alcance `write:rbac_groups`. Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta [Agregar miembro al grupo](https://platform.claude.com/docs/es/api/beta/organization/rbac_groups/members/add) en la referencia de la API. ```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_01AbCdEfGhIjKlMnOpQrSt"}' ``` ```bash CLI ant beta:organization:rbac-groups:members add \ --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn \ --user-id user_01AbCdEfGhIjKlMnOpQrSt ``` ```python Python client = anthropic.Anthropic() member = client.beta.organization.rbac_groups.members.add( "rbac_group_01UvWxYzAbCdEfGhIjKlMn", user_id="user_01AbCdEfGhIjKlMnOpQrSt" ) print(f"user_id: {member.user_id}") print(f"email: {member.email}") ``` ```typescript TypeScript const client = new Anthropic(); const member = await client.beta.organization.rbacGroups.members.add( "rbac_group_01UvWxYzAbCdEfGhIjKlMn", { user_id: "user_01AbCdEfGhIjKlMnOpQrSt" } ); console.log(`user_id: ${member.user_id}`); console.log(`email: ${member.email}`); ``` ```csharp C# AnthropicClient client = new(); var member = await client.Beta.Organization.RbacGroups.Members.Add( "rbac_group_01UvWxYzAbCdEfGhIjKlMn", new() { UserID = "user_01AbCdEfGhIjKlMnOpQrSt" } ); Console.WriteLine($"user_id: {member.UserID}"); Console.WriteLine($"email: {member.Email}"); ``` ```go Go client := anthropic.NewClient() member, err := client.Beta.Organization.RBACGroups.Members.Add( context.Background(), "rbac_group_01UvWxYzAbCdEfGhIjKlMn", anthropic.BetaOrganizationRBACGroupMemberAddParams{ UserID: "user_01AbCdEfGhIjKlMnOpQrSt", }, ) if err != nil { log.Fatal(err) } fmt.Printf("user_id: %s\n", member.UserID) fmt.Printf("email: %s\n", member.Email) ``` ```java Java import com.anthropic.models.beta.organization.rbacgroups.members.MemberAddParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = MemberAddParams.builder() .userId("user_01AbCdEfGhIjKlMnOpQrSt") .build(); var member = client.beta().organization().rbacGroups().members() .add("rbac_group_01UvWxYzAbCdEfGhIjKlMn", params); IO.println("user_id: " + member.userId()); IO.println("email: " + member.email()); } ``` ```php PHP $client = new Client(); $member = $client->beta->organization->rbacGroups->members->add( rbacGroupID: 'rbac_group_01UvWxYzAbCdEfGhIjKlMn', userID: 'user_01AbCdEfGhIjKlMnOpQrSt', ); echo "user_id: {$member->userID}\n"; echo "email: {$member->email}\n"; ``` ```ruby Ruby client = Anthropic::Client.new rbac_group_id = "rbac_group_01UvWxYzAbCdEfGhIjKlMn" member = client.beta.organization.rbac_groups.members.add( rbac_group_id, user_id: "user_01AbCdEfGhIjKlMnOpQrSt" ) puts "user_id: #{member.user_id}" puts "email: #{member.email}" ``` ```json { "type": "rbac_group_member", "rbac_group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn", "group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn", "user_id": "user_01AbCdEfGhIjKlMnOpQrSt", "email": "jane@example.com", "created_at": "2026-07-09T18:00:00Z" } ``` ### Eliminar un miembro de un grupo `DELETE /v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}` elimina al miembro del grupo; sigue siendo miembro de su organización. La solicitud devuelve 404 si el usuario no es miembro del grupo, y 400 para los grupos `scim`, cuya membresía se gestiona en tu proveedor de identidad. Requiere el alcance `write:rbac_groups`. Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta [Eliminar miembro del grupo](https://platform.claude.com/docs/es/api/beta/organization/rbac_groups/members/remove) en la referencia de la API. ```bash cURL curl -X DELETE "https://api.anthropic.com/v1/organizations/rbac_groups/rbac_group_01UvWxYzAbCdEfGhIjKlMn/members/user_01AbCdEfGhIjKlMnOpQrSt" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant beta:organization:rbac-groups:members remove \ --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn \ --user-id user_01AbCdEfGhIjKlMnOpQrSt ``` ```python Python client = anthropic.Anthropic() removed_member = client.beta.organization.rbac_groups.members.remove( "user_01AbCdEfGhIjKlMnOpQrSt", rbac_group_id="rbac_group_01UvWxYzAbCdEfGhIjKlMn" ) print(f"user_id: {removed_member.user_id}") ``` ```typescript TypeScript const client = new Anthropic(); const removedMember = await client.beta.organization.rbacGroups.members.remove( "user_01AbCdEfGhIjKlMnOpQrSt", { rbac_group_id: "rbac_group_01UvWxYzAbCdEfGhIjKlMn" } ); console.log(`user_id: ${removedMember.user_id}`); ``` ```csharp C# AnthropicClient client = new(); var removedMember = await client.Beta.Organization.RbacGroups.Members.Remove( "user_01AbCdEfGhIjKlMnOpQrSt", new() { RbacGroupID = "rbac_group_01UvWxYzAbCdEfGhIjKlMn" } ); Console.WriteLine($"user_id: {removedMember.UserID}"); ``` ```go Go client := anthropic.NewClient() removedMember, err := client.Beta.Organization.RBACGroups.Members.Remove( context.Background(), "user_01AbCdEfGhIjKlMnOpQrSt", anthropic.BetaOrganizationRBACGroupMemberRemoveParams{ RBACGroupID: "rbac_group_01UvWxYzAbCdEfGhIjKlMn", }, ) if err != nil { log.Fatal(err) } fmt.Printf("user_id: %s\n", removedMember.UserID) ``` ```java Java import com.anthropic.models.beta.organization.rbacgroups.members.MemberRemoveParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = MemberRemoveParams.builder() .rbacGroupId("rbac_group_01UvWxYzAbCdEfGhIjKlMn") .build(); var removedMember = client.beta().organization().rbacGroups().members() .remove("user_01AbCdEfGhIjKlMnOpQrSt", params); IO.println("user_id: " + removedMember.userId()); } ``` ```php PHP $client = new Client(); $removedMember = $client->beta->organization->rbacGroups->members->remove( userID: 'user_01AbCdEfGhIjKlMnOpQrSt', rbacGroupID: 'rbac_group_01UvWxYzAbCdEfGhIjKlMn', ); echo "user_id: {$removedMember->userID}\n"; ``` ```ruby Ruby client = Anthropic::Client.new rbac_group_id = "rbac_group_01UvWxYzAbCdEfGhIjKlMn" removed_member = client.beta.organization.rbac_groups.members.remove( "user_01AbCdEfGhIjKlMnOpQrSt", rbac_group_id: rbac_group_id ) puts "user_id: #{removed_member.user_id}" ``` ```json { "rbac_group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn", "group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn", "user_id": "user_01AbCdEfGhIjKlMnOpQrSt", "type": "rbac_group_member_deleted" } ``` ## Roles personalizados Los roles personalizados son de solo lectura a través de la API: estos endpoints catalogan los roles personalizados de tu organización (definidos en la [configuración de la organización de claude.ai](https://claude.ai/admin-settings) o aprovisionados por Anthropic) y los permisos que otorga cada rol. Las lecturas de roles personalizados usan el alcance `read:members` (no existe un alcance de roles separado) y funcionan con una clave a nivel de organización: a diferencia de los endpoints de grupos, no requieren una clave creada para todas las organizaciones vinculadas, y el catálogo devuelto es el propio de tu organización. Lee el nombre de un rol en su campo `display_name`. Todavía se devuelve el campo obsoleto `name`, siempre igual a `display_name`. En un rol aprovisionado por Anthropic, `display_name` puede diferir de la etiqueta que muestra claude.ai, y Anthropic podría cambiar el nombre. Para conservar una referencia duradera a un rol, almacena su `id`. ### Listar roles `GET /v1/organizations/rbac_roles` devuelve los roles personalizados de tu organización. Requiere el alcance `read:members`. Para obtener detalles completos de los parámetros y esquemas de respuesta, consulta [Listar roles](https://platform.claude.com/docs/es/api/beta/organization/rbac_roles/list) en la referencia de la API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/rbac_roles?limit=20" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant beta:organization:rbac-roles list --limit 20 ``` ```python Python client = anthropic.Anthropic() roles = client.beta.organization.rbac_roles.list(limit=20) for role in roles: print(f"{role.id}: {role.display_name}") ``` ```typescript TypeScript const client = new Anthropic(); const roles = await client.beta.organization.rbacRoles.list({ limit: 20 }); for await (const role of roles) { console.log(`${role.id}: ${role.display_name}`); } ``` ```csharp C# AnthropicClient client = new(); var page = await client.Beta.Organization.RbacRoles.List(new() { Limit = 20 }); await foreach (var role in page.Paginate()) { Console.WriteLine($"{role.ID}: {role.DisplayName}"); } ``` ```go Go client := anthropic.NewClient() roles := client.Beta.Organization.RBACRoles.ListAutoPaging(context.Background(), anthropic.BetaOrganizationRBACRoleListParams{ Limit: anthropic.Int(20), }) for roles.Next() { role := roles.Current() fmt.Printf("%s: %s\n", role.ID, role.DisplayName) } if err := roles.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.beta.organization.rbacroles.RbacRoleListParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = RbacRoleListParams.builder() .limit(20) .build(); var roles = client.beta().organization().rbacRoles().list(params); for (var role : roles.autoPager()) { IO.println(role.id() + ": " + role.displayName()); } } ``` ```php PHP $client = new Client(); $roles = $client->beta->organization->rbacRoles->list(limit: 20); foreach ($roles->pagingEachItem() as $role) { echo "{$role->id}: {$role->displayName}\n"; } ``` ```ruby Ruby client = Anthropic::Client.new roles = client.beta.organization.rbac_roles.list(limit: 20) roles.auto_paging_each do |role| puts "#{role.id}: #{role.display_name}" end ``` ```json { "data": [ { "type": "rbac_role", "id": "rbac_role_01CdEfGhIjKlMnOpQrStUv", "display_name": "Engineering base", "name": "Engineering base", "created_at": "2026-03-18T10:01:42Z", "updated_at": "2026-05-02T08:55:09Z" } ], "has_more": false, "next_page": null } ``` ### Obtener un rol `GET /v1/organizations/rbac_roles/{rbac_role_id}` devuelve un rol por ID. Requiere el alcance `read:members`. Para obtener detalles completos de los parámetros y esquemas de respuesta, consulta [Obtener rol](https://platform.claude.com/docs/es/api/beta/organization/rbac_roles/retrieve) en la referencia de la API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/rbac_roles/rbac_role_01CdEfGhIjKlMnOpQrStUv" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant beta:organization:rbac-roles retrieve \ --rbac-role-id rbac_role_01CdEfGhIjKlMnOpQrStUv ``` ```python Python client = anthropic.Anthropic() role = client.beta.organization.rbac_roles.retrieve("rbac_role_01CdEfGhIjKlMnOpQrStUv") print(f"id: {role.id}") print(f"display_name: {role.display_name}") ``` ```typescript TypeScript const client = new Anthropic(); const role = await client.beta.organization.rbacRoles.retrieve( "rbac_role_01CdEfGhIjKlMnOpQrStUv" ); console.log(`id: ${role.id}`); console.log(`display_name: ${role.display_name}`); ``` ```csharp C# AnthropicClient client = new(); var role = await client.Beta.Organization.RbacRoles.Retrieve("rbac_role_01CdEfGhIjKlMnOpQrStUv"); Console.WriteLine($"id: {role.ID}"); Console.WriteLine($"display_name: {role.DisplayName}"); ``` ```go Go client := anthropic.NewClient() role, err := client.Beta.Organization.RBACRoles.Get(context.Background(), "rbac_role_01CdEfGhIjKlMnOpQrStUv") if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", role.ID) fmt.Printf("display_name: %s\n", role.DisplayName) ``` ```java Java AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var role = client.beta().organization().rbacRoles() .retrieve("rbac_role_01CdEfGhIjKlMnOpQrStUv"); IO.println("id: " + role.id()); IO.println("display_name: " + role.displayName()); ``` ```php PHP $client = new Client(); $role = $client->beta->organization->rbacRoles->retrieve( rbacRoleID: 'rbac_role_01CdEfGhIjKlMnOpQrStUv', ); echo "id: {$role->id}\n"; echo "display_name: {$role->displayName}\n"; ``` ```ruby Ruby client = Anthropic::Client.new rbac_role_id = "rbac_role_01CdEfGhIjKlMnOpQrStUv" role = client.beta.organization.rbac_roles.retrieve(rbac_role_id) puts "id: #{role.id}" puts "display_name: #{role.display_name}" ``` ### Listar los permisos de un rol `GET /v1/organizations/rbac_roles/{rbac_role_id}/permissions` devuelve los permisos del rol. Cada permiso combina un `resource` (a qué se aplica: las funciones del producto de la organización, una herramienta de conector, un alcance OAuth de conector, un conector o todos los conectores) con una `action` (lo que otorga sobre ese recurso). Se omiten las filas de funciones que no están habilitadas para tu organización, por lo que una página puede contener menos de `limit` filas mientras `has_more` es `true`. Requiere el alcance `read:members`. Dos valores de `action` requieren especial cuidado: un permiso `organization` cuya acción es `capability_access_all` (todas las funciones de producto) o `capability_access_all_ga` (todas las funciones de producto estables, es decir, todas las funciones no etiquetadas como beta o vista previa de investigación) es una concesión general (una que no cubre ni el acceso a modelos ni los permisos del panel de administración con prefijo `permission_`) y se lista como esa única fila en lugar de expandirse. Cuando contabilices lo que otorga un rol, trata una fila general como si cubriera todo lo que describe su variante, no solo las funciones nombradas en otras filas. Para obtener detalles completos de los parámetros y esquemas de respuesta, consulta [Listar permisos del rol](https://platform.claude.com/docs/es/api/beta/organization/rbac_roles/permissions/list) en la referencia de la API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/rbac_roles/rbac_role_01CdEfGhIjKlMnOpQrStUv/permissions?limit=20" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant beta:organization:rbac-roles:permissions list \ --rbac-role-id rbac_role_01CdEfGhIjKlMnOpQrStUv \ --limit 20 ``` ```python Python client = anthropic.Anthropic() permissions = client.beta.organization.rbac_roles.permissions.list( "rbac_role_01CdEfGhIjKlMnOpQrStUv", limit=20 ) for permission in permissions: print(permission.action) ``` ```typescript TypeScript const client = new Anthropic(); const permissions = await client.beta.organization.rbacRoles.permissions.list( "rbac_role_01CdEfGhIjKlMnOpQrStUv", { limit: 20 } ); for await (const permission of permissions) { console.log(permission.action); } ``` ```csharp C# AnthropicClient client = new(); var page = await client.Beta.Organization.RbacRoles.Permissions.List( "rbac_role_01CdEfGhIjKlMnOpQrStUv", new() { Limit = 20 } ); await foreach (var permission in page.Paginate()) { Console.WriteLine(permission.Action); } ``` ```go Go client := anthropic.NewClient() permissions := client.Beta.Organization.RBACRoles.Permissions.ListAutoPaging( context.Background(), "rbac_role_01CdEfGhIjKlMnOpQrStUv", anthropic.BetaOrganizationRBACRolePermissionListParams{ Limit: anthropic.Int(20), }, ) for permissions.Next() { permission := permissions.Current() fmt.Println(permission.Action) } if err := permissions.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.beta.organization.rbacroles.permissions.PermissionListParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = PermissionListParams.builder() .limit(20) .build(); var permissions = client.beta().organization().rbacRoles().permissions() .list("rbac_role_01CdEfGhIjKlMnOpQrStUv", params); for (var permission : permissions.autoPager()) { IO.println(permission.action()); } } ``` ```php PHP $client = new Client(); $permissions = $client->beta->organization->rbacRoles->permissions->list( rbacRoleID: 'rbac_role_01CdEfGhIjKlMnOpQrStUv', limit: 20, ); foreach ($permissions->pagingEachItem() as $permission) { echo "{$permission->action}\n"; } ``` ```ruby Ruby client = Anthropic::Client.new rbac_role_id = "rbac_role_01CdEfGhIjKlMnOpQrStUv" permissions = client.beta.organization.rbac_roles.permissions.list(rbac_role_id, limit: 20) permissions.auto_paging_each do |permission| puts permission.action end ``` ```json { "data": [ { "type": "rbac_role_permission", "resource": { "type": "organization", "organization_id": "12345678-1234-5678-1234-567812345678" }, "action": "capability_access_all_ga" }, { "type": "rbac_role_permission", "resource": { "type": "connector_tool", "connector_id": "mcpsrv_01WxYzAbCdEfGhIjKlMnOp", "tool_name": "search_tickets" }, "action": "use" } ], "has_more": false, "next_page": null } ``` ## Flujos de trabajo de ejemplo ### Dar de baja a un empleado que se va 1. Busca al miembro por correo electrónico: ```bash cURL curl "https://api.anthropic.com/v1/organizations/users?email=departing@example.com" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant organization:users list --email departing@example.com ``` ```python Python client = anthropic.Anthropic() users = client.organization.users.list(email="departing@example.com") for user in users: print(f"{user.id}: {user.email} ({user.role})") ``` ```typescript TypeScript const client = new Anthropic(); const users = await client.organization.users.list({ email: "departing@example.com" }); for await (const user of users) { console.log(`${user.id}: ${user.email} (${user.role})`); } ``` ```csharp C# AnthropicClient client = new(); var page = await client.Organization.Users.List(new() { Email = "departing@example.com" }); await foreach (var user in page.Paginate()) { Console.WriteLine($"{user.ID}: {user.Email} ({user.Role.Raw()})"); } ``` ```go Go client := anthropic.NewClient() users := client.Organization.Users.ListAutoPaging(context.Background(), anthropic.OrganizationUserListParams{ Email: anthropic.String("departing@example.com"), }) for users.Next() { user := users.Current() fmt.Printf("%s: %s (%s)\n", user.ID, user.Email, user.Role) } if err := users.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.organization.users.UserListParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = UserListParams.builder() .email("departing@example.com") .build(); var users = client.organization().users().list(params); for (var user : users.autoPager()) { IO.println(user.id() + ": " + user.email() + " (" + user.role().asString() + ")"); } } ``` ```php PHP $client = new Client(); $users = $client->organization->users->list(email: 'departing@example.com'); foreach ($users->pagingEachItem() as $user) { echo "{$user->id}: {$user->email} ({$user->role})\n"; } ``` ```ruby Ruby client = Anthropic::Client.new users = client.organization.users.list(email: "departing@example.com") users.auto_paging_each do |user| puts "#{user.id}: #{user.email} (#{user.role})" end ``` 2. Elimínalo con `DELETE /v1/organizations/users/{user_id}`, usando el `id` de la respuesta. Su asiento, si lo tenía, vuelve al conjunto. 3. Si la persona aún no se había unido, la búsqueda no devuelve ningún miembro; lista las invitaciones y retira su invitación `pending` en su lugar. ### Auditar la membresía de grupos 1. Lista los grupos y registra el `id`, el `name` y los `role_ids` de cada grupo. 2. Para cada grupo que tenga roles sensibles, recorre las páginas de `GET /v1/organizations/rbac_groups/{rbac_group_id}/members` y compara los correos electrónicos de los miembros con la lista de tu proveedor de identidad. 3. Elimina a los miembros que ya no deberían estar en el grupo con `DELETE /v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}`. En los grupos `scim`, haz el cambio en tu proveedor de identidad. Para un flujo de trabajo que combina la membresía de grupos con un aumento temporal del límite de gasto, consulta [Aumentar temporalmente el límite de gasto de un miembro durante un incidente](https://platform.claude.com/docs/es/manage-claude/spend-limits-api#temporarily-raise-a-members-spend-limit-during-an-incident) en la página de la Spend Limits API. ## Preguntas frecuentes ### ¿Es esta una API diferente de la Admin API? No. Los endpoints de miembros e invitaciones son los mismos endpoints `/v1/organizations/` que usan las organizaciones de Claude Console; esta página documenta su comportamiento en Claude Enterprise. Los endpoints de grupos y roles personalizados forman parte de la misma API y existen solo para organizaciones de Claude Enterprise. La [tabla de disponibilidad](https://platform.claude.com/docs/es/manage-claude/user-management#which-endpoints-can-your-organization-use) muestra qué endpoints puede llamar cada tipo de organización. ### ¿Puedo asignar el rol de propietario o de administrador de membresía a través de la API? No. La API solo asigna `user` y `managed`, al crear invitaciones y al actualizar roles. Los roles administrativos se asignan en la configuración de la organización de claude.ai, y los miembros que los tienen no pueden modificarse ni eliminarse a través de la API. ### ¿Puedo crear o modificar grupos a través de la API? Sí, con el alcance `write:rbac_groups`: crea, renombra y elimina grupos, y agrega o elimina sus miembros. Dos cosas que la API no puede cambiar: los grupos aprovisionados por tu proveedor de identidad (`source_type: "scim"`), cuyo nombre y membresía pertenecen al proveedor de identidad, y los roles personalizados, que se gestionan en la configuración de la organización de claude.ai (la API [los lee](https://platform.claude.com/docs/es/manage-claude/user-management#custom-roles)). ### ¿Una invitación no aceptada consume un asiento? En planes con un conjunto finito de asientos, sí: una invitación `pending` retiene un asiento. Retirar la invitación o dejar que expire libera el asiento. En planes sin conjunto de asientos, las invitaciones no consumen nada. ### Mi organización usa inicio de sesión único. ¿Qué operaciones funcionan? Si tu proveedor de identidad aprovisiona usuarios automáticamente (JIT o SCIM), la creación de invitaciones devuelve 400. Si gestiona los roles (SSO avanzado o aprovisionamiento SCIM avanzado), las actualizaciones de rol devuelven 400. Si gestiona la membresía (aprovisionamiento SCIM), las eliminaciones de miembros devuelven 400. Las lecturas funcionan en cualquier caso. ### ¿Qué pasa con una clave de Admin API cuando la persona que la creó se va? La clave sigue funcionando. Las claves de Admin API tienen alcance de organización, no de usuarios individuales, y una clave creada en claude.ai no expira. Eliminar al creador de la organización o desaprovisionarlo a través de tu proveedor de identidad termina su propio acceso, pero no las claves que creó. Rebajar su rol tampoco cambia las claves: cada clave permanece activa con sus alcances originales. Cuando des de baja a alguien que creó claves de Admin API, elimina esas claves en la sección **Keys** de [claude.ai > Configuración de la organización > API](https://claude.ai/admin-settings/api-access) y crea reemplazos. ## Ver también Dónde crea tu propietario principal una clave con alcance y qué alcances seleccionar. Audita la actividad y recupera o elimina contenido de usuarios en toda tu organización. Informes de uso y costos por usuario y agrupados por intervalos de tiempo para Claude Enterprise. Establece límites de gasto por miembro y revisa las solicitudes de aumento.