---
title: Gestion des utilisateurs
url: https://platform.claude.com/docs/fr/manage-claude/user-management
description: "Gérez les personnes de votre organisation Claude Enterprise avec l'Admin API : listez les membres et modifiez les rôles, envoyez et retirez des invitations, gérez les groupes et consultez les rôles personnalisés."
---
Cette page explique comment gérer par programmation les personnes de votre organisation **Claude Enterprise** (claude.ai) à l'aide de l'[Admin API](https://platform.claude.com/docs/fr/api/beta/organization) : 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](https://platform.claude.com/docs/fr/manage-claude/admin-api).
Les requêtes relatives aux groupes et aux rôles personnalisés ne nécessitent pas l'[en-tête bêta](https://platform.claude.com/docs/fr/api/beta-headers) `anthropic-beta: ce-user-management-2026-07-13`. Les requêtes qui l'envoient encore sont acceptées et se comportent de manière identique.
## Quels points de terminaison votre organisation peut-elle utiliser ?
L'Admin API est un ensemble unique d'« endpoints » (points de terminaison) situés sous `https://api.anthropic.com/v1/organizations/`. Les organisations Claude Console et Claude Enterprise s'authentifient avec des [clés différentes](https://platform.claude.com/docs/fr/manage-claude/admin-api-keys) et ont chacune accès à un sous-ensemble différent des points de terminaison :
| Points de terminaison | Claude Console (Claude Platform) | Claude Enterprise (claude.ai) |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Membres](https://platform.claude.com/docs/fr/manage-claude/user-management#members) et [invitations](https://platform.claude.com/docs/fr/manage-claude/user-management#invites) | Disponible ; consultez le [guide de l'Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api) | Disponible (cette page) |
| [Groupes](https://platform.claude.com/docs/fr/manage-claude/user-management#groups) | Non disponible | Disponible (cette page) |
| [Rôles personnalisés](https://platform.claude.com/docs/fr/manage-claude/user-management#custom-roles) | Non disponible | Disponible, en lecture seule (cette page) |
| [Limites de dépenses](https://platform.claude.com/docs/fr/manage-claude/spend-limits-api) | Non disponible | Disponible |
| Rapports d'utilisation et de coûts | Disponible ; consultez l'[API d'utilisation et de coûts](https://platform.claude.com/docs/fr/manage-claude/usage-cost-api) | Disponible via l'[API Claude Enterprise Analytics](https://platform.claude.com/docs/fr/manage-claude/analytics-api#get-access-to-the-claude-enterprise-analytics-api) |
| [Espaces de travail](https://platform.claude.com/docs/fr/manage-claude/workspaces), [clés API](https://platform.claude.com/docs/fr/manage-claude/admin-api#api-keys), [limites de débit](https://platform.claude.com/docs/fr/manage-claude/rate-limits-api) et les autres points de terminaison du [guide de l'Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api) | Disponible | Non disponible |
Les points de terminaison des membres et des invitations sont les mêmes pour les deux types d'organisation. Cette page documente leur comportement pour Claude Enterprise, y compris les [rôles d'organisation](https://platform.claude.com/docs/fr/manage-claude/user-management#organization-roles) de Claude Enterprise. Les points de terminaison des groupes et des rôles personnalisés n'existent que pour Claude Enterprise.
**Clé Admin API à portée limitée requise**
Ces points de terminaison nécessitent une clé Admin API disposant de la portée `read:members` (points de terminaison `GET` des membres et des invitations, et tous les points de terminaison de rôles personnalisés ; il n'existe pas de portée distincte pour les rôles), de la portée `write:members` (points de terminaison `POST` et `DELETE` des membres et des invitations), de la portée `read:rbac_groups` (points de terminaison `GET` des groupes) ou de la portée `write:rbac_groups` (points de terminaison `POST` et `DELETE` des groupes). L'attribution du rôle `managed`, ou de groupes lors d'une invitation, nécessite `write:rbac_groups` en plus de `write:members`. Une clé disposant de la portée `read:org_audit` (une portée en lecture seule destinée aux intégrations d'audit de sécurité) peut également appeler tous les points de terminaison `GET` de cette page ainsi que les points de terminaison de lecture de la [Compliance API](https://platform.claude.com/docs/fr/manage-claude/compliance-api). Consultez [Créer une clé API Admin](https://platform.claude.com/docs/fr/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization) pour savoir où votre propriétaire principal en crée une et quelles portées sélectionner. Transmettez la clé dans l'en-tête `x-api-key` de chaque requête, avec l'en-tête [`anthropic-version`](https://platform.claude.com/docs/fr/api/versioning).
## Vue d'ensemble
Cette page couvre cinq ressources :
| Ressource | Points de terminaison | Utilisation |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------- |
| **Membres** | `GET /v1/organizations/users`
`GET /v1/organizations/users/{user_id}`
`POST /v1/organizations/users/{user_id}`
`DELETE /v1/organizations/users/{user_id}` | Lister les membres de l'organisation ou en rechercher un par e-mail ; modifier le rôle d'un membre ; supprimer un membre. |
| **Invitations** | `POST /v1/organizations/invites`
`GET /v1/organizations/invites`
`GET /v1/organizations/invites/{invite_id}`
`DELETE /v1/organizations/invites/{invite_id}` | Inviter une personne dans l'organisation, suivre le statut de l'invitation et la retirer avant qu'elle ne soit acceptée. |
| **Groupes** | `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}` | Consulter les groupes de votre entreprise et les rôles personnalisés associés à chacun ; créer, renommer et supprimer des groupes. |
| **Membres de groupe** | `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}` | Consulter les membres d'un groupe ; ajouter et supprimer des membres. |
| **Rôles personnalisés** | `GET /v1/organizations/rbac_roles`
`GET /v1/organizations/rbac_roles/{rbac_role_id}`
`GET /v1/organizations/rbac_roles/{rbac_role_id}/permissions` | Consulter les rôles personnalisés de votre organisation et les permissions accordées par chaque rôle. |
Les rôles personnalisés et leurs associations aux groupes sont gérés dans les [paramètres d'organisation de claude.ai](https://claude.ai/admin-settings). L'API peut les lire, mais 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 `x-api-key` et `anthropic-version` à votre place.
Listez les membres de l'organisation, les plus récents en premier :
```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"
}
```
## 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 l'une des cinq valeurs suivantes :
| Rôle | Signification |
| ------------------ | ------------------------------------------------------------------------------------------------- |
| `user` | Un membre standard. |
| `managed` | Un membre dont les permissions sont accordées par les rôles personnalisés attachés à ses groupes. |
| `owner` | Un propriétaire de l'organisation. |
| `membership_admin` | Un membre qui peut gérer les membres de l'organisation. |
| `primary_owner` | Le propriétaire principal de l'organisation. Il y en a exactement un. |
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 permissions 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 d'organisation de 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 puise ses membres dans un pool fini de sièges achetés, une invitation en attente consomme un siège. Le point de terminaison 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 ayant des disponibilités. La création d'une invitation lorsqu'aucun siège n'est libre échoue avec une erreur 400 au lieu d'acheter un siège. Retirer l'invitation, la laisser expirer ou supprimer le membre ultérieurement restitue le siège au pool.
### Groupes et rôles
Les groupes relient les membres aux rôles personnalisés. Ce mécanisme est le « role-based access control » (contrôle d'accès basé sur les rôles), ou RBAC, d'où le `rbac` dans les chemins des points de terminaison et les noms des portées. Les groupes appartiennent à votre entreprise dans son ensemble, et non à une seule organisation. L'entreprise comprend l'organisation parente et toutes les organisations qui en dépendent. Les portées de groupe (`read:rbac_groups` et `write:rbac_groups`) exigent 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 « identity provider » (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 permissions avec les [points de terminaison des rôles personnalisés](https://platform.claude.com/docs/fr/manage-claude/user-management#custom-roles). Le catalogue de rôles est propre à chaque organisation, alors que les groupes s'appliquent à toute l'entreprise. Récupérer un rôle qui appartient à une autre organisation de votre entreprise renvoie donc une erreur 404 pour votre clé. Le champ vaut `null` (plutôt que `[]`) lorsque les données de rôle étaient temporairement indisponibles. Réessayez pour distinguer une lecture dégradée d'un groupe sans rôle. Deux champs dépréciés sont encore renvoyés : `roles` sur les groupes, toujours égal à `role_ids`, et `group_id` sur les membres de groupe, toujours égal à `rbac_group_id`.
## Gestion des versions
Envoyez l'en-tête `anthropic-version` dans chaque requête ; consultez [Versions de l'API](https://platform.claude.com/docs/fr/api/versioning) pour connaître les versions disponibles.
## Limites de débit
Les points de terminaison 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 ID : transmettez `limit` (20 par défaut, 1000 au maximum) plus 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` vaille `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` vaille `null`.
Lorsque vous itérez sur les résultats, le SDK récupère les pages suivantes pour vous ; `limit` définit donc la taille de 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 page.
## Réponses d'erreur
Les réponses d'erreur suivent la forme standard documentée dans [Erreurs](https://platform.claude.com/docs/fr/api/errors).
## 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 [Lister les utilisateurs](https://platform.claude.com/docs/fr/api/organization/users/list) dans la référence de l'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
```
### 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 [Obtenir un utilisateur](https://platform.claude.com/docs/fr/api/organization/users/retrieve) dans la référence de l'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}"
```
### 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 ce point de terminaison, et les rôles administratifs ne peuvent pas être attribués ; ces deux cas renvoient une erreur 400 et sont gérés dans les paramètres d'organisation de 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 une erreur 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 [Mettre à jour un utilisateur](https://platform.claude.com/docs/fr/api/organization/users/update) dans la référence de l'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}"
```
### 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 ce point de terminaison, et si votre fournisseur d'identité gère l'appartenance (SCIM), les suppressions renvoient une erreur 400. Nécessite la portée `write:members`.
Pour le détail complet des paramètres et des schémas de réponse, consultez [Supprimer un utilisateur](https://platform.claude.com/docs/fr/api/organization/users/remove) dans la référence de l'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"
}
```
## Invitations
### Créer une invitation
`POST /v1/organizations/invites` envoie un e-mail d'invitation et renvoie l'invitation avec un `expires_at` attribué 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 une erreur 400 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 fini de sièges, l'invitation prend automatiquement un siège dans le 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 et réessayez.
Le champ facultatif `rbac_group_ids` liste les groupes (par identifiant préfixé par `rbac_group_`) à attribuer au membre lorsqu'il accepte. Transmettre un `rbac_group_ids` non vide exige en outre que la clé dispose de la portée `write:rbac_groups`, car l'attribution à un groupe peut accorder les permissions associées aux rôles du groupe.
Pour le détail complet des paramètres et des schémas de réponse, consultez [Créer une invitation](https://platform.claude.com/docs/fr/api/organization/invites/create) dans la référence de l'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"]
}
```
### 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 [Lister les invitations](https://platform.claude.com/docs/fr/api/organization/invites/list) dans la référence de l'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
```
### 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 [Obtenir une invitation](https://platform.claude.com/docs/fr/api/organization/invites/retrieve) dans la référence de l'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}"
```
### 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. Retirer une invitation `accepted` renvoie une erreur 400 (supprimez plutôt le membre) ; retirer une invitation `expired` renvoie une erreur 400. Nécessite la portée `write:members`.
Pour le détail complet des paramètres et des schémas de réponse, consultez [Supprimer une invitation](https://platform.claude.com/docs/fr/api/organization/invites/delete) dans la référence de l'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}"
```
## Groupes
Les groupes que votre entreprise crée directement, dans les [paramètres d'organisation de claude.ai](https://claude.ai/admin-settings) 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 une erreur 400, car votre fournisseur d'identité en est propriétaire.
### 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 les schémas de réponse, consultez [Lister les groupes](https://platform.claude.com/docs/fr/api/beta/organization/rbac_groups/list) dans la référence de l'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
}
```
### Obtenir un groupe
`GET /v1/organizations/rbac_groups/{rbac_group_id}` renvoie un groupe à partir de son identifiant. Nécessite la portée `read:rbac_groups`.
Pour le détail complet des paramètres et les schémas de réponse, consultez [Obtenir un groupe](https://platform.claude.com/docs/fr/api/beta/organization/rbac_groups/retrieve) dans la référence de l'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}"
```
### Créer un groupe
`POST /v1/organizations/rbac_groups` crée un groupe portant le `name` indiqué (de 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 les schémas de réponse, consultez [Créer un groupe](https://platform.claude.com/docs/fr/api/beta/organization/rbac_groups/create) dans la référence de l'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"
}
```
### Renommer un groupe
`POST /v1/organizations/rbac_groups/{rbac_group_id}` met à jour le groupe. `name` est le seul champ que ce point de terminaison peut modifier. Nécessite la portée `write:rbac_groups`.
Pour le détail complet des paramètres et les schémas de réponse, consultez [Mettre à jour un groupe](https://platform.claude.com/docs/fr/api/beta/organization/rbac_groups/update) dans la référence de l'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}"
```
### 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 permissions des rôles associés au groupe. Si le groupe avait une [limite de dépenses](https://platform.claude.com/docs/fr/manage-claude/spend-limits-api), elle cesse de s'appliquer à eux. Nécessite la portée `write:rbac_groups`.
Pour le détail complet des paramètres et les schémas de réponse, consultez [Supprimer un groupe](https://platform.claude.com/docs/fr/api/beta/organization/rbac_groups/delete) dans la référence de l'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"
}
```
### Lister les membres d'un groupe
`GET /v1/organizations/rbac_groups/{rbac_group_id}/members` renvoie les membres du groupe, des plus anciens aux plus récents, chacun avec son `user_id` et son adresse e-mail. 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 les schémas de réponse, consultez [Lister les membres d'un groupe](https://platform.claude.com/docs/fr/api/beta/organization/rbac_groups/members/list) dans la référence de l'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
}
```
### 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 une erreur 404), et ajouter une personne qui fait déjà partie du groupe renvoie une erreur 400. Pour les groupes `scim`, l'appartenance est gérée dans votre fournisseur d'identité et cette requête renvoie une erreur 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](https://platform.claude.com/docs/fr/manage-claude/user-management#create-an-invite). Nécessite la portée `write:rbac_groups`.
Pour le détail complet des paramètres et des schémas de réponse, consultez [Ajouter un membre à un groupe](https://platform.claude.com/docs/fr/api/beta/organization/rbac_groups/members/add) dans la référence de l'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"
}
```
### 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 une erreur 404 si l'utilisateur n'est pas membre du groupe, et une erreur 400 pour les groupes `scim`, dont l'appartenance est gérée 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 [Retirer un membre d'un groupe](https://platform.claude.com/docs/fr/api/beta/organization/rbac_groups/members/remove) dans la référence de l'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"
}
```
## Rôles personnalisés
Les rôles personnalisés sont en lecture seule via l'API : ces points de terminaison cataloguent les rôles personnalisés de votre organisation (définis dans les [paramètres d'organisation de claude.ai](https://claude.ai/admin-settings) ou provisionnés par Anthropic) et les permissions que chaque rôle accorde. 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 points de terminaison des 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`. Le champ `name`, déprécié, est toujours renvoyé et reste toujours égal à `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 les schémas de réponse, consultez [Lister les rôles](https://platform.claude.com/docs/fr/api/beta/organization/rbac_roles/list) dans la référence de l'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
}
```
### Obtenir un rôle
`GET /v1/organizations/rbac_roles/{rbac_role_id}` renvoie un rôle à partir de son identifiant. Nécessite la portée `read:members`.
Pour le détail complet des paramètres et les schémas de réponse, consultez [Obtenir un rôle](https://platform.claude.com/docs/fr/api/beta/organization/rbac_roles/retrieve) dans la référence de l'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}"
```
### Lister les permissions d'un rôle
`GET /v1/organizations/rbac_roles/{rbac_role_id}/permissions` renvoie les permissions du rôle. Chaque permission associe une `resource` (ce à quoi la permission s'applique : les fonctionnalités produit de l'organisation, un outil de connecteur, une portée OAuth de connecteur, un connecteur précis ou tous les connecteurs) à une `action` (ce que la permission accorde sur cette ressource). Les lignes correspondant à 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` d'une permission `organization` demandent une attention particulière. Chacune constitue une autorisation globale, listée sous la forme d'une seule ligne plutôt que détaillée : `capability_access_all` (toutes les fonctionnalités produit) et `capability_access_all_ga` (toutes les fonctionnalités produit stables, c'est-à-dire toutes celles qui ne sont pas étiquetées bêta ou aperçu de recherche). Ces autorisations globales ne couvrent ni l'accès aux modèles ni les permissions du panneau d'administration préfixées par `permission_`. 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 les schémas de réponse, consultez [Lister les permissions d'un rôle](https://platform.claude.com/docs/fr/api/beta/organization/rbac_roles/permissions/list) dans la référence de l'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
}
```
## Exemples de flux de travail
### Gérer le départ d'un employé
1. Recherchez le membre par 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. 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 au pool.
3. Si la personne n'avait pas encore rejoint l'organisation, la recherche ne renvoie aucun membre ; listez les invitations et retirez plutôt son invitation `pending`.
### Auditer les membres des groupes
1. Listez les groupes et notez l'`id`, le `name` et les `role_ids` de chacun.
2. Pour chaque groupe doté de rôles sensibles, parcourez les pages de `GET /v1/organizations/rbac_groups/{rbac_group_id}/members`. 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 qui combine l'appartenance à un groupe et une hausse temporaire de la limite de dépenses, consultez [Augmenter temporairement la limite de dépenses d'un membre pendant un incident](https://platform.claude.com/docs/fr/manage-claude/spend-limits-api#temporarily-raise-a-members-spend-limit-during-an-incident) sur la page de l'API Spend Limits.
## Foire aux questions
### S'agit-il d'une API différente de l'Admin API ?
Non. Les points de terminaison des membres et des invitations sont les mêmes points de terminaison `/v1/organizations/` que ceux utilisés par les organisations Claude Console ; cette page documente leur comportement pour Claude Enterprise. Les points de terminaison des groupes et des rôles personnalisés font partie de la même API et n'existent que pour les organisations Claude Enterprise. Le [tableau de disponibilité](https://platform.claude.com/docs/fr/manage-claude/user-management#which-endpoints-can-your-organization-use) indique quels points de terminaison 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 d'organisation de 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éez, renommez et supprimez des groupes, et ajoutez ou supprimez leurs membres. Deux choses que l'API ne peut pas modifier : 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 d'organisation de claude.ai (l'API [les lit](https://platform.claude.com/docs/fr/manage-claude/user-management#custom-roles)).
### Une invitation non acceptée consomme-t-elle un siège ?
Sur les forfaits disposant d'un pool de sièges fini, oui : une invitation `pending` occupe un siège. Retirer l'invitation ou la laisser expirer 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 l'appartenance (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. Rétrograder 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 > Paramètres de l'organisation > API](https://claude.ai/admin-settings/api-access) et créez-en de nouvelles en remplacement.
## Voir aussi
Où votre propriétaire principal crée une clé à portée limitée et quelles portées sélectionner.
Auditez l'activité et récupérez ou supprimez le contenu des utilisateurs dans toute votre organisation.
Rapports d'utilisation et de coûts par utilisateur et par tranche temporelle pour Claude Enterprise.
Définissez des limites de dépenses par membre et examinez les demandes d'augmentation.