Gerenciamento de usuários

Esta página aborda o gerenciamento programático das pessoas na sua organização Claude Enterprise (claude.ai), usando a Admin API: liste membros e procure-os por endereço de e-mail, altere a função de um membro, remova membros, envie e retire convites, gerencie os grupos da sua empresa e seus membros, e leia 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:

Membros e convites são os mesmos endpoints para ambos os tipos de organização; esta página documenta seu comportamento no Claude Enterprise, incluindo as funções de organização do Claude Enterprise. Os endpoints de grupos e 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 as lê, mas não pode alterá-las.

Início rápido

Defina a variável de ambiente ANTHROPIC_API_KEY com sua chave da Admin API. Os exemplos desta página leem a chave dela. O SDK e a CLI ant enviam os cabeçalhos Authorization 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 de 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 anexadas 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 ou removidos por meio desta API.

Membros e convites

Uma pessoa se torna membro ao aceitar um convite (ou por meio do "single sign-on" (login único) da sua organização, quando configurado). Criar um convite envia um e-mail de convite; o convite então aparece como pending até que o destinatário aceite (accepted) ou que seu expires_at atribuído pelo servidor passe (expired). Apenas 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 assentos comprados, um convite pendente consome um assento. O endpoint de criação de convites não aceita um parâmetro de assento ou nível: o assento é atribuído automaticamente a partir do nível mais baixo que tenha disponibilidade. Criar um convite quando nenhum assento está livre falha com um erro 400 em vez de comprar um assento. Retirar o convite, deixá-lo expirar ou remover o membro posteriormente devolve o assento ao conjunto.

Grupos e funções

Os grupos conectam membros a funções personalizadas ("role-based access control" (controle de acesso baseado em funções), o rbac nos caminhos dos endpoints e nos nomes dos escopos). Os grupos pertencem à sua empresa como um todo (a organização principal junto com todas as organizações abaixo dela) em vez de a uma única organização, portanto 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 anexadas a ele; resolva-os em nomes e permissões com os endpoints de funções personalizadas, observando que o catálogo de funções é por organização enquanto os grupos abrangem toda a empresa, então buscar uma função que pertence a uma organização diferente da sua empresa retorna 404 para sua chave. O campo é null (em vez de []) quando os dados de funções estavam temporariamente indisponíveis, então tente novamente para distinguir uma leitura degradada de um grupo sem funções.

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 limite por organização de 100 solicitações por minuto; a criação de convites tem seu próprio limite 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) mais no máximo um entre before_id ou after_id, e pagine usando os campos first_id e last_id de cada resposta até que has_more seja false. As listas de grupos e funções personalizadas usam um cursor opaco: o valor next_page da resposta é passado 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 primeiro. Filtre por email para procurar 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 List users 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 Get user 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 que possuem 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 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 Update user 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 Remove user 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 automaticamente ocupa um assento do nível mais baixo que tenha disponibilidade. A API não aceita um parâmetro de nível. Se nenhum assento estiver 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 de grupos pode conceder as permissões anexadas às funções do grupo.

Para detalhes completos dos parâmetros e esquemas de resposta, consulte Create invite 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 primeiro, 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 List invites 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 Get invite 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 Delete invite na referência da API.

client = anthropic.Anthropic()

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

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

Grupos

Grupos que sua empresa cria diretamente, nas configurações da organização no claude.ai ou por meio desta API (source_type: "direct"), suportam todos os endpoints desta seção. Grupos provisionados pelo seu provedor de identidade (source_type: "scim") podem ser lidos, mas não modificados: renomear ou excluir um grupo SCIM, ou alterar seus membros, retorna 400, porque seu provedor de identidade é o proprietário dele.

Listar grupos

GET /v1/organizations/rbac_groups retorna os grupos da sua empresa, incluindo grupos gerenciados pelo provedor de identidade (scim). Requer o escopo read:rbac_groups.

Para detalhes completos dos parâmetros e esquemas de resposta, consulte List groups 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 por ID. Requer o escopo read:rbac_groups.

Para detalhes completos dos parâmetros e esquemas de resposta, consulte Get group 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 fornecido (1–255 caracteres) e sem funções ou membros. Requer o escopo write:rbac_groups.

Para detalhes completos dos parâmetros e esquemas de resposta, consulte Create group 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 Update group 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. Seus membros continuam sendo membros de suas organizações, mas perdem as permissões das funções anexadas, e um limite de gastos do grupo, se existia, deixa de se aplicar a eles. Requer o escopo write:rbac_groups.

Para detalhes completos dos parâmetros e esquemas de resposta, consulte Delete group 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 (cada um com seu user_id e e-mail), dos mais antigos primeiro. Apenas membros atuais das organizações da sua empresa são retornados, então uma página pode conter menos de limit entradas enquanto has_more é true. Requer o escopo read:rbac_groups.

Para detalhes completos dos parâmetros e esquemas de resposta, consulte List group members 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 Add group member 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 Remove group member 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. Para uma função provisionada pela Anthropic, display_name pode diferir do rótulo que o claude.ai mostra, 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 List roles 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 por ID. Requer o escopo read:members.

Para detalhes completos dos parâmetros e esquemas de resposta, consulte Get role 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. Cada permissão combina um resource (ao que ela se aplica: os recursos de produto da organização, uma ferramenta de conector, um escopo OAuth de conector, um conector ou todos os conectores) com uma action (o que ela concede sobre esse recurso). Linhas para recursos não habilitados para sua organização são omitidas, então uma página pode conter menos de limit linhas enquanto has_more é true. Requer o escopo read:members.

Dois valores de action exigem cuidado 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 não rotulados como beta ou prévia de pesquisa) é uma concessão geral (que não abrange nem o acesso a modelos nem as permissões do painel de administração com prefixo permission_) e é listada como essa única linha em vez de expandida. Ao contabilizar o que uma função concede, trate uma linha de concessão geral como abrangendo tudo o que sua variante descreve, não apenas os recursos nomeados em outras linhas.

Para detalhes completos dos parâmetros e esquemas de resposta, consulte List role permissions 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. Procure 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, a busca não retorna nenhum membro; liste os convites e retire o convite pending dela.

Auditar a associação a grupos

1. Liste os grupos e registre o id, o name e os role_ids de cada grupo.

2. Para cada grupo que tenha 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 a associação a 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/ que as organizações do Claude Console usam; esta página documenta seu comportamento no Claude Enterprise. Os endpoints de grupos e 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 por meio da API?

Não. A API atribui apenas user e managed, na criação de convites e em atualizações de função. As funções administrativas são atribuídas nas configurações da organização no claude.ai, e membros que as possuem não podem ser modificados ou removidos por meio da API.

Posso criar ou modificar grupos por meio da API?

Sim, com o escopo write:rbac_groups: crie, renomeie e exclua grupos, e adicione ou remova seus membros. Há duas coisas que a API não pode alterar: grupos provisionados pelo seu provedor de identidade (source_type: "scim"), cujo nome e membros pertencem ao provedor de identidade, e funções personalizadas, que são gerenciadas nas configurações da organização no claude.ai (a API 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 um conjunto de assentos, os convites não consomem nada.

Minha organização usa single sign-on. Quais operações funcionam?

Se o seu provedor de identidade provisiona usuários automaticamente (JIT ou SCIM), a criação de convites retorna 400. Se ele gerencia funções (SSO avançado ou provisionamento SCIM avançado), as atualizações de função retornam 400. Se ele gerencia a associação (provisionamento SCIM), as remoções de membros retornam 400. As leituras funcionam em qualquer caso.

O que acontece com uma chave da Admin API quando a pessoa que a criou sai?

A chave continua funcionando. As chaves da Admin API têm escopo na organização, não em usuários individuais, e uma chave criada no claude.ai não expira. Remover o criador da organização ou desprovisioná-lo por meio do 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 permanece ativa com seus escopos originais. Ao desligar alguém que criou chaves da Admin API, exclua essas chaves na seção Keys de claude.ai > Organization settings > API e crie substitutas.

Veja também