Gestion des utilisateurs

Cette page explique comment gérer par programmation les personnes de votre organisation Claude Enterprise (claude.ai) à l'aide de l'Admin API : lister les membres et les rechercher par adresse e-mail, modifier le rôle d'un membre, supprimer des membres, envoyer et retirer des invitations, gérer les groupes de votre entreprise et leurs membres, et consulter les rôles personnalisés de votre organisation. Pour les organisations Claude Console (Claude Platform), consultez le guide de l'Admin API pour Claude Console.

Quels endpoints votre organisation peut-elle utiliser ?

L'Admin API est un ensemble unique d'endpoints sous https://api.anthropic.com/v1/organizations/. Les organisations Claude Console et Claude Enterprise s'authentifient avec des clés différentes et ont chacune accès à un sous-ensemble différent des endpoints :

Les membres et les invitations utilisent les mêmes endpoints pour les deux types d'organisation ; cette page documente leur comportement pour Claude Enterprise, y compris les rôles d'organisation de Claude Enterprise. Les endpoints de groupes et de rôles personnalisés n'existent que pour Claude Enterprise.

Vue d'ensemble

Cette page couvre cinq ressources :

Les rôles personnalisés et leurs associations aux groupes sont gérés dans les paramètres de l'organisation claude.ai ; l'API les lit mais ne peut pas les modifier.

Démarrage rapide

Définissez la variable d'environnement ANTHROPIC_API_KEY sur votre clé Admin API. Les exemples de cette page lisent la clé depuis cette variable. Le SDK et la CLI ant envoient les en-têtes Authorization et anthropic-version à votre place.

Listez les membres de l'organisation, du plus récent au plus ancien :

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

Concepts clés

Rôles d'organisation

Chaque membre possède exactement un rôle d'organisation. Les lectures renvoient le rôle du membre sous la forme de l'une des cinq valeurs suivantes :

L'API ne peut attribuer que les rôles user et managed, lors de la création d'une invitation et lors des mises à jour de rôle. L'attribution de managed nécessite la portée write:rbac_groups en plus de write:members, car les autorisations d'un membre géré proviennent des rôles personnalisés associés à ses groupes. Les rôles administratifs (owner, membership_admin et primary_owner) sont attribués dans les paramètres de l'organisation claude.ai, et les membres qui les détiennent ne peuvent pas être modifiés ni supprimés via cette API.

Membres et invitations

Une personne devient membre en acceptant une invitation (ou via l'authentification unique de votre organisation, lorsqu'elle est configurée). La création d'une invitation envoie un e-mail d'invitation ; l'invitation apparaît ensuite comme pending jusqu'à ce que le destinataire l'accepte (accepted) ou que sa date expires_at attribuée par le serveur soit dépassée (expired). Seule une invitation pending peut être retirée. Pour modifier l'adresse e-mail ou le rôle d'une invitation en attente, retirez-la et créez-en une nouvelle.

Si le forfait de votre organisation attribue les membres à partir d'un nombre limité de sièges achetés, une invitation en attente consomme un siège. L'endpoint de création d'invitation n'accepte pas de paramètre de siège ou de niveau : le siège est attribué automatiquement à partir du niveau le plus bas disposant de disponibilités. La création d'une invitation alors qu'aucun siège n'est libre échoue avec une erreur 400 au lieu d'acheter un siège. Le retrait de l'invitation, son expiration ou la suppression ultérieure du membre remet le siège dans le pool.

Groupes et rôles

Les groupes relient les membres aux rôles personnalisés (contrôle d'accès basé sur les rôles, le rbac dans les chemins des endpoints et les noms des portées). Les groupes appartiennent à votre entreprise dans son ensemble (l'organisation parente ainsi que toutes les organisations qui en dépendent) plutôt qu'à une seule organisation ; les portées de groupe (read:rbac_groups et write:rbac_groups) nécessitent donc une clé créée pour toutes les organisations liées. Chaque groupe possède un source_type : direct pour les groupes créés dans claude.ai, scim pour les groupes provisionnés par votre fournisseur d'identité. Le champ role_ids d'un groupe liste les identifiants des rôles personnalisés qui lui sont associés ; résolvez-les en noms et en autorisations avec les endpoints de rôles personnalisés, en notant que le catalogue de rôles est propre à chaque organisation alors que les groupes s'appliquent à toute l'entreprise : la récupération d'un rôle appartenant à une autre organisation de votre entreprise renvoie donc 404 pour votre clé. Le champ vaut null (plutôt que []) lorsque les données de rôle étaient temporairement indisponibles ; réessayez donc pour distinguer une lecture dégradée d'un groupe sans rôle.

Gestion des versions

Envoyez l'en-tête anthropic-version dans chaque requête ; consultez Versions de l'API pour connaître les versions disponibles.

Limites de débit

Les endpoints de l'Admin API partagent une limite par organisation de 100 requêtes par minute ; la création d'invitations dispose à la place de sa propre limite de 1 200 requêtes par heure. Les requêtes dépassant une limite renvoient 429 Too Many Requests.

Pagination

Les listes de membres et d'invitations utilisent une pagination basée sur les identifiants : transmettez limit (20 par défaut, 1000 au maximum) ainsi qu'au plus l'un des paramètres before_id ou after_id, et paginez à l'aide des champs first_id et last_id de chaque réponse jusqu'à ce que has_more soit false. Les listes de groupes et de rôles personnalisés utilisent à la place un curseur opaque : la valeur next_page de la réponse est transmise telle quelle comme paramètre page de la requête suivante, jusqu'à ce que next_page soit null.

Lorsque vous itérez sur les résultats, le SDK récupère les pages supplémentaires à votre place ; limit définit donc la taille de la page, et non le total. Dans la CLI, --limit définit le nombre total de résultats pour les listes de membres et d'invitations. Pour les listes de groupes et de rôles, il définit la taille de la page.

Réponses d'erreur

Les réponses d'erreur suivent la structure standard documentée dans Erreurs.

Membres

Lister les membres

GET /v1/organizations/users renvoie les membres de l'organisation, les plus récemment ajoutés en premier. Filtrez par email pour rechercher un membre spécifique ; la correspondance est insensible à la casse et tolère les variantes courantes d'une même adresse (par exemple, jane+hiring@example.com correspond à jane@example.com). Nécessite la portée read:members.

Pour le détail complet des paramètres et des schémas de réponse, consultez List users dans la référence de l'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})")

Obtenir un membre

GET /v1/organizations/users/{user_id} renvoie un membre par son identifiant. Nécessite la portée read:members.

Pour le détail complet des paramètres et des schémas de réponse, consultez Get user dans la référence de l'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}")

Modifier le rôle d'un membre

POST /v1/organizations/users/{user_id} définit le rôle du membre sur user ou managed. Les membres détenant un rôle administratif (owner, membership_admin ou primary_owner) ne peuvent pas être modifiés via cet endpoint, et les rôles administratifs ne peuvent pas être attribués ; ces deux cas renvoient 400 et sont gérés dans les paramètres de l'organisation claude.ai. Si le fournisseur d'identité de votre organisation gère les rôles (SSO avancé ou provisionnement SCIM avancé), les mises à jour de rôle renvoient 400. Nécessite la portée write:members, ainsi que write:rbac_groups lorsque le rôle est changé en managed.

Pour le détail complet des paramètres et des schémas de réponse, consultez Update user dans la référence de l'API.

client = anthropic.Anthropic()

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

print(f"id: {user.id}")
print(f"role: {user.role}")

Supprimer un membre

DELETE /v1/organizations/users/{user_id} supprime le membre de l'organisation et remet dans le pool de l'organisation tout siège acheté qu'il occupait. Les membres détenant un rôle administratif ne peuvent pas être supprimés via cet endpoint, et si votre fournisseur d'identité gère les adhésions (SCIM), les suppressions renvoient 400. Nécessite la portée write:members.

Pour le détail complet des paramètres et des schémas de réponse, consultez Remove user dans la référence de l'API.

client = anthropic.Anthropic()

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

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

{
  "type": "user_deleted",
  "id": "user_01AbCdEfGhIjKlMnOpQrSt"
}

Invitations

Créer une invitation

POST /v1/organizations/invites envoie un e-mail d'invitation et renvoie l'invitation avec une date expires_at attribuée par le serveur. role doit être user ou managed. Si une invitation en attente existe déjà pour l'adresse e-mail, ou si l'adresse appartient déjà à un membre, la requête renvoie 400 en indiquant la ressource existante. Les organisations dont le fournisseur d'identité provisionne automatiquement les utilisateurs (JIT ou SCIM) ne peuvent pas créer d'invitations via l'API. Nécessite la portée write:members, ainsi que write:rbac_groups lorsque role vaut managed.

Sur les forfaits qui attribuent les membres à partir d'un pool de sièges limité, l'invitation prend automatiquement un siège du niveau le plus bas disposant de disponibilités. L'API n'accepte pas de paramètre de niveau. Si aucun siège n'est libre, la requête échoue avec une erreur 400 au lieu d'acheter un siège. Ajoutez des sièges via la gestion du forfait de l'organisation, puis réessayez.

Le champ facultatif rbac_group_ids liste les groupes (par identifiant préfixé par rbac_group_) à attribuer au membre lorsqu'il accepte. La transmission d'un rbac_group_ids non vide exige en outre que la clé dispose de la portée write:rbac_groups, car l'attribution de groupes peut accorder les autorisations associées aux rôles du groupe.

Pour le détail complet des paramètres et des schémas de réponse, consultez Create invite dans la référence de l'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"]
}

Lister les invitations

GET /v1/organizations/invites renvoie les invitations de l'organisation, les plus récentes en premier, dans les états pending, accepted et expired ; il n'existe pas de filtre par statut. Nécessite la portée read:members.

Pour le détail complet des paramètres et des schémas de réponse, consultez List invites dans la référence de l'API.

client = anthropic.Anthropic()

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

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

Obtenir une invitation

GET /v1/organizations/invites/{invite_id} renvoie une invitation par son identifiant. Nécessite la portée read:members.

Pour le détail complet des paramètres et des schémas de réponse, consultez Get invite dans la référence de l'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}")

Retirer une invitation

DELETE /v1/organizations/invites/{invite_id} retire une invitation pending, ce qui désactive le lien contenu dans l'e-mail d'invitation. Le retrait d'une invitation accepted renvoie 400 (supprimez plutôt le membre) ; le retrait d'une invitation expired renvoie 400. Nécessite la portée write:members.

Pour le détail complet des paramètres et des schémas de réponse, consultez Delete invite dans la référence de l'API.

client = anthropic.Anthropic()

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

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

Groupes

Les groupes que votre entreprise crée directement, dans les paramètres de l'organisation claude.ai ou via cette API (source_type: "direct"), prennent en charge tous les endpoints de cette section. Les groupes provisionnés par votre fournisseur d'identité (source_type: "scim") peuvent être lus mais pas modifiés : renommer ou supprimer un groupe SCIM, ou modifier ses membres, renvoie 400, car il appartient à votre fournisseur d'identité.

Lister les groupes

GET /v1/organizations/rbac_groups renvoie les groupes de votre entreprise, y compris les groupes gérés par le fournisseur d'identité (scim). Nécessite la portée read:rbac_groups.

Pour le détail complet des paramètres et des schémas de réponse, consultez List groups dans la référence de l'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
}

Obtenir un groupe

GET /v1/organizations/rbac_groups/{rbac_group_id} renvoie un groupe par son identifiant. Nécessite la portée read:rbac_groups.

Pour le détail complet des paramètres et des schémas de réponse, consultez Get group dans la référence de l'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}")

Créer un groupe

POST /v1/organizations/rbac_groups crée un groupe avec le name indiqué (1 à 255 caractères), sans rôle ni membre. Nécessite la portée write:rbac_groups.

Pour le détail complet des paramètres et des schémas de réponse, consultez Create group dans la référence de l'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"
}

Renommer un groupe

POST /v1/organizations/rbac_groups/{rbac_group_id} met à jour le groupe. name est le seul champ que cet endpoint peut modifier. Nécessite la portée write:rbac_groups.

Pour le détail complet des paramètres et des schémas de réponse, consultez Update group dans la référence de l'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}")

Supprimer un groupe

DELETE /v1/organizations/rbac_groups/{rbac_group_id} supprime le groupe. Ses membres restent membres de leurs organisations, mais ils perdent les autorisations des rôles associés, et une éventuelle limite de dépenses de groupe cesse de s'appliquer à eux. Nécessite la portée write:rbac_groups.

Pour le détail complet des paramètres et des schémas de réponse, consultez Delete group dans la référence de l'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"
}

Lister les membres d'un groupe

GET /v1/organizations/rbac_groups/{rbac_group_id}/members renvoie les membres du groupe (chacun avec son user_id et son adresse e-mail), les plus anciens en premier. Seuls les membres actuels des organisations de votre entreprise sont renvoyés ; une page peut donc contenir moins de limit entrées alors que has_more vaut true. Nécessite la portée read:rbac_groups.

Pour le détail complet des paramètres et des schémas de réponse, consultez List group members dans la référence de l'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
}

Ajouter un membre à un groupe

POST /v1/organizations/rbac_groups/{rbac_group_id}/members ajoute un membre de l'organisation au groupe par son user_id. L'utilisateur doit déjà être membre de l'une des organisations de votre entreprise (sinon la requête renvoie 404), et l'ajout d'une personne déjà présente dans le groupe renvoie 400. Pour les groupes scim, les membres sont gérés dans votre fournisseur d'identité et cette requête renvoie 400. Pour attribuer des groupes à une personne qui n'a pas encore rejoint l'organisation, utilisez plutôt rbac_group_ids lors de la création de l'invitation. Nécessite la portée write:rbac_groups.

Pour le détail complet des paramètres et des schémas de réponse, consultez Add group member dans la référence de l'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"
}

Retirer un membre d'un groupe

DELETE /v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id} retire le membre du groupe ; il reste membre de son organisation. La requête renvoie 404 si l'utilisateur n'est pas membre du groupe, et 400 pour les groupes scim, dont les membres sont gérés dans votre fournisseur d'identité. Nécessite la portée write:rbac_groups.

Pour le détail complet des paramètres et des schémas de réponse, consultez Remove group member dans la référence de l'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"
}

Rôles personnalisés

Les rôles personnalisés sont en lecture seule via l'API : ces endpoints cataloguent les rôles personnalisés de votre organisation (définis dans les paramètres de l'organisation claude.ai ou provisionnés par Anthropic) et les autorisations accordées par chaque rôle. Les lectures de rôles personnalisés utilisent la portée read:members (il n'existe pas de portée distincte pour les rôles) et fonctionnent avec une clé au niveau de l'organisation : contrairement aux endpoints de groupes, elles ne nécessitent pas de clé créée pour toutes les organisations liées, et le catalogue renvoyé est celui de votre propre organisation.

Lisez le nom d'un rôle dans son champ display_name. Pour un rôle provisionné par Anthropic, display_name peut différer du libellé affiché par claude.ai, et Anthropic peut modifier ce nom. Pour conserver une référence durable à un rôle, stockez son id.

Lister les rôles

GET /v1/organizations/rbac_roles renvoie les rôles personnalisés de votre organisation. Nécessite la portée read:members.

Pour le détail complet des paramètres et des schémas de réponse, consultez List roles dans la référence de l'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
}

Obtenir un rôle

GET /v1/organizations/rbac_roles/{rbac_role_id} renvoie un rôle par son identifiant. Nécessite la portée read:members.

Pour le détail complet des paramètres et des schémas de réponse, consultez Get role dans la référence de l'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}")

Lister les autorisations d'un rôle

GET /v1/organizations/rbac_roles/{rbac_role_id}/permissions renvoie les autorisations du rôle. Chaque autorisation associe une resource (ce à quoi elle s'applique : les fonctionnalités produit de l'organisation, un outil de connecteur, une portée OAuth de connecteur, un connecteur ou tous les connecteurs) à une action (ce qu'elle accorde sur cette ressource). Les lignes concernant des fonctionnalités non activées pour votre organisation sont omises ; une page peut donc contenir moins de limit lignes alors que has_more vaut true. Nécessite la portée read:members.

Deux valeurs d'action demandent une attention particulière : une autorisation organization dont l'action est capability_access_all (toutes les fonctionnalités produit) ou capability_access_all_ga (toutes les fonctionnalités produit stables, c'est-à-dire toutes les fonctionnalités qui ne sont pas étiquetées bêta ou aperçu de recherche) est une autorisation globale (qui ne couvre ni l'accès aux modèles ni les autorisations du panneau d'administration préfixées par permission_) et est listée sous la forme de cette seule ligne plutôt que développée. Lorsque vous faites le bilan de ce qu'un rôle accorde, considérez qu'une ligne globale couvre tout ce que décrit sa variante, et pas seulement les fonctionnalités nommées dans les autres lignes.

Pour le détail complet des paramètres et des schémas de réponse, consultez List role permissions dans la référence de l'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
}

Exemples de flux de travail

Gérer le départ d'un employé

1. Recherchez le membre par 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. Supprimez-le avec DELETE /v1/organizations/users/{user_id}, en utilisant l'id de la réponse. Son siège, le cas échéant, retourne dans le pool.

3. Si la personne n'avait pas encore rejoint l'organisation, la recherche ne renvoie aucun membre ; listez plutôt les invitations et retirez son invitation pending.

Auditer les membres des groupes

1. Listez les groupes et notez l'id, le name et les role_ids de chaque groupe.

2. Pour chaque groupe comportant des rôles sensibles, parcourez les pages de GET /v1/organizations/rbac_groups/{rbac_group_id}/members et comparez les adresses e-mail des membres à la liste de votre fournisseur d'identité.

3. Retirez les membres qui ne devraient plus faire partie du groupe avec DELETE /v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}. Pour les groupes scim, effectuez plutôt la modification dans votre fournisseur d'identité.

Pour un flux de travail combinant l'appartenance à un groupe et une augmentation temporaire de la limite de dépenses, consultez Augmenter temporairement la limite de dépenses d'un membre lors d'un incident sur la page de l'API Spend Limits.

Questions fréquentes

S'agit-il d'une API différente de l'Admin API ?

Non. Les endpoints des membres et des invitations sont les mêmes endpoints /v1/organizations/ que ceux utilisés par les organisations Claude Console ; cette page documente leur comportement pour Claude Enterprise. Les endpoints de groupes et de rôles personnalisés font partie de la même API et n'existent que pour les organisations Claude Enterprise. Le tableau de disponibilité indique quels endpoints chaque type d'organisation peut appeler.

Puis-je attribuer le rôle de propriétaire ou d'administrateur des membres via l'API ?

Non. L'API n'attribue que user et managed, lors de la création d'invitations et des mises à jour de rôle. Les rôles administratifs sont attribués dans les paramètres de l'organisation claude.ai, et les membres qui les détiennent ne peuvent pas être modifiés ni supprimés via l'API.

Puis-je créer ou modifier des groupes via l'API ?

Oui, avec la portée write:rbac_groups : créer, renommer et supprimer des groupes, et ajouter ou retirer leurs membres. Deux éléments ne peuvent pas être modifiés par l'API : les groupes provisionnés par votre fournisseur d'identité (source_type: "scim"), dont le nom et les membres appartiennent au fournisseur d'identité, et les rôles personnalisés, qui sont gérés dans les paramètres de l'organisation claude.ai (l'API les lit).

Une invitation non acceptée consomme-t-elle un siège ?

Sur les forfaits disposant d'un pool de sièges limité, oui : une invitation pending occupe un siège. Le retrait de l'invitation ou son expiration libère le siège. Sur les forfaits sans pool de sièges, les invitations ne consomment rien.

Mon organisation utilise l'authentification unique. Quelles opérations fonctionnent ?

Si votre fournisseur d'identité provisionne automatiquement les utilisateurs (JIT ou SCIM), la création d'invitations renvoie 400. S'il gère les rôles (SSO avancé ou provisionnement SCIM avancé), les mises à jour de rôle renvoient 400. S'il gère les adhésions (provisionnement SCIM), les suppressions de membres renvoient 400. Les lectures fonctionnent dans tous les cas.

Qu'advient-il d'une clé Admin API lorsque la personne qui l'a créée quitte l'organisation ?

La clé continue de fonctionner. Les clés Admin API sont rattachées à l'organisation, et non à des utilisateurs individuels, et une clé créée dans claude.ai n'expire pas. Supprimer le créateur de l'organisation ou le déprovisionner via votre fournisseur d'identité met fin à son propre accès, mais pas aux clés qu'il a créées. La rétrogradation de son rôle ne modifie pas non plus les clés : chaque clé reste active avec ses portées d'origine. Lorsque vous gérez le départ d'une personne ayant créé des clés Admin API, supprimez ces clés dans la section Keys de claude.ai > Organization settings > API et créez-en de nouvelles pour les remplacer.

Voir aussi