Gestione degli utenti

Questa pagina spiega come gestire in modo programmatico le persone nella tua organizzazione Claude Enterprise (claude.ai), utilizzando l'Admin API: elencare i membri e cercarli per indirizzo email, modificare il ruolo di un membro, rimuovere membri, inviare e ritirare inviti, gestire i gruppi della tua azienda e i relativi membri, e leggere i ruoli personalizzati della tua organizzazione. Per le organizzazioni Claude Console (Claude Platform), consulta la guida all'Admin API per Claude Console.

Quali endpoint può usare la tua organizzazione?

L'Admin API è un unico insieme di endpoint sotto https://api.anthropic.com/v1/organizations/. Le organizzazioni Claude Console e Claude Enterprise si autenticano con chiavi diverse e ciascuna ha accesso a un sottoinsieme diverso degli endpoint:

Membri e inviti sono gli stessi endpoint per entrambi i tipi di organizzazione; questa pagina ne documenta il comportamento in Claude Enterprise, inclusi i ruoli dell'organizzazione di Claude Enterprise. Gli endpoint per gruppi e ruoli personalizzati esistono solo per Claude Enterprise.

Panoramica

Questa pagina tratta cinque risorse:

I ruoli personalizzati e le loro associazioni ai gruppi si gestiscono nelle impostazioni dell'organizzazione di claude.ai; l'API li legge ma non può modificarli.

Guida rapida

Imposta la variabile d'ambiente ANTHROPIC_API_KEY sulla tua chiave Admin API. Gli esempi in questa pagina leggono la chiave da essa. L'SDK e la CLI ant inviano per te gli header Authorization e anthropic-version.

Elenca i membri dell'organizzazione, dal più recente:

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

Concetti chiave

Ruoli dell'organizzazione

Ogni membro ha esattamente un ruolo nell'organizzazione. Le letture restituiscono il ruolo del membro come uno di cinque valori:

L'API può assegnare solo i ruoli user e managed, alla creazione di un invito e negli aggiornamenti di ruolo. L'assegnazione di managed richiede lo scope write:rbac_groups oltre a write:members, perché i permessi di un membro gestito derivano dai ruoli personalizzati associati ai suoi gruppi. I ruoli amministrativi (owner, membership_admin e primary_owner) si assegnano nelle impostazioni dell'organizzazione di claude.ai, e i membri che li detengono non possono essere modificati o rimossi tramite questa API.

Membri e inviti

Una persona diventa membro accettando un invito (o tramite il single sign-on della tua organizzazione, se configurato). La creazione di un invito invia un'email di invito; l'invito risulta quindi pending finché il destinatario non lo accetta (accepted) o finché non viene superato il suo expires_at assegnato dal server (expired). Solo un invito pending può essere ritirato. Per modificare l'indirizzo email o il ruolo di un invito in sospeso, ritiralo e creane uno nuovo.

Se il piano della tua organizzazione attinge i membri da un pool finito di posti acquistati, un invito in sospeso occupa un posto. L'endpoint di creazione degli inviti non accetta un parametro per il posto o il livello: il posto viene assegnato automaticamente dal livello più basso che ha disponibilità. La creazione di un invito quando non ci sono posti liberi fallisce con un errore 400 anziché acquistare un posto. Ritirare l'invito, lasciarlo scadere o rimuovere successivamente il membro restituisce il posto al pool.

Gruppi e ruoli

I gruppi collegano i membri ai ruoli personalizzati (controllo degli accessi basato sui ruoli, il rbac nei percorsi degli endpoint e nei nomi degli scope). I gruppi appartengono alla tua azienda nel suo complesso (l'organizzazione principale insieme a ogni organizzazione sottostante) anziché a una singola organizzazione, quindi gli scope dei gruppi (read:rbac_groups e write:rbac_groups) richiedono una chiave creata per tutte le organizzazioni collegate. Ogni gruppo ha un source_type: direct per i gruppi creati in claude.ai, scim per i gruppi forniti dal tuo provider di identità. Il campo role_ids di un gruppo elenca gli ID dei ruoli personalizzati associati; risolvili in nomi e permessi con gli endpoint dei ruoli personalizzati, tenendo presente che il catalogo dei ruoli è per organizzazione mentre i gruppi sono a livello aziendale, quindi il recupero di un ruolo che appartiene a un'altra organizzazione della tua azienda restituisce 404 per la tua chiave. Il campo è null (anziché []) quando i dati dei ruoli erano temporaneamente non disponibili, quindi riprova per distinguere una lettura degradata da un gruppo senza ruoli.

Versionamento

Invia l'header anthropic-version in ogni richiesta; consulta Versioni dell'API per le versioni disponibili.

Limiti di velocità

Gli endpoint dell'Admin API condividono un limite per organizzazione di 100 richieste al minuto; la creazione di inviti ha invece un proprio limite di 1.200 richieste all'ora. Le richieste oltre un limite restituiscono 429 Too Many Requests.

Paginazione

Gli elenchi di membri e inviti usano la paginazione basata su ID: passa limit (predefinito 20, massimo 1000) più al massimo uno tra before_id e after_id, e scorri le pagine usando i campi first_id e last_id di ogni risposta finché has_more non è false. Gli elenchi di gruppi e ruoli personalizzati usano invece un cursore opaco: il valore next_page della risposta viene passato invariato come parametro page nella richiesta successiva, finché next_page non è null.

Quando iteri sui risultati, l'SDK recupera per te le pagine successive, quindi limit imposta la dimensione della pagina, non il totale. Nella CLI, --limit imposta il numero totale di risultati per gli elenchi di membri e inviti. Per gli elenchi di gruppi e ruoli, imposta la dimensione della pagina.

Risposte di errore

Le risposte di errore seguono la struttura standard documentata in Errori.

Membri

Elencare i membri

GET /v1/organizations/users restituisce i membri dell'organizzazione, a partire da quelli aggiunti più di recente. Filtra per email per cercare un membro specifico; la corrispondenza non distingue tra maiuscole e minuscole e tollera varianti comuni dello stesso indirizzo (ad esempio, jane+hiring@example.com corrisponde a jane@example.com). Richiede lo scope read:members.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta List users nel riferimento API.

client = anthropic.Anthropic()

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

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

Ottenere un membro

GET /v1/organizations/users/{user_id} restituisce un membro tramite ID. Richiede lo scope read:members.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta Get user nel riferimento API.

client = anthropic.Anthropic()

user = client.organization.users.retrieve("user_01AbCdEfGhIjKlMnOpQrSt")

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

Modificare il ruolo di un membro

POST /v1/organizations/users/{user_id} imposta il ruolo del membro su user o managed. I membri che detengono un ruolo amministrativo (owner, membership_admin o primary_owner) non possono essere modificati tramite questo endpoint, e i ruoli amministrativi non possono essere assegnati; entrambi i casi restituiscono 400 e si gestiscono nelle impostazioni dell'organizzazione di claude.ai. Se il provider di identità della tua organizzazione gestisce i ruoli (SSO avanzato o provisioning SCIM avanzato), gli aggiornamenti di ruolo restituiscono 400. Richiede lo scope write:members, più write:rbac_groups quando si modifica il ruolo in managed.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta Update user nel riferimento API.

client = anthropic.Anthropic()

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

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

Rimuovere un membro

DELETE /v1/organizations/users/{user_id} rimuove il membro dall'organizzazione, restituendo al pool dell'organizzazione l'eventuale posto acquistato che occupava. I membri che detengono un ruolo amministrativo non possono essere rimossi tramite questo endpoint, e se il tuo provider di identità gestisce l'appartenenza (SCIM), le rimozioni restituiscono 400. Richiede lo scope write:members.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta Remove user nel riferimento API.

client = anthropic.Anthropic()

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

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

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

Inviti

Creare un invito

POST /v1/organizations/invites invia un'email di invito e restituisce l'invito con un expires_at assegnato dal server. role deve essere user o managed. Se esiste già un invito in sospeso per l'indirizzo email, o l'indirizzo appartiene già a un membro, la richiesta restituisce 400 indicando la risorsa esistente. Le organizzazioni il cui provider di identità effettua il provisioning automatico degli utenti (JIT o SCIM) non possono creare inviti tramite l'API. Richiede lo scope write:members, più write:rbac_groups quando role è managed.

Nei piani che attingono i membri da un pool finito di posti, l'invito occupa automaticamente un posto dal livello più basso che ha disponibilità. L'API non accetta un parametro per il livello. Se non ci sono posti liberi, la richiesta fallisce con un errore 400 anziché acquistare un posto. Aggiungi posti tramite la gestione del piano dell'organizzazione e riprova.

Il campo facoltativo rbac_group_ids elenca i gruppi (tramite ID con prefisso rbac_group_) da assegnare al membro quando accetta. Passare un rbac_group_ids non vuoto richiede inoltre che la chiave abbia lo scope write:rbac_groups, perché l'assegnazione a un gruppo può concedere i permessi associati ai ruoli del gruppo.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta Create invite nel riferimento API.

client = anthropic.Anthropic()

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

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

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

Elencare gli inviti

GET /v1/organizations/invites restituisce gli inviti dell'organizzazione, dal più recente, negli stati pending, accepted ed expired; non esiste un filtro per stato. Richiede lo scope read:members.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta List invites nel riferimento API.

client = anthropic.Anthropic()

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

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

Ottenere un invito

GET /v1/organizations/invites/{invite_id} restituisce un invito tramite ID. Richiede lo scope read:members.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta Get invite nel riferimento API.

client = anthropic.Anthropic()

invite = client.organization.invites.retrieve("invite_01QrStUvWxYzAbCdEfGhIj")

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

Ritirare un invito

DELETE /v1/organizations/invites/{invite_id} ritira un invito pending, disattivando il link nell'email di invito. Il ritiro di un invito accepted restituisce 400 (rimuovi invece il membro); il ritiro di un invito expired restituisce 400. Richiede lo scope write:members.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta Delete invite nel riferimento API.

client = anthropic.Anthropic()

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

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

Gruppi

I gruppi che la tua azienda crea direttamente, nelle impostazioni dell'organizzazione di claude.ai o tramite questa API (source_type: "direct"), supportano ogni endpoint di questa sezione. I gruppi forniti dal tuo provider di identità (source_type: "scim") possono essere letti ma non modificati: rinominare o eliminare un gruppo SCIM, o modificarne i membri, restituisce 400, perché è di proprietà del tuo provider di identità.

Elencare i gruppi

GET /v1/organizations/rbac_groups restituisce i gruppi della tua azienda, inclusi quelli gestiti dal provider di identità (scim). Richiede lo scope read:rbac_groups.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta List groups nel riferimento API.

client = anthropic.Anthropic()

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

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

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

Ottenere un gruppo

GET /v1/organizations/rbac_groups/{rbac_group_id} restituisce un gruppo tramite ID. Richiede lo scope read:rbac_groups.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta Get group nel riferimento API.

client = anthropic.Anthropic()

group = client.beta.organization.rbac_groups.retrieve(
    "rbac_group_01UvWxYzAbCdEfGhIjKlMn"
)

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

Creare un gruppo

POST /v1/organizations/rbac_groups crea un gruppo con il name indicato (1–255 caratteri) e senza ruoli né membri. Richiede lo scope write:rbac_groups.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta Create group nel riferimento API.

client = anthropic.Anthropic()

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

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

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

Rinominare un gruppo

POST /v1/organizations/rbac_groups/{rbac_group_id} aggiorna il gruppo. name è l'unico campo che questo endpoint può modificare. Richiede lo scope write:rbac_groups.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta Update group nel riferimento API.

client = anthropic.Anthropic()

group = client.beta.organization.rbac_groups.update(
    "rbac_group_01UvWxYzAbCdEfGhIjKlMn", name="Platform Engineering"
)

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

Eliminare un gruppo

DELETE /v1/organizations/rbac_groups/{rbac_group_id} elimina il gruppo. I suoi membri restano membri delle rispettive organizzazioni, ma perdono i permessi dei ruoli associati, e un eventuale limite di spesa del gruppo smette di applicarsi a loro. Richiede lo scope write:rbac_groups.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta Delete group nel riferimento API.

client = anthropic.Anthropic()

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

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

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

Elencare i membri di un gruppo

GET /v1/organizations/rbac_groups/{rbac_group_id}/members restituisce i membri del gruppo (ciascuno con il proprio user_id ed email), dal meno recente. Vengono restituiti solo i membri attuali delle organizzazioni della tua azienda, quindi una pagina potrebbe contenere meno di limit voci mentre has_more è true. Richiede lo scope read:rbac_groups.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta List group members nel riferimento API.

client = anthropic.Anthropic()

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

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

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

Aggiungere un membro a un gruppo

POST /v1/organizations/rbac_groups/{rbac_group_id}/members aggiunge un membro dell'organizzazione al gruppo tramite user_id. L'utente deve essere già membro di una delle organizzazioni della tua azienda (altrimenti la richiesta restituisce 404), e aggiungere qualcuno che è già nel gruppo restituisce 400. Per i gruppi scim, l'appartenenza si gestisce nel tuo provider di identità e questa richiesta restituisce 400. Per assegnare gruppi a una persona che non si è ancora unita, usa invece rbac_group_ids nella creazione dell'invito. Richiede lo scope write:rbac_groups.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta Add group member nel riferimento API.

client = anthropic.Anthropic()

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

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

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

Rimuovere un membro da un gruppo

DELETE /v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id} rimuove il membro dal gruppo; resta membro della propria organizzazione. La richiesta restituisce 404 se l'utente non è membro del gruppo, e 400 per i gruppi scim, la cui appartenenza si gestisce nel tuo provider di identità. Richiede lo scope write:rbac_groups.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta Remove group member nel riferimento API.

client = anthropic.Anthropic()

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

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

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

Ruoli personalizzati

I ruoli personalizzati sono in sola lettura tramite l'API: questi endpoint catalogano i ruoli personalizzati della tua organizzazione (definiti nelle impostazioni dell'organizzazione di claude.ai o forniti da Anthropic) e i permessi concessi da ciascun ruolo. Le letture dei ruoli personalizzati usano lo scope read:members (non esiste uno scope separato per i ruoli) e funzionano con una chiave a livello di organizzazione: a differenza degli endpoint dei gruppi, non richiedono una chiave creata per tutte le organizzazioni collegate, e il catalogo restituito è quello della tua organizzazione.

Leggi il nome di un ruolo dal suo campo display_name. Per un ruolo fornito da Anthropic, display_name può differire dall'etichetta mostrata da claude.ai, e Anthropic potrebbe modificarne il nome. Per mantenere un riferimento duraturo a un ruolo, memorizzane l'id.

Elencare i ruoli

GET /v1/organizations/rbac_roles restituisce i ruoli personalizzati della tua organizzazione. Richiede lo scope read:members.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta List roles nel riferimento API.

client = anthropic.Anthropic()

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

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

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

Ottenere un ruolo

GET /v1/organizations/rbac_roles/{rbac_role_id} restituisce un ruolo tramite ID. Richiede lo scope read:members.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta Get role nel riferimento API.

client = anthropic.Anthropic()

role = client.beta.organization.rbac_roles.retrieve("rbac_role_01CdEfGhIjKlMnOpQrStUv")

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

Elencare i permessi di un ruolo

GET /v1/organizations/rbac_roles/{rbac_role_id}/permissions restituisce i permessi del ruolo. Ogni permesso associa una resource (ciò a cui si applica: le funzionalità di prodotto dell'organizzazione, uno strumento di un connettore, uno scope OAuth di un connettore, un singolo connettore o tutti i connettori) a un'action (ciò che concede su quella risorsa). Le righe relative a funzionalità non abilitate per la tua organizzazione vengono omesse, quindi una pagina potrebbe contenere meno di limit righe mentre has_more è true. Richiede lo scope read:members.

Due valori di action richiedono particolare attenzione: un permesso organization la cui azione è capability_access_all (tutte le funzionalità di prodotto) o capability_access_all_ga (tutte le funzionalità di prodotto stabili, ovvero ogni funzionalità non etichettata come beta o research preview) è una concessione generale (che non copre né l'accesso ai modelli né i permessi del pannello di amministrazione con prefisso permission_) ed è elencato come quella singola riga anziché essere espanso. Quando calcoli ciò che un ruolo concede, considera una riga generale come copertura di tutto ciò che la sua variante descrive, non solo delle funzionalità indicate nelle altre righe.

Per i dettagli completi sui parametri e gli schemi di risposta, consulta List role permissions nel riferimento API.

client = anthropic.Anthropic()

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

for permission in permissions:
    print(permission.action)

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

Flussi di lavoro di esempio

Gestire l'uscita di un dipendente

1. Cerca il membro per email:

   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. Rimuovilo con DELETE /v1/organizations/users/{user_id}, usando l'id della risposta. Il suo eventuale posto torna al pool.

3. Se la persona non si era ancora unita, la ricerca non restituisce alcun membro; elenca invece gli inviti e ritira il suo invito pending.

Verificare l'appartenenza ai gruppi

1. Elenca i gruppi e registra l'id, il name e i role_ids di ciascun gruppo.

2. Per ogni gruppo che ha ruoli sensibili, scorri le pagine di GET /v1/organizations/rbac_groups/{rbac_group_id}/members e confronta le email dei membri con l'elenco del tuo provider di identità.

3. Rimuovi i membri che non dovrebbero più far parte del gruppo con DELETE /v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}. Per i gruppi scim, apporta invece la modifica nel tuo provider di identità.

Per un flusso di lavoro che combina l'appartenenza ai gruppi con un aumento temporaneo del limite di spesa, consulta Aumentare temporaneamente il limite di spesa di un membro durante un incidente nella pagina della Spend Limits API.

Domande frequenti

Si tratta di un'API diversa dall'Admin API?

No. Gli endpoint per membri e inviti sono gli stessi endpoint /v1/organizations/ usati dalle organizzazioni Claude Console; questa pagina ne documenta il comportamento in Claude Enterprise. Gli endpoint per gruppi e ruoli personalizzati fanno parte della stessa API ed esistono solo per le organizzazioni Claude Enterprise. La tabella di disponibilità mostra quali endpoint può chiamare ciascun tipo di organizzazione.

Posso assegnare il ruolo di proprietario o di amministratore dei membri tramite l'API?

No. L'API assegna solo user e managed, alla creazione degli inviti e negli aggiornamenti di ruolo. I ruoli amministrativi si assegnano nelle impostazioni dell'organizzazione di claude.ai, e i membri che li detengono non possono essere modificati o rimossi tramite l'API.

Posso creare o modificare gruppi tramite l'API?

Sì, con lo scope write:rbac_groups: puoi creare, rinominare ed eliminare gruppi, e aggiungerne o rimuoverne i membri. Due cose che l'API non può modificare: i gruppi forniti dal tuo provider di identità (source_type: "scim"), il cui nome e i cui membri sono di proprietà del provider di identità, e i ruoli personalizzati, che si gestiscono nelle impostazioni dell'organizzazione di claude.ai (l'API li legge).

Un invito non accettato occupa un posto?

Nei piani con un pool finito di posti, sì: un invito pending occupa un posto. Ritirare l'invito o lasciarlo scadere libera il posto. Nei piani senza pool di posti, gli inviti non occupano nulla.

La mia organizzazione usa il single sign-on. Quali operazioni funzionano?

Se il tuo provider di identità effettua il provisioning automatico degli utenti (JIT o SCIM), la creazione di inviti restituisce 400. Se gestisce i ruoli (SSO avanzato o provisioning SCIM avanzato), gli aggiornamenti di ruolo restituiscono 400. Se gestisce l'appartenenza (provisioning SCIM), le rimozioni di membri restituiscono 400. Le letture funzionano in ogni caso.

Cosa succede a una chiave Admin API quando la persona che l'ha creata se ne va?

La chiave continua a funzionare. Le chiavi Admin API sono associate all'organizzazione, non ai singoli utenti, e una chiave creata in claude.ai non scade. Rimuovere il creatore dall'organizzazione o revocarne il provisioning tramite il tuo provider di identità pone fine al suo accesso personale, ma non alle chiavi che ha creato. Anche il declassamento del suo ruolo non modifica le chiavi: ogni chiave resta attiva con i suoi scope originali. Quando gestisci l'uscita di qualcuno che ha creato chiavi Admin API, elimina tali chiavi nella sezione Keys di claude.ai > Organization settings > API e crea delle sostitute.

Vedi anche