---
title: Workspaces
url: https://platform.claude.com/docs/pt-BR/manage-claude/workspaces
description: Organize chaves de API, gerencie o acesso da equipe e controle custos com workspaces.
---

Os workspaces fornecem uma maneira de organizar o uso da sua API dentro de uma organização. Use workspaces para separar diferentes projetos, ambientes ou equipes, mantendo o faturamento e a administração centralizados.

## Como os workspaces funcionam

Toda organização tem um **Default Workspace** que não pode ser renomeado, arquivado ou excluído. Quando você cria workspaces adicionais, pode atribuir membros, contas de serviço, chaves de API e limites de recursos a cada um.

Características principais:

* **Identificadores de workspace** usam o prefixo `wrkspc_` (por exemplo, `wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ`)
* **Máximo de 100 workspaces** por organização por padrão (workspaces arquivados não contam); entre em contato com sua equipe de conta se precisar de mais
* O **Default Workspace** tem um ID `wrkspc_` como qualquer outro workspace (retornado no [cabeçalho de resposta `anthropic-workspace-id`](https://platform.claude.com/docs/pt-BR/manage-claude/workspaces#identify-the-workspace-behind-an-api-response) e aceito por [Get Workspace](https://platform.claude.com/docs/pt-BR/api/organization/workspaces/retrieve)), mas aparece nos resultados de [List Workspaces](https://platform.claude.com/docs/pt-BR/api/organization/workspaces/list) somente quando você passa `include_default=true`, e chaves de API, relatórios de uso e relatórios de custo mostram `null` para seu `workspace_id`, assim como as chaves de API de todos os workspaces (o campo `scope` de uma chave de API diferencia os dois casos; para uma chave vinculada ao Default Workspace, ele contém o ID real)
* **Chaves de API** podem ter escopo limitado a um único workspace. Nesse caso, elas só podem acessar recursos dentro desse workspace. Algumas chaves de API podem receber permissões em vários workspaces e fornecer um [cabeçalho de ID de workspace](https://platform.claude.com/docs/pt-BR/manage-claude/authentication#select-a-workspace) para acessar recursos dentro desse workspace

### Workspace do Claude Code

Quando um membro da sua organização faz login pela primeira vez no [Claude Code](https://code.claude.com/docs/en/overview) com sua conta do Claude Console, a Anthropic cria automaticamente um workspace **Claude Code** na organização e adiciona esse membro a ele. Todo membro subsequente que faz login no Claude Code é adicionado da mesma forma.

O workspace do Claude Code mantém o tráfego do Claude Code separado das suas outras cargas de trabalho da API:

* O Claude Code gera uma chave de API por usuário neste workspace no momento do login. Você não pode criar chaves nele manualmente pelo Console.
* Uma chave do Claude Code para de funcionar se seu proprietário for removido do workspace ou da organização, ao contrário de uma chave de workspace.
* O uso do Claude Code tem limite de taxa separado, e os administradores podem limitar sua parcela dos limites da organização na página [Rate limits](https://platform.claude.com/usage/limits) no Claude Console.
* É o único workspace que suporta limites de gasto mensal por usuário.

<Warning>
  Arquivar o workspace do Claude Code desativa o login do Claude Code por meio do faturamento do Console para toda a organização.
</Warning>

## Funções e permissões de workspace

Os membros podem ter funções diferentes em cada workspace, permitindo controle de acesso granular.

| Função                      | Permissões                                                                                                                |
| --------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| Workspace User              | Usar apenas o playground                                                                                                  |
| Workspace Limited Developer | Criar e gerenciar chaves de API, usar a API. Não pode acessar visualizações de rastreamento de sessão ou baixar arquivos. |
| Workspace Developer         | Criar e gerenciar chaves de API, usar a API                                                                               |
| Workspace Admin             | Controle total sobre configurações e membros do workspace                                                                 |
| Workspace Billing           | Visualizar informações de faturamento do workspace (herdado da função de faturamento da organização)                      |

### Herança de funções

* **Administradores da organização** recebem automaticamente acesso de Workspace Admin a todos os workspaces
* **Membros de faturamento da organização** recebem automaticamente acesso de Workspace Billing a todos os workspaces
* **Usuários e desenvolvedores da organização** devem ser adicionados explicitamente a cada workspace
* **Contas de serviço** são adicionadas a workspaces na página [Service accounts](https://platform.claude.com/settings/service-accounts) (`platform.claude.com/settings/service-accounts`) no Claude Console: selecione **Add to workspace** no menu da conta ou na própria página dela. Para ver as contas de um workspace, filtre a lista por workspace.

<Note>
  A função Workspace Billing não pode ser atribuída manualmente. Ela é herdada por ter a função de faturamento da organização.
</Note>

## Gerenciando workspaces

<Note>
  Apenas administradores da organização podem criar workspaces. Usuários e desenvolvedores da organização devem ser adicionados aos workspaces por um administrador.
</Note>

### Usando o Console

Crie e gerencie workspaces no [Claude Console](https://platform.claude.com/settings/workspaces).

#### Criar um workspace

<Steps>
  <Step title="Abra as configurações de workspace">
    No Claude Console, acesse a página [Workspaces](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`).
  </Step>

  <Step title="Abra a página Create workspace">
    Clique em **Create workspace** para abrir a página [Create workspace](https://platform.claude.com/settings/workspaces/new) (`platform.claude.com/settings/workspaces/new`) no Console.
  </Step>

  <Step title="Configure o workspace">
    Insira um nome para o workspace e selecione uma cor para identificação visual.
  </Step>

  <Step title="Crie o workspace">
    Clique em **Create workspace** para finalizar.
  </Step>
</Steps>

<Tip>
  Para alternar entre workspaces no Console, abra uma página que pertença a um workspace, como [Files](https://platform.claude.com/files) (`platform.claude.com/files`), e use o seletor de workspace na barra lateral.
</Tip>

#### Editar detalhes do workspace

Para modificar o nome ou a cor de um workspace:

1. Selecione o workspace na lista.
2. Abra o menu **More actions** (três pontos) e selecione **Edit details**.
3. Atualize o nome ou a cor e salve suas alterações.

<Note>
  O Default Workspace não pode ser renomeado ou excluído.
</Note>

#### Adicionar membros a um workspace

1. No Claude Console, acesse a página [Members](https://platform.claude.com/settings/members) (`platform.claude.com/settings/members`).
2. Clique em **Add to workspace**.
3. Selecione o workspace, o membro da organização a ser adicionado e sua [função de workspace](https://platform.claude.com/docs/pt-BR/manage-claude/workspaces#workspace-roles-and-permissions).
4. Clique em **Add to workspace** para confirmar.

#### Remover membros de um workspace

1. Na página [Members](https://platform.claude.com/settings/members) no Claude Console, selecione o workspace no menu suspenso **Workspace**. Se ele mostrar **All**, **Remove member** remove o membro da sua organização, e não apenas do workspace.
2. No final da linha do membro, abra o menu **More actions** (três pontos) e selecione **Remove member**.
3. Clique em **Remove** para confirmar.

<Note>
  Administradores da organização e membros de faturamento não podem ser removidos dos workspaces enquanto mantiverem essas funções da organização.
</Note>

#### Definir limites do workspace

Você define os limites de taxa e os limites de gasto de um workspace em lugares diferentes:

* **Limites de taxa:** Na página [Rate limits](https://platform.claude.com/usage/limits) no Claude Console, selecione o workspace no menu suspenso **Workspace** e clique em **Edit** ao lado de um modelo para definir limites de requisições por minuto, tokens de entrada ou tokens de saída.
* **Limites de gasto:** Na página [Workspaces](https://platform.claude.com/settings/workspaces) no Claude Console, selecione o workspace. No painel que se abre, clique em **Spend limits** para limitar o gasto mensal e configurar alertas quando o gasto atingir determinados limiares.

#### Arquivar um workspace

Para arquivar um workspace, abra o menu **More actions** (três pontos) do workspace e selecione **Archive workspace**. O arquivamento:

* Preserva dados históricos para relatórios
* Desativa o workspace e arquiva todas as chaves de API criadas para ele
* Não pode ser desfeito

<Warning>
  Arquivar um workspace arquiva todas as chaves de API criadas para esse workspace em segundos (elas permanecem listadas na Admin API como arquivadas), e as chaves de múltiplos workspaces não podem mais atuar nele. Esta ação não pode ser desfeita. Se você arquivar o [workspace do Claude Code](https://platform.claude.com/docs/pt-BR/manage-claude/workspaces#claude-code-workspace), os membros da sua organização não poderão mais fazer login no Claude Code por meio do faturamento do Console.
</Warning>

### Usando a Admin API

Gerencie workspaces programaticamente usando a [Admin API](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api).

<Note>
  Os endpoints da Admin API aceitam uma [chave da Admin API](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api-keys), um token OAuth `org:admin` ou uma chave pessoal ou de conta de serviço que não tenha escopo limitado a um workspace específico. Chaves de workspace não funcionam lá. Consulte [Autenticação](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api#authentication).
</Note>

Os exemplos de SDK e CLI a seguir constroem o cliente padrão, que lê a chave da Admin API da variável de ambiente `ANTHROPIC_API_KEY`; os SDKs expõem esses endpoints em `client.organization.workspaces` (csharp, go: `client.Organization.Workspaces`; java: `client.organization().workspaces()`; php: `$client->organization->workspaces`). Os métodos de listagem dos SDKs buscam páginas adicionais sob demanda, então `limit` define o tamanho da página; os exemplos em PHP, Ruby e curl retornam uma página.

Criar um 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>

Listar workspaces:

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

Arquivar um 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>

Para detalhes completos dos parâmetros e esquemas de resposta, consulte a [referência da API de Workspaces](https://platform.claude.com/docs/pt-BR/api/organization/workspaces/retrieve).

### Gerenciando membros do workspace

Adicionar um membro a um 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>

Atualizar a função de um 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>

Remover um membro de um 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>

Para detalhes completos dos parâmetros, consulte a [referência da API de Membros de Workspace](https://platform.claude.com/docs/pt-BR/api/organization/workspaces/members/retrieve).

## Chaves de API e escopo de recursos

Toda requisição é executada em exatamente um workspace e só pode acessar recursos dentro desse workspace. Qual workspace depende do [tipo de chave](https://platform.claude.com/docs/pt-BR/manage-claude/authentication#key-types):

* Uma **chave de workspace** (uma chave legada sem proprietário) pertence ao workspace em que foi criada e sempre é executada lá.
* Uma **chave pessoal** ou **chave de conta de serviço** atua como seu usuário ou conta de serviço. Uma chave de workspace único sempre é executada no workspace escolhido quando foi criada. Uma chave de múltiplos workspaces é executada no workspace nomeado pelo cabeçalho `anthropic-workspace-id` de cada requisição. As contas devem ter acesso ao workspace para usá-lo.

Os recursos com escopo limitado a workspaces incluem:

* **Arquivos** criados por meio da [Files API](https://platform.claude.com/docs/pt-BR/build-with-claude/files)
* **Message Batches** criados por meio da [Batch API](https://platform.claude.com/docs/pt-BR/build-with-claude/batch-processing)
* **Skills** criadas por meio da [Skills API](https://platform.claude.com/docs/pt-BR/build-with-claude/skills-guide)

Alguns recursos são gerenciados de forma diferente:

* **[Túneis MCP](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-tunnels/overview)** são gerenciados com um token OAuth `workspace:manage_tunnels` obtido por meio de [Workload Identity Federation](https://platform.claude.com/docs/pt-BR/manage-claude/workload-identity-federation), não uma chave de API. Os túneis são criados em um workspace, e a lista **MCP tunnels** do Console e o seletor de servidor do Managed Agent mostram apenas os túneis do workspace atual; o limite de 10 túneis ativos se aplica a toda a organização. O gerenciamento de túneis requer uma função com permissões de gerenciamento de túneis; os desenvolvedores da organização podem visualizá-los, mas não alterá-los.
* **Workspaces** em si e **membros da organização** são gerenciados no nível da organização por meio da [Admin API](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api), usando uma chave da Admin API, um token OAuth `org:admin` ou uma chave pessoal ou de conta de serviço que não tenha escopo limitado a um workspace específico.

Para consultar os IDs de workspace da sua organização, chame o endpoint [List Workspaces](https://platform.claude.com/docs/pt-BR/api/organization/workspaces/list) (passe `include_default=true` para incluir o Default Workspace) ou encontre-os no [Claude Console](https://platform.claude.com/settings/workspaces).

<Note>
  Os [caches de prompt](https://platform.claude.com/docs/pt-BR/build-with-claude/prompt-caching) também são isolados por workspace na Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws) e [Microsoft Foundry](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-in-microsoft-foundry). No Amazon Bedrock e no Google Cloud, os caches de prompt são isolados por organização.
</Note>

## Identificar o workspace por trás de uma resposta da API

As respostas da Claude API incluem um cabeçalho `anthropic-workspace-id` junto com os [cabeçalhos de resposta](https://platform.claude.com/docs/pt-BR/api/overview#response-headers) `request-id` e `anthropic-organization-id`. Seu valor é o ID com prefixo `wrkspc_` do workspace para o qual a chave de API ou o token de acesso da requisição foi resolvido, inclusive quando esse workspace é o Default Workspace. Por exemplo, uma resposta bem-sucedida inclui cabeçalhos como estes:

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

O cabeçalho está ausente quando a credencial não é resolvida para um workspace (por exemplo, em requisições da Admin API) ou quando a requisição falha antes da conclusão da autenticação, como um erro 401.

Os exemplos a seguir enviam uma requisição da Messages API e imprimem o ID do workspace a partir dos cabeçalhos de resposta:

<CodeGroup>
  ```bash cURL
  # -D - imprime os cabeçalhos da resposta; -o /dev/null descarta o 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 imprime a resposta HTTP, incluindo o Anthropic-Workspace-Id
  # header, no stderr; > /dev/null oculta o corpo JSON no 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

  # Leia os cabeçalhos de resposta no middleware por requisição, que recebe a
  # resposta HTTP bruta antes de o SDK analisá-la
  workspace_id = nil
  read_workspace_id = lambda do |request, call_next|
    response = call_next.call(request)
    # As chaves em response.headers estão em minúsculas
    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
```

Os mesmos acessadores leem o cabeçalho de outros endpoints da Claude API também, incluindo as APIs de [Claude Managed Agents](https://platform.claude.com/docs/pt-BR/managed-agents/overview). Por exemplo, leia `anthropic-workspace-id` da resposta que [cria uma sessão](https://platform.claude.com/docs/pt-BR/managed-agents/sessions) para registrar a qual workspace a sessão pertence.

Com o ID do workspace de uma resposta, você pode:

* Confirmar para qual uso, custo e [limites de taxa](https://platform.claude.com/docs/pt-BR/api/rate-limits) de workspace a requisição foi contabilizada
* Compará-lo com o campo `workspace_id` nos relatórios da [Usage and Cost API](https://platform.claude.com/docs/pt-BR/manage-claude/usage-cost-api) e em objetos da [Admin API](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api), como chaves de API (ambos reportam `null` para o Default Workspace, assim como as chaves de API fazem para chaves de todos os workspaces; o campo `scope` de uma chave de API diferencia os dois e, para uma chave vinculada a um workspace, carrega o ID real desse workspace)
* Verificar se é o ID do seu Default Workspace passando-o para [Get Workspace](https://platform.claude.com/docs/pt-BR/api/organization/workspaces/retrieve) com uma [chave da Admin API](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api-keys): o Default Workspace é retornado com `"name": "Default"`, embora [List Workspaces](https://platform.claude.com/docs/pt-BR/api/organization/workspaces/list) o omita, a menos que você passe `include_default=true`
* Abrir esse workspace no [Console](https://platform.claude.com/settings/workspaces) para encontrar os recursos da requisição, como sessões, arquivos, lotes de mensagens e skills

## Limites de workspace

Você pode definir limites personalizados de gasto e de taxa para cada workspace para proteger contra uso excessivo e garantir a distribuição justa de recursos.

### Definindo limites de workspace

Você pode definir limites de workspace menores (mas não maiores) do que os limites da sua organização:

* **Limites de gasto:** Limite o gasto mensal de um workspace. Para defini-los, acesse a página [Workspaces](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`) no Claude Console e selecione o workspace. No painel que se abre, clique em **Spend limits**.
* **Limites de taxa:** Limite requisições por minuto, tokens de entrada por minuto ou tokens de saída por minuto. Para defini-los, vá para a página [Rate limits](https://platform.claude.com/usage/limits) no Claude Console, selecione o workspace no menu suspenso **Workspace** e clique em **Edit** ao lado de um modelo.

<Note>
  - Você não pode definir limites no Default Workspace
  - Se não definidos, os limites do workspace correspondem aos limites da organização
  - Os limites de toda a organização sempre se aplicam, mesmo que os limites dos workspaces somem mais
</Note>

Para informações detalhadas sobre limites de taxa e como eles funcionam, consulte [Limites de taxa](https://platform.claude.com/docs/pt-BR/api/rate-limits). Você também pode ler seus limites de taxa atuais da organização e do workspace programaticamente com a [Rate Limits API](https://platform.claude.com/docs/pt-BR/manage-claude/rate-limits-api).

## Rastreamento de uso e custo

Rastreie o uso e os custos por workspace usando a [Usage and Cost API](https://platform.claude.com/docs/pt-BR/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"
```

O uso e os custos atribuídos ao Default Workspace têm um valor `null` para `workspace_id`.

## Casos de uso comuns

### Separação de ambientes

Crie workspaces separados para desenvolvimento, staging e produção:

| Workspace   | Finalidade                                                     |
| ----------- | -------------------------------------------------------------- |
| Development | Testes e experimentação com limites de taxa mais baixos        |
| Staging     | Testes de pré-produção com limites semelhantes aos de produção |
| Production  | Tráfego ao vivo com limites de taxa completos e monitoramento  |

### Isolamento de equipe ou departamento

Atribua workspaces a diferentes equipes para alocação de custos e controle de acesso:

* **Equipe de engenharia** com acesso de desenvolvedor
* **Equipe de ciência de dados** com suas próprias chaves de API
* **Equipe de suporte** com acesso limitado para ferramentas de cliente

### Organização baseada em projetos

Crie workspaces para projetos ou produtos específicos para rastrear uso e custos separadamente.

## Melhores práticas

<Steps>
  <Step title="Planeje a estrutura do seu workspace">
    Considere como você organizará os workspaces antes de criá-los. Pense nas necessidades de faturamento, controle de acesso e rastreamento de uso.
  </Step>

  <Step title="Use nomes significativos">
    Nomeie os workspaces claramente para indicar sua finalidade (por exemplo, "Production - Customer Chatbot" ou "Dev - Internal Tools").
  </Step>

  <Step title="Defina limites apropriados">
    Configure limites de gasto e de taxa para evitar custos inesperados e garantir a distribuição justa de recursos.
  </Step>

  <Step title="Audite o acesso regularmente">
    Revise a associação ao workspace periodicamente para garantir que apenas usuários apropriados tenham acesso.
  </Step>

  <Step title="Monitore o uso">
    Use a [Usage and Cost API](https://platform.claude.com/docs/pt-BR/manage-claude/usage-cost-api) para rastrear o consumo no nível do workspace.
  </Step>
</Steps>

## Perguntas frequentes

<AccordionGroup>
  <Accordion title="O que é o Default Workspace?">
    Toda organização tem um "Default Workspace" que não pode ser renomeado, arquivado ou excluído. Como todo workspace, ele tem um ID `wrkspc_`: a API o retorna no [cabeçalho de resposta `anthropic-workspace-id`](https://platform.claude.com/docs/pt-BR/manage-claude/workspaces#identify-the-workspace-behind-an-api-response), e você pode passá-lo para [Get Workspace](https://platform.claude.com/docs/pt-BR/api/organization/workspaces/retrieve) e [Update Workspace](https://platform.claude.com/docs/pt-BR/api/organization/workspaces/update). Ele não tem uma lista de membros própria, porque o acesso a ele segue a função de cada membro na organização. Ele aparece nos resultados de [List Workspaces](https://platform.claude.com/docs/pt-BR/api/organization/workspaces/list) somente quando você passa `include_default=true`, e chaves de API, relatórios de uso e relatórios de custo que pertencem a ele mostram `null` para `workspace_id`, assim como as chaves de API de todos os workspaces; o campo `scope` de uma chave de API diferencia os dois casos e, para uma chave que pertence ao Default Workspace, contém seu ID real.
  </Accordion>

  <Accordion title="O que é o workspace do Claude Code?">
    A Anthropic cria o workspace do Claude Code automaticamente na primeira vez que um membro da sua organização faz login no Claude Code com sua conta do Console. Ele isola as chaves de API, o uso e os limites de taxa do Claude Code das suas outras cargas de trabalho. Consulte [Workspace do Claude Code](https://platform.claude.com/docs/pt-BR/manage-claude/workspaces#claude-code-workspace) para detalhes.
  </Accordion>

  <Accordion title="Existem limites nos workspaces?">
    Sim. Cada organização pode ter até 100 workspaces por padrão, e os workspaces arquivados não contam para esse limite. Se você precisar de mais, entre em contato com sua equipe de conta.
  </Accordion>

  <Accordion title="Como as funções da organização afetam o acesso ao workspace?">
    Os administradores da organização recebem automaticamente a função Workspace Admin em todos os workspaces. Os membros de faturamento da organização recebem automaticamente a função Workspace Billing. Os usuários e desenvolvedores da organização devem ser adicionados manualmente a cada workspace.
  </Accordion>

  <Accordion title="Quais funções podem ser atribuídas nos workspaces?">
    Os usuários e desenvolvedores da organização podem receber as funções Workspace Admin, Workspace Developer, Workspace Limited Developer ou Workspace User. A função Workspace Billing não pode ser atribuída manualmente; ela é herdada por ter a função `billing` da organização.
  </Accordion>

  <Accordion title="As funções de workspace dos administradores da organização ou membros de faturamento podem ser alteradas?">
    Os administradores da organização e membros de faturamento não podem ter suas funções de workspace alteradas ou ser removidos dos workspaces enquanto mantiverem essas funções da organização (com uma exceção: os membros de faturamento podem ser promovidos a uma função Workspace Admin). Para todos os outros cobertos por essa restrição, altere primeiro a função da organização para alterar o acesso ao workspace.
  </Accordion>

  <Accordion title="O que acontece com o acesso ao workspace quando as funções da organização mudam?">
    Se um administrador da organização ou membro de faturamento for rebaixado para usuário ou desenvolvedor, ele perde o acesso a todos os workspaces, exceto aqueles onde recebeu funções atribuídas manualmente. Quando os usuários são promovidos a funções de administrador ou faturamento, eles ganham acesso automático a todos os workspaces.
  </Accordion>

  <Accordion title="O que acontece com as chaves de API quando um usuário é removido de um workspace?">
    O comportamento depende do [tipo de chave](https://platform.claude.com/docs/pt-BR/manage-claude/authentication#key-types).

    Uma chave pessoal ou de conta de serviço para de funcionar em um workspace logo após seu usuário ou conta de serviço ser removido dele. Uma chave de conta de serviço continua funcionando mesmo que o usuário que a criou seja removido. As chaves de API de workspace continuam funcionando. No [workspace do Claude Code](https://platform.claude.com/docs/pt-BR/manage-claude/workspaces#claude-code-workspace), cada chave é vinculada ao membro que a criou e para de funcionar quando esse membro é removido.

    As chaves pessoais são arquivadas quando seu usuário é removido da organização. Se o usuário for reconvidado, ele precisa criar novas chaves; as chaves arquivadas não são restauradas.
  </Accordion>
</AccordionGroup>

## Veja também

* [Admin API](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api)
* [Referência da Admin API](https://platform.claude.com/docs/pt-BR/api/organization)
* [Limites de taxa](https://platform.claude.com/docs/pt-BR/api/rate-limits)
* [Usage and Cost API](https://platform.claude.com/docs/pt-BR/manage-claude/usage-cost-api)