--- title: Gestione degli utenti url: https://platform.claude.com/docs/it/manage-claude/user-management description: "Gestisci le persone nella tua organizzazione Claude Enterprise con l'Admin API: elenca i membri e modifica i ruoli, invia e ritira gli inviti, gestisci i gruppi e leggi i ruoli personalizzati." --- Questa pagina spiega come gestire in modo programmatico le persone nella tua organizzazione **Claude Enterprise** (claude.ai) usando l'[Admin API](https://platform.claude.com/docs/it/api/beta/organization). Puoi 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](https://platform.claude.com/docs/it/manage-claude/admin-api). Le richieste relative a gruppi e ruoli personalizzati non richiedono l'[header beta](https://platform.claude.com/docs/it/api/beta-headers) `anthropic-beta: ce-user-management-2026-07-13`. Le richieste che lo inviano ancora vengono accettate e si comportano in modo identico. ## 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](https://platform.claude.com/docs/it/manage-claude/admin-api-keys) e ciascuna ha accesso a un sottoinsieme diverso degli endpoint: | Endpoint | Claude Console (Claude Platform) | Claude Enterprise (claude.ai) | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Membri](https://platform.claude.com/docs/it/manage-claude/user-management#members) e [inviti](https://platform.claude.com/docs/it/manage-claude/user-management#invites) | Disponibili; consulta la [guida all'Admin API](https://platform.claude.com/docs/it/manage-claude/admin-api) | Disponibili (questa pagina) | | [Gruppi](https://platform.claude.com/docs/it/manage-claude/user-management#groups) | Non disponibili | Disponibili (questa pagina) | | [Ruoli personalizzati](https://platform.claude.com/docs/it/manage-claude/user-management#custom-roles) | Non disponibili | Disponibili, in sola lettura (questa pagina) | | [Limiti di spesa](https://platform.claude.com/docs/it/manage-claude/spend-limits-api) | Non disponibili | Disponibili | | Report di utilizzo e costi | Disponibili; consulta l'[Usage and Cost API](https://platform.claude.com/docs/it/manage-claude/usage-cost-api) | Disponibili tramite la [Claude Enterprise Analytics API](https://platform.claude.com/docs/it/manage-claude/analytics-api#get-access-to-the-claude-enterprise-analytics-api) | | [Workspace](https://platform.claude.com/docs/it/manage-claude/workspaces), [chiavi API](https://platform.claude.com/docs/it/manage-claude/admin-api#api-keys), [limiti di velocità](https://platform.claude.com/docs/it/manage-claude/rate-limits-api) e gli altri endpoint nella [guida all'Admin API](https://platform.claude.com/docs/it/manage-claude/admin-api) | Disponibili | Non disponibili | Gli endpoint per membri e inviti sono gli stessi per entrambi i tipi di organizzazione. Questa pagina ne documenta il comportamento in Claude Enterprise, inclusi i [ruoli dell'organizzazione](https://platform.claude.com/docs/it/manage-claude/user-management#organization-roles) di Claude Enterprise. Gli endpoint per gruppi e ruoli personalizzati esistono solo per Claude Enterprise. **È richiesta una chiave Admin API con scope** Questi endpoint richiedono una chiave Admin API con lo "scope" (ambito) `read:members` (endpoint `GET` per membri e inviti, e tutti gli endpoint dei ruoli personalizzati; non esiste uno scope separato per i ruoli), lo scope `write:members` (endpoint `POST` e `DELETE` per membri e inviti), lo scope `read:rbac_groups` (endpoint `GET` dei gruppi) o lo scope `write:rbac_groups` (endpoint `POST` e `DELETE` dei gruppi). Assegnare il ruolo `managed`, o gruppi in un invito, richiede `write:rbac_groups` oltre a `write:members`. Una chiave con lo scope `read:org_audit` (uno scope in sola lettura per le integrazioni di audit di sicurezza) può inoltre chiamare ogni endpoint `GET` di questa pagina e gli endpoint di lettura della [Compliance API](https://platform.claude.com/docs/it/manage-claude/compliance-api). Consulta [Creare una chiave Admin API](https://platform.claude.com/docs/it/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization) per sapere dove il tuo proprietario principale ne crea una e quali scope selezionare. Passa la chiave nell'header `x-api-key` in ogni richiesta, insieme all'header [`anthropic-version`](https://platform.claude.com/docs/it/api/versioning). ## Panoramica Questa pagina tratta cinque risorse: | Risorsa | Endpoint | Utilizzo | | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------- | | **Membri** | `GET /v1/organizations/users`
`GET /v1/organizations/users/{user_id}`
`POST /v1/organizations/users/{user_id}`
`DELETE /v1/organizations/users/{user_id}` | Elencare i membri dell'organizzazione o cercarne uno per email; modificare il ruolo di un membro; rimuovere un membro. | | **Inviti** | `POST /v1/organizations/invites`
`GET /v1/organizations/invites`
`GET /v1/organizations/invites/{invite_id}`
`DELETE /v1/organizations/invites/{invite_id}` | Invitare una persona nell'organizzazione, monitorare lo stato dell'invito e ritirarlo prima che venga accettato. | | **Gruppi** | `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}` | Leggere i gruppi della tua azienda e i ruoli personalizzati associati a ciascuno; creare, rinominare ed eliminare gruppi. | | **Membri dei gruppi** | `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}` | Leggere i membri di un gruppo; aggiungere e rimuovere membri. | | **Ruoli personalizzati** | `GET /v1/organizations/rbac_roles`
`GET /v1/organizations/rbac_roles/{rbac_role_id}`
`GET /v1/organizations/rbac_roles/{rbac_role_id}/permissions` | Leggere i ruoli personalizzati della tua organizzazione e i permessi concessi da ciascun ruolo. | I ruoli personalizzati e le loro associazioni ai gruppi si gestiscono nelle [impostazioni dell'organizzazione di claude.ai](https://claude.ai/admin-settings). L'API può leggerli ma non 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 lì. L'SDK e la CLI `ant` inviano gli header `x-api-key` e `anthropic-version` al posto tuo. Elenca i membri dell'organizzazione, dal più recente: ```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" } ``` ## 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: | Ruolo | Significato | | ------------------ | ----------------------------------------------------------------------------------------------- | | `user` | Un membro standard. | | `managed` | Un membro i cui permessi sono concessi tramite i ruoli personalizzati associati ai suoi gruppi. | | `owner` | Un proprietario dell'organizzazione. | | `membership_admin` | Un membro che può gestire i membri dell'organizzazione. | | `primary_owner` | Il proprietario principale dell'organizzazione. Ce n'è esattamente uno. | L'API può assegnare solo i ruoli `user` e `managed`, alla creazione di un invito e negli aggiornamenti di ruolo. Assegnare `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 né rimossi tramite questa API. ### Membri e inviti Una persona diventa membro accettando un invito oppure, dove configurato, tramite il "single sign-on" (accesso unico), o SSO, della tua organizzazione. 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 superata la sua scadenza `expires_at`, assegnata 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 limitato di "seat" (postazioni) acquistate, un invito in sospeso occupa una postazione. L'endpoint di creazione degli inviti non accetta un parametro per la postazione o il livello: la postazione viene assegnata automaticamente dal livello più basso che ne ha di disponibili. Se non ci sono postazioni libere, la creazione di un invito fallisce con un errore 400 invece di acquistare una postazione. La postazione torna nel pool quando ritiri l'invito, quando l'invito scade o quando in seguito rimuovi il membro. ### Gruppi e ruoli I gruppi collegano i membri ai ruoli personalizzati. Si tratta del "role-based access control" (controllo degli accessi basato sui ruoli), da cui deriva `rbac` nei percorsi degli endpoint e nei nomi degli scope. I gruppi appartengono alla tua azienda nel suo complesso, cioè all'organizzazione padre insieme a tutte le organizzazioni che ne fanno parte, e non a una singola organizzazione. Per questo 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. Per ottenerne nomi e permessi, usa gli [endpoint dei ruoli personalizzati](https://platform.claude.com/docs/it/manage-claude/user-management#custom-roles). Tieni presente che il catalogo dei ruoli è specifico di ogni organizzazione, mentre i gruppi valgono per tutta l'azienda. Se recuperi un ruolo che appartiene a un'altra organizzazione della tua azienda, la tua chiave riceve un errore 404. Il campo è `null` (anziché `[]`) quando i dati dei ruoli non erano temporaneamente disponibili. In questo caso riprova, per distinguere una lettura degradata da un gruppo senza ruoli. Vengono ancora restituiti due campi deprecati: `roles` sui gruppi, sempre uguale a `role_ids`, e `group_id` sui membri dei gruppi, sempre uguale a `rbac_group_id`. ## Versionamento Invia l'header `anthropic-version` in ogni richiesta. Consulta [Versioni dell'API](https://platform.claude.com/docs/it/api/versioning) per le versioni disponibili. ## Limiti di velocità Gli endpoint dell'Admin API condividono un "rate limit" (limite di velocità) per organizzazione di **100 richieste al minuto**. La creazione degli inviti ha invece un proprio limite di **1.200 richieste all'ora**. Le richieste che superano un limite restituiscono **429 Too Many Requests**. ## Paginazione Gli elenchi di membri e inviti usano una paginazione basata su ID: passa `limit` (predefinito 20, massimo 1000) e 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 **"opaque cursor" (cursore opaco)**: passa il valore `next_page` della risposta, senza modificarlo, come parametro `page` nella richiesta successiva, finché `next_page` non è `null`. Quando iteri sui risultati, l'SDK recupera altre pagine al posto tuo, 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](https://platform.claude.com/docs/it/api/errors). ## 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](https://platform.claude.com/docs/it/api/organization/users/list) nel riferimento API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/users?email=jane@example.com" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant organization:users list --email jane@example.com ``` ```python Python client = anthropic.Anthropic() users = client.organization.users.list(email="jane@example.com") for user in users: print(f"{user.id}: {user.email} ({user.role})") ``` ```typescript TypeScript const client = new Anthropic(); const users = await client.organization.users.list({ email: "jane@example.com" }); for await (const user of users) { console.log(`${user.id}: ${user.email} (${user.role})`); } ``` ```csharp C# AnthropicClient client = new(); var page = await client.Organization.Users.List(new() { Email = "jane@example.com" }); await foreach (var user in page.Paginate()) { Console.WriteLine($"{user.ID}: {user.Email} ({user.Role.Raw()})"); } ``` ```go Go client := anthropic.NewClient() users := client.Organization.Users.ListAutoPaging(context.Background(), anthropic.OrganizationUserListParams{ Email: anthropic.String("jane@example.com"), }) for users.Next() { user := users.Current() fmt.Printf("%s: %s (%s)\n", user.ID, user.Email, user.Role) } if err := users.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.organization.users.UserListParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = UserListParams.builder() .email("jane@example.com") .build(); var users = client.organization().users().list(params); for (var user : users.autoPager()) { IO.println(user.id() + ": " + user.email() + " (" + user.role().asString() + ")"); } } ``` ```php PHP $client = new Client(); $users = $client->organization->users->list(email: 'jane@example.com'); foreach ($users->pagingEachItem() as $user) { echo "{$user->id}: {$user->email} ({$user->role})\n"; } ``` ```ruby Ruby client = Anthropic::Client.new users = client.organization.users.list(email: "jane@example.com") users.auto_paging_each do |user| puts "#{user.id}: #{user.email} (#{user.role})" end ``` ### 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](https://platform.claude.com/docs/it/api/organization/users/retrieve) nel riferimento API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/users/user_01AbCdEfGhIjKlMnOpQrSt" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant organization:users retrieve --user-id user_01AbCdEfGhIjKlMnOpQrSt ``` ```python Python client = anthropic.Anthropic() user = client.organization.users.retrieve("user_01AbCdEfGhIjKlMnOpQrSt") print(f"id: {user.id}") print(f"email: {user.email}") print(f"role: {user.role}") ``` ```typescript TypeScript const client = new Anthropic(); const user = await client.organization.users.retrieve("user_01AbCdEfGhIjKlMnOpQrSt"); console.log(`id: ${user.id}`); console.log(`email: ${user.email}`); console.log(`role: ${user.role}`); ``` ```csharp C# AnthropicClient client = new(); var user = await client.Organization.Users.Retrieve("user_01AbCdEfGhIjKlMnOpQrSt"); Console.WriteLine($"id: {user.ID}"); Console.WriteLine($"email: {user.Email}"); Console.WriteLine($"role: {user.Role.Raw()}"); ``` ```go Go client := anthropic.NewClient() user, err := client.Organization.Users.Get(context.Background(), "user_01AbCdEfGhIjKlMnOpQrSt") if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", user.ID) fmt.Printf("email: %s\n", user.Email) fmt.Printf("role: %s\n", user.Role) ``` ```java Java AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var user = client.organization().users() .retrieve("user_01AbCdEfGhIjKlMnOpQrSt"); IO.println("id: " + user.id()); IO.println("email: " + user.email()); IO.println("role: " + user.role().asString()); ``` ```php PHP $client = new Client(); $user = $client->organization->users->retrieve( userID: 'user_01AbCdEfGhIjKlMnOpQrSt', ); echo "id: {$user->id}\n"; echo "email: {$user->email}\n"; echo "role: {$user->role}\n"; ``` ```ruby Ruby client = Anthropic::Client.new user = client.organization.users.retrieve("user_01AbCdEfGhIjKlMnOpQrSt") puts "id: #{user.id}" puts "email: #{user.email}" puts "role: #{user.role}" ``` ### 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 cambia il ruolo in `managed`. Per i dettagli completi sui parametri e gli schemi di risposta, consulta [Update user](https://platform.claude.com/docs/it/api/organization/users/update) nel riferimento API. ```bash cURL curl -X POST "https://api.anthropic.com/v1/organizations/users/user_01AbCdEfGhIjKlMnOpQrSt" \ -H "content-type: application/json" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -d '{"role": "managed"}' ``` ```bash CLI ant organization:users update \ --user-id user_01AbCdEfGhIjKlMnOpQrSt \ --role managed ``` ```python Python client = anthropic.Anthropic() user = client.organization.users.update("user_01AbCdEfGhIjKlMnOpQrSt", role="managed") print(f"id: {user.id}") print(f"role: {user.role}") ``` ```typescript TypeScript const client = new Anthropic(); const user = await client.organization.users.update("user_01AbCdEfGhIjKlMnOpQrSt", { role: "managed" }); console.log(`id: ${user.id}`); console.log(`role: ${user.role}`); ``` ```csharp C# using Anthropic.Models.Organization.Users; // ... AnthropicClient client = new(); var user = await client.Organization.Users.Update( "user_01AbCdEfGhIjKlMnOpQrSt", new() { Role = Role.Managed } ); Console.WriteLine($"id: {user.ID}"); Console.WriteLine($"role: {user.Role.Raw()}"); ``` ```go Go client := anthropic.NewClient() user, err := client.Organization.Users.Update( context.Background(), "user_01AbCdEfGhIjKlMnOpQrSt", anthropic.OrganizationUserUpdateParams{ Role: anthropic.OrganizationUserUpdateParamsRoleManaged, }, ) if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", user.ID) fmt.Printf("role: %s\n", user.Role) ``` ```java Java import com.anthropic.models.organization.users.UserUpdateParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = UserUpdateParams.builder() .role(UserUpdateParams.Role.MANAGED) .build(); var user = client.organization().users() .update("user_01AbCdEfGhIjKlMnOpQrSt", params); IO.println("id: " + user.id()); IO.println("role: " + user.role().asString()); } ``` ```php PHP use Anthropic\Organization\Users\UserUpdateParams\Role; // ... $client = new Client(); $user = $client->organization->users->update( userID: 'user_01AbCdEfGhIjKlMnOpQrSt', role: Role::MANAGED, ); echo "id: {$user->id}\n"; echo "role: {$user->role}\n"; ``` ```ruby Ruby client = Anthropic::Client.new user_id = "user_01AbCdEfGhIjKlMnOpQrSt" user = client.organization.users.update(user_id, role: :managed) puts "id: #{user.id}" puts "role: #{user.role}" ``` ### Rimuovere un membro `DELETE /v1/organizations/users/{user_id}` rimuove il membro dall'organizzazione, restituendo al pool dell'organizzazione l'eventuale postazione acquistata 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](https://platform.claude.com/docs/it/api/organization/users/remove) nel riferimento API. ```bash cURL curl -X DELETE "https://api.anthropic.com/v1/organizations/users/user_01AbCdEfGhIjKlMnOpQrSt" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant organization:users remove --user-id user_01AbCdEfGhIjKlMnOpQrSt ``` ```python Python client = anthropic.Anthropic() removed_user = client.organization.users.remove("user_01AbCdEfGhIjKlMnOpQrSt") print(f"id: {removed_user.id}") ``` ```typescript TypeScript const client = new Anthropic(); const removedUser = await client.organization.users.remove("user_01AbCdEfGhIjKlMnOpQrSt"); console.log(`id: ${removedUser.id}`); ``` ```csharp C# AnthropicClient client = new(); var removedUser = await client.Organization.Users.Remove("user_01AbCdEfGhIjKlMnOpQrSt"); Console.WriteLine($"id: {removedUser.ID}"); ``` ```go Go client := anthropic.NewClient() removedUser, err := client.Organization.Users.Remove(context.Background(), "user_01AbCdEfGhIjKlMnOpQrSt") if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", removedUser.ID) ``` ```java Java AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var removedUser = client.organization().users() .remove("user_01AbCdEfGhIjKlMnOpQrSt"); IO.println("id: " + removedUser.id()); ``` ```php PHP $client = new Client(); $removedUser = $client->organization->users->remove( userID: 'user_01AbCdEfGhIjKlMnOpQrSt', ); echo "id: {$removedUser->id}\n"; ``` ```ruby Ruby client = Anthropic::Client.new user_id = "user_01AbCdEfGhIjKlMnOpQrSt" removed_user = client.organization.users.remove(user_id) puts "id: #{removed_user.id}" ``` ```json { "type": "user_deleted", "id": "user_01AbCdEfGhIjKlMnOpQrSt" } ``` ## 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 postazioni, l'invito occupa automaticamente una postazione del livello più basso che ne ha di disponibili. L'API non accetta un parametro per il livello. Se non ci sono postazioni libere, la richiesta fallisce con un errore 400 anziché acquistare una postazione. Aggiungi postazioni 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](https://platform.claude.com/docs/it/api/organization/invites/create) nel riferimento API. ```bash cURL curl -X POST "https://api.anthropic.com/v1/organizations/invites" \ -H "content-type: application/json" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -d '{ "email": "newhire@example.com", "role": "managed", "rbac_group_ids": ["rbac_group_01UvWxYzAbCdEfGhIjKlMn"] }' ``` ```bash CLI ant organization:invites create \ --email newhire@example.com \ --role managed \ --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn ``` ```python Python client = anthropic.Anthropic() invite = client.organization.invites.create( email="newhire@example.com", role="managed", rbac_group_ids=["rbac_group_01UvWxYzAbCdEfGhIjKlMn"], ) print(f"id: {invite.id}") print(f"email: {invite.email}") print(f"status: {invite.status}") print(f"expires_at: {invite.expires_at}") ``` ```typescript TypeScript const client = new Anthropic(); const invite = await client.organization.invites.create({ email: "newhire@example.com", role: "managed", rbac_group_ids: ["rbac_group_01UvWxYzAbCdEfGhIjKlMn"] }); console.log(`id: ${invite.id}`); console.log(`email: ${invite.email}`); console.log(`status: ${invite.status}`); console.log(`expires_at: ${invite.expires_at}`); ``` ```csharp C# using Anthropic.Models.Organization.Invites; // ... AnthropicClient client = new(); var invite = await client.Organization.Invites.Create(new() { Email = "newhire@example.com", Role = Role.Managed, RbacGroupIds = ["rbac_group_01UvWxYzAbCdEfGhIjKlMn"] }); Console.WriteLine($"id: {invite.ID}"); Console.WriteLine($"email: {invite.Email}"); Console.WriteLine($"status: {invite.Status.Raw()}"); Console.WriteLine($"expires_at: {invite.ExpiresAt:O}"); ``` ```go Go client := anthropic.NewClient() invite, err := client.Organization.Invites.New(context.Background(), anthropic.OrganizationInviteNewParams{ Email: "newhire@example.com", Role: anthropic.OrganizationInviteNewParamsRoleManaged, RBACGroupIDs: []string{"rbac_group_01UvWxYzAbCdEfGhIjKlMn"}, }) if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", invite.ID) fmt.Printf("email: %s\n", invite.Email) fmt.Printf("status: %s\n", invite.Status) fmt.Printf("expires_at: %s\n", invite.ExpiresAt.Format(time.RFC3339)) ``` ```java Java import com.anthropic.models.organization.invites.InviteCreateParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = InviteCreateParams.builder() .email("newhire@example.com") .role(InviteCreateParams.Role.MANAGED) .addRbacGroupId("rbac_group_01UvWxYzAbCdEfGhIjKlMn") .build(); var invite = client.organization().invites().create(params); IO.println("id: " + invite.id()); IO.println("email: " + invite.email()); IO.println("status: " + invite.status().asString()); IO.println("expires_at: " + invite.expiresAt()); } ``` ```php PHP use Anthropic\Organization\Invites\InviteCreateParams\Role; // ... $client = new Client(); $invite = $client->organization->invites->create( email: 'newhire@example.com', role: Role::MANAGED, rbacGroupIDs: ['rbac_group_01UvWxYzAbCdEfGhIjKlMn'], ); echo "id: {$invite->id}\n"; echo "email: {$invite->email}\n"; echo "status: {$invite->status}\n"; echo "expires_at: {$invite->expiresAt->format(DATE_ATOM)}\n"; ``` ```ruby Ruby client = Anthropic::Client.new invite = client.organization.invites.create( email: "newhire@example.com", role: :managed, rbac_group_ids: ["rbac_group_01UvWxYzAbCdEfGhIjKlMn"] ) puts "id: #{invite.id}" puts "email: #{invite.email}" puts "status: #{invite.status}" puts "expires_at: #{invite.expires_at.iso8601}" ``` ```json { "type": "invite", "id": "invite_01QrStUvWxYzAbCdEfGhIj", "email": "newhire@example.com", "role": "managed", "invited_at": "2026-07-06T16:20:11Z", "expires_at": "2026-07-27T16:20:11Z", "accepted_at": null, "status": "pending", "rbac_group_ids": ["rbac_group_01UvWxYzAbCdEfGhIjKlMn"] } ``` ### 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](https://platform.claude.com/docs/it/api/organization/invites/list) nel riferimento API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/invites?limit=20" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant organization:invites list --limit 20 ``` ```python Python client = anthropic.Anthropic() invites = client.organization.invites.list(limit=20) for invite in invites: print(f"{invite.id}: {invite.email} ({invite.status})") ``` ```typescript TypeScript const client = new Anthropic(); const invites = await client.organization.invites.list({ limit: 20 }); for await (const invite of invites) { console.log(`${invite.id}: ${invite.email} (${invite.status})`); } ``` ```csharp C# AnthropicClient client = new(); var page = await client.Organization.Invites.List(new() { Limit = 20 }); await foreach (var invite in page.Paginate()) { Console.WriteLine($"{invite.ID}: {invite.Email} ({invite.Status.Raw()})"); } ``` ```go Go client := anthropic.NewClient() invites := client.Organization.Invites.ListAutoPaging(context.Background(), anthropic.OrganizationInviteListParams{ Limit: anthropic.Int(20), }) for invites.Next() { invite := invites.Current() fmt.Printf("%s: %s (%s)\n", invite.ID, invite.Email, invite.Status) } if err := invites.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.organization.invites.InviteListParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = InviteListParams.builder() .limit(20) .build(); var invites = client.organization().invites().list(params); for (var invite : invites.autoPager()) { IO.println(invite.id() + ": " + invite.email() + " (" + invite.status().asString() + ")"); } } ``` ```php PHP $client = new Client(); $invites = $client->organization->invites->list(limit: 20); foreach ($invites->pagingEachItem() as $invite) { echo "{$invite->id}: {$invite->email} ({$invite->status})\n"; } ``` ```ruby Ruby client = Anthropic::Client.new invites = client.organization.invites.list(limit: 20) invites.auto_paging_each do |invite| puts "#{invite.id}: #{invite.email} (#{invite.status})" end ``` ### 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](https://platform.claude.com/docs/it/api/organization/invites/retrieve) nel riferimento API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/invites/invite_01QrStUvWxYzAbCdEfGhIj" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant organization:invites retrieve --invite-id invite_01QrStUvWxYzAbCdEfGhIj ``` ```python Python client = anthropic.Anthropic() invite = client.organization.invites.retrieve("invite_01QrStUvWxYzAbCdEfGhIj") print(f"id: {invite.id}") print(f"email: {invite.email}") print(f"status: {invite.status}") ``` ```typescript TypeScript const client = new Anthropic(); const invite = await client.organization.invites.retrieve("invite_01QrStUvWxYzAbCdEfGhIj"); console.log(`id: ${invite.id}`); console.log(`email: ${invite.email}`); console.log(`status: ${invite.status}`); ``` ```csharp C# AnthropicClient client = new(); var invite = await client.Organization.Invites.Retrieve("invite_01QrStUvWxYzAbCdEfGhIj"); Console.WriteLine($"id: {invite.ID}"); Console.WriteLine($"email: {invite.Email}"); Console.WriteLine($"status: {invite.Status.Raw()}"); ``` ```go Go client := anthropic.NewClient() invite, err := client.Organization.Invites.Get(context.Background(), "invite_01QrStUvWxYzAbCdEfGhIj") if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", invite.ID) fmt.Printf("email: %s\n", invite.Email) fmt.Printf("status: %s\n", invite.Status) ``` ```java Java AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var invite = client.organization().invites() .retrieve("invite_01QrStUvWxYzAbCdEfGhIj"); IO.println("id: " + invite.id()); IO.println("email: " + invite.email()); IO.println("status: " + invite.status().asString()); ``` ```php PHP $client = new Client(); $invite = $client->organization->invites->retrieve( inviteID: 'invite_01QrStUvWxYzAbCdEfGhIj', ); echo "id: {$invite->id}\n"; echo "email: {$invite->email}\n"; echo "status: {$invite->status}\n"; ``` ```ruby Ruby client = Anthropic::Client.new invite = client.organization.invites.retrieve("invite_01QrStUvWxYzAbCdEfGhIj") puts "id: #{invite.id}" puts "email: #{invite.email}" puts "status: #{invite.status}" ``` ### Ritirare un invito `DELETE /v1/organizations/invites/{invite_id}` ritira un invito `pending`, disattivando il link nell'email di invito. Ritirare un invito `accepted` restituisce 400 (rimuovi invece il membro); ritirare un invito `expired` restituisce 400. Richiede lo scope `write:members`. Per i dettagli completi sui parametri e gli schemi di risposta, consulta [Delete invite](https://platform.claude.com/docs/it/api/organization/invites/delete) nel riferimento API. ```bash cURL curl -X DELETE "https://api.anthropic.com/v1/organizations/invites/invite_01QrStUvWxYzAbCdEfGhIj" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant organization:invites delete --invite-id invite_01QrStUvWxYzAbCdEfGhIj ``` ```python Python client = anthropic.Anthropic() deleted_invite = client.organization.invites.delete("invite_01QrStUvWxYzAbCdEfGhIj") print(f"id: {deleted_invite.id}") ``` ```typescript TypeScript const client = new Anthropic(); const deletedInvite = await client.organization.invites.delete( "invite_01QrStUvWxYzAbCdEfGhIj" ); console.log(`id: ${deletedInvite.id}`); ``` ```csharp C# AnthropicClient client = new(); var deletedInvite = await client.Organization.Invites.Delete("invite_01QrStUvWxYzAbCdEfGhIj"); Console.WriteLine($"id: {deletedInvite.ID}"); ``` ```go Go client := anthropic.NewClient() deletedInvite, err := client.Organization.Invites.Delete(context.Background(), "invite_01QrStUvWxYzAbCdEfGhIj") if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", deletedInvite.ID) ``` ```java Java AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var deletedInvite = client.organization().invites() .delete("invite_01QrStUvWxYzAbCdEfGhIj"); IO.println("id: " + deletedInvite.id()); ``` ```php PHP $client = new Client(); $deletedInvite = $client->organization->invites->delete( inviteID: 'invite_01QrStUvWxYzAbCdEfGhIj', ); echo "id: {$deletedInvite->id}\n"; ``` ```ruby Ruby client = Anthropic::Client.new invite_id = "invite_01QrStUvWxYzAbCdEfGhIj" deleted_invite = client.organization.invites.delete(invite_id) puts "id: #{deleted_invite.id}" ``` ## Gruppi I gruppi creati direttamente dalla tua azienda (`source_type: "direct"`), nelle [impostazioni dell'organizzazione di claude.ai](https://claude.ai/admin-settings) o tramite questa API, supportano tutti gli endpoint di questa sezione. I gruppi forniti dal tuo provider di identità (`source_type: "scim"`) possono essere letti ma non modificati, perché appartengono al provider di identità. Se provi a rinominare o eliminare un gruppo SCIM, o a modificarne i membri, la richiesta restituisce 400. ### 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](https://platform.claude.com/docs/it/api/beta/organization/rbac_groups/list) nel riferimento API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/rbac_groups?limit=20" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant beta:organization:rbac-groups list --limit 20 ``` ```python Python client = anthropic.Anthropic() groups = client.beta.organization.rbac_groups.list(limit=20) for group in groups: print(f"{group.id}: {group.name} ({group.source_type})") ``` ```typescript TypeScript const client = new Anthropic(); const groups = await client.beta.organization.rbacGroups.list({ limit: 20 }); for await (const group of groups) { console.log(`${group.id}: ${group.name} (${group.source_type})`); } ``` ```csharp C# AnthropicClient client = new(); var page = await client.Beta.Organization.RbacGroups.List(new() { Limit = 20 }); await foreach (var group in page.Paginate()) { Console.WriteLine($"{group.ID}: {group.Name} ({group.SourceType.Raw()})"); } ``` ```go Go client := anthropic.NewClient() groups := client.Beta.Organization.RBACGroups.ListAutoPaging(context.Background(), anthropic.BetaOrganizationRBACGroupListParams{ Limit: anthropic.Int(20), }) for groups.Next() { group := groups.Current() fmt.Printf("%s: %s (%s)\n", group.ID, group.Name, group.SourceType) } if err := groups.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.beta.organization.rbacgroups.RbacGroupListParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = RbacGroupListParams.builder() .limit(20) .build(); var groups = client.beta().organization().rbacGroups().list(params); for (var group : groups.autoPager()) { IO.println(group.id() + ": " + group.name() + " (" + group.sourceType().asString() + ")"); } } ``` ```php PHP $client = new Client(); $groups = $client->beta->organization->rbacGroups->list(limit: 20); foreach ($groups->pagingEachItem() as $group) { echo "{$group->id}: {$group->name} ({$group->sourceType})\n"; } ``` ```ruby Ruby client = Anthropic::Client.new groups = client.beta.organization.rbac_groups.list(limit: 20) groups.auto_paging_each do |group| puts "#{group.id}: #{group.name} (#{group.source_type})" end ``` ```json { "data": [ { "type": "rbac_group", "id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn", "name": "Engineering", "source_type": "direct", "role_ids": ["rbac_role_01CdEfGhIjKlMnOpQrStUv"], "roles": ["rbac_role_01CdEfGhIjKlMnOpQrStUv"], "created_at": "2026-03-18T10:01:42Z", "updated_at": "2026-05-02T08:55:09Z" } ], "has_more": false, "next_page": null } ``` ### 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](https://platform.claude.com/docs/it/api/beta/organization/rbac_groups/retrieve) nel riferimento API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/rbac_groups/rbac_group_01UvWxYzAbCdEfGhIjKlMn" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant beta:organization:rbac-groups retrieve \ --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn ``` ```python Python client = anthropic.Anthropic() group = client.beta.organization.rbac_groups.retrieve( "rbac_group_01UvWxYzAbCdEfGhIjKlMn" ) print(f"id: {group.id}") print(f"name: {group.name}") print(f"source_type: {group.source_type}") ``` ```typescript TypeScript const client = new Anthropic(); const group = await client.beta.organization.rbacGroups.retrieve( "rbac_group_01UvWxYzAbCdEfGhIjKlMn" ); console.log(`id: ${group.id}`); console.log(`name: ${group.name}`); console.log(`source_type: ${group.source_type}`); ``` ```csharp C# AnthropicClient client = new(); var group = await client.Beta.Organization.RbacGroups.Retrieve("rbac_group_01UvWxYzAbCdEfGhIjKlMn"); Console.WriteLine($"id: {group.ID}"); Console.WriteLine($"name: {group.Name}"); Console.WriteLine($"source_type: {group.SourceType.Raw()}"); ``` ```go Go client := anthropic.NewClient() group, err := client.Beta.Organization.RBACGroups.Get(context.Background(), "rbac_group_01UvWxYzAbCdEfGhIjKlMn") if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", group.ID) fmt.Printf("name: %s\n", group.Name) fmt.Printf("source_type: %s\n", group.SourceType) ``` ```java Java AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var group = client.beta().organization().rbacGroups() .retrieve("rbac_group_01UvWxYzAbCdEfGhIjKlMn"); IO.println("id: " + group.id()); IO.println("name: " + group.name()); IO.println("source_type: " + group.sourceType().asString()); ``` ```php PHP $client = new Client(); $group = $client->beta->organization->rbacGroups->retrieve( rbacGroupID: 'rbac_group_01UvWxYzAbCdEfGhIjKlMn', ); echo "id: {$group->id}\n"; echo "name: {$group->name}\n"; echo "source_type: {$group->sourceType}\n"; ``` ```ruby Ruby client = Anthropic::Client.new rbac_group_id = "rbac_group_01UvWxYzAbCdEfGhIjKlMn" group = client.beta.organization.rbac_groups.retrieve(rbac_group_id) puts "id: #{group.id}" puts "name: #{group.name}" puts "source_type: #{group.source_type}" ``` ### Creare un gruppo `POST /v1/organizations/rbac_groups` crea un gruppo con il `name` indicato (da 1 a 255 caratteri), senza ruoli né membri. Richiede lo scope `write:rbac_groups`. Per i dettagli completi sui parametri e gli schemi di risposta, consulta [Create group](https://platform.claude.com/docs/it/api/beta/organization/rbac_groups/create) nel riferimento API. ```bash cURL curl -X POST "https://api.anthropic.com/v1/organizations/rbac_groups" \ -H "content-type: application/json" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -d '{"name": "Engineering"}' ``` ```bash CLI ant beta:organization:rbac-groups create --name Engineering ``` ```python Python client = anthropic.Anthropic() group = client.beta.organization.rbac_groups.create(name="Engineering") print(f"id: {group.id}") print(f"name: {group.name}") ``` ```typescript TypeScript const client = new Anthropic(); const group = await client.beta.organization.rbacGroups.create({ name: "Engineering" }); console.log(`id: ${group.id}`); console.log(`name: ${group.name}`); ``` ```csharp C# AnthropicClient client = new(); var group = await client.Beta.Organization.RbacGroups.Create(new() { Name = "Engineering" }); Console.WriteLine($"id: {group.ID}"); Console.WriteLine($"name: {group.Name}"); ``` ```go Go client := anthropic.NewClient() group, err := client.Beta.Organization.RBACGroups.New(context.Background(), anthropic.BetaOrganizationRBACGroupNewParams{ Name: "Engineering", }) if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", group.ID) fmt.Printf("name: %s\n", group.Name) ``` ```java Java import com.anthropic.models.beta.organization.rbacgroups.RbacGroupCreateParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = RbacGroupCreateParams.builder() .name("Engineering") .build(); var group = client.beta().organization().rbacGroups().create(params); IO.println("id: " + group.id()); IO.println("name: " + group.name()); } ``` ```php PHP $client = new Client(); $group = $client->beta->organization->rbacGroups->create( name: 'Engineering', ); echo "id: {$group->id}\n"; echo "name: {$group->name}\n"; ``` ```ruby Ruby client = Anthropic::Client.new group = client.beta.organization.rbac_groups.create(name: "Engineering") puts "id: #{group.id}" puts "name: #{group.name}" ``` ```json { "type": "rbac_group", "id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn", "name": "Engineering", "source_type": "direct", "role_ids": [], "roles": [], "created_at": "2026-07-09T18:00:00Z", "updated_at": "2026-07-09T18:00:00Z" } ``` ### 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](https://platform.claude.com/docs/it/api/beta/organization/rbac_groups/update) nel riferimento API. ```bash cURL curl -X POST "https://api.anthropic.com/v1/organizations/rbac_groups/rbac_group_01UvWxYzAbCdEfGhIjKlMn" \ -H "content-type: application/json" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -d '{"name": "Platform Engineering"}' ``` ```bash CLI ant beta:organization:rbac-groups update \ --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn \ --name "Platform Engineering" ``` ```python Python client = anthropic.Anthropic() group = client.beta.organization.rbac_groups.update( "rbac_group_01UvWxYzAbCdEfGhIjKlMn", name="Platform Engineering" ) print(f"id: {group.id}") print(f"name: {group.name}") ``` ```typescript TypeScript const client = new Anthropic(); const group = await client.beta.organization.rbacGroups.update( "rbac_group_01UvWxYzAbCdEfGhIjKlMn", { name: "Platform Engineering" } ); console.log(`id: ${group.id}`); console.log(`name: ${group.name}`); ``` ```csharp C# AnthropicClient client = new(); var group = await client.Beta.Organization.RbacGroups.Update( "rbac_group_01UvWxYzAbCdEfGhIjKlMn", new() { Name = "Platform Engineering" } ); Console.WriteLine($"id: {group.ID}"); Console.WriteLine($"name: {group.Name}"); ``` ```go Go client := anthropic.NewClient() group, err := client.Beta.Organization.RBACGroups.Update( context.Background(), "rbac_group_01UvWxYzAbCdEfGhIjKlMn", anthropic.BetaOrganizationRBACGroupUpdateParams{ Name: anthropic.String("Platform Engineering"), }, ) if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", group.ID) fmt.Printf("name: %s\n", group.Name) ``` ```java Java import com.anthropic.models.beta.organization.rbacgroups.RbacGroupUpdateParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = RbacGroupUpdateParams.builder() .name("Platform Engineering") .build(); var group = client.beta().organization().rbacGroups() .update("rbac_group_01UvWxYzAbCdEfGhIjKlMn", params); IO.println("id: " + group.id()); IO.println("name: " + group.name()); } ``` ```php PHP $client = new Client(); $group = $client->beta->organization->rbacGroups->update( rbacGroupID: 'rbac_group_01UvWxYzAbCdEfGhIjKlMn', name: 'Platform Engineering', ); echo "id: {$group->id}\n"; echo "name: {$group->name}\n"; ``` ```ruby Ruby client = Anthropic::Client.new rbac_group_id = "rbac_group_01UvWxYzAbCdEfGhIjKlMn" group = client.beta.organization.rbac_groups.update(rbac_group_id, name: "Platform Engineering") puts "id: #{group.id}" puts "name: #{group.name}" ``` ### 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 al gruppo. Inoltre, l'eventuale [limite di spesa](https://platform.claude.com/docs/it/manage-claude/spend-limits-api) 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](https://platform.claude.com/docs/it/api/beta/organization/rbac_groups/delete) nel riferimento API. ```bash cURL curl -X DELETE "https://api.anthropic.com/v1/organizations/rbac_groups/rbac_group_01UvWxYzAbCdEfGhIjKlMn" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant beta:organization:rbac-groups delete \ --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn ``` ```python Python client = anthropic.Anthropic() deleted_group = client.beta.organization.rbac_groups.delete( "rbac_group_01UvWxYzAbCdEfGhIjKlMn" ) print(f"id: {deleted_group.id}") ``` ```typescript TypeScript const client = new Anthropic(); const deletedGroup = await client.beta.organization.rbacGroups.delete( "rbac_group_01UvWxYzAbCdEfGhIjKlMn" ); console.log(`id: ${deletedGroup.id}`); ``` ```csharp C# AnthropicClient client = new(); var deletedGroup = await client.Beta.Organization.RbacGroups.Delete( "rbac_group_01UvWxYzAbCdEfGhIjKlMn" ); Console.WriteLine($"id: {deletedGroup.ID}"); ``` ```go Go client := anthropic.NewClient() deletedGroup, err := client.Beta.Organization.RBACGroups.Delete(context.Background(), "rbac_group_01UvWxYzAbCdEfGhIjKlMn") if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", deletedGroup.ID) ``` ```java Java AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var deletedGroup = client.beta().organization().rbacGroups() .delete("rbac_group_01UvWxYzAbCdEfGhIjKlMn"); IO.println("id: " + deletedGroup.id()); ``` ```php PHP $client = new Client(); $deletedGroup = $client->beta->organization->rbacGroups->delete( rbacGroupID: 'rbac_group_01UvWxYzAbCdEfGhIjKlMn', ); echo "id: {$deletedGroup->id}\n"; ``` ```ruby Ruby client = Anthropic::Client.new rbac_group_id = "rbac_group_01UvWxYzAbCdEfGhIjKlMn" deleted_group = client.beta.organization.rbac_groups.delete(rbac_group_id) puts "id: #{deleted_group.id}" ``` ```json { "id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn", "type": "rbac_group_deleted" } ``` ### 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` e la propria email), a partire dal meno recente. Vengono restituiti solo i membri attuali delle organizzazioni della tua azienda, quindi una pagina potrebbe contenere meno di `limit` voci anche quando `has_more` è `true`. Richiede lo scope `read:rbac_groups`. Per i dettagli completi sui parametri e gli schemi di risposta, consulta [List group members](https://platform.claude.com/docs/it/api/beta/organization/rbac_groups/members/list) nel riferimento API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/rbac_groups/rbac_group_01UvWxYzAbCdEfGhIjKlMn/members?limit=100" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant beta:organization:rbac-groups:members list \ --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn \ --limit 100 ``` ```python Python client = anthropic.Anthropic() members = client.beta.organization.rbac_groups.members.list( "rbac_group_01UvWxYzAbCdEfGhIjKlMn", limit=100 ) for member in members: print(f"{member.user_id}: {member.email}") ``` ```typescript TypeScript const client = new Anthropic(); const members = await client.beta.organization.rbacGroups.members.list( "rbac_group_01UvWxYzAbCdEfGhIjKlMn", { limit: 100 } ); for await (const member of members) { console.log(`${member.user_id}: ${member.email}`); } ``` ```csharp C# AnthropicClient client = new(); var page = await client.Beta.Organization.RbacGroups.Members.List( "rbac_group_01UvWxYzAbCdEfGhIjKlMn", new() { Limit = 100 } ); await foreach (var member in page.Paginate()) { Console.WriteLine($"{member.UserID}: {member.Email}"); } ``` ```go Go client := anthropic.NewClient() members := client.Beta.Organization.RBACGroups.Members.ListAutoPaging( context.Background(), "rbac_group_01UvWxYzAbCdEfGhIjKlMn", anthropic.BetaOrganizationRBACGroupMemberListParams{ Limit: anthropic.Int(100), }, ) for members.Next() { member := members.Current() fmt.Printf("%s: %s\n", member.UserID, member.Email) } if err := members.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.beta.organization.rbacgroups.members.MemberListParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = MemberListParams.builder() .limit(100) .build(); var members = client.beta().organization().rbacGroups().members() .list("rbac_group_01UvWxYzAbCdEfGhIjKlMn", params); for (var member : members.autoPager()) { IO.println(member.userId() + ": " + member.email()); } } ``` ```php PHP $client = new Client(); $members = $client->beta->organization->rbacGroups->members->list( rbacGroupID: 'rbac_group_01UvWxYzAbCdEfGhIjKlMn', limit: 100, ); foreach ($members->pagingEachItem() as $member) { echo "{$member->userID}: {$member->email}\n"; } ``` ```ruby Ruby client = Anthropic::Client.new rbac_group_id = "rbac_group_01UvWxYzAbCdEfGhIjKlMn" members = client.beta.organization.rbac_groups.members.list(rbac_group_id, limit: 100) members.auto_paging_each do |member| puts "#{member.user_id}: #{member.email}" end ``` ```json { "data": [ { "type": "rbac_group_member", "rbac_group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn", "group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn", "user_id": "user_01AbCdEfGhIjKlMnOpQrSt", "email": "jane@example.com", "created_at": "2026-04-07T12:30:00Z" } ], "has_more": false, "next_page": null } ``` ### 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 è gestita 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](https://platform.claude.com/docs/it/manage-claude/user-management#create-an-invite). Richiede lo scope `write:rbac_groups`. Per i dettagli completi sui parametri e gli schemi di risposta, consulta [Add group member](https://platform.claude.com/docs/it/api/beta/organization/rbac_groups/members/add) nel riferimento API. ```bash cURL curl -X POST "https://api.anthropic.com/v1/organizations/rbac_groups/rbac_group_01UvWxYzAbCdEfGhIjKlMn/members" \ -H "content-type: application/json" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -d '{"user_id": "user_01AbCdEfGhIjKlMnOpQrSt"}' ``` ```bash CLI ant beta:organization:rbac-groups:members add \ --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn \ --user-id user_01AbCdEfGhIjKlMnOpQrSt ``` ```python Python client = anthropic.Anthropic() member = client.beta.organization.rbac_groups.members.add( "rbac_group_01UvWxYzAbCdEfGhIjKlMn", user_id="user_01AbCdEfGhIjKlMnOpQrSt" ) print(f"user_id: {member.user_id}") print(f"email: {member.email}") ``` ```typescript TypeScript const client = new Anthropic(); const member = await client.beta.organization.rbacGroups.members.add( "rbac_group_01UvWxYzAbCdEfGhIjKlMn", { user_id: "user_01AbCdEfGhIjKlMnOpQrSt" } ); console.log(`user_id: ${member.user_id}`); console.log(`email: ${member.email}`); ``` ```csharp C# AnthropicClient client = new(); var member = await client.Beta.Organization.RbacGroups.Members.Add( "rbac_group_01UvWxYzAbCdEfGhIjKlMn", new() { UserID = "user_01AbCdEfGhIjKlMnOpQrSt" } ); Console.WriteLine($"user_id: {member.UserID}"); Console.WriteLine($"email: {member.Email}"); ``` ```go Go client := anthropic.NewClient() member, err := client.Beta.Organization.RBACGroups.Members.Add( context.Background(), "rbac_group_01UvWxYzAbCdEfGhIjKlMn", anthropic.BetaOrganizationRBACGroupMemberAddParams{ UserID: "user_01AbCdEfGhIjKlMnOpQrSt", }, ) if err != nil { log.Fatal(err) } fmt.Printf("user_id: %s\n", member.UserID) fmt.Printf("email: %s\n", member.Email) ``` ```java Java import com.anthropic.models.beta.organization.rbacgroups.members.MemberAddParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = MemberAddParams.builder() .userId("user_01AbCdEfGhIjKlMnOpQrSt") .build(); var member = client.beta().organization().rbacGroups().members() .add("rbac_group_01UvWxYzAbCdEfGhIjKlMn", params); IO.println("user_id: " + member.userId()); IO.println("email: " + member.email()); } ``` ```php PHP $client = new Client(); $member = $client->beta->organization->rbacGroups->members->add( rbacGroupID: 'rbac_group_01UvWxYzAbCdEfGhIjKlMn', userID: 'user_01AbCdEfGhIjKlMnOpQrSt', ); echo "user_id: {$member->userID}\n"; echo "email: {$member->email}\n"; ``` ```ruby Ruby client = Anthropic::Client.new rbac_group_id = "rbac_group_01UvWxYzAbCdEfGhIjKlMn" member = client.beta.organization.rbac_groups.members.add( rbac_group_id, user_id: "user_01AbCdEfGhIjKlMnOpQrSt" ) puts "user_id: #{member.user_id}" puts "email: #{member.email}" ``` ```json { "type": "rbac_group_member", "rbac_group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn", "group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn", "user_id": "user_01AbCdEfGhIjKlMnOpQrSt", "email": "jane@example.com", "created_at": "2026-07-09T18:00:00Z" } ``` ### Rimuovere un membro da un gruppo `DELETE /v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}` rimuove il membro dal gruppo; resta comunque membro della propria organizzazione. La richiesta restituisce 404 se l'utente non è membro del gruppo, e 400 per i gruppi `scim`, la cui appartenenza è gestita 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](https://platform.claude.com/docs/it/api/beta/organization/rbac_groups/members/remove) nel riferimento API. ```bash cURL curl -X DELETE "https://api.anthropic.com/v1/organizations/rbac_groups/rbac_group_01UvWxYzAbCdEfGhIjKlMn/members/user_01AbCdEfGhIjKlMnOpQrSt" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant beta:organization:rbac-groups:members remove \ --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn \ --user-id user_01AbCdEfGhIjKlMnOpQrSt ``` ```python Python client = anthropic.Anthropic() removed_member = client.beta.organization.rbac_groups.members.remove( "user_01AbCdEfGhIjKlMnOpQrSt", rbac_group_id="rbac_group_01UvWxYzAbCdEfGhIjKlMn" ) print(f"user_id: {removed_member.user_id}") ``` ```typescript TypeScript const client = new Anthropic(); const removedMember = await client.beta.organization.rbacGroups.members.remove( "user_01AbCdEfGhIjKlMnOpQrSt", { rbac_group_id: "rbac_group_01UvWxYzAbCdEfGhIjKlMn" } ); console.log(`user_id: ${removedMember.user_id}`); ``` ```csharp C# AnthropicClient client = new(); var removedMember = await client.Beta.Organization.RbacGroups.Members.Remove( "user_01AbCdEfGhIjKlMnOpQrSt", new() { RbacGroupID = "rbac_group_01UvWxYzAbCdEfGhIjKlMn" } ); Console.WriteLine($"user_id: {removedMember.UserID}"); ``` ```go Go client := anthropic.NewClient() removedMember, err := client.Beta.Organization.RBACGroups.Members.Remove( context.Background(), "user_01AbCdEfGhIjKlMnOpQrSt", anthropic.BetaOrganizationRBACGroupMemberRemoveParams{ RBACGroupID: "rbac_group_01UvWxYzAbCdEfGhIjKlMn", }, ) if err != nil { log.Fatal(err) } fmt.Printf("user_id: %s\n", removedMember.UserID) ``` ```java Java import com.anthropic.models.beta.organization.rbacgroups.members.MemberRemoveParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = MemberRemoveParams.builder() .rbacGroupId("rbac_group_01UvWxYzAbCdEfGhIjKlMn") .build(); var removedMember = client.beta().organization().rbacGroups().members() .remove("user_01AbCdEfGhIjKlMnOpQrSt", params); IO.println("user_id: " + removedMember.userId()); } ``` ```php PHP $client = new Client(); $removedMember = $client->beta->organization->rbacGroups->members->remove( userID: 'user_01AbCdEfGhIjKlMnOpQrSt', rbacGroupID: 'rbac_group_01UvWxYzAbCdEfGhIjKlMn', ); echo "user_id: {$removedMember->userID}\n"; ``` ```ruby Ruby client = Anthropic::Client.new rbac_group_id = "rbac_group_01UvWxYzAbCdEfGhIjKlMn" removed_member = client.beta.organization.rbac_groups.members.remove( "user_01AbCdEfGhIjKlMnOpQrSt", rbac_group_id: rbac_group_id ) puts "user_id: #{removed_member.user_id}" ``` ```json { "rbac_group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn", "group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn", "user_id": "user_01AbCdEfGhIjKlMnOpQrSt", "type": "rbac_group_member_deleted" } ``` ## 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](https://claude.ai/admin-settings) 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`. Il campo deprecato `name` viene ancora restituito, sempre uguale a `display_name`. Per un ruolo fornito da Anthropic, `display_name` può differire dall'etichetta mostrata da claude.ai, e Anthropic potrebbe cambiarne 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](https://platform.claude.com/docs/it/api/beta/organization/rbac_roles/list) nel riferimento API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/rbac_roles?limit=20" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant beta:organization:rbac-roles list --limit 20 ``` ```python Python client = anthropic.Anthropic() roles = client.beta.organization.rbac_roles.list(limit=20) for role in roles: print(f"{role.id}: {role.display_name}") ``` ```typescript TypeScript const client = new Anthropic(); const roles = await client.beta.organization.rbacRoles.list({ limit: 20 }); for await (const role of roles) { console.log(`${role.id}: ${role.display_name}`); } ``` ```csharp C# AnthropicClient client = new(); var page = await client.Beta.Organization.RbacRoles.List(new() { Limit = 20 }); await foreach (var role in page.Paginate()) { Console.WriteLine($"{role.ID}: {role.DisplayName}"); } ``` ```go Go client := anthropic.NewClient() roles := client.Beta.Organization.RBACRoles.ListAutoPaging(context.Background(), anthropic.BetaOrganizationRBACRoleListParams{ Limit: anthropic.Int(20), }) for roles.Next() { role := roles.Current() fmt.Printf("%s: %s\n", role.ID, role.DisplayName) } if err := roles.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.beta.organization.rbacroles.RbacRoleListParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = RbacRoleListParams.builder() .limit(20) .build(); var roles = client.beta().organization().rbacRoles().list(params); for (var role : roles.autoPager()) { IO.println(role.id() + ": " + role.displayName()); } } ``` ```php PHP $client = new Client(); $roles = $client->beta->organization->rbacRoles->list(limit: 20); foreach ($roles->pagingEachItem() as $role) { echo "{$role->id}: {$role->displayName}\n"; } ``` ```ruby Ruby client = Anthropic::Client.new roles = client.beta.organization.rbac_roles.list(limit: 20) roles.auto_paging_each do |role| puts "#{role.id}: #{role.display_name}" end ``` ```json { "data": [ { "type": "rbac_role", "id": "rbac_role_01CdEfGhIjKlMnOpQrStUv", "display_name": "Engineering base", "name": "Engineering base", "created_at": "2026-03-18T10:01:42Z", "updated_at": "2026-05-02T08:55:09Z" } ], "has_more": false, "next_page": null } ``` ### 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](https://platform.claude.com/docs/it/api/beta/organization/rbac_roles/retrieve) nel riferimento API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/rbac_roles/rbac_role_01CdEfGhIjKlMnOpQrStUv" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant beta:organization:rbac-roles retrieve \ --rbac-role-id rbac_role_01CdEfGhIjKlMnOpQrStUv ``` ```python Python client = anthropic.Anthropic() role = client.beta.organization.rbac_roles.retrieve("rbac_role_01CdEfGhIjKlMnOpQrStUv") print(f"id: {role.id}") print(f"display_name: {role.display_name}") ``` ```typescript TypeScript const client = new Anthropic(); const role = await client.beta.organization.rbacRoles.retrieve( "rbac_role_01CdEfGhIjKlMnOpQrStUv" ); console.log(`id: ${role.id}`); console.log(`display_name: ${role.display_name}`); ``` ```csharp C# AnthropicClient client = new(); var role = await client.Beta.Organization.RbacRoles.Retrieve("rbac_role_01CdEfGhIjKlMnOpQrStUv"); Console.WriteLine($"id: {role.ID}"); Console.WriteLine($"display_name: {role.DisplayName}"); ``` ```go Go client := anthropic.NewClient() role, err := client.Beta.Organization.RBACRoles.Get(context.Background(), "rbac_role_01CdEfGhIjKlMnOpQrStUv") if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", role.ID) fmt.Printf("display_name: %s\n", role.DisplayName) ``` ```java Java AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var role = client.beta().organization().rbacRoles() .retrieve("rbac_role_01CdEfGhIjKlMnOpQrStUv"); IO.println("id: " + role.id()); IO.println("display_name: " + role.displayName()); ``` ```php PHP $client = new Client(); $role = $client->beta->organization->rbacRoles->retrieve( rbacRoleID: 'rbac_role_01CdEfGhIjKlMnOpQrStUv', ); echo "id: {$role->id}\n"; echo "display_name: {$role->displayName}\n"; ``` ```ruby Ruby client = Anthropic::Client.new rbac_role_id = "rbac_role_01CdEfGhIjKlMnOpQrStUv" role = client.beta.organization.rbac_roles.retrieve(rbac_role_id) puts "id: #{role.id}" puts "display_name: #{role.display_name}" ``` ### 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` (a cosa si applica il permesso: 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 una `action` (cosa concede il permesso 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 anche quando `has_more` è `true`. Richiede lo scope `read:members`. Due valori di `action` richiedono particolare attenzione. Un permesso `organization` con una di queste azioni è una concessione generale: `capability_access_all` (tutte le funzionalità di prodotto) o `capability_access_all_ga` (tutte le funzionalità di prodotto stabili, cioè tutte quelle non contrassegnate come beta o anteprima di ricerca). Una concessione generale non copre né l'accesso ai modelli né i permessi del pannello di amministrazione con prefisso `permission_`. Viene elencata come singola riga anziché essere espansa. Quando calcoli cosa concede un ruolo, considera una riga generale come copertura di tutto ciò che descrive la sua variante, non solo delle funzionalità indicate nelle altre righe. Per i dettagli completi sui parametri e gli schemi di risposta, consulta [List role permissions](https://platform.claude.com/docs/it/api/beta/organization/rbac_roles/permissions/list) nel riferimento API. ```bash cURL curl "https://api.anthropic.com/v1/organizations/rbac_roles/rbac_role_01CdEfGhIjKlMnOpQrStUv/permissions?limit=20" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" ``` ```bash CLI ant beta:organization:rbac-roles:permissions list \ --rbac-role-id rbac_role_01CdEfGhIjKlMnOpQrStUv \ --limit 20 ``` ```python Python client = anthropic.Anthropic() permissions = client.beta.organization.rbac_roles.permissions.list( "rbac_role_01CdEfGhIjKlMnOpQrStUv", limit=20 ) for permission in permissions: print(permission.action) ``` ```typescript TypeScript const client = new Anthropic(); const permissions = await client.beta.organization.rbacRoles.permissions.list( "rbac_role_01CdEfGhIjKlMnOpQrStUv", { limit: 20 } ); for await (const permission of permissions) { console.log(permission.action); } ``` ```csharp C# AnthropicClient client = new(); var page = await client.Beta.Organization.RbacRoles.Permissions.List( "rbac_role_01CdEfGhIjKlMnOpQrStUv", new() { Limit = 20 } ); await foreach (var permission in page.Paginate()) { Console.WriteLine(permission.Action); } ``` ```go Go client := anthropic.NewClient() permissions := client.Beta.Organization.RBACRoles.Permissions.ListAutoPaging( context.Background(), "rbac_role_01CdEfGhIjKlMnOpQrStUv", anthropic.BetaOrganizationRBACRolePermissionListParams{ Limit: anthropic.Int(20), }, ) for permissions.Next() { permission := permissions.Current() fmt.Println(permission.Action) } if err := permissions.Err(); err != nil { log.Fatal(err) } ``` ```java Java import com.anthropic.models.beta.organization.rbacroles.permissions.PermissionListParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = PermissionListParams.builder() .limit(20) .build(); var permissions = client.beta().organization().rbacRoles().permissions() .list("rbac_role_01CdEfGhIjKlMnOpQrStUv", params); for (var permission : permissions.autoPager()) { IO.println(permission.action()); } } ``` ```php PHP $client = new Client(); $permissions = $client->beta->organization->rbacRoles->permissions->list( rbacRoleID: 'rbac_role_01CdEfGhIjKlMnOpQrStUv', limit: 20, ); foreach ($permissions->pagingEachItem() as $permission) { echo "{$permission->action}\n"; } ``` ```ruby Ruby client = Anthropic::Client.new rbac_role_id = "rbac_role_01CdEfGhIjKlMnOpQrStUv" permissions = client.beta.organization.rbac_roles.permissions.list(rbac_role_id, limit: 20) permissions.auto_paging_each do |permission| puts permission.action end ``` ```json { "data": [ { "type": "rbac_role_permission", "resource": { "type": "organization", "organization_id": "12345678-1234-5678-1234-567812345678" }, "action": "capability_access_all_ga" }, { "type": "rbac_role_permission", "resource": { "type": "connector_tool", "connector_id": "mcpsrv_01WxYzAbCdEfGhIjKlMnOp", "tool_name": "search_tickets" }, "action": "use" } ], "has_more": false, "next_page": null } ``` ## Flussi di lavoro di esempio ### Gestire l'uscita di un dipendente 1. Cerca il membro per email: ```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. Rimuovilo con `DELETE /v1/organizations/users/{user_id}`, usando l'`id` della risposta. L'eventuale postazione torna nel pool. 3. Se la persona non si era ancora unita all'organizzazione, la ricerca non restituisce alcun membro. In questo caso, elenca gli inviti e ritira il suo invito `pending`. ### Verificare i membri dei gruppi 1. Elenca i gruppi e annota `id`, `name` e `role_ids` di ciascun gruppo. 2. Per ogni gruppo con 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 i membri dei gruppi con un aumento temporaneo del limite di spesa, consulta [Aumentare temporaneamente il limite di spesa di un membro durante un incidente](https://platform.claude.com/docs/it/manage-claude/spend-limits-api#temporarily-raise-a-members-spend-limit-during-an-incident) 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à](https://platform.claude.com/docs/it/manage-claude/user-management#which-endpoints-can-your-organization-use) 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 né 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. L'API non può però modificare: * I gruppi forniti dal tuo provider di identità (`source_type: "scim"`), il cui nome e i cui membri appartengono al provider di identità. * I ruoli personalizzati, che si gestiscono nelle impostazioni dell'organizzazione di claude.ai. L'API può solo [leggerli](https://platform.claude.com/docs/it/manage-claude/user-management#custom-roles). ### Un invito non accettato occupa una postazione? Nei piani con un pool limitato di postazioni, sì: un invito `pending` occupa una postazione, che si libera quando ritiri l'invito o quando l'invito scade. Nei piani senza pool di postazioni, gli inviti non occupano nulla. ### La mia organizzazione usa il single sign-on. Quali operazioni funzionano? Dipende da cosa gestisce il tuo provider di identità: * Se fornisce gli utenti automaticamente (JIT o SCIM), la creazione degli 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 dei membri restituiscono 400. Le letture funzionano in ogni caso. ### Cosa succede a una chiave Admin API quando la persona che l'ha creata lascia l'organizzazione? La chiave continua a funzionare. Le chiavi Admin API sono legate all'organizzazione, non ai singoli utenti, e una chiave creata in claude.ai non scade. Se rimuovi il creatore dall'organizzazione o ne revochi il provisioning tramite il provider di identità, termina il suo accesso personale, ma non le chiavi che ha creato. Anche il declassamento del suo ruolo non modifica le chiavi: ciascuna resta attiva con i suoi scope originali. Quando gestisci l'uscita di una persona che ha creato chiavi Admin API, elimina quelle chiavi nella sezione **Keys** di [claude.ai > Organization settings > API](https://claude.ai/admin-settings/api-access) e creane di sostitutive. ## Vedi anche Dove il tuo proprietario principale crea una chiave con scope e quali scope selezionare. Verifica le attività e recupera o elimina i contenuti degli utenti in tutta la tua organizzazione. Report su utilizzo e costi per utente e per intervalli di tempo per Claude Enterprise. Imposta limiti di spesa per membro ed esamina le richieste di aumento.