---
title: Benutzerverwaltung
url: https://platform.claude.com/docs/de/manage-claude/user-management
description: "Verwalte die Personen in deiner Claude Enterprise-Organisation mit der Admin API: Mitglieder auflisten und Rollen ändern, Einladungen senden und zurückziehen, Gruppen verwalten und benutzerdefinierte Rollen lesen."
---
Diese Seite behandelt die programmatische Verwaltung der Personen in deiner **Claude Enterprise**-Organisation (claude.ai) mithilfe der [Admin API](https://platform.claude.com/docs/de/api/beta/organization): Mitglieder auflisten und anhand der E-Mail-Adresse nachschlagen, die Rolle eines Mitglieds ändern, Mitglieder entfernen, Einladungen senden und zurückziehen, die Gruppen deines Unternehmens und deren Mitgliedschaft verwalten sowie die benutzerdefinierten Rollen deiner Organisation lesen. Für Claude Console-Organisationen (Claude Platform) siehe den [Admin API-Leitfaden für Claude Console](https://platform.claude.com/docs/de/manage-claude/admin-api).
Anfragen zu Gruppen und benutzerdefinierten Rollen erfordern nicht den [Beta-Header](https://platform.claude.com/docs/de/api/beta-headers) `anthropic-beta: ce-user-management-2026-07-13`. Anfragen, die ihn weiterhin senden, werden akzeptiert und verhalten sich identisch.
## Welche Endpunkte kann deine Organisation nutzen?
Die Admin API ist ein einziger Satz von Endpunkten unter `https://api.anthropic.com/v1/organizations/`. Claude Console- und Claude Enterprise-Organisationen authentifizieren sich mit [unterschiedlichen Keys](https://platform.claude.com/docs/de/manage-claude/admin-api-keys) und haben jeweils Zugriff auf eine andere Teilmenge der Endpunkte:
| Endpunkte | Claude Console (Claude Platform) | Claude Enterprise (claude.ai) |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Mitglieder](https://platform.claude.com/docs/de/manage-claude/user-management#members) und [Einladungen](https://platform.claude.com/docs/de/manage-claude/user-management#invites) | Verfügbar; siehe den [Admin-API-Leitfaden](https://platform.claude.com/docs/de/manage-claude/admin-api) | Verfügbar (diese Seite) |
| [Gruppen](https://platform.claude.com/docs/de/manage-claude/user-management#groups) | Nicht verfügbar | Verfügbar (diese Seite) |
| [Benutzerdefinierte Rollen](https://platform.claude.com/docs/de/manage-claude/user-management#custom-roles) | Nicht verfügbar | Verfügbar, schreibgeschützt (diese Seite) |
| [Ausgabenlimits](https://platform.claude.com/docs/de/manage-claude/spend-limits-api) | Nicht verfügbar | Verfügbar |
| Nutzungs- und Kostenberichte | Verfügbar; siehe die [Usage and Cost API](https://platform.claude.com/docs/de/manage-claude/usage-cost-api) | Verfügbar über die [Claude Enterprise Analytics API](https://platform.claude.com/docs/de/manage-claude/analytics-api#get-access-to-the-claude-enterprise-analytics-api) |
| [Workspaces](https://platform.claude.com/docs/de/manage-claude/workspaces), [API-Keys](https://platform.claude.com/docs/de/manage-claude/admin-api#api-keys), [Ratenlimits](https://platform.claude.com/docs/de/manage-claude/rate-limits-api) und die anderen Endpunkte im [Admin-API-Leitfaden](https://platform.claude.com/docs/de/manage-claude/admin-api) | Verfügbar | Nicht verfügbar |
Mitglieder und Einladungen sind für beide Organisationstypen dieselben Endpunkte; diese Seite dokumentiert ihr Verhalten bei Claude Enterprise, einschließlich der Claude Enterprise-[Organisationsrollen](https://platform.claude.com/docs/de/manage-claude/user-management#organization-roles). Die Endpunkte für Gruppen und benutzerdefinierte Rollen existieren nur für Claude Enterprise.
**Admin API-Key mit Scopes erforderlich**
Diese Endpunkte erfordern einen Admin API-Key mit dem „scope“ (Berechtigungsbereich) `read:members` (`GET`-Endpunkte für Mitglieder und Einladungen sowie alle Endpunkte für benutzerdefinierte Rollen; es gibt keinen separaten Rollen-Scope), dem Scope `write:members` (`POST`- und `DELETE`-Endpunkte für Mitglieder und Einladungen), dem Scope `read:rbac_groups` (`GET`-Endpunkte für Gruppen) oder dem Scope `write:rbac_groups` (`POST`- und `DELETE`-Endpunkte für Gruppen). Das Zuweisen der Rolle `managed` oder von Gruppen bei einer Einladung erfordert zusätzlich zu `write:members` auch `write:rbac_groups`. Ein Key mit dem Scope `read:org_audit` (ein schreibgeschützter Scope für Sicherheitsaudit-Integrationen) kann ebenfalls jeden `GET`-Endpunkt auf dieser Seite sowie die Lese-Endpunkte der [Compliance API](https://platform.claude.com/docs/de/manage-claude/compliance-api) aufrufen. Unter [Einen Admin-API-Key erstellen](https://platform.claude.com/docs/de/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization) erfährst du, wo dein primärer Eigentümer einen solchen Key erstellt und welche Scopes auszuwählen sind. Übergib den Key bei jeder Anfrage im Header `x-api-key`, zusammen mit dem Header [`anthropic-version`](https://platform.claude.com/docs/de/api/versioning).
## Überblick
Diese Seite behandelt fünf Ressourcen:
| Ressource | Endpunkte | Verwendung |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------- |
| **Mitglieder** | `GET /v1/organizations/users`
`GET /v1/organizations/users/{user_id}`
`POST /v1/organizations/users/{user_id}`
`DELETE /v1/organizations/users/{user_id}` | Die Mitglieder der Organisation auflisten oder eines per E-Mail nachschlagen; die Rolle eines Mitglieds ändern; ein Mitglied entfernen. |
| **Einladungen** | `POST /v1/organizations/invites`
`GET /v1/organizations/invites`
`GET /v1/organizations/invites/{invite_id}`
`DELETE /v1/organizations/invites/{invite_id}` | Eine Person in die Organisation einladen, den Status der Einladung verfolgen und sie zurückziehen, bevor sie angenommen wird. |
| **Gruppen** | `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}` | Die Gruppen deines Unternehmens und die jeweils zugeordneten benutzerdefinierten Rollen lesen; Gruppen erstellen, umbenennen und löschen. |
| **Gruppenmitglieder** | `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}` | Die Mitglieder einer Gruppe lesen; Mitglieder hinzufügen und entfernen. |
| **Benutzerdefinierte Rollen** | `GET /v1/organizations/rbac_roles`
`GET /v1/organizations/rbac_roles/{rbac_role_id}`
`GET /v1/organizations/rbac_roles/{rbac_role_id}/permissions` | Die benutzerdefinierten Rollen deiner Organisation und die Berechtigungen lesen, die jede Rolle gewährt. |
Benutzerdefinierte Rollen und ihre Gruppenzuordnungen werden in den [claude.ai-Organisationseinstellungen](https://claude.ai/admin-settings) verwaltet; die API liest sie, kann sie aber nicht ändern.
## Schnellstart
Setze die Umgebungsvariable `ANTHROPIC_API_KEY` auf deinen Admin API-Key. Die Beispiele auf dieser Seite lesen den Key daraus. Das SDK und die `ant`-CLI senden die Header `x-api-key` und `anthropic-version` für dich.
Liste die Mitglieder der Organisation auf, die neuesten zuerst:
```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"
}
```
## Wichtige Konzepte
### Organisationsrollen
Jedes Mitglied hat genau eine Organisationsrolle. Lesevorgänge geben die Rolle des Mitglieds als einen von fünf Werten zurück:
| Rolle | Bedeutung |
| ------------------ | -------------------------------------------------------------------------------------------------------------------------- |
| `user` | Ein Standardmitglied. |
| `managed` | Ein Mitglied, dessen Berechtigungen über die benutzerdefinierten Rollen gewährt werden, die seinen Gruppen angehängt sind. |
| `owner` | Ein Eigentümer der Organisation. |
| `membership_admin` | Ein Mitglied, das die Mitglieder der Organisation verwalten kann. |
| `primary_owner` | Der primäre Eigentümer der Organisation. Es gibt genau einen. |
Die API kann nur die Rollen `user` und `managed` zuweisen, bei der Erstellung von Einladungen und bei Rollenaktualisierungen. Das Zuweisen von `managed` erfordert zusätzlich zu `write:members` den Scope `write:rbac_groups`, da die Berechtigungen eines verwalteten Mitglieds aus den benutzerdefinierten Rollen stammen, die seinen Gruppen zugeordnet sind. Die administrativen Rollen (`owner`, `membership_admin` und `primary_owner`) werden in den claude.ai-Organisationseinstellungen zugewiesen, und Mitglieder mit diesen Rollen können über diese API weder geändert noch entfernt werden.
### Mitglieder und Einladungen
Eine Person wird Mitglied, indem sie eine Einladung annimmt (oder über das Single Sign-On deiner Organisation, sofern konfiguriert). Das Erstellen einer Einladung sendet eine Einladungs-E-Mail; die Einladung wird dann als `pending` gelesen, bis der Empfänger annimmt (`accepted`) oder ihr vom Server zugewiesenes `expires_at` verstreicht (`expired`). Nur eine Einladung im Status `pending` kann zurückgezogen werden. Um die E-Mail-Adresse oder Rolle einer ausstehenden Einladung zu ändern, ziehe sie zurück und erstelle eine neue.
Wenn der Plan deiner Organisation Mitglieder aus einem begrenzten Pool gekaufter Seats bezieht, verbraucht eine ausstehende Einladung einen Seat. Der Endpunkt zum Erstellen von Einladungen nimmt keinen Seat- oder Tier-Parameter entgegen: Der Seat wird automatisch aus dem niedrigsten Tier mit Verfügbarkeit zugewiesen. Das Erstellen einer Einladung, wenn kein Seat frei ist, schlägt mit einem 400-Fehler fehl, anstatt einen Seat zu kaufen. Das Zurückziehen der Einladung, ihr Ablaufen oder das spätere Entfernen des Mitglieds gibt den Seat an den Pool zurück.
### Gruppen und Rollen
Gruppen verbinden Mitglieder mit benutzerdefinierten Rollen („role-based access control" (rollenbasierte Zugriffskontrolle), das `rbac` in den Endpunktpfaden und Scope-Namen). Gruppen gehören deinem Unternehmen als Ganzes (der übergeordneten Organisation zusammen mit jeder ihr untergeordneten Organisation) und nicht einer einzelnen Organisation, daher erfordern die Gruppen-Scopes (`read:rbac_groups` und `write:rbac_groups`) einen Key, der für alle verknüpften Organisationen erstellt wurde. Jede Gruppe hat einen `source_type`: `direct` für Gruppen, die in claude.ai erstellt wurden, `scim` für Gruppen, die von deinem „identity provider" (Identitätsanbieter) bereitgestellt werden. Das Feld `role_ids` einer Gruppe listet die IDs der ihr zugeordneten benutzerdefinierten Rollen auf; löse sie mit den [Endpunkten für benutzerdefinierte Rollen](https://platform.claude.com/docs/de/manage-claude/user-management#custom-roles) in Namen und Berechtigungen auf. Beachte dabei, dass der Rollenkatalog pro Organisation gilt, während Gruppen unternehmensweit gelten, sodass das Abrufen einer Rolle, die zu einer anderen Organisation deines Unternehmens gehört, für deinen Key 404 zurückgibt. Das Feld ist `null` (statt `[]`), wenn Rollendaten vorübergehend nicht verfügbar waren; wiederhole die Anfrage also, um einen beeinträchtigten Lesevorgang von einer Gruppe ohne Rollen zu unterscheiden. Zwei abgekündigte Felder werden weiterhin zurückgegeben: `roles` bei Gruppen, immer gleich `role_ids`, und `group_id` bei Gruppenmitgliedern, immer gleich `rbac_group_id`.
## Versionierung
Sende bei jeder Anfrage den Header `anthropic-version`; die verfügbaren Versionen findest du unter [API-Versionen](https://platform.claude.com/docs/de/api/versioning).
## Ratenlimits
Admin API-Endpunkte teilen sich ein „rate limit“ (Ratenlimit) pro Organisation von **100 Anfragen pro Minute**; die Erstellung von Einladungen hat stattdessen ein eigenes Limit von **1.200 Anfragen pro Stunde**. Anfragen über einem Limit geben **429 Too Many Requests** zurück.
## Paginierung
Mitglieder- und Einladungslisten verwenden ID-basierte Paginierung: Übergib `limit` (Standard 20, maximal 1000) plus höchstens eines von `before_id` oder `after_id`, und blättere mithilfe der Felder `first_id` und `last_id` jeder Antwort, bis `has_more` `false` ist. Listen von Gruppen und benutzerdefinierten Rollen verwenden stattdessen einen **opaken Cursor**: Der Wert `next_page` der Antwort wird unverändert als Parameter `page` bei der nächsten Anfrage übergeben, bis `next_page` `null` ist.
Wenn du über die Ergebnisse iterierst, ruft das SDK weitere Seiten für dich ab, sodass `limit` die Seitengröße festlegt, nicht die Gesamtzahl. In der CLI legt `--limit` bei Mitglieder- und Einladungslisten die Gesamtzahl der Ergebnisse fest. Bei Gruppen- und Rollenlisten legt es die Seitengröße fest.
## Fehlerantworten
Fehlerantworten folgen der in [Fehler](https://platform.claude.com/docs/de/api/errors) dokumentierten Standardform.
## Mitglieder
### Mitglieder auflisten
`GET /v1/organizations/users` gibt die Mitglieder der Organisation zurück, die zuletzt hinzugefügten zuerst. Filtere nach `email`, um ein bestimmtes Mitglied nachzuschlagen; der Abgleich ist unabhängig von Groß- und Kleinschreibung und toleriert gängige Varianten derselben Adresse (zum Beispiel passt `jane+hiring@example.com` zu `jane@example.com`). Erfordert den Scope `read:members`.
Vollständige Parameterdetails und Antwortschemata findest du unter [Benutzer auflisten](https://platform.claude.com/docs/de/api/organization/users/list) in der API-Referenz.
```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
```
### Ein Mitglied abrufen
`GET /v1/organizations/users/{user_id}` gibt ein Mitglied anhand der ID zurück. Erfordert den Scope `read:members`.
Vollständige Parameterdetails und Antwortschemata findest du unter [Benutzer abrufen](https://platform.claude.com/docs/de/api/organization/users/retrieve) in der API-Referenz.
```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}"
```
### Die Rolle eines Mitglieds ändern
`POST /v1/organizations/users/{user_id}` setzt die Rolle des Mitglieds auf `user` oder `managed`. Mitglieder mit einer administrativen Rolle (`owner`, `membership_admin` oder `primary_owner`) können über diesen Endpunkt nicht geändert werden, und administrative Rollen können nicht zugewiesen werden; beides gibt 400 zurück und wird in den claude.ai-Organisationseinstellungen verwaltet. Wenn der Identitätsanbieter deiner Organisation Rollen verwaltet (erweitertes SSO oder erweiterte SCIM-Bereitstellung), geben Rollenaktualisierungen 400 zurück. Erfordert den Scope `write:members`, plus `write:rbac_groups`, wenn die Rolle auf `managed` geändert wird.
Vollständige Parameterdetails und Antwortschemata findest du unter [Benutzer aktualisieren](https://platform.claude.com/docs/de/api/organization/users/update) in der API-Referenz.
```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}"
```
### Ein Mitglied entfernen
`DELETE /v1/organizations/users/{user_id}` entfernt das Mitglied aus der Organisation und gibt einen gegebenenfalls belegten gekauften Seat an den Pool der Organisation zurück. Mitglieder mit einer administrativen Rolle können über diesen Endpunkt nicht entfernt werden, und wenn dein Identitätsanbieter die Mitgliedschaft verwaltet (SCIM), geben Entfernungen 400 zurück. Erfordert den Scope `write:members`.
Vollständige Parameterdetails und Antwortschemata findest du unter [Benutzer entfernen](https://platform.claude.com/docs/de/api/organization/users/remove) in der API-Referenz.
```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"
}
```
## Einladungen
### Eine Einladung erstellen
`POST /v1/organizations/invites` sendet eine Einladungs-E-Mail und gibt die Einladung mit einem vom Server zugewiesenen `expires_at` zurück. `role` muss `user` oder `managed` sein. Wenn für die E-Mail-Adresse bereits eine ausstehende Einladung existiert oder die Adresse bereits zu einem Mitglied gehört, gibt die Anfrage 400 zurück und nennt die vorhandene Ressource. Organisationen, deren Identitätsanbieter Benutzer automatisch bereitstellt (JIT oder SCIM), können keine Einladungen über die API erstellen. Erfordert den Scope `write:members`, plus `write:rbac_groups`, wenn `role` den Wert `managed` hat.
Bei Plänen, die Mitglieder aus einem begrenzten Seat-Pool beziehen, belegt die Einladung automatisch einen Seat aus dem niedrigsten Tier mit Verfügbarkeit. Die API nimmt keinen Tier-Parameter entgegen. Wenn kein Seat frei ist, schlägt die Anfrage mit einem 400-Fehler fehl, anstatt einen Seat zu kaufen. Füge Seats über die Planverwaltung der Organisation hinzu und versuche es erneut.
Das optionale Feld `rbac_group_ids` listet Gruppen (anhand der ID mit dem Präfix `rbac_group_`) auf, die dem Mitglied bei Annahme zugewiesen werden sollen. Das Übergeben eines nicht leeren `rbac_group_ids` erfordert zusätzlich, dass der Key den Scope `write:rbac_groups` trägt, da die Gruppenzuweisung die an die Rollen der Gruppe angehängten Berechtigungen gewähren kann.
Vollständige Parameterdetails und Antwortschemata findest du unter [Einladung erstellen](https://platform.claude.com/docs/de/api/organization/invites/create) in der API-Referenz.
```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"]
}
```
### Einladungen auflisten
`GET /v1/organizations/invites` gibt die Einladungen der Organisation zurück, die neuesten zuerst, über die Zustände `pending`, `accepted` und `expired` hinweg; es gibt keinen Statusfilter. Erfordert den Scope `read:members`.
Vollständige Parameterdetails und Antwortschemata findest du unter [Einladungen auflisten](https://platform.claude.com/docs/de/api/organization/invites/list) in der API-Referenz.
```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
```
### Eine Einladung abrufen
`GET /v1/organizations/invites/{invite_id}` gibt eine Einladung anhand der ID zurück. Erfordert den Scope `read:members`.
Vollständige Parameterdetails und Antwortschemata findest du unter [Einladung abrufen](https://platform.claude.com/docs/de/api/organization/invites/retrieve) in der API-Referenz.
```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}"
```
### Eine Einladung zurückziehen
`DELETE /v1/organizations/invites/{invite_id}` zieht eine Einladung im Status `pending` zurück und deaktiviert den Link in der Einladungs-E-Mail. Das Zurückziehen einer Einladung im Status `accepted` gibt 400 zurück (entferne stattdessen das Mitglied); das Zurückziehen einer Einladung im Status `expired` gibt 400 zurück. Erfordert den Scope `write:members`.
Vollständige Parameterdetails und Antwortschemata findest du unter [Einladung löschen](https://platform.claude.com/docs/de/api/organization/invites/delete) in der API-Referenz.
```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}"
```
## Gruppen
Gruppen, die dein Unternehmen direkt erstellt, in den [claude.ai-Organisationseinstellungen](https://claude.ai/admin-settings) oder über diese API (`source_type: "direct"`), unterstützen jeden Endpunkt in diesem Abschnitt. Gruppen, die von deinem Identitätsanbieter bereitgestellt werden (`source_type: "scim"`), können gelesen, aber nicht geändert werden: Das Umbenennen oder Löschen einer SCIM-Gruppe oder das Ändern ihrer Mitgliedschaft gibt 400 zurück, da dein Identitätsanbieter sie verwaltet.
### Gruppen auflisten
`GET /v1/organizations/rbac_groups` gibt die Gruppen deines Unternehmens zurück, einschließlich vom Identitätsanbieter verwalteter (`scim`) Gruppen. Erfordert den Scope `read:rbac_groups`.
Vollständige Parameterdetails und Antwortschemata findest du unter [Gruppen auflisten](https://platform.claude.com/docs/de/api/beta/organization/rbac_groups/list) in der API-Referenz.
```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
}
```
### Eine Gruppe abrufen
`GET /v1/organizations/rbac_groups/{rbac_group_id}` gibt eine Gruppe anhand ihrer ID zurück. Erfordert den Scope `read:rbac_groups`.
Vollständige Parameterdetails und Antwortschemata findest du unter [Gruppe abrufen](https://platform.claude.com/docs/de/api/beta/organization/rbac_groups/retrieve) in der API-Referenz.
```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}"
```
### Eine Gruppe erstellen
`POST /v1/organizations/rbac_groups` erstellt eine Gruppe mit dem angegebenen `name` (1–255 Zeichen) und ohne Rollen oder Mitglieder. Erfordert den Scope `write:rbac_groups`.
Vollständige Parameterdetails und Antwortschemata findest du unter [Gruppe erstellen](https://platform.claude.com/docs/de/api/beta/organization/rbac_groups/create) in der API-Referenz.
```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"
}
```
### Eine Gruppe umbenennen
`POST /v1/organizations/rbac_groups/{rbac_group_id}` aktualisiert die Gruppe. `name` ist das einzige Feld, das dieser Endpunkt ändern kann. Erfordert den Scope `write:rbac_groups`.
Vollständige Parameterdetails und Antwortschemata findest du unter [Gruppe aktualisieren](https://platform.claude.com/docs/de/api/beta/organization/rbac_groups/update) in der API-Referenz.
```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}"
```
### Eine Gruppe löschen
`DELETE /v1/organizations/rbac_groups/{rbac_group_id}` löscht die Gruppe. Ihre Mitglieder bleiben Mitglieder ihrer Organisationen, verlieren aber die Berechtigungen der zugeordneten Rollen, und ein gegebenenfalls vorhandenes [Ausgabenlimit](https://platform.claude.com/docs/de/manage-claude/spend-limits-api) der Gruppe gilt nicht mehr für sie. Erfordert den Scope `write:rbac_groups`.
Vollständige Parameterdetails und Antwortschemata findest du unter [Gruppe löschen](https://platform.claude.com/docs/de/api/beta/organization/rbac_groups/delete) in der API-Referenz.
```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"
}
```
### Die Mitglieder einer Gruppe auflisten
`GET /v1/organizations/rbac_groups/{rbac_group_id}/members` gibt die Mitglieder der Gruppe zurück (jeweils mit ihrer `user_id` und E-Mail-Adresse), die ältesten zuerst. Es werden nur aktuelle Mitglieder der Organisationen deines Unternehmens zurückgegeben, sodass eine Seite weniger als `limit` Einträge enthalten kann, während `has_more` den Wert `true` hat. Erfordert den Scope `read:rbac_groups`.
Vollständige Parameterdetails und Antwortschemata findest du unter [Gruppenmitglieder auflisten](https://platform.claude.com/docs/de/api/beta/organization/rbac_groups/members/list) in der API-Referenz.
```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
}
```
### Ein Mitglied zu einer Gruppe hinzufügen
`POST /v1/organizations/rbac_groups/{rbac_group_id}/members` fügt der Gruppe ein Organisationsmitglied anhand der `user_id` hinzu. Der Benutzer muss bereits Mitglied einer der Organisationen deines Unternehmens sein (andernfalls gibt die Anfrage 404 zurück), und das Hinzufügen einer Person, die bereits in der Gruppe ist, gibt 400 zurück. Bei `scim`-Gruppen wird die Mitgliedschaft in deinem Identitätsanbieter verwaltet, und diese Anfrage gibt 400 zurück. Um einer Person, die noch nicht beigetreten ist, Gruppen zuzuweisen, verwende stattdessen `rbac_group_ids` beim [Erstellen der Einladung](https://platform.claude.com/docs/de/manage-claude/user-management#create-an-invite). Erfordert den Scope `write:rbac_groups`.
Vollständige Parameterdetails und Antwortschemata findest du unter [Gruppenmitglied hinzufügen](https://platform.claude.com/docs/de/api/beta/organization/rbac_groups/members/add) in der API-Referenz.
```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"
}
```
### Ein Mitglied aus einer Gruppe entfernen
`DELETE /v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}` entfernt das Mitglied aus der Gruppe; es bleibt Mitglied seiner Organisation. Die Anfrage gibt 404 zurück, wenn der Benutzer kein Mitglied der Gruppe ist, und 400 bei `scim`-Gruppen, deren Mitgliedschaft in deinem Identitätsanbieter verwaltet wird. Erfordert den Scope `write:rbac_groups`.
Vollständige Parameterdetails und Antwortschemata findest du unter [Gruppenmitglied entfernen](https://platform.claude.com/docs/de/api/beta/organization/rbac_groups/members/remove) in der API-Referenz.
```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"
}
```
## Benutzerdefinierte Rollen
Benutzerdefinierte Rollen sind über die API schreibgeschützt: Diese Endpunkte katalogisieren die benutzerdefinierten Rollen deiner Organisation (definiert in den [claude.ai-Organisationseinstellungen](https://claude.ai/admin-settings) oder von Anthropic bereitgestellt) und die Berechtigungen, die jede Rolle gewährt. Lesevorgänge für benutzerdefinierte Rollen verwenden den Scope `read:members` (es gibt keinen separaten Rollen-Scope) und funktionieren mit einem Key auf Organisationsebene: Anders als die Gruppen-Endpunkte erfordern sie keinen Key, der für alle verknüpften Organisationen erstellt wurde, und der zurückgegebene Katalog ist der deiner eigenen Organisation.
Lies den Namen einer Rolle aus ihrem Feld `display_name`. Das abgekündigte Feld `name` wird weiterhin zurückgegeben, immer gleich `display_name`. Bei einer von Anthropic bereitgestellten Rolle kann `display_name` von der Bezeichnung abweichen, die claude.ai anzeigt, und Anthropic kann den Namen ändern. Um einen dauerhaften Verweis auf eine Rolle zu behalten, speichere ihre `id`.
### Rollen auflisten
`GET /v1/organizations/rbac_roles` gibt die benutzerdefinierten Rollen deiner Organisation zurück. Erfordert den Scope `read:members`.
Vollständige Parameterdetails und Antwortschemata findest du unter [Rollen auflisten](https://platform.claude.com/docs/de/api/beta/organization/rbac_roles/list) in der API-Referenz.
```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
}
```
### Eine Rolle abrufen
`GET /v1/organizations/rbac_roles/{rbac_role_id}` gibt eine Rolle anhand ihrer ID zurück. Erfordert den Scope `read:members`.
Vollständige Parameterdetails und Antwortschemata findest du unter [Rolle abrufen](https://platform.claude.com/docs/de/api/beta/organization/rbac_roles/retrieve) in der API-Referenz.
```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}"
```
### Die Berechtigungen einer Rolle auflisten
`GET /v1/organizations/rbac_roles/{rbac_role_id}/permissions` gibt die Berechtigungen der Rolle zurück. Jede Berechtigung kombiniert eine `resource` (worauf sie sich bezieht: die Produktfunktionen der Organisation, ein Connector-Tool, einen Connector-OAuth-Scope, einen einzelnen Connector oder jeden Connector) mit einer `action` (was sie für diese Ressource gewährt). Zeilen für Funktionen, die für deine Organisation nicht aktiviert sind, werden ausgelassen, sodass eine Seite weniger als `limit` Zeilen enthalten kann, während `has_more` den Wert `true` hat. Erfordert den Scope `read:members`.
Zwei `action`-Werte erfordern besondere Sorgfalt: Eine `organization`-Berechtigung, deren Aktion `capability_access_all` (jede Produktfunktion) oder `capability_access_all_ga` (jede stabile Produktfunktion, das heißt jede Funktion, die nicht als Beta oder Research Preview gekennzeichnet ist) lautet, ist eine pauschale Gewährung (eine, die weder den Modellzugriff noch die Admin-Panel-Berechtigungen mit dem Präfix `permission_` abdeckt) und wird als diese einzelne Zeile aufgeführt statt aufgeschlüsselt. Wenn du zusammenzählst, was eine Rolle gewährt, behandle eine pauschale Zeile so, dass sie alles abdeckt, was ihre Variante beschreibt, nicht nur die in anderen Zeilen genannten Funktionen.
Vollständige Parameterdetails und Antwortschemata findest du unter [Rollenberechtigungen auflisten](https://platform.claude.com/docs/de/api/beta/organization/rbac_roles/permissions/list) in der API-Referenz.
```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
}
```
## Beispiel-Workflows
### Einen ausscheidenden Mitarbeiter offboarden
1. Schlage das Mitglied anhand der E-Mail nach:
```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. Entferne es mit `DELETE /v1/organizations/users/{user_id}` unter Verwendung der `id` aus der Antwort. Sein Seat, falls vorhanden, kehrt in den Pool zurück.
3. Wenn die Person noch nicht beigetreten war, gibt die Suche kein Mitglied zurück; liste stattdessen die Einladungen auf und ziehe ihre Einladung im Status `pending` zurück.
### Gruppenmitgliedschaft prüfen
1. Liste die Gruppen auf und notiere für jede Gruppe `id`, `name` und `role_ids`.
2. Blättere für jede Gruppe mit sensiblen Rollen durch `GET /v1/organizations/rbac_groups/{rbac_group_id}/members` und vergleiche die E-Mail-Adressen der Mitglieder mit der Liste deines Identitätsanbieters.
3. Entferne Mitglieder, die nicht mehr in der Gruppe sein sollten, mit `DELETE /v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}`. Nimm die Änderung bei `scim`-Gruppen stattdessen in deinem Identitätsanbieter vor.
Einen Workflow, der Gruppenmitgliedschaft mit einer vorübergehenden Erhöhung des Ausgabenlimits kombiniert, findest du unter [Das Ausgabenlimit eines Mitglieds während eines Vorfalls vorübergehend erhöhen](https://platform.claude.com/docs/de/manage-claude/spend-limits-api#temporarily-raise-a-members-spend-limit-during-an-incident) auf der Seite zur Spend Limits API.
## Häufig gestellte Fragen
### Ist dies eine andere API als die Admin API?
Nein. Die Endpunkte für Mitglieder und Einladungen sind dieselben `/v1/organizations/`-Endpunkte, die Claude Console-Organisationen verwenden; diese Seite dokumentiert ihr Verhalten bei Claude Enterprise. Die Endpunkte für Gruppen und benutzerdefinierte Rollen sind Teil derselben API und existieren nur für Claude Enterprise-Organisationen. Die [Verfügbarkeitstabelle](https://platform.claude.com/docs/de/manage-claude/user-management#which-endpoints-can-your-organization-use) zeigt, welche Endpunkte jeder Organisationstyp aufrufen kann.
### Kann ich die Rolle Eigentümer oder Mitgliedschaftsadministrator über die API zuweisen?
Nein. Die API weist nur `user` und `managed` zu, bei der Erstellung von Einladungen und bei Rollenaktualisierungen. Administrative Rollen werden in den claude.ai-Organisationseinstellungen zugewiesen, und Mitglieder, die sie innehaben, können über die API nicht geändert oder entfernt werden.
### Kann ich Gruppen über die API erstellen oder ändern?
Ja, mit dem Scope `write:rbac_groups`: Gruppen erstellen, umbenennen und löschen sowie ihre Mitglieder hinzufügen oder entfernen. Zwei Dinge kann die API nicht ändern: von deinem Identitätsanbieter bereitgestellte Gruppen (`source_type: "scim"`), deren Name und Mitgliedschaft dem Identitätsanbieter gehören, und benutzerdefinierte Rollen, die in den claude.ai-Organisationseinstellungen verwaltet werden (die API [liest sie](https://platform.claude.com/docs/de/manage-claude/user-management#custom-roles)).
### Verbraucht eine nicht angenommene Einladung einen Seat?
Bei Plänen mit einem begrenzten Seat-Pool ja: Eine Einladung im Status `pending` belegt einen Seat. Das Zurückziehen der Einladung oder ihr Ablaufen gibt den Seat frei. Bei Plänen ohne Seat-Pool verbrauchen Einladungen nichts.
### Meine Organisation verwendet Single Sign-On. Welche Vorgänge funktionieren?
Wenn dein Identitätsanbieter Benutzer automatisch bereitstellt (JIT oder SCIM), gibt die Erstellung von Einladungen 400 zurück. Wenn er Rollen verwaltet (erweitertes SSO oder erweiterte SCIM-Bereitstellung), geben Rollenaktualisierungen 400 zurück. Wenn er die Mitgliedschaft verwaltet (SCIM-Bereitstellung), geben Entfernungen von Mitgliedern 400 zurück. Lesevorgänge funktionieren unabhängig davon.
### Was passiert mit einem Admin API-Key, wenn die Person, die ihn erstellt hat, das Unternehmen verlässt?
Der Key funktioniert weiterhin. Admin API-Keys sind auf die Organisation bezogen, nicht auf einzelne Benutzer, und ein in claude.ai erstellter Key läuft nicht ab. Das Entfernen des Erstellers aus der Organisation oder seine Deprovisionierung über deinen Identitätsanbieter beendet seinen eigenen Zugriff, aber nicht die von ihm erstellten Keys. Auch das Herabstufen seiner Rolle ändert die Keys nicht: Jeder Key bleibt mit seinen ursprünglichen Scopes aktiv. Wenn du jemanden offboardest, der Admin API-Keys erstellt hat, lösche diese Keys im Abschnitt **Keys** unter [claude.ai > Organisationseinstellungen > API](https://claude.ai/admin-settings/api-access) und erstelle Ersatz-Keys.
## Siehe auch
Wo dein primärer Eigentümer einen Key mit Scopes erstellt und welche Scopes auszuwählen sind.
Prüfe Aktivitäten und rufe Benutzerinhalte in deiner gesamten Organisation ab oder lösche sie.
Nutzungs- und Kostenberichte pro Benutzer und nach Zeitintervallen für Claude Enterprise.
Lege Ausgabenlimits pro Mitglied fest und prüfe Erhöhungsanfragen.