---
title: Gerenciamento de usuários
url: https://platform.claude.com/docs/pt-BR/manage-claude/user-management
description: "Gerencie as pessoas na sua organização Claude Enterprise com a Admin API: liste membros e altere funções, envie e retire convites, gerencie grupos e leia funções personalizadas."
---
Esta página explica como gerenciar programaticamente as pessoas na sua organização **Claude Enterprise** (claude.ai) usando a [Admin API](https://platform.claude.com/docs/pt-BR/api/beta/organization). Com ela, você pode listar membros e localizá-los por endereço de e-mail, alterar a função de um membro, remover membros, enviar e retirar convites, gerenciar os grupos da sua empresa e seus membros, e ler as funções personalizadas da sua organização. Para organizações do Claude Console (Claude Platform), consulte o [guia da Admin API para o Claude Console](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api).
Solicitações de grupos e de funções personalizadas não exigem o [cabeçalho beta](https://platform.claude.com/docs/pt-BR/api/beta-headers) `anthropic-beta: ce-user-management-2026-07-13`. Solicitações que ainda o enviam são aceitas e se comportam da mesma forma.
## Quais endpoints sua organização pode usar?
A Admin API é um único conjunto de endpoints em `https://api.anthropic.com/v1/organizations/`. Organizações do Claude Console e do Claude Enterprise se autenticam com [chaves diferentes](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api-keys) e cada uma tem acesso a um subconjunto diferente dos endpoints:
| Endpoints | Claude Console (Claude Platform) | Claude Enterprise (claude.ai) |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [Membros](https://platform.claude.com/docs/pt-BR/manage-claude/user-management#members) e [convites](https://platform.claude.com/docs/pt-BR/manage-claude/user-management#invites) | Disponível; consulte o [guia da Admin API](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api) | Disponível (esta página) |
| [Grupos](https://platform.claude.com/docs/pt-BR/manage-claude/user-management#groups) | Não disponível | Disponível (esta página) |
| [Funções personalizadas](https://platform.claude.com/docs/pt-BR/manage-claude/user-management#custom-roles) | Não disponível | Disponível, somente leitura (esta página) |
| [Limites de gastos](https://platform.claude.com/docs/pt-BR/manage-claude/spend-limits-api) | Não disponível | Disponível |
| Relatórios de uso e custo | Disponível; consulte a [Usage and Cost API](https://platform.claude.com/docs/pt-BR/manage-claude/usage-cost-api) | Disponível por meio da [Claude Enterprise Analytics API](https://platform.claude.com/docs/pt-BR/manage-claude/analytics-api#get-access-to-the-claude-enterprise-analytics-api) |
| [Workspaces](https://platform.claude.com/docs/pt-BR/manage-claude/workspaces), [chaves de API](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api#api-keys), [limites de taxa](https://platform.claude.com/docs/pt-BR/manage-claude/rate-limits-api) e os outros endpoints no [guia da Admin API](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api) | Disponível | Não disponível |
Os endpoints de membros e convites são os mesmos para os dois tipos de organização. Esta página documenta o comportamento deles no Claude Enterprise, incluindo as [funções de organização](https://platform.claude.com/docs/pt-BR/manage-claude/user-management#organization-roles) do Claude Enterprise. Os endpoints de grupos e de funções personalizadas existem apenas para o Claude Enterprise.
**É necessária uma chave de Admin API com escopo**
Esses endpoints exigem uma chave de Admin API com o "scope" (escopo) `read:members` (endpoints `GET` de membros e convites, e todos os endpoints de funções personalizadas; não há um escopo separado para funções), o escopo `write:members` (endpoints `POST` e `DELETE` de membros e convites), o escopo `read:rbac_groups` (endpoints `GET` de grupos) ou o escopo `write:rbac_groups` (endpoints `POST` e `DELETE` de grupos). Atribuir a função `managed`, ou grupos em um convite, exige `write:rbac_groups` além de `write:members`. Uma chave com o escopo `read:org_audit` (um escopo somente leitura para integrações de auditoria de segurança) também pode chamar todos os endpoints `GET` desta página e os endpoints de leitura da [Compliance API](https://platform.claude.com/docs/pt-BR/manage-claude/compliance-api). Consulte [Criar uma chave de Admin API](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization) para saber onde seu proprietário principal cria uma e quais escopos selecionar. Passe a chave no cabeçalho `x-api-key` em todas as solicitações, junto com o cabeçalho [`anthropic-version`](https://platform.claude.com/docs/pt-BR/api/versioning).
## Visão geral
Esta página aborda cinco recursos:
| Recurso | Endpoints | Usado para |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------- |
| **Membros** | `GET /v1/organizations/users`
`GET /v1/organizations/users/{user_id}`
`POST /v1/organizations/users/{user_id}`
`DELETE /v1/organizations/users/{user_id}` | Listar os membros da organização ou buscar um por e-mail; alterar a função de um membro; remover um membro. |
| **Convites** | `POST /v1/organizations/invites`
`GET /v1/organizations/invites`
`GET /v1/organizations/invites/{invite_id}`
`DELETE /v1/organizations/invites/{invite_id}` | Convidar uma pessoa para a organização, acompanhar o status do convite e retirá-lo antes que seja aceito. |
| **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}` | Ler os grupos da sua empresa e as funções personalizadas vinculadas a cada um; criar, renomear e excluir grupos. |
| **Membros 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}` | Ler os membros de um grupo; adicionar e remover membros. |
| **Funções personalizadas** | `GET /v1/organizations/rbac_roles`
`GET /v1/organizations/rbac_roles/{rbac_role_id}`
`GET /v1/organizations/rbac_roles/{rbac_role_id}/permissions` | Ler as funções personalizadas da sua organização e as permissões que cada função concede. |
As funções personalizadas e seus vínculos com grupos são gerenciados nas [configurações da organização no claude.ai](https://claude.ai/admin-settings). A API pode lê-los, mas não pode alterá-los.
## Início rápido
Defina a variável de ambiente `ANTHROPIC_API_KEY` com sua chave de Admin API. Os exemplos desta página leem a chave dessa variável. O SDK e a CLI `ant` enviam os cabeçalhos `x-api-key` e `anthropic-version` para você.
Liste os membros da organização, dos mais recentes para os mais antigos:
```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"
}
```
## Conceitos principais
### Funções de organização
Cada membro tem exatamente uma função de organização. As leituras retornam a função do membro como um destes cinco valores:
| Função | Significado |
| ------------------ | -------------------------------------------------------------------------------------------------- |
| `user` | Um membro padrão. |
| `managed` | Um membro cujas permissões são concedidas pelas funções personalizadas vinculadas aos seus grupos. |
| `owner` | Um proprietário da organização. |
| `membership_admin` | Um membro que pode gerenciar os membros da organização. |
| `primary_owner` | O proprietário principal da organização. Existe exatamente um. |
A API pode atribuir apenas as funções `user` e `managed`, na criação de convites e em atualizações de função. Atribuir `managed` exige o escopo `write:rbac_groups` além de `write:members`, porque as permissões de um membro gerenciado vêm das funções personalizadas vinculadas aos seus grupos. As funções administrativas (`owner`, `membership_admin` e `primary_owner`) são atribuídas nas configurações da organização no claude.ai, e membros que as possuem não podem ser modificados nem removidos por meio desta API.
### Membros e convites
Uma pessoa se torna membro ao aceitar um convite ou, quando configurado, pelo "single sign-on" (logon único), ou SSO, da sua organização. Criar um convite envia um e-mail de convite. A partir daí, o convite aparece como `pending` até que o destinatário o aceite (`accepted`) ou até que passe o `expires_at` atribuído pelo servidor (`expired`). Somente um convite `pending` pode ser retirado. Para alterar o endereço de e-mail ou a função de um convite pendente, retire-o e crie um novo.
Se o plano da sua organização obtém membros de um conjunto finito de "seats" (assentos) comprados, cada convite pendente consome um assento. O endpoint de criação de convites não aceita parâmetro de assento ou de nível: o assento é atribuído automaticamente a partir do nível mais baixo que tenha disponibilidade. Se não houver assento livre, a criação do convite falha com um erro 400, em vez de comprar um assento. O assento volta ao conjunto quando você retira o convite, quando ele expira ou quando você remove o membro posteriormente.
### Grupos e funções
Os grupos conectam membros a funções personalizadas. Esse é o "role-based access control" (controle de acesso baseado em funções), ou RBAC, que dá origem ao `rbac` nos caminhos dos endpoints e nos nomes dos escopos. Os grupos pertencem à sua empresa como um todo, e não a uma única organização. A empresa inclui a organização principal e todas as organizações abaixo dela. Por isso, os escopos de grupo (`read:rbac_groups` e `write:rbac_groups`) exigem uma chave criada para todas as organizações vinculadas. Cada grupo tem um `source_type`: `direct` para grupos criados no claude.ai, `scim` para grupos provisionados pelo seu provedor de identidade. O campo `role_ids` de um grupo lista os IDs das funções personalizadas vinculadas a ele. Use os [endpoints de funções personalizadas](https://platform.claude.com/docs/pt-BR/manage-claude/user-management#custom-roles) para obter os nomes e as permissões dessas funções. O catálogo de funções é por organização, enquanto os grupos abrangem toda a empresa. Por isso, buscar uma função que pertence a outra organização da sua empresa retorna 404 para a sua chave. O campo é `null` (em vez de `[]`) quando os dados de funções estavam temporariamente indisponíveis. Tente novamente para distinguir uma leitura degradada de um grupo sem funções. Dois campos descontinuados ainda são retornados: `roles` nos grupos, sempre igual a `role_ids`, e `group_id` nos membros de grupos, sempre igual a `rbac_group_id`.
## Versionamento
Envie o cabeçalho `anthropic-version` em todas as solicitações. Consulte [Versões da API](https://platform.claude.com/docs/pt-BR/api/versioning) para ver as versões disponíveis.
## Limites de taxa
Os endpoints da Admin API compartilham um "rate limit" (limite de taxa) por organização de **100 solicitações por minuto**. A criação de convites tem um limite próprio de **1.200 solicitações por hora**. Solicitações acima de um limite retornam **429 Too Many Requests**.
## Paginação
As listas de membros e convites usam paginação baseada em ID. Passe `limit` (padrão 20, máximo 1000) e, no máximo, um entre `before_id` ou `after_id`. Para paginar, use os campos `first_id` e `last_id` de cada resposta até que `has_more` seja `false`. As listas de grupos e de funções personalizadas usam um **"opaque cursor" (cursor opaco)**. Passe o valor `next_page` da resposta, sem alterações, como o parâmetro `page` na próxima solicitação, até que `next_page` seja `null`.
Quando você itera sobre os resultados, o SDK busca mais páginas para você, então `limit` define o tamanho da página, não o total. Na CLI, `--limit` define o número total de resultados para listas de membros e convites. Para listas de grupos e funções, ele define o tamanho da página.
## Respostas de erro
As respostas de erro seguem o formato padrão documentado em [Erros](https://platform.claude.com/docs/pt-BR/api/errors).
## Membros
### Listar membros
`GET /v1/organizations/users` retorna os membros da organização, dos adicionados mais recentemente para os mais antigos. Filtre por `email` para pesquisar um membro específico; a correspondência não diferencia maiúsculas de minúsculas e tolera variantes comuns do mesmo endereço (por exemplo, `jane+hiring@example.com` corresponde a `jane@example.com`). Requer o escopo `read:members`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Listar usuários](https://platform.claude.com/docs/pt-BR/api/organization/users/list) na referência da 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
```
### Obter um membro
`GET /v1/organizations/users/{user_id}` retorna um membro por ID. Requer o escopo `read:members`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Obter usuário](https://platform.claude.com/docs/pt-BR/api/organization/users/retrieve) na referência da 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}"
```
### Alterar a função de um membro
`POST /v1/organizations/users/{user_id}` define a função do membro como `user` ou `managed`. Membros com uma função administrativa (`owner`, `membership_admin` ou `primary_owner`) não podem ser alterados por meio deste endpoint, e funções administrativas não podem ser atribuídas; ambos os casos retornam 400 e são gerenciados nas configurações da organização no claude.ai. Se o provedor de identidade da sua organização gerencia funções (SSO avançado ou provisionamento SCIM avançado), as atualizações de função retornam 400. Requer o escopo `write:members`, mais `write:rbac_groups` ao alterar a função para `managed`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Atualizar usuário](https://platform.claude.com/docs/pt-BR/api/organization/users/update) na referência da 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}"
```
### Remover um membro
`DELETE /v1/organizations/users/{user_id}` remove o membro da organização, devolvendo qualquer assento comprado que ele ocupava ao conjunto da organização. Membros que possuem uma função administrativa não podem ser removidos por meio deste endpoint e, se o seu provedor de identidade gerencia a associação (SCIM), as remoções retornam 400. Requer o escopo `write:members`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Remover usuário](https://platform.claude.com/docs/pt-BR/api/organization/users/remove) na referência da 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"
}
```
## Convites
### Criar um convite
`POST /v1/organizations/invites` envia um e-mail de convite e retorna o convite com um `expires_at` atribuído pelo servidor. `role` deve ser `user` ou `managed`. Se já existir um convite pendente para o endereço de e-mail, ou se o endereço já pertencer a um membro, a solicitação retorna 400 indicando o recurso existente. Organizações cujo provedor de identidade provisiona usuários automaticamente (JIT ou SCIM) não podem criar convites por meio da API. Requer o escopo `write:members`, mais `write:rbac_groups` quando `role` é `managed`.
Em planos que obtêm membros de um conjunto finito de assentos, o convite ocupa automaticamente um assento do nível mais baixo que tenha disponibilidade. A API não aceita um parâmetro de nível. Se não houver assento livre, a solicitação falha com um erro 400 em vez de comprar um assento. Adicione assentos por meio do gerenciamento do plano da organização e tente novamente.
O campo opcional `rbac_group_ids` lista grupos (por ID com prefixo `rbac_group_`) a serem atribuídos ao membro quando ele aceitar. Passar um `rbac_group_ids` não vazio exige adicionalmente que a chave tenha o escopo `write:rbac_groups`, porque a atribuição a grupos pode conceder as permissões vinculadas às funções do grupo.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Criar convite](https://platform.claude.com/docs/pt-BR/api/organization/invites/create) na referência da 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 convites
`GET /v1/organizations/invites` retorna os convites da organização, dos mais recentes para os mais antigos, nos estados `pending`, `accepted` e `expired`; não há filtro de status. Requer o escopo `read:members`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Listar convites](https://platform.claude.com/docs/pt-BR/api/organization/invites/list) na referência da 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
```
### Obter um convite
`GET /v1/organizations/invites/{invite_id}` retorna um convite por ID. Requer o escopo `read:members`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Obter convite](https://platform.claude.com/docs/pt-BR/api/organization/invites/retrieve) na referência da 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 um convite
`DELETE /v1/organizations/invites/{invite_id}` retira um convite `pending`, desativando o link no e-mail de convite. Retirar um convite `accepted` retorna 400 (remova o membro em vez disso); retirar um convite `expired` retorna 400. Requer o escopo `write:members`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Excluir convite](https://platform.claude.com/docs/pt-BR/api/organization/invites/delete) na referência da 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
Os grupos que sua empresa cria diretamente (`source_type: "direct"`), nas [configurações da organização no claude.ai](https://claude.ai/admin-settings) ou por esta API, são compatíveis com todos os endpoints desta seção. Os grupos provisionados pelo seu provedor de identidade (`source_type: "scim"`) podem ser lidos, mas não modificados. Como o provedor de identidade é o dono desses grupos, renomear ou excluir um grupo SCIM, ou alterar seus membros, retorna 400.
### Listar grupos
`GET /v1/organizations/rbac_groups` retorna os grupos da sua empresa, incluindo os grupos gerenciados pelo provedor de identidade (`scim`). Requer o escopo `read:rbac_groups`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Listar grupos](https://platform.claude.com/docs/pt-BR/api/beta/organization/rbac_groups/list) na referência da 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
}
```
### Obter um grupo
`GET /v1/organizations/rbac_groups/{rbac_group_id}` retorna um grupo pelo ID. Requer o escopo `read:rbac_groups`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Obter grupo](https://platform.claude.com/docs/pt-BR/api/beta/organization/rbac_groups/retrieve) na referência da 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}"
```
### Criar um grupo
`POST /v1/organizations/rbac_groups` cria um grupo com o `name` informado (de 1 a 255 caracteres), sem funções nem membros. Requer o escopo `write:rbac_groups`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Criar grupo](https://platform.claude.com/docs/pt-BR/api/beta/organization/rbac_groups/create) na referência da 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"
}
```
### Renomear um grupo
`POST /v1/organizations/rbac_groups/{rbac_group_id}` atualiza o grupo. `name` é o único campo que este endpoint pode alterar. Requer o escopo `write:rbac_groups`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Atualizar grupo](https://platform.claude.com/docs/pt-BR/api/beta/organization/rbac_groups/update) na referência da 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}"
```
### Excluir um grupo
`DELETE /v1/organizations/rbac_groups/{rbac_group_id}` exclui o grupo. Requer o escopo `write:rbac_groups`. Os membros do grupo continuam sendo membros de suas organizações, mas perdem as permissões das funções vinculadas ao grupo. Se o grupo tinha um [limite de gastos](https://platform.claude.com/docs/pt-BR/manage-claude/spend-limits-api), esse limite deixa de se aplicar a eles.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Excluir grupo](https://platform.claude.com/docs/pt-BR/api/beta/organization/rbac_groups/delete) na referência da 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 os membros de um grupo
`GET /v1/organizations/rbac_groups/{rbac_group_id}/members` retorna os membros do grupo, dos mais antigos para os mais recentes, cada um com seu `user_id` e e-mail. Somente os membros atuais das organizações da sua empresa são retornados. Por isso, uma página pode conter menos de `limit` entradas mesmo quando `has_more` é `true`. Requer o escopo `read:rbac_groups`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Listar membros do grupo](https://platform.claude.com/docs/pt-BR/api/beta/organization/rbac_groups/members/list) na referência da 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
}
```
### Adicionar um membro a um grupo
`POST /v1/organizations/rbac_groups/{rbac_group_id}/members` adiciona um membro da organização ao grupo por `user_id`. O usuário já deve ser membro de uma das organizações da sua empresa (caso contrário, a solicitação retorna 404), e adicionar alguém que já está no grupo retorna 400. Para grupos `scim`, a associação é gerenciada no seu provedor de identidade e esta solicitação retorna 400. Para atribuir grupos a uma pessoa que ainda não entrou, use `rbac_group_ids` na [criação de convites](https://platform.claude.com/docs/pt-BR/manage-claude/user-management#create-an-invite). Requer o escopo `write:rbac_groups`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Adicionar membro ao grupo](https://platform.claude.com/docs/pt-BR/api/beta/organization/rbac_groups/members/add) na referência da 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"
}
```
### Remover um membro de um grupo
`DELETE /v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}` remove o membro do grupo; ele continua sendo membro de sua organização. A solicitação retorna 404 se o usuário não for membro do grupo, e 400 para grupos `scim`, cuja associação é gerenciada no seu provedor de identidade. Requer o escopo `write:rbac_groups`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Remover membro do grupo](https://platform.claude.com/docs/pt-BR/api/beta/organization/rbac_groups/members/remove) na referência da 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"
}
```
## Funções personalizadas
As funções personalizadas são somente leitura por meio da API: esses endpoints catalogam as funções personalizadas da sua organização (definidas nas [configurações da organização no claude.ai](https://claude.ai/admin-settings) ou provisionadas pela Anthropic) e as permissões que cada função concede. As leituras de funções personalizadas usam o escopo `read:members` (não há um escopo separado para funções) e funcionam com uma chave no nível da organização: diferentemente dos endpoints de grupos, elas não exigem uma chave criada para todas as organizações vinculadas, e o catálogo retornado é o da sua própria organização.
Leia o nome de uma função a partir do seu campo `display_name`. O campo descontinuado `name` ainda é retornado, sempre igual a `display_name`. Para uma função provisionada pela Anthropic, `display_name` pode diferir do rótulo que o claude.ai exibe, e a Anthropic pode alterar o nome. Para manter uma referência duradoura a uma função, armazene seu `id`.
### Listar funções
`GET /v1/organizations/rbac_roles` retorna as funções personalizadas da sua organização. Requer o escopo `read:members`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Listar funções](https://platform.claude.com/docs/pt-BR/api/beta/organization/rbac_roles/list) na referência da 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
}
```
### Obter uma função
`GET /v1/organizations/rbac_roles/{rbac_role_id}` retorna uma função pelo ID. Requer o escopo `read:members`.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Obter função](https://platform.claude.com/docs/pt-BR/api/beta/organization/rbac_roles/retrieve) na referência da 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 as permissões de uma função
`GET /v1/organizations/rbac_roles/{rbac_role_id}/permissions` retorna as permissões da função. Requer o escopo `read:members`. Cada permissão combina um `resource` (a que a permissão se aplica: os recursos de produto da organização, uma ferramenta de conector, um escopo OAuth de conector, um conector específico ou todos os conectores) com uma `action` (o que a permissão concede sobre esse recurso). Linhas de recursos que não estão habilitados para a sua organização são omitidas. Por isso, uma página pode conter menos de `limit` linhas mesmo quando `has_more` é `true`.
Dois valores de `action` exigem atenção especial. Uma permissão `organization` cuja ação é `capability_access_all` (todos os recursos de produto) ou `capability_access_all_ga` (todos os recursos de produto estáveis, ou seja, todos os recursos que não estão marcados como beta ou prévia de pesquisa) é uma concessão abrangente. Uma concessão abrangente não cobre o acesso a modelos nem as permissões do painel de administração com o prefixo `permission_`. Ela aparece como uma única linha, em vez de ser expandida. Ao contabilizar o que uma função concede, considere que uma linha abrangente cobre tudo o que sua variante descreve, e não apenas os recursos nomeados em outras linhas.
Para detalhes completos dos parâmetros e esquemas de resposta, consulte [Listar permissões da função](https://platform.claude.com/docs/pt-BR/api/beta/organization/rbac_roles/permissions/list) na referência da 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
}
```
## Fluxos de trabalho de exemplo
### Desligar um funcionário que está saindo
1. Localize o membro por e-mail:
```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. Remova-o com `DELETE /v1/organizations/users/{user_id}`, usando o `id` da resposta. O assento dele, se houver, volta ao conjunto.
3. Se a pessoa ainda não tinha entrado na organização, a busca não retorna nenhum membro. Nesse caso, liste os convites e retire o convite `pending` dela.
### Auditar os membros dos grupos
1. Liste os grupos e registre o `id`, o `name` e os `role_ids` de cada um.
2. Para cada grupo com funções sensíveis, percorra as páginas de `GET /v1/organizations/rbac_groups/{rbac_group_id}/members` e compare os e-mails dos membros com a lista do seu provedor de identidade.
3. Remova os membros que não devem mais estar no grupo com `DELETE /v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}`. Para grupos `scim`, faça a alteração no seu provedor de identidade.
Para um fluxo de trabalho que combina os membros de grupos com um aumento temporário do limite de gastos, consulte [Aumentar temporariamente o limite de gastos de um membro durante um incidente](https://platform.claude.com/docs/pt-BR/manage-claude/spend-limits-api#temporarily-raise-a-members-spend-limit-during-an-incident) na página da Spend Limits API.
## Perguntas frequentes
### Esta é uma API diferente da Admin API?
Não. Os endpoints de membros e convites são os mesmos endpoints `/v1/organizations/` usados pelas organizações do Claude Console. Esta página documenta o comportamento deles no Claude Enterprise. Os endpoints de grupos e de funções personalizadas fazem parte da mesma API e existem apenas para organizações do Claude Enterprise. A [tabela de disponibilidade](https://platform.claude.com/docs/pt-BR/manage-claude/user-management#which-endpoints-can-your-organization-use) mostra quais endpoints cada tipo de organização pode chamar.
### Posso atribuir a função de proprietário ou de administrador de membros pela API?
Não. A API atribui apenas `user` e `managed`, na criação de convites e nas atualizações de função. As funções administrativas são atribuídas nas configurações da organização no claude.ai, e membros com essas funções não podem ser modificados nem removidos pela API.
### Posso criar ou modificar grupos pela API?
Sim, com o escopo `write:rbac_groups`: você pode criar, renomear e excluir grupos, além de adicionar ou remover seus membros. A API não pode alterar duas coisas:
* Grupos provisionados pelo seu provedor de identidade (`source_type: "scim"`), cujo nome e membros pertencem ao provedor de identidade.
* Funções personalizadas, que são gerenciadas nas configurações da organização no claude.ai. A API apenas [as lê](https://platform.claude.com/docs/pt-BR/manage-claude/user-management#custom-roles).
### Um convite não aceito consome um assento?
Em planos com um conjunto finito de assentos, sim: um convite `pending` ocupa um assento. Retirar o convite ou deixá-lo expirar libera o assento. Em planos sem conjunto de assentos, os convites não consomem nada.
### Minha organização usa single sign-on. Quais operações funcionam?
Depende do que o seu provedor de identidade gerencia:
* Se ele provisiona usuários automaticamente (JIT ou SCIM), a criação de convites retorna 400.
* Se ele gerencia as funções (SSO avançado ou provisionamento SCIM avançado), as atualizações de função retornam 400.
* Se ele gerencia os membros (provisionamento SCIM), as remoções de membros retornam 400.
As leituras funcionam em todos os casos.
### O que acontece com uma chave de Admin API quando a pessoa que a criou sai da organização?
A chave continua funcionando. As chaves de Admin API pertencem à organização, e não a usuários individuais, e uma chave criada no claude.ai não expira.
Remover o criador da organização ou desprovisioná-lo pelo seu provedor de identidade encerra o acesso dele, mas não as chaves que ele criou. Rebaixar a função dele também não altera as chaves: cada chave continua ativa com seus escopos originais.
Ao desligar alguém que criou chaves de Admin API, exclua essas chaves na seção **Keys** de [claude.ai > Organization settings > API](https://claude.ai/admin-settings/api-access) e crie chaves substitutas.
## Veja também
Onde o proprietário principal cria uma chave com escopos e quais escopos selecionar.
Audite atividades e recupere ou exclua conteúdo de usuários em toda a sua organização.
Relatórios de uso e custo por usuário e por intervalo de tempo para o Claude Enterprise.
Defina limites de gastos por membro e analise solicitações de aumento.