Benutzerverwaltung

Diese Seite behandelt die programmatische Verwaltung der Personen in deiner Claude Enterprise-Organisation (claude.ai) mithilfe der Admin API: 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 Mitgliedschaften verwalten sowie die benutzerdefinierten Rollen deiner Organisation lesen. Für Claude Console-Organisationen (Claude Platform) siehe den Admin API-Leitfaden für Claude Console.

Welche Endpunkte kann deine Organisation verwenden?

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 und haben jeweils Zugriff auf eine andere Teilmenge der Endpunkte:

Mitglieder und Einladungen sind für beide Organisationstypen dieselben Endpunkte; diese Seite dokumentiert ihr Verhalten in Claude Enterprise, einschließlich der Claude Enterprise-Organisationsrollen. Die Endpunkte für Gruppen und benutzerdefinierte Rollen existieren nur für Claude Enterprise.

Überblick

Diese Seite behandelt fünf Ressourcen:

Benutzerdefinierte Rollen und ihre Gruppenzuordnungen werden in den claude.ai-Organisationseinstellungen 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 Authorization und anthropic-version für dich.

Liste die Mitglieder der Organisation auf, die neuesten zuerst:

client = anthropic.Anthropic()

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

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

{
  "data": [
    {
      "type": "user",
      "id": "user_01AbCdEfGhIjKlMnOpQrSt",
      "email": "jane@example.com",
      "name": "Jane Smith",
      "role": "user",
      "added_at": "2026-06-12T09:14:03Z"
    }
  ],
  "has_more": false,
  "first_id": "user_01AbCdEfGhIjKlMnOpQrSt",
  "last_id": "user_01AbCdEfGhIjKlMnOpQrSt"
}

Zentrale Konzepte

Organisationsrollen

Jedes Mitglied hat genau eine Organisationsrolle. Lesevorgänge geben die Rolle des Mitglieds als einen von fünf Werten zurück:

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 hat dann den Status pending, bis der Empfänger sie annimmt (accepted) oder ihr vom Server zugewiesenes expires_at verstreicht (expired). Nur eine Einladung mit 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 Plätze bezieht, belegt eine ausstehende Einladung einen Platz. Der Endpunkt zum Erstellen von Einladungen akzeptiert keinen Platz- oder Tier-Parameter: Der Platz wird automatisch aus dem niedrigsten Tier mit Verfügbarkeit zugewiesen. Das Erstellen einer Einladung, wenn kein Platz frei ist, schlägt mit einem 400-Fehler fehl, anstatt einen Platz zu kaufen. Das Zurückziehen der Einladung, ihr Ablaufen oder das spätere Entfernen des Mitglieds gibt den Platz 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 Organisation darunter) 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 in claude.ai erstellte Gruppen, scim für von deinem Identitätsanbieter bereitgestellte Gruppen. 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 in Namen und Berechtigungen auf. Beachte dabei, dass der Rollenkatalog pro Organisation gilt, während Gruppen unternehmensweit sind, 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 eingeschränkten Lesevorgang von einer Gruppe ohne Rollen zu unterscheiden.

Versionierung

Sende den Header anthropic-version bei jeder Anfrage; siehe API-Versionen für die verfügbaren Versionen.

Ratenlimits

Admin API-Endpunkte teilen sich ein Limit pro Organisation von 100 Anfragen pro Minute; für die Erstellung von Einladungen gilt 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 einen der Parameter before_id oder after_id, und blättere mithilfe der Felder first_id und last_id jeder Antwort, bis has_more den Wert false hat. Gruppen- und Rollenlisten 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 den Wert null hat.

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 Standardstruktur, die unter Fehler dokumentiert ist.

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 berücksichtigt keine Groß-/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 Antwortschemas findest du unter List users in der API-Referenz.

client = anthropic.Anthropic()

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

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

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 Antwortschemas findest du unter Get user in der API-Referenz.

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

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 Antwortschemas findest du unter Update user in der API-Referenz.

client = anthropic.Anthropic()

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

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

Ein Mitglied entfernen

DELETE /v1/organizations/users/{user_id} entfernt das Mitglied aus der Organisation und gibt einen eventuell belegten gekauften Platz 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 Antwortschemas findest du unter Remove user in der API-Referenz.

client = anthropic.Anthropic()

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

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

{
  "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 Platz-Pool beziehen, belegt die Einladung automatisch einen Platz aus dem niedrigsten Tier mit Verfügbarkeit. Die API akzeptiert keinen Tier-Parameter. Wenn kein Platz frei ist, schlägt die Anfrage mit einem 400-Fehler fehl, anstatt einen Platz zu kaufen. Füge über die Planverwaltung der Organisation Plätze hinzu und versuche es erneut.

Das optionale Feld rbac_group_ids listet Gruppen (anhand der mit rbac_group_ beginnenden ID) auf, die dem Mitglied bei der Annahme zugewiesen werden. Die Übergabe eines nicht leeren rbac_group_ids erfordert zusätzlich, dass der Key den Scope write:rbac_groups besitzt, da die Gruppenzuweisung die Berechtigungen gewähren kann, die den Rollen der Gruppe zugeordnet sind.

Vollständige Parameterdetails und Antwortschemas findest du unter Create invite in der API-Referenz.

client = anthropic.Anthropic()

invite = client.organization.invites.create(
    email="newhire@example.com",
    role="managed",
    rbac_group_ids=["rbac_group_01UvWxYzAbCdEfGhIjKlMn"],
)

print(f"id: {invite.id}")
print(f"email: {invite.email}")
print(f"status: {invite.status}")
print(f"expires_at: {invite.expires_at}")

{
  "type": "invite",
  "id": "invite_01QrStUvWxYzAbCdEfGhIj",
  "email": "newhire@example.com",
  "role": "managed",
  "invited_at": "2026-07-06T16:20:11Z",
  "expires_at": "2026-07-27T16:20:11Z",
  "accepted_at": null,
  "status": "pending",
  "rbac_group_ids": ["rbac_group_01UvWxYzAbCdEfGhIjKlMn"]
}

Einladungen auflisten

GET /v1/organizations/invites gibt die Einladungen der Organisation zurück, die neuesten zuerst, über die Status pending, accepted und expired hinweg; es gibt keinen Statusfilter. Erfordert den Scope read:members.

Vollständige Parameterdetails und Antwortschemas findest du unter List invites in der API-Referenz.

client = anthropic.Anthropic()

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

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

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 Antwortschemas findest du unter Get invite in der API-Referenz.

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

Eine Einladung zurückziehen

DELETE /v1/organizations/invites/{invite_id} zieht eine Einladung mit Status pending zurück und deaktiviert den Link in der Einladungs-E-Mail. Das Zurückziehen einer Einladung mit Status accepted gibt 400 zurück (entferne stattdessen das Mitglied); das Zurückziehen einer Einladung mit Status expired gibt 400 zurück. Erfordert den Scope write:members.

Vollständige Parameterdetails und Antwortschemas findest du unter Delete invite in der API-Referenz.

client = anthropic.Anthropic()

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

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

Gruppen

Gruppen, die dein Unternehmen direkt erstellt, in den claude.ai-Organisationseinstellungen oder über diese API (source_type: "direct"), unterstützen jeden Endpunkt in diesem Abschnitt. Von deinem Identitätsanbieter bereitgestellte Gruppen (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 besitzt.

Gruppen auflisten

GET /v1/organizations/rbac_groups gibt die Gruppen deines Unternehmens zurück, einschließlich der vom Identitätsanbieter verwalteten (scim) Gruppen. Erfordert den Scope read:rbac_groups.

Vollständige Parameterdetails und Antwortschemas findest du unter List groups in der API-Referenz.

client = anthropic.Anthropic()

groups = client.beta.organization.rbac_groups.list(limit=20)

for group in groups:
    print(f"{group.id}: {group.name} ({group.source_type})")

{
  "data": [
    {
      "type": "rbac_group",
      "id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
      "name": "Engineering",
      "source_type": "direct",
      "role_ids": ["rbac_role_01CdEfGhIjKlMnOpQrStUv"],
      "roles": ["rbac_role_01CdEfGhIjKlMnOpQrStUv"],
      "created_at": "2026-03-18T10:01:42Z",
      "updated_at": "2026-05-02T08:55:09Z"
    }
  ],
  "has_more": false,
  "next_page": null
}

Eine Gruppe abrufen

GET /v1/organizations/rbac_groups/{rbac_group_id} gibt eine Gruppe anhand der ID zurück. Erfordert den Scope read:rbac_groups.

Vollständige Parameterdetails und Antwortschemas findest du unter Get group in der API-Referenz.

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

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 Antwortschemas findest du unter Create group in der API-Referenz.

client = anthropic.Anthropic()

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

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

{
  "type": "rbac_group",
  "id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
  "name": "Engineering",
  "source_type": "direct",
  "role_ids": [],
  "roles": [],
  "created_at": "2026-07-09T18:00:00Z",
  "updated_at": "2026-07-09T18:00:00Z"
}

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 Antwortschemas findest du unter Update group in der API-Referenz.

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

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 eventuell vorhandenes Ausgabenlimit der Gruppe gilt nicht mehr für sie. Erfordert den Scope write:rbac_groups.

Vollständige Parameterdetails und Antwortschemas findest du unter Delete group in der API-Referenz.

client = anthropic.Anthropic()

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

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

{
  "id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
  "type": "rbac_group_deleted"
}

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 Antwortschemas findest du unter List group members in der API-Referenz.

client = anthropic.Anthropic()

members = client.beta.organization.rbac_groups.members.list(
    "rbac_group_01UvWxYzAbCdEfGhIjKlMn", limit=100
)

for member in members:
    print(f"{member.user_id}: {member.email}")

{
  "data": [
    {
      "type": "rbac_group_member",
      "rbac_group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
      "group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
      "user_id": "user_01AbCdEfGhIjKlMnOpQrSt",
      "email": "jane@example.com",
      "created_at": "2026-04-07T12:30:00Z"
    }
  ],
  "has_more": false,
  "next_page": null
}

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 bei der Erstellung der Einladung. Erfordert den Scope write:rbac_groups.

Vollständige Parameterdetails und Antwortschemas findest du unter Add group member in der API-Referenz.

client = anthropic.Anthropic()

member = client.beta.organization.rbac_groups.members.add(
    "rbac_group_01UvWxYzAbCdEfGhIjKlMn", user_id="user_01AbCdEfGhIjKlMnOpQrSt"
)

print(f"user_id: {member.user_id}")
print(f"email: {member.email}")

{
  "type": "rbac_group_member",
  "rbac_group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
  "group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
  "user_id": "user_01AbCdEfGhIjKlMnOpQrSt",
  "email": "jane@example.com",
  "created_at": "2026-07-09T18:00:00Z"
}

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 Antwortschemas findest du unter Remove group member in der API-Referenz.

client = anthropic.Anthropic()

removed_member = client.beta.organization.rbac_groups.members.remove(
    "user_01AbCdEfGhIjKlMnOpQrSt", rbac_group_id="rbac_group_01UvWxYzAbCdEfGhIjKlMn"
)

print(f"user_id: {removed_member.user_id}")

{
  "rbac_group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
  "group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
  "user_id": "user_01AbCdEfGhIjKlMnOpQrSt",
  "type": "rbac_group_member_deleted"
}

Benutzerdefinierte Rollen

Benutzerdefinierte Rollen sind über die API nur lesbar: Diese Endpunkte katalogisieren die benutzerdefinierten Rollen deiner Organisation (definiert in den claude.ai-Organisationseinstellungen 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. Bei einer von Anthropic bereitgestellten Rolle kann display_name von der Bezeichnung abweichen, die claude.ai anzeigt, und Anthropic kann den Namen ändern. Um eine dauerhafte Referenz 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 Antwortschemas findest du unter List roles in der API-Referenz.

client = anthropic.Anthropic()

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

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

{
  "data": [
    {
      "type": "rbac_role",
      "id": "rbac_role_01CdEfGhIjKlMnOpQrStUv",
      "display_name": "Engineering base",
      "name": "Engineering base",
      "created_at": "2026-03-18T10:01:42Z",
      "updated_at": "2026-05-02T08:55:09Z"
    }
  ],
  "has_more": false,
  "next_page": null
}

Eine Rolle abrufen

GET /v1/organizations/rbac_roles/{rbac_role_id} gibt eine Rolle anhand der ID zurück. Erfordert den Scope read:members.

Vollständige Parameterdetails und Antwortschemas findest du unter Get role in der API-Referenz.

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

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, also jede Funktion, die nicht als Beta oder Research Preview gekennzeichnet ist) ist, ist eine Pauschalberechtigung (eine, die weder den Modellzugriff noch die mit permission_ beginnenden Admin-Panel-Berechtigungen abdeckt) und wird als diese einzelne Zeile aufgeführt, statt aufgeschlüsselt zu werden. Wenn du zusammenstellst, was eine Rolle gewährt, behandle eine Pauschalzeile so, dass sie alles abdeckt, was ihre Variante beschreibt, nicht nur die in anderen Zeilen genannten Funktionen.

Vollständige Parameterdetails und Antwortschemas findest du unter List role permissions in der API-Referenz.

client = anthropic.Anthropic()

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

for permission in permissions:
    print(permission.action)

{
  "data": [
    {
      "type": "rbac_role_permission",
      "resource": {
        "type": "organization",
        "organization_id": "12345678-1234-5678-1234-567812345678"
      },
      "action": "capability_access_all_ga"
    },
    {
      "type": "rbac_role_permission",
      "resource": {
        "type": "connector_tool",
        "connector_id": "mcpsrv_01WxYzAbCdEfGhIjKlMnOp",
        "tool_name": "search_tickets"
      },
      "action": "use"
    }
  ],
  "has_more": false,
  "next_page": null
}

Beispiel-Workflows

Einen ausscheidenden Mitarbeiter offboarden

1. Schlage das Mitglied per E-Mail nach:

   cURLCLIPythonTypeScriptC#GoJavaPHPRuby

   Python

   

   client = anthropic.Anthropic()
   
   users = client.organization.users.list(email="departing@example.com")
   
   for user in users:
       print(f"{user.id}: {user.email} ({user.role})")

2. Entferne es mit DELETE /v1/organizations/users/{user_id} und verwende dabei die id aus der Antwort. Sein Platz, falls vorhanden, geht an den Pool zurück.

3. Wenn die Person noch nicht beigetreten war, gibt die Suche kein Mitglied zurück; liste in diesem Fall die Einladungen auf und ziehe stattdessen ihre Einladung mit Status pending zurück.

Gruppenmitgliedschaften 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 auf der Seite zur Spend Limits API.

Häufig gestellte Fragen

Ist das 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 in 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 zeigt, welche Endpunkte jeder Organisationstyp aufrufen kann.

Kann ich die Rolle Owner oder Membership Admin ü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 mit diesen Rollen können über die API weder geändert noch 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).

Belegt eine nicht angenommene Einladung einen Platz?

Bei Plänen mit einem begrenzten Platz-Pool ja: Eine Einladung mit Status pending belegt einen Platz. Das Zurückziehen der Einladung oder ihr Ablaufen gibt den Platz frei. Bei Plänen ohne Platz-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 in jedem Fall.

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 an die Organisation gebunden, nicht an 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 eine Herabstufung seiner Rolle ändert nichts an den Keys: 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 und erstelle Ersatz-Keys.

Siehe auch