---
title: Workspace
url: https://platform.claude.com/docs/it/manage-claude/workspaces
description: Organizza le chiavi API, gestisci l'accesso del team e controlla i costi con i workspace.
---

I workspace offrono un modo per organizzare l'utilizzo dell'API all'interno di un'organizzazione. Usa i workspace per separare progetti, ambienti o team diversi mantenendo al contempo fatturazione e amministrazione centralizzate.

## Come funzionano i workspace

Ogni organizzazione ha un **Default Workspace** che non può essere rinominato, archiviato o eliminato. Quando crei workspace aggiuntivi, puoi assegnare membri, account di servizio, chiavi API e limiti di risorse a ciascuno di essi.

Caratteristiche principali:

* Gli **identificatori dei workspace** usano il prefisso `wrkspc_` (ad esempio, `wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ`)
* **Massimo 100 workspace** per organizzazione per impostazione predefinita (i workspace archiviati non vengono conteggiati); contatta il tuo account team se ne hai bisogno di più
* Il **Default Workspace** ha un ID `wrkspc_` come qualsiasi altro workspace (restituito nell'[header di risposta `anthropic-workspace-id`](https://platform.claude.com/docs/it/manage-claude/workspaces#identify-the-workspace-behind-an-api-response) e accettato da [Get Workspace](https://platform.claude.com/docs/it/api/organization/workspaces/retrieve)), ma compare nei risultati di [List Workspaces](https://platform.claude.com/docs/it/api/organization/workspaces/list) solo quando passi `include_default=true`, e le chiavi API, i report di utilizzo e i report dei costi mostrano `null` per il suo `workspace_id`, così come le chiavi API valide per tutti i workspace (il campo `scope` di una chiave API permette di distinguerle; per una chiave associata al Default Workspace contiene l'ID reale)
* Le **chiavi API** possono essere limitate a un singolo workspace. In questo caso, possono accedere solo alle risorse all'interno di quel workspace. Ad alcune chiavi API possono essere concessi permessi su più workspace, e forniscono un [header dell'ID del workspace](https://platform.claude.com/docs/it/manage-claude/authentication#select-a-workspace) per accedere alle risorse all'interno di quel workspace

### Workspace Claude Code

Quando un membro della tua organizzazione accede per la prima volta a [Claude Code](https://code.claude.com/docs/en/overview) con il proprio account Claude Console, Anthropic crea automaticamente un workspace **Claude Code** nell'organizzazione e aggiunge quel membro ad esso. Ogni membro successivo che accede a Claude Code viene aggiunto allo stesso modo.

Il workspace Claude Code mantiene il traffico di Claude Code separato dagli altri carichi di lavoro API:

* Claude Code genera una chiave API per utente in questo workspace al momento dell'accesso. Non puoi creare chiavi in esso manualmente dalla Console.
* Una chiave Claude Code smette di funzionare se il suo proprietario viene rimosso dal workspace o dall'organizzazione, a differenza di una chiave del workspace.
* L'utilizzo di Claude Code è soggetto a limiti di velocità separati, e gli amministratori possono limitarne la quota rispetto ai limiti dell'organizzazione nella pagina [Rate limits](https://platform.claude.com/usage/limits) della Claude Console.
* È l'unico workspace che supporta limiti di spesa mensili per utente.

<Warning>
  L'archiviazione del workspace Claude Code disabilita l'accesso a Claude Code tramite la fatturazione della Console per l'intera organizzazione.
</Warning>

## Ruoli e permessi dei workspace

I membri possono avere ruoli diversi in ciascun workspace, consentendo un controllo degli accessi granulare.

| Ruolo                       | Permessi                                                                                                            |
| --------------------------- | ------------------------------------------------------------------------------------------------------------------- |
| Workspace User              | Usa solo il playground                                                                                              |
| Workspace Limited Developer | Crea e gestisce chiavi API, usa l'API. Non può accedere alle viste di tracciamento delle sessioni o scaricare file. |
| Workspace Developer         | Crea e gestisce chiavi API, usa l'API                                                                               |
| Workspace Admin             | Controllo completo sulle impostazioni e sui membri del workspace                                                    |
| Workspace Billing           | Visualizza le informazioni di fatturazione del workspace (ereditato dal ruolo di fatturazione dell'organizzazione)  |

### Ereditarietà dei ruoli

* Gli **amministratori dell'organizzazione** ricevono automaticamente l'accesso Workspace Admin a tutti i workspace
* I **membri di fatturazione dell'organizzazione** ricevono automaticamente l'accesso Workspace Billing a tutti i workspace
* Gli **utenti e sviluppatori dell'organizzazione** devono essere aggiunti esplicitamente a ciascun workspace
* Gli **account di servizio** vengono aggiunti ai workspace nella pagina [Service accounts](https://platform.claude.com/settings/service-accounts) (`platform.claude.com/settings/service-accounts`) della Claude Console: seleziona **Add to workspace** nel menu dell'account o nella sua pagina. Per vedere gli account in un workspace, filtra l'elenco per workspace.

<Note>
  Il ruolo Workspace Billing non può essere assegnato manualmente. Viene ereditato dall'avere il ruolo di fatturazione dell'organizzazione.
</Note>

## Gestione dei workspace

<Note>
  Solo gli amministratori dell'organizzazione possono creare workspace. Gli utenti e gli sviluppatori dell'organizzazione devono essere aggiunti ai workspace da un amministratore.
</Note>

### Utilizzo della Console

Crea e gestisci i workspace nella [Claude Console](https://platform.claude.com/settings/workspaces).

#### Crea un workspace

<Steps>
  <Step title="Apri le impostazioni dei workspace">
    Nella Claude Console, vai alla pagina [Workspaces](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`).
  </Step>

  <Step title="Apri la pagina Create workspace">
    Fai clic su **Create workspace** per aprire la pagina [Create workspace](https://platform.claude.com/settings/workspaces/new) (`platform.claude.com/settings/workspaces/new`) nella Console.
  </Step>

  <Step title="Configura il workspace">
    Inserisci un nome per il workspace e seleziona un colore per l'identificazione visiva.
  </Step>

  <Step title="Crea il workspace">
    Fai clic su **Create workspace** per completare.
  </Step>
</Steps>

<Tip>
  Per passare da un workspace all'altro nella Console, apri una pagina che appartiene a un workspace, come [Files](https://platform.claude.com/files) (`platform.claude.com/files`), e usa il selettore di workspace nella barra laterale.
</Tip>

#### Modifica i dettagli del workspace

Per modificare il nome o il colore di un workspace:

1. Seleziona il workspace dall'elenco.
2. Apri il menu **More actions** (tre puntini) e seleziona **Edit details**.
3. Aggiorna il nome o il colore e salva le modifiche.

<Note>
  Il Default Workspace non può essere rinominato o eliminato.
</Note>

#### Aggiungi membri a un workspace

1. Nella Claude Console, vai alla pagina [Members](https://platform.claude.com/settings/members) (`platform.claude.com/settings/members`).
2. Fai clic su **Add to workspace**.
3. Seleziona il workspace, il membro dell'organizzazione da aggiungere e il suo [ruolo nel workspace](https://platform.claude.com/docs/it/manage-claude/workspaces#workspace-roles-and-permissions).
4. Fai clic su **Add to workspace** per confermare.

#### Rimuovi membri da un workspace

1. Nella pagina [Members](https://platform.claude.com/settings/members) della Claude Console, seleziona il workspace dal menu a discesa **Workspace**. Se mostra **All**, **Remove member** rimuove invece il membro dalla tua organizzazione.
2. Alla fine della riga del membro, apri il menu **More actions** (tre puntini) e seleziona **Remove member**.
3. Fai clic su **Remove** per confermare.

<Note>
  Gli amministratori dell'organizzazione e i membri di fatturazione non possono essere rimossi dai workspace mentre detengono quei ruoli dell'organizzazione.
</Note>

#### Imposta i limiti del workspace

I limiti di velocità e i limiti di spesa di un workspace si impostano in posti diversi:

* **Limiti di velocità:** Nella pagina [Rate limits](https://platform.claude.com/usage/limits) della Claude Console, seleziona il workspace dal menu a discesa **Workspace** e fai clic su **Edit** accanto a un modello per impostare i limiti per richieste al minuto, token di input o token di output.
* **Limiti di spesa:** Nella pagina [Workspaces](https://platform.claude.com/settings/workspaces) della Claude Console, seleziona il workspace. Nel pannello che si apre, fai clic su **Spend limits** per limitare la spesa mensile e configurare avvisi quando la spesa raggiunge determinate soglie.

#### Archivia un workspace

Per archiviare un workspace, apri il suo menu **More actions** (tre puntini) e seleziona **Archive workspace**. L'archiviazione:

* Conserva i dati storici per la reportistica
* Disattiva il workspace e archivia ogni chiave API creata per esso
* Non può essere annullata

<Warning>
  L'archiviazione di un workspace archivia ogni chiave API creata per quel workspace entro pochi secondi (rimangono elencate nell'Admin API come archiviate), e le chiavi multi-workspace non possono più operare in esso. Questa azione non può essere annullata. Se archivi il [workspace Claude Code](https://platform.claude.com/docs/it/manage-claude/workspaces#claude-code-workspace), i membri della tua organizzazione non possono più accedere a Claude Code tramite la fatturazione della Console.
</Warning>

### Utilizzo dell'Admin API

Gestisci i workspace in modo programmatico utilizzando l'[Admin API](https://platform.claude.com/docs/it/manage-claude/admin-api).

<Note>
  Gli endpoint dell'Admin API accettano una [chiave Admin API](https://platform.claude.com/docs/it/manage-claude/admin-api-keys), un token OAuth `org:admin`, o una chiave personale o di account di servizio che non sia limitata a un workspace specifico. Le chiavi del workspace non funzionano lì. Consulta [Authentication](https://platform.claude.com/docs/it/manage-claude/admin-api#authentication).
</Note>

I seguenti esempi SDK e CLI costruiscono il client predefinito, che legge la chiave Admin API dalla variabile d'ambiente `ANTHROPIC_API_KEY`; gli SDK espongono questi endpoint sotto `client.organization.workspaces` (csharp, go: `client.Organization.Workspaces`; java: `client.organization().workspaces()`; php: `$client->organization->workspaces`). I metodi di elenco degli SDK recuperano le pagine successive su richiesta, quindi `limit` imposta la dimensione della pagina; gli esempi PHP, Ruby e curl restituiscono una sola pagina.

Crea un workspace:

<CodeGroup>
  ```bash cURL
  curl -X POST "https://api.anthropic.com/v1/organizations/workspaces" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{"name": "Production"}'
  ```

  ```bash CLI
  ant organization:workspaces create --name Production
  ```

  ```python Python
  client = anthropic.Anthropic()

  workspace = client.organization.workspaces.create(name="Production")

  print(f"id: {workspace.id}")
  print(f"name: {workspace.name}")
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const workspace = await client.organization.workspaces.create({ name: "Production" });

  console.log(`id: ${workspace.id}`);
  console.log(`name: ${workspace.name}`);
  ```

  ```csharp C#
  AnthropicClient client = new();

  var workspace = await client.Organization.Workspaces.Create(new()
  {
      Name = "Production"
  });

  Console.WriteLine($"id: {workspace.ID}");
  Console.WriteLine($"name: {workspace.Name}");
  ```

  ```go Go
  client := anthropic.NewClient()

  workspace, err := client.Organization.Workspaces.New(context.Background(), anthropic.OrganizationWorkspaceNewParams{
  	Name: "Production",
  })
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("id: %s\n", workspace.ID)
  fmt.Printf("name: %s\n", workspace.Name)
  ```

  ```java Java
  import com.anthropic.models.organization.workspaces.WorkspaceCreateParams;

  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      var params = WorkspaceCreateParams.builder()
          .name("Production")
          .build();
      var workspace = client.organization().workspaces().create(params);

      IO.println("id: " + workspace.id());
      IO.println("name: " + workspace.name());
  }
  ```

  ```php PHP
  $client = new Client();

  $workspace = $client->organization->workspaces->create(
      name: 'Production',
  );

  echo "id: {$workspace->id}\n";
  echo "name: {$workspace->name}\n";
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  workspace = client.organization.workspaces.create(name: "Production")

  puts "id: #{workspace.id}"
  puts "name: #{workspace.name}"
  ```
</CodeGroup>

Elenca i workspace:

<CodeGroup>
  ```bash cURL
  curl "https://api.anthropic.com/v1/organizations/workspaces?limit=10&include_archived=false" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01"
  ```

  ```bash CLI
  ant organization:workspaces list --limit 10 --include-archived=false
  ```

  ```python Python
  client = anthropic.Anthropic()

  workspaces = client.organization.workspaces.list(limit=10, include_archived=False)

  for workspace in workspaces:
      print(f"{workspace.id}: {workspace.name}")
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const workspaces = await client.organization.workspaces.list({
    limit: 10,
    include_archived: false
  });

  for await (const workspace of workspaces) {
    console.log(`${workspace.id}: ${workspace.name}`);
  }
  ```

  ```csharp C#
  AnthropicClient client = new();

  var workspaces = await client.Organization.Workspaces.List(new()
  {
      Limit = 10,
      IncludeArchived = false
  });

  await foreach (var workspace in workspaces.Paginate())
  {
      Console.WriteLine($"{workspace.ID}: {workspace.Name}");
  }
  ```

  ```go Go
  client := anthropic.NewClient()

  workspaces := client.Organization.Workspaces.ListAutoPaging(context.Background(), anthropic.OrganizationWorkspaceListParams{
  	Limit:           anthropic.Int(10),
  	IncludeArchived: anthropic.Bool(false),
  })

  for workspaces.Next() {
  	workspace := workspaces.Current()
  	fmt.Printf("%s: %s\n", workspace.ID, workspace.Name)
  }
  if err := workspaces.Err(); err != nil {
  	log.Fatal(err)
  }
  ```

  ```java Java
  import com.anthropic.models.organization.workspaces.WorkspaceListParams;

  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      var params = WorkspaceListParams.builder()
          .limit(10)
          .includeArchived(false)
          .build();
      var workspaces = client.organization().workspaces().list(params);

      for (var workspace : workspaces.autoPager()) {
          IO.println(workspace.id() + ": " + workspace.name());
      }
  }
  ```

  ```php PHP
  $client = new Client();

  $workspaces = $client->organization->workspaces->list(
      limit: 10,
      includeArchived: false,
  );

  foreach ($workspaces->getItems() as $workspace) {
      echo "{$workspace->id}: {$workspace->name}\n";
  }
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  workspaces = client.organization.workspaces.list(limit: 10, include_archived: false)

  workspaces.data.each do |workspace|
    puts "#{workspace.id}: #{workspace.name}"
  end
  ```
</CodeGroup>

Archivia un workspace:

<CodeGroup>
  ```bash cURL
  curl -X POST "https://api.anthropic.com/v1/organizations/workspaces/wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ/archive" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01"
  ```

  ```bash CLI
  ant organization:workspaces archive --workspace-id wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ
  ```

  ```python Python
  client = anthropic.Anthropic()

  workspace = client.organization.workspaces.archive("wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ")

  print(f"id: {workspace.id}")
  print(f"archived_at: {workspace.archived_at}")
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const workspace = await client.organization.workspaces.archive(
    "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"
  );

  console.log(`id: ${workspace.id}`);
  console.log(`archived_at: ${workspace.archived_at}`);
  ```

  ```csharp C#
  AnthropicClient client = new();

  var workspace = await client.Organization.Workspaces.Archive(
      "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"
  );

  Console.WriteLine($"id: {workspace.ID}");
  Console.WriteLine($"archived_at: {workspace.ArchivedAt:O}");
  ```

  ```go Go
  client := anthropic.NewClient()

  workspace, err := client.Organization.Workspaces.Archive(context.Background(), "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ")
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("id: %s\n", workspace.ID)
  fmt.Printf("archived_at: %s\n", workspace.ArchivedAt)
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  var workspace = client.organization().workspaces()
      .archive("wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ");

  IO.println("id: " + workspace.id());
  IO.println("archived_at: " + workspace.archivedAt().orElseThrow());
  ```

  ```php PHP
  $client = new Client();

  $workspace = $client->organization->workspaces->archive(
      workspaceID: 'wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ',
  );

  echo "id: {$workspace->id}\n";
  echo "archived_at: {$workspace->archivedAt?->format(DATE_ATOM)}\n";
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  workspace_id = "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"
  workspace = client.organization.workspaces.archive(workspace_id)

  puts "id: #{workspace.id}"
  puts "archived_at: #{workspace.archived_at}"
  ```
</CodeGroup>

Per i dettagli completi sui parametri e gli schemi di risposta, consulta il [riferimento dell'API Workspaces](https://platform.claude.com/docs/it/api/organization/workspaces/retrieve).

### Gestione dei membri del workspace

Aggiungi un membro a un workspace:

<CodeGroup>
  ```bash cURL
  curl -X POST "https://api.anthropic.com/v1/organizations/workspaces/wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ/members" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "user_id": "user_01XyDMpzjS89pFZXqSFUBDr6",
      "workspace_role": "workspace_developer"
    }'
  ```

  ```bash CLI
  ant organization:workspaces:members add \
    --workspace-id wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ \
    --user-id user_01XyDMpzjS89pFZXqSFUBDr6 \
    --workspace-role workspace_developer
  ```

  ```python Python
  client = anthropic.Anthropic()

  member = client.organization.workspaces.members.add(
      "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
      user_id="user_01XyDMpzjS89pFZXqSFUBDr6",
      workspace_role="workspace_developer",
  )

  print(f"user_id: {member.user_id}")
  print(f"workspace_role: {member.workspace_role}")
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const member = await client.organization.workspaces.members.add(
    "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
    {
      user_id: "user_01XyDMpzjS89pFZXqSFUBDr6",
      workspace_role: "workspace_developer"
    }
  );

  console.log(`user_id: ${member.user_id}`);
  console.log(`workspace_role: ${member.workspace_role}`);
  ```

  ```csharp C#
  using Anthropic.Models.Organization.Workspaces;

  AnthropicClient client = new();

  var member = await client.Organization.Workspaces.Members.Add(
      "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
      new()
      {
          UserID = "user_01XyDMpzjS89pFZXqSFUBDr6",
          WorkspaceRole = NoBillingWorkspaceRole.WorkspaceDeveloper
      }
  );

  Console.WriteLine($"user_id: {member.UserID}");
  Console.WriteLine($"workspace_role: {member.WorkspaceRole.Raw()}");
  ```

  ```go Go
  client := anthropic.NewClient()

  member, err := client.Organization.Workspaces.Members.Add(
  	context.Background(),
  	"wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
  	anthropic.OrganizationWorkspaceMemberAddParams{
  		UserID:        "user_01XyDMpzjS89pFZXqSFUBDr6",
  		WorkspaceRole: anthropic.NoBillingWorkspaceRoleWorkspaceDeveloper,
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("user_id: %s\n", member.UserID)
  fmt.Printf("workspace_role: %s\n", member.WorkspaceRole)
  ```

  ```java Java
  import com.anthropic.models.organization.workspaces.NoBillingWorkspaceRole;
  import com.anthropic.models.organization.workspaces.members.MemberAddParams;

  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      var params = MemberAddParams.builder()
          .userId("user_01XyDMpzjS89pFZXqSFUBDr6")
          .workspaceRole(NoBillingWorkspaceRole.WORKSPACE_DEVELOPER)
          .build();
      var member = client.organization().workspaces().members()
          .add("wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ", params);

      IO.println("user_id: " + member.userId());
      IO.println("workspace_role: " + member.workspaceRole().asString());
  }
  ```

  ```php PHP
  use Anthropic\Organization\Workspaces\NoBillingWorkspaceRole;
  // ...

  $client = new Client();

  $member = $client->organization->workspaces->members->add(
      workspaceID: 'wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ',
      userID: 'user_01XyDMpzjS89pFZXqSFUBDr6',
      workspaceRole: NoBillingWorkspaceRole::WORKSPACE_DEVELOPER,
  );

  echo "user_id: {$member->userID}\n";
  echo "workspace_role: {$member->workspaceRole}\n";
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  workspace_id = "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"
  member = client.organization.workspaces.members.add(
    workspace_id,
    user_id: "user_01XyDMpzjS89pFZXqSFUBDr6",
    workspace_role: :workspace_developer
  )

  puts "user_id: #{member.user_id}"
  puts "workspace_role: #{member.workspace_role}"
  ```
</CodeGroup>

Aggiorna il ruolo di un membro:

<CodeGroup>
  ```bash cURL
  curl -X POST "https://api.anthropic.com/v1/organizations/workspaces/wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ/members/user_01XyDMpzjS89pFZXqSFUBDr6" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{"workspace_role": "workspace_admin"}'
  ```

  ```bash CLI
  ant organization:workspaces:members update \
    --user-id user_01XyDMpzjS89pFZXqSFUBDr6 \
    --workspace-id wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ \
    --workspace-role workspace_admin
  ```

  ```python Python
  client = anthropic.Anthropic()

  member = client.organization.workspaces.members.update(
      "user_01XyDMpzjS89pFZXqSFUBDr6",
      workspace_id="wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
      workspace_role="workspace_admin",
  )

  print(f"user_id: {member.user_id}")
  print(f"workspace_role: {member.workspace_role}")
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const member = await client.organization.workspaces.members.update(
    "user_01XyDMpzjS89pFZXqSFUBDr6",
    {
      workspace_id: "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
      workspace_role: "workspace_admin"
    }
  );

  console.log(`user_id: ${member.user_id}`);
  console.log(`workspace_role: ${member.workspace_role}`);
  ```

  ```csharp C#
  using Anthropic.Models.Organization.Workspaces;

  AnthropicClient client = new();

  var member = await client.Organization.Workspaces.Members.Update(
      "user_01XyDMpzjS89pFZXqSFUBDr6",
      new()
      {
          WorkspaceID = "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
          WorkspaceRole = WorkspaceRole.WorkspaceAdmin
      }
  );

  Console.WriteLine($"user_id: {member.UserID}");
  Console.WriteLine($"workspace_role: {member.WorkspaceRole.Raw()}");
  ```

  ```go Go
  client := anthropic.NewClient()

  member, err := client.Organization.Workspaces.Members.Update(
  	context.Background(),
  	"user_01XyDMpzjS89pFZXqSFUBDr6",
  	anthropic.OrganizationWorkspaceMemberUpdateParams{
  		WorkspaceID:   "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
  		WorkspaceRole: anthropic.WorkspaceRoleWorkspaceAdmin,
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("user_id: %s\n", member.UserID)
  fmt.Printf("workspace_role: %s\n", member.WorkspaceRole)
  ```

  ```java Java
  import com.anthropic.models.organization.workspaces.WorkspaceRole;
  import com.anthropic.models.organization.workspaces.members.MemberUpdateParams;

  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      var params = MemberUpdateParams.builder()
          .workspaceId("wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ")
          .workspaceRole(WorkspaceRole.WORKSPACE_ADMIN)
          .build();
      var member = client.organization().workspaces().members()
          .update("user_01XyDMpzjS89pFZXqSFUBDr6", params);

      IO.println("user_id: " + member.userId());
      IO.println("workspace_role: " + member.workspaceRole().asString());
  }
  ```

  ```php PHP
  use Anthropic\Organization\Workspaces\WorkspaceRole;
  // ...

  $client = new Client();

  $member = $client->organization->workspaces->members->update(
      userID: 'user_01XyDMpzjS89pFZXqSFUBDr6',
      workspaceID: 'wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ',
      workspaceRole: WorkspaceRole::WORKSPACE_ADMIN,
  );

  echo "user_id: {$member->userID}\n";
  echo "workspace_role: {$member->workspaceRole}\n";
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  user_id = "user_01XyDMpzjS89pFZXqSFUBDr6"
  member = client.organization.workspaces.members.update(
    user_id,
    workspace_id: "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
    workspace_role: :workspace_admin
  )

  puts "user_id: #{member.user_id}"
  puts "workspace_role: #{member.workspace_role}"
  ```
</CodeGroup>

Rimuovi un membro da un workspace:

<CodeGroup>
  ```bash cURL
  curl -X DELETE "https://api.anthropic.com/v1/organizations/workspaces/wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ/members/user_01XyDMpzjS89pFZXqSFUBDr6" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01"
  ```

  ```bash CLI
  ant organization:workspaces:members remove \
    --user-id user_01XyDMpzjS89pFZXqSFUBDr6 \
    --workspace-id wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ
  ```

  ```python Python
  client = anthropic.Anthropic()

  removed_member = client.organization.workspaces.members.remove(
      "user_01XyDMpzjS89pFZXqSFUBDr6",
      workspace_id="wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
  )

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

  ```typescript TypeScript
  const client = new Anthropic();

  const removedMember = await client.organization.workspaces.members.remove(
    "user_01XyDMpzjS89pFZXqSFUBDr6",
    { workspace_id: "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ" }
  );

  console.log(`user_id: ${removedMember.user_id}`);
  ```

  ```csharp C#
  AnthropicClient client = new();

  var removedMember = await client.Organization.Workspaces.Members.Remove(
      "user_01XyDMpzjS89pFZXqSFUBDr6",
      new() { WorkspaceID = "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ" }
  );

  Console.WriteLine($"user_id: {removedMember.UserID}");
  ```

  ```go Go
  client := anthropic.NewClient()

  removedMember, err := client.Organization.Workspaces.Members.Remove(
  	context.Background(),
  	"user_01XyDMpzjS89pFZXqSFUBDr6",
  	anthropic.OrganizationWorkspaceMemberRemoveParams{
  		WorkspaceID: "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("user_id: %s\n", removedMember.UserID)
  ```

  ```java Java
  import com.anthropic.models.organization.workspaces.members.MemberRemoveParams;

  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      var params = MemberRemoveParams.builder()
          .workspaceId("wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ")
          .build();
      var removedMember = client.organization().workspaces().members()
          .remove("user_01XyDMpzjS89pFZXqSFUBDr6", params);

      IO.println("user_id: " + removedMember.userId());
  }
  ```

  ```php PHP
  $client = new Client();

  $removedMember = $client->organization->workspaces->members->remove(
      userID: 'user_01XyDMpzjS89pFZXqSFUBDr6',
      workspaceID: 'wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ',
  );

  echo "user_id: {$removedMember->userID}\n";
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  user_id = "user_01XyDMpzjS89pFZXqSFUBDr6"
  removed_member = client.organization.workspaces.members.remove(
    user_id,
    workspace_id: "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"
  )

  puts "user_id: #{removed_member.user_id}"
  ```
</CodeGroup>

Per i dettagli completi sui parametri, consulta il [riferimento dell'API Workspace Members](https://platform.claude.com/docs/it/api/organization/workspaces/members/retrieve).

## Chiavi API e ambito delle risorse

Ogni richiesta viene eseguita in esattamente un workspace e può accedere solo alle risorse all'interno di quel workspace. Quale workspace dipende dal [tipo di chiave](https://platform.claude.com/docs/it/manage-claude/authentication#key-types):

* Una **chiave del workspace** (una chiave legacy senza proprietario) appartiene al workspace in cui è stata creata e viene sempre eseguita lì.
* Una **chiave personale** o una **chiave di account di servizio** agisce come il suo utente o account di servizio. Una chiave a singolo workspace viene sempre eseguita nel workspace scelto al momento della sua creazione. Una chiave multi-workspace viene eseguita nel workspace indicato dall'header `anthropic-workspace-id` di ciascuna richiesta. Gli account devono avere accesso al workspace per poterlo utilizzare.

Le risorse limitate ai workspace includono:

* **File** creati tramite l'[API Files](https://platform.claude.com/docs/it/build-with-claude/files)
* **Message Batches** creati tramite l'[API Batch](https://platform.claude.com/docs/it/build-with-claude/batch-processing)
* **Skills** create tramite l'[API Skills](https://platform.claude.com/docs/it/build-with-claude/skills-guide)

Alcune risorse vengono gestite in modo diverso:

* I **[tunnel MCP](https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/overview)** vengono gestiti con un token OAuth `workspace:manage_tunnels` ottenuto tramite [Workload Identity Federation](https://platform.claude.com/docs/it/manage-claude/workload-identity-federation), non una chiave API. I tunnel vengono creati in un workspace, e l'elenco **MCP tunnels** della Console e il selettore del server Managed Agent mostrano solo i tunnel nel workspace corrente; il limite di 10 tunnel attivi si applica a livello di organizzazione. La gestione dei tunnel richiede un ruolo con permessi di gestione dei tunnel; gli sviluppatori dell'organizzazione possono visualizzarli ma non modificarli.
* I **workspace** stessi e i **membri dell'organizzazione** vengono gestiti a livello di organizzazione tramite l'[Admin API](https://platform.claude.com/docs/it/manage-claude/admin-api), utilizzando una chiave Admin API, un token OAuth `org:admin`, o una chiave personale o di account di servizio che non sia limitata a un workspace specifico.

Per trovare gli ID dei workspace della tua organizzazione, chiama l'endpoint [List Workspaces](https://platform.claude.com/docs/it/api/organization/workspaces/list) (passa `include_default=true` per includere il Default Workspace) oppure trovali nella [Claude Console](https://platform.claude.com/settings/workspaces).

<Note>
  Le [cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/prompt-caching) sono anch'esse isolate per workspace sull'API Claude, [Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws) e [Microsoft Foundry](https://platform.claude.com/docs/it/build-with-claude/claude-in-microsoft-foundry). Su Amazon Bedrock e Google Cloud, le cache dei prompt sono isolate per organizzazione.
</Note>

## Identifica il workspace dietro una risposta API

Le risposte dell'API Claude includono un header `anthropic-workspace-id` insieme agli [header di risposta](https://platform.claude.com/docs/it/api/overview#response-headers) `request-id` e `anthropic-organization-id`. Il suo valore è l'ID con prefisso `wrkspc_` del workspace a cui la chiave API o il token di accesso della richiesta è stato risolto, incluso quando quel workspace è il Default Workspace. Ad esempio, una risposta riuscita include header come questi:

```http
HTTP/1.1 200 OK
request-id: req_018EeWyXxfu5pfWkrYcMdjWG
anthropic-organization-id: 0d0e7a3b-52f1-4c7e-9a51-3f6f2f7c1b9e
anthropic-workspace-id: wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ
```

L'header è assente quando la credenziale non si risolve in un workspace (ad esempio, nelle richieste dell'Admin API) o quando la richiesta fallisce prima del completamento dell'autenticazione, come un errore 401.

I seguenti esempi inviano una richiesta all'API Messages e stampano l'ID del workspace dagli header di risposta:

<CodeGroup>
  ```bash cURL
  # -D - stampa le intestazioni della risposta; -o /dev/null scarta il corpo
  curl -sS -D - -o /dev/null https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 1024,
      "messages": [{"role": "user", "content": "Hello, Claude"}]
    }' | grep -i '^anthropic-workspace-id'
  ```

  ```bash CLI
  # --debug stampa la risposta HTTP, incluso l'header Anthropic-Workspace-Id,
  # su stderr; > /dev/null nasconde il corpo JSON su stdout
  ant --debug messages create \
    --model claude-opus-5-5 \
    --max-tokens 1024 \
    --message '{role: user, content: "Hello, Claude"}' > /dev/null
  ```

  ```python Python
  client = anthropic.Anthropic()

  response = client.messages.with_raw_response.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[{"role": "user", "content": "Hello, Claude"}],
  )
  workspace_id = response.headers.get("anthropic-workspace-id")
  print(f"Workspace ID: {workspace_id}")
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const { response } = await client.messages
    .create({
      model: "claude-opus-5-5",
      max_tokens: 1024,
      messages: [{ role: "user", content: "Hello, Claude" }]
    })
    .withResponse();
  console.log("Workspace ID:", response.headers.get("anthropic-workspace-id"));
  ```

  ```csharp C#
  AnthropicClient client = new();

  using var response = await client.WithRawResponse.Messages.Create(new()
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Messages = [new() { Role = Role.User, Content = "Hello, Claude" }]
  });
  var workspaceId = response.GetHeaderValues("anthropic-workspace-id").First();
  Console.WriteLine($"Workspace ID: {workspaceId}");
  ```

  ```go Go
  client := anthropic.NewClient()

  var response *http.Response
  _, err := client.Messages.New(
  	context.Background(),
  	anthropic.MessageNewParams{
  		Model:     anthropic.ModelClaudeOpus5_5,
  		MaxTokens: 1024,
  		Messages: []anthropic.MessageParam{
  			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")),
  		},
  	},
  	option.WithResponseInto(&response),
  )
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Println("Workspace ID:", response.Header.Get("anthropic-workspace-id"))
  ```

  ```java Java
  import com.anthropic.client.AnthropicClient;
  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
  import com.anthropic.core.http.HttpResponseFor;
  import com.anthropic.models.messages.Message;
  import com.anthropic.models.messages.MessageCreateParams;
  import com.anthropic.models.messages.Model;

  void main() {
      AnthropicClient client = AnthropicOkHttpClient.fromEnv();

      HttpResponseFor<Message> response = client.messages().withRawResponse().create(
          MessageCreateParams.builder()
              .model(Model.CLAUDE_OPUS_5_5)
              .maxTokens(1024)
              .addUserMessage("Hello, Claude")
              .build()
      );

      String workspaceId = response.headers().values("anthropic-workspace-id").getFirst();
      IO.println("Workspace ID: " + workspaceId);
  }
  ```

  ```php PHP
  $client = new Client();

  $response = $client->messages->raw->create([
      'model' => Model::CLAUDE_OPUS_5_5,
      'maxTokens' => 1024,
      'messages' => [['role' => 'user', 'content' => 'Hello, Claude']],
  ]);
  echo 'Workspace ID: ' . $response->getHeaderLine('anthropic-workspace-id') . "\n";
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  # Leggi le intestazioni della risposta nel middleware per richiesta, che riceve la
  # risposta HTTP grezza prima che l'SDK la analizzi
  workspace_id = nil
  read_workspace_id = lambda do |request, call_next|
    response = call_next.call(request)
    # Le chiavi in response.headers sono in minuscolo
    workspace_id = response.headers["anthropic-workspace-id"]
    response
  end

  client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    request_options: { middleware: [read_workspace_id] }
  )
  puts "Workspace ID: #{workspace_id}"
  ```
</CodeGroup>

```text Output wrap
Workspace ID: wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ
```

Gli stessi accessor leggono l'header anche da altri endpoint dell'API Claude, incluse le API [Claude Managed Agents](https://platform.claude.com/docs/it/managed-agents/overview). Ad esempio, leggi `anthropic-workspace-id` dalla risposta che [crea una sessione](https://platform.claude.com/docs/it/managed-agents/sessions) per registrare a quale workspace appartiene la sessione.

Con l'ID del workspace da una risposta, puoi:

* Confermare a quale utilizzo, costo e [limiti di velocità](https://platform.claude.com/docs/it/api/rate-limits) del workspace è stata conteggiata la richiesta
* Confrontarlo con il campo `workspace_id` nei report dell'[API Usage and Cost](https://platform.claude.com/docs/it/manage-claude/usage-cost-api) e sugli oggetti dell'[Admin API](https://platform.claude.com/docs/it/manage-claude/admin-api) come le chiavi API (entrambi riportano `null` per il Default Workspace, come fanno anche le chiavi API per le chiavi di tutti i workspace; il campo `scope` di una chiave API distingue i due e, per una chiave associata a un workspace, riporta l'ID reale di quel workspace)
* Verificare se si tratta dell'ID del tuo Default Workspace passandolo a [Get Workspace](https://platform.claude.com/docs/it/api/organization/workspaces/retrieve) con una [chiave Admin API](https://platform.claude.com/docs/it/manage-claude/admin-api-keys): il Default Workspace viene restituito con `"name": "Default"`, anche se [List Workspaces](https://platform.claude.com/docs/it/api/organization/workspaces/list) lo omette a meno che tu non passi `include_default=true`
* Aprire quel workspace nella [Console](https://platform.claude.com/settings/workspaces) per trovare le risorse della richiesta, come sessioni, file, batch di messaggi e skill

## Limiti del workspace

Puoi impostare limiti di spesa e di velocità personalizzati per ciascun workspace per proteggerti dall'uso eccessivo e garantire una distribuzione equa delle risorse.

### Impostazione dei limiti del workspace

Puoi impostare limiti del workspace inferiori (ma non superiori) ai limiti della tua organizzazione:

* **Limiti di spesa:** Limita la spesa mensile di un workspace. Per impostarli, vai alla pagina [Workspaces](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`) nella Claude Console e seleziona il workspace. Nel pannello che si apre, fai clic su **Spend limits**.
* **Limiti di velocità:** Limita le richieste al minuto, i token di input al minuto o i token di output al minuto. Per impostarli, vai alla pagina [Rate limits](https://platform.claude.com/usage/limits) nella Claude Console, seleziona il workspace dal menu a discesa **Workspace** e fai clic su **Edit** accanto a un modello.

<Note>
  - Non puoi impostare limiti sul Default Workspace
  - Se non impostati, i limiti del workspace corrispondono ai limiti dell'organizzazione
  - I limiti a livello di organizzazione si applicano sempre, anche se i limiti dei workspace sommati superano tale valore
</Note>

Per informazioni dettagliate sui limiti di velocità e su come funzionano, consulta [Limiti di velocità](https://platform.claude.com/docs/it/api/rate-limits). Puoi anche leggere i limiti di velocità correnti della tua organizzazione e del workspace in modo programmatico con l'[API Rate Limits](https://platform.claude.com/docs/it/manage-claude/rate-limits-api).

## Tracciamento dell'utilizzo e dei costi

Traccia l'utilizzo e i costi per workspace utilizzando l'[API Usage and Cost](https://platform.claude.com/docs/it/manage-claude/usage-cost-api):

```bash cURL
curl "https://api.anthropic.com/v1/organizations/usage_report/messages?\
starting_at=2025-01-01T00:00:00Z&\
ending_at=2025-01-08T00:00:00Z&\
workspace_ids[]=wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ&\
group_by[]=workspace_id&\
bucket_width=1d" \
  -H "anthropic-version: 2023-06-01" \
  -H "x-api-key: $ANTHROPIC_ADMIN_KEY"
```

L'utilizzo e i costi attribuiti al Default Workspace hanno un valore `null` per `workspace_id`.

## Casi d'uso comuni

### Separazione degli ambienti

Crea workspace separati per sviluppo, staging e produzione:

| Workspace   | Scopo                                                        |
| ----------- | ------------------------------------------------------------ |
| Development | Test e sperimentazione con limiti di velocità inferiori      |
| Staging     | Test pre-produzione con limiti simili a quelli di produzione |
| Production  | Traffico live con limiti di velocità completi e monitoraggio |

### Isolamento di team o reparti

Assegna i workspace a team diversi per l'allocazione dei costi e il controllo degli accessi:

* **Team di ingegneria** con accesso sviluppatore
* **Team di data science** con le proprie chiavi API
* **Team di supporto** con accesso limitato per gli strumenti dei clienti

### Organizzazione basata sui progetti

Crea workspace per progetti o prodotti specifici per tracciare l'utilizzo e i costi separatamente.

## Best practice

<Steps>
  <Step title="Pianifica la struttura del tuo workspace">
    Considera come organizzerai i workspace prima di crearli. Pensa alle esigenze di fatturazione, controllo degli accessi e tracciamento dell'utilizzo.
  </Step>

  <Step title="Usa nomi significativi">
    Assegna nomi chiari ai workspace per indicarne lo scopo (ad esempio, "Production - Customer Chatbot" o "Dev - Internal Tools").
  </Step>

  <Step title="Imposta limiti appropriati">
    Configura i limiti di spesa e di velocità per prevenire costi imprevisti e garantire una distribuzione equa delle risorse.
  </Step>

  <Step title="Verifica regolarmente gli accessi">
    Rivedi periodicamente l'appartenenza ai workspace per assicurarti che solo gli utenti appropriati abbiano accesso.
  </Step>

  <Step title="Monitora l'utilizzo">
    Usa l'[API Usage and Cost](https://platform.claude.com/docs/it/manage-claude/usage-cost-api) per monitorare il consumo a livello di workspace.
  </Step>
</Steps>

## Domande frequenti

<AccordionGroup>
  <Accordion title="Cos'è il Default Workspace?">
    Ogni organizzazione ha un "Default Workspace" che non può essere rinominato, archiviato o eliminato. Come ogni workspace, ha un ID `wrkspc_`: l'API lo restituisce nell'[header di risposta `anthropic-workspace-id`](https://platform.claude.com/docs/it/manage-claude/workspaces#identify-the-workspace-behind-an-api-response), e puoi passarlo a [Get Workspace](https://platform.claude.com/docs/it/api/organization/workspaces/retrieve) e [Update Workspace](https://platform.claude.com/docs/it/api/organization/workspaces/update). Non ha un proprio elenco di membri, perché l'accesso a esso segue il ruolo di ciascun membro nell'organizzazione. Compare nei risultati di [List Workspaces](https://platform.claude.com/docs/it/api/organization/workspaces/list) solo quando passi `include_default=true`, e le chiavi API, i report di utilizzo e i report dei costi che gli appartengono mostrano `null` per `workspace_id`, così come le chiavi API valide per tutti i workspace; il campo `scope` di una chiave API permette di distinguere i due casi e, per una chiave che appartiene al Default Workspace, contiene il suo ID reale.
  </Accordion>

  <Accordion title="Cos'è il workspace Claude Code?">
    Anthropic crea automaticamente il workspace Claude Code la prima volta che un membro della tua organizzazione accede a Claude Code con il proprio account Console. Isola le chiavi API, l'utilizzo e i limiti di velocità di Claude Code dagli altri carichi di lavoro. Consulta [Workspace Claude Code](https://platform.claude.com/docs/it/manage-claude/workspaces#claude-code-workspace) per i dettagli.
  </Accordion>

  <Accordion title="Ci sono limiti sui workspace?">
    Sì. Ogni organizzazione può avere fino a 100 workspace per impostazione predefinita, e i workspace archiviati non vengono conteggiati in questo limite. Se ne hai bisogno di più, contatta il tuo account team.
  </Accordion>

  <Accordion title="Come influiscono i ruoli dell'organizzazione sull'accesso ai workspace?">
    Gli amministratori dell'organizzazione ottengono automaticamente il ruolo Workspace Admin in tutti i workspace. I membri di fatturazione dell'organizzazione ottengono automaticamente il ruolo Workspace Billing. Gli utenti e gli sviluppatori dell'organizzazione devono essere aggiunti manualmente a ciascun workspace.
  </Accordion>

  <Accordion title="Quali ruoli possono essere assegnati nei workspace?">
    Agli utenti e agli sviluppatori dell'organizzazione possono essere assegnati i ruoli Workspace Admin, Workspace Developer, Workspace Limited Developer o Workspace User. Il ruolo Workspace Billing non può essere assegnato manualmente; viene ereditato dall'avere il ruolo `billing` dell'organizzazione.
  </Accordion>

  <Accordion title="I ruoli del workspace degli amministratori dell'organizzazione o dei membri di fatturazione possono essere modificati?">
    Gli amministratori dell'organizzazione e i membri di fatturazione non possono avere i loro ruoli del workspace modificati né essere rimossi dai workspace mentre detengono quei ruoli dell'organizzazione (con un'eccezione: i membri di fatturazione possono essere promossi a un ruolo Workspace Admin). Per tutti gli altri coperti da questo vincolo, modifica prima il loro ruolo dell'organizzazione per cambiare il loro accesso al workspace.
  </Accordion>

  <Accordion title="Cosa succede all'accesso ai workspace quando cambiano i ruoli dell'organizzazione?">
    Se un amministratore dell'organizzazione o un membro di fatturazione viene retrocesso a utente o sviluppatore, perde l'accesso a tutti i workspace tranne quelli in cui gli sono stati assegnati manualmente dei ruoli. Quando gli utenti vengono promossi a ruoli di amministratore o di fatturazione, ottengono l'accesso automatico a tutti i workspace.
  </Accordion>

  <Accordion title="Cosa succede alle chiavi API quando un utente viene rimosso da un workspace?">
    Il comportamento dipende dal [tipo di chiave](https://platform.claude.com/docs/it/manage-claude/authentication#key-types).

    Una chiave personale o di account di servizio smette di funzionare in un workspace poco dopo che il suo utente o account di servizio viene rimosso da esso. Una chiave di account di servizio continua a funzionare anche se l'utente che l'ha creata viene rimosso. Le chiavi API del workspace continuano a funzionare. Nel [workspace Claude Code](https://platform.claude.com/docs/it/manage-claude/workspaces#claude-code-workspace), ogni chiave è associata al membro che l'ha creata e smette di funzionare quando quel membro viene rimosso.

    Le chiavi personali vengono archiviate quando il loro utente viene rimosso dall'organizzazione. Se l'utente viene reinvitato, deve creare nuove chiavi; le chiavi archiviate non vengono ripristinate.
  </Accordion>
</AccordionGroup>

## Vedi anche

* [Admin API](https://platform.claude.com/docs/it/manage-claude/admin-api)
* [Riferimento dell'Admin API](https://platform.claude.com/docs/it/api/organization)
* [Limiti di velocità](https://platform.claude.com/docs/it/api/rate-limits)
* [API Usage and Cost](https://platform.claude.com/docs/it/manage-claude/usage-cost-api)