Gerenciamento de usuários

Esta página explica como gerenciar programaticamente as pessoas na sua organização Claude Enterprise (claude.ai) usando a Admin API. 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.

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 e cada uma tem acesso a um subconjunto diferente dos endpoints:

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 do Claude Enterprise. Os endpoints de grupos e de funções personalizadas existem apenas para o Claude Enterprise.

Visão geral

Esta página aborda cinco recursos:

As funções personalizadas e seus vínculos com grupos são gerenciados nas configurações da organização no claude.ai. 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:

client = anthropic.Anthropic()

users = client.organization.users.list(limit=20)

for user in users:
    print(f"{user.id}: {user.email} ({user.role})")

{
  "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:

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 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 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.

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 na referência da API.

client = anthropic.Anthropic()

users = client.organization.users.list(email="jane@example.com")

for user in users:
    print(f"{user.id}: {user.email} ({user.role})")

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 na referência da API.

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}")

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 na referência da API.

client = anthropic.Anthropic()

user = client.organization.users.update("user_01AbCdEfGhIjKlMnOpQrSt", role="managed")

print(f"id: {user.id}")
print(f"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 na referência da API.

client = anthropic.Anthropic()

removed_user = client.organization.users.remove("user_01AbCdEfGhIjKlMnOpQrSt")

print(f"id: {removed_user.id}")

{
  "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 na referência da API.

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}")

{
  "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 na referência da API.

client = anthropic.Anthropic()

invites = client.organization.invites.list(limit=20)

for invite in invites:
    print(f"{invite.id}: {invite.email} ({invite.status})")

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 na referência da API.

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}")

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 na referência da API.

client = anthropic.Anthropic()

deleted_invite = client.organization.invites.delete("invite_01QrStUvWxYzAbCdEfGhIj")

print(f"id: {deleted_invite.id}")

Grupos

Os grupos que sua empresa cria diretamente (source_type: "direct"), nas configurações da organização no claude.ai 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 na referência da API.

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})")

{
  "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 na referência da API.

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}")

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 na referência da API.

client = anthropic.Anthropic()

group = client.beta.organization.rbac_groups.create(name="Engineering")

print(f"id: {group.id}")
print(f"name: {group.name}")

{
  "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 na referência da API.

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}")

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, esse limite deixa de se aplicar a eles.

Para detalhes completos dos parâmetros e esquemas de resposta, consulte Excluir grupo na referência da API.

client = anthropic.Anthropic()

deleted_group = client.beta.organization.rbac_groups.delete(
    "rbac_group_01UvWxYzAbCdEfGhIjKlMn"
)

print(f"id: {deleted_group.id}")

{
  "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 na referência da API.

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}")

{
  "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. Requer o escopo write:rbac_groups.

Para detalhes completos dos parâmetros e esquemas de resposta, consulte Adicionar membro ao grupo na referência da API.

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}")

{
  "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 na referência da API.

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}")

{
  "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 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 na referência da API.

client = anthropic.Anthropic()

roles = client.beta.organization.rbac_roles.list(limit=20)

for role in roles:
    print(f"{role.id}: {role.display_name}")

{
  "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 na referência da API.

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}")

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 na referência da API.

client = anthropic.Anthropic()

permissions = client.beta.organization.rbac_roles.permissions.list(
    "rbac_role_01CdEfGhIjKlMnOpQrStUv", limit=20
)

for permission in permissions:
    print(permission.action)

{
  "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:

   cURLCLIPythonTypeScriptC#GoJavaPHPRuby

   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})")

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 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 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ê.

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 e crie chaves substitutas.

Veja também