---
title: 工作區
url: https://platform.claude.com/docs/zh-TW/manage-claude/workspaces
description: 使用工作區組織 API 金鑰、管理團隊存取權限並控制成本。
---

工作區（workspaces）提供了一種在組織內組織 API 使用的方式。使用工作區來分隔不同的專案、環境或團隊，同時維持集中式的計費和管理。

## 工作區如何運作

每個組織都有一個**預設工作區（Default Workspace）**，無法重新命名、封存或刪除。當您建立額外的工作區時，您可以為每個工作區指派成員、服務帳戶、API 金鑰和資源限制。

主要特性：

* **工作區識別碼**使用 `wrkspc_` 前綴（例如 `wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ`）
* 每個組織預設**最多 100 個工作區**（已封存的工作區不計入）；如果您需要更多，請聯繫您的客戶團隊
* **預設工作區**與其他工作區一樣具有 `wrkspc_` ID（會在 [`anthropic-workspace-id` 回應標頭](https://platform.claude.com/docs/zh-TW/manage-claude/workspaces#identify-the-workspace-behind-an-api-response)中傳回，且 [Get Workspace](https://platform.claude.com/docs/zh-TW/api/organization/workspaces/retrieve) 接受此 ID），但只有在您傳入 `include_default=true` 時，它才會出現在 [List Workspaces](https://platform.claude.com/docs/zh-TW/api/organization/workspaces/list) 的結果中，而 API 金鑰、使用量報告和成本報告中其 `workspace_id` 顯示為 `null`，適用於所有工作區的 API 金鑰也是如此（API 金鑰的 `scope` 欄位可區分兩者；對於綁定至預設工作區的金鑰，該欄位會帶有真實 ID）
* **API 金鑰**可以限定於單一工作區。在這種情況下，它們只能存取該工作區內的資源。某些 API 金鑰可以被授予跨多個工作區的權限，並提供[工作區 ID 標頭](https://platform.claude.com/docs/zh-TW/manage-claude/authentication#select-a-workspace)以存取該工作區內的資源

### Claude Code 工作區

當您組織的成員首次使用其 Claude Console 帳戶登入 [Claude Code](https://code.claude.com/docs/en/overview) 時，Anthropic 會自動在組織中建立一個 **Claude Code** 工作區並將該成員加入其中。每個後續登入 Claude Code 的成員都會以相同方式被加入。

Claude Code 工作區將 Claude Code 流量與您的其他 API 工作負載分開：

* Claude Code 在登入時於此工作區中鑄造每位使用者的 API 金鑰。您無法從 Console 手動在其中建立金鑰。
* 與工作區金鑰不同，如果 Claude Code 金鑰的擁有者從工作區或組織中被移除，該金鑰將停止運作。
* Claude Code 的使用量會單獨進行速率限制，管理員可以在 Claude Console 的[速率限制](https://platform.claude.com/usage/limits)頁面上限制其在組織限制中所佔的份額。
* 它是唯一支援每位使用者每月支出限制的工作區。

<Warning>
  封存 Claude Code 工作區會停用整個組織透過 Console 計費的 Claude Code 登入。
</Warning>

## 工作區角色和權限

成員在每個工作區中可以擁有不同的角色，允許細粒度的存取控制。

| 角色                          | 權限                                     |
| --------------------------- | -------------------------------------- |
| Workspace User              | 僅使用 playground                         |
| Workspace Limited Developer | 建立和管理 API 金鑰、使用 API。無法存取工作階段追蹤檢視或下載檔案。 |
| Workspace Developer         | 建立和管理 API 金鑰、使用 API                    |
| Workspace Admin             | 完全控制工作區設定和成員                           |
| Workspace Billing           | 檢視工作區計費資訊（繼承自組織計費角色）                   |

### 角色繼承

* **組織管理員**自動獲得所有工作區的 Workspace Admin 存取權限
* **組織計費成員**自動獲得所有工作區的 Workspace Billing 存取權限
* **組織使用者和開發者**必須被明確加入每個工作區
* **服務帳戶**是在 Claude Console 的[服務帳戶](https://platform.claude.com/settings/service-accounts)頁面（`platform.claude.com/settings/service-accounts`）上加入工作區：在帳戶的選單中或其專屬頁面上選擇**加入工作區**。若要查看某個工作區中的帳戶，請依工作區篩選清單。

<Note>
  Workspace Billing 角色無法手動指派。它繼承自擁有組織計費角色。
</Note>

## 管理工作區

<Note>
  只有組織管理員可以建立工作區。組織使用者和開發者必須由管理員加入工作區。
</Note>

### 使用 Console

在 [Claude Console](https://platform.claude.com/settings/workspaces) 中建立和管理工作區。

#### 建立工作區

<Steps>
  <Step title="開啟工作區設定">
    在 Claude Console 中，前往[工作區](https://platform.claude.com/settings/workspaces)頁面（`platform.claude.com/settings/workspaces`）。
  </Step>

  <Step title="開啟「建立工作區」頁面">
    點擊**建立工作區**以開啟 Console 中的[建立工作區](https://platform.claude.com/settings/workspaces/new)頁面（`platform.claude.com/settings/workspaces/new`）。
  </Step>

  <Step title="設定工作區">
    輸入工作區名稱並選擇一種顏色以便視覺識別。
  </Step>

  <Step title="建立工作區">
    點擊**建立工作區**以完成。
  </Step>
</Steps>

<Tip>
  若要在 Console 中切換工作區，請開啟屬於某個工作區的頁面，例如[檔案](https://platform.claude.com/files)（`platform.claude.com/files`），並使用側邊欄中的工作區選擇器。
</Tip>

#### 編輯工作區詳細資訊

若要修改工作區的名稱或顏色：

1. 從清單中選擇工作區。
2. 開啟**更多動作**選單（三個點）並選擇**編輯詳細資訊**。
3. 更新名稱或顏色並儲存您的變更。

<Note>
  預設工作區無法重新命名或刪除。
</Note>

#### 將成員加入工作區

1. 在 Claude Console 中，前往[成員](https://platform.claude.com/settings/members)頁面（`platform.claude.com/settings/members`）。
2. 點擊**加入工作區**。
3. 選擇工作區、要加入的組織成員，以及其[工作區角色](https://platform.claude.com/docs/zh-TW/manage-claude/workspaces#workspace-roles-and-permissions)。
4. 點擊**加入工作區**以確認。

#### 從工作區移除成員

1. 在 Claude Console 的[成員](https://platform.claude.com/settings/members)頁面上，從**工作區**下拉選單中選擇工作區。如果顯示的是**全部**，**移除成員**會改為將該成員從您的組織中移除。
2. 在該成員所在列的末端，開啟**更多動作**選單（三個點）並選擇**移除成員**。
3. 點擊**移除**以確認。

<Note>
  組織管理員和計費成員在擁有這些組織角色時無法從工作區中被移除。
</Note>

#### 設定工作區限制

您需要在不同的位置設定工作區的速率限制和支出限制：

* **速率限制：**&#x5728; Claude Console 的[速率限制](https://platform.claude.com/usage/limits)頁面上，從**工作區**下拉選單中選擇工作區，然後點擊模型旁的**編輯**，以設定每分鐘請求數、輸入 token 或輸出 token 的限制。
* **支出限制：**&#x5728; Claude Console 的[工作區](https://platform.claude.com/settings/workspaces)頁面上選擇工作區。在開啟的面板中，點擊**支出限制**以設定每月支出上限，並設定支出達到特定門檻時的警示。

#### 封存工作區

若要封存工作區，請開啟其**更多動作**選單（三個點）並選擇**封存工作區**。封存會：

* 保留歷史資料以供報告使用
* 停用工作區並封存為其建立的每個 API 金鑰
* 無法復原

<Warning>
  封存工作區會在幾秒內封存為該工作區建立的每個 API 金鑰（它們在 Admin API 中仍列為已封存），且多工作區金鑰無法再在其中運作。此操作無法復原。如果您封存 [Claude Code 工作區](https://platform.claude.com/docs/zh-TW/manage-claude/workspaces#claude-code-workspace)，您組織的成員將無法再透過 Console 計費登入 Claude Code。
</Warning>

### 使用 Admin API

使用 [Admin API](https://platform.claude.com/docs/zh-TW/manage-claude/admin-api) 以程式化方式管理工作區。

<Note>
  Admin API 端點接受 [Admin API 金鑰](https://platform.claude.com/docs/zh-TW/manage-claude/admin-api-keys)、`org:admin` OAuth token，或未限定於特定工作區的個人或服務帳戶金鑰。工作區金鑰在此無法運作。請參閱[驗證](https://platform.claude.com/docs/zh-TW/manage-claude/admin-api#authentication)。
</Note>

以下 SDK 和 CLI 範例會建構預設用戶端，該用戶端會從 `ANTHROPIC_API_KEY` 環境變數讀取 Admin API 金鑰；SDK 在 `client.organization.workspaces` (csharp, go: `client.Organization.Workspaces`; java: `client.organization().workspaces()`; php: `$client->organization->workspaces`) 下公開這些端點。SDK 的列表方法會依需求擷取後續頁面，因此 `limit` 設定的是頁面大小；PHP、Ruby 和 curl 範例只會傳回一頁。

建立工作區：

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

列出工作區：

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

封存工作區：

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

如需完整的參數詳細資訊和回應結構描述，請參閱 [Workspaces API 參考](https://platform.claude.com/docs/zh-TW/api/organization/workspaces/retrieve)。

### 管理工作區成員

將成員加入工作區：

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

更新成員的角色：

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

從工作區移除成員：

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

如需完整的參數詳細資訊，請參閱 [Workspace Members API 參考](https://platform.claude.com/docs/zh-TW/api/organization/workspaces/members/retrieve)。

## API 金鑰和資源範圍

每個請求都在恰好一個工作區中執行，且只能存取該工作區內的資源。取決於[金鑰類型](https://platform.claude.com/docs/zh-TW/manage-claude/authentication#key-types)的是哪個工作區：

* **工作區金鑰**（沒有擁有者的舊版金鑰）屬於它被建立的工作區，並始終在那裡執行。
* **個人金鑰**或**服務帳戶金鑰**作為其使用者或服務帳戶運作。單一工作區金鑰始終在建立時選擇的工作區中執行。多工作區金鑰在每個請求的 `anthropic-workspace-id` 標頭所指定的工作區中執行。帳戶必須有權存取該工作區才能使用它。

限定於工作區的資源包括：

* 透過 [Files API](https://platform.claude.com/docs/zh-TW/build-with-claude/files) 建立的**檔案**
* 透過 [Batch API](https://platform.claude.com/docs/zh-TW/build-with-claude/batch-processing) 建立的**訊息批次**
* 透過 [Skills API](https://platform.claude.com/docs/zh-TW/build-with-claude/skills-guide) 建立的**技能**

某些資源的管理方式不同：

* **[MCP 通道](https://platform.claude.com/docs/zh-TW/agents-and-tools/mcp-tunnels/overview)**&#x4F7F;用透過[工作負載身分聯合](https://platform.claude.com/docs/zh-TW/manage-claude/workload-identity-federation)取得的 `workspace:manage_tunnels` OAuth token 管理，而非 API 金鑰。通道在工作區中建立，Console 的 **MCP 通道**清單和 Managed Agent 伺服器選擇器僅顯示目前工作區中的通道；10 個活躍通道的上限適用於整個組織。通道管理需要具有通道管理權限的角色；組織開發者可以檢視但無法變更它們。
* **工作區**本身和**組織成員**在組織層級透過 [Admin API](https://platform.claude.com/docs/zh-TW/manage-claude/admin-api) 管理，使用 Admin API 金鑰、`org:admin` OAuth token，或未限定於特定工作區的個人或服務帳戶金鑰。

若要查詢您組織的工作區 ID，請呼叫 [List Workspaces](https://platform.claude.com/docs/zh-TW/api/organization/workspaces/list) 端點（傳入 `include_default=true` 以包含預設工作區），或在 [Claude Console](https://platform.claude.com/settings/workspaces) 中找到它們。

<Note>
  在 Claude API、[Claude Platform on AWS](https://platform.claude.com/docs/zh-TW/build-with-claude/claude-platform-on-aws) 和 [Microsoft Foundry](https://platform.claude.com/docs/zh-TW/build-with-claude/claude-in-microsoft-foundry) 上，[提示快取](https://platform.claude.com/docs/zh-TW/build-with-claude/prompt-caching)也會按工作區隔離。在 Amazon Bedrock 和 Google Cloud 上，提示快取按組織隔離。
</Note>

## 識別 API 回應背後的工作區

Claude API 回應在 `request-id` 和 `anthropic-organization-id` [回應標頭](https://platform.claude.com/docs/zh-TW/api/overview#response-headers)旁包含一個 `anthropic-workspace-id` 標頭。其值是請求的 API 金鑰或存取 token 解析到的工作區的 `wrkspc_` 前綴 ID，包括當該工作區是預設工作區時。例如，成功的回應包含如下標頭：

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

當憑證未解析到工作區時（例如在 Admin API 請求上），或當請求在驗證完成前失敗時（例如 401 錯誤），該標頭不存在。

以下範例傳送 Messages API 請求並從回應標頭列印工作區 ID：

<CodeGroup>
  ```bash cURL
  # -D - 印出回應標頭；-o /dev/null 捨棄主體
  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 會將 HTTP 回應（包含 Anthropic-Workspace-Id
  # 標頭）印出至 stderr；> /dev/null 則隱藏 stdout 上的 JSON 主體
  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

  # 在每個請求的中介軟體中讀取回應標頭，該中介軟體會接收
  # SDK 解析前的原始 HTTP 回應
  workspace_id = nil
  read_workspace_id = lambda do |request, call_next|
    response = call_next.call(request)
    # response.headers 中的鍵為小寫
    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
```

相同的存取器也可以從其他 Claude API 端點讀取該標頭，包括 [Claude Managed Agents](https://platform.claude.com/docs/zh-TW/managed-agents/overview) API。例如，從[建立工作階段](https://platform.claude.com/docs/zh-TW/managed-agents/sessions)的回應中讀取 `anthropic-workspace-id`，以記錄該工作階段屬於哪個工作區。

有了來自回應的工作區 ID，您可以：

* 確認請求計入哪個工作區的使用量、成本和[速率限制](https://platform.claude.com/docs/zh-TW/api/rate-limits)
* 將其與[使用量和成本 API](https://platform.claude.com/docs/zh-TW/manage-claude/usage-cost-api) 報告中以及 [Admin API](https://platform.claude.com/docs/zh-TW/manage-claude/admin-api) 物件（例如 API 金鑰）上的 `workspace_id` 欄位進行比對（兩者對於預設工作區都回報 `null`，API 金鑰對於所有工作區金鑰也是如此；API 金鑰的 `scope` 欄位可以區分這兩者，而對於綁定到一個工作區的金鑰，它會帶有該工作區的真實 ID）
* 使用 [Admin API 金鑰](https://platform.claude.com/docs/zh-TW/manage-claude/admin-api-keys)將其傳入 [Get Workspace](https://platform.claude.com/docs/zh-TW/api/organization/workspaces/retrieve)，以檢查它是否為您預設工作區的 ID：預設工作區會以 `"name": "Default"` 傳回，即使 [List Workspaces](https://platform.claude.com/docs/zh-TW/api/organization/workspaces/list) 在您未傳入 `include_default=true` 時會省略它
* 在 [Console](https://platform.claude.com/settings/workspaces) 中開啟該工作區以找到請求的資源，例如工作階段、檔案、訊息批次和技能

## 工作區限制

您可以為每個工作區設定自訂的支出和速率限制，以防止過度使用並確保公平的資源分配。

### 設定工作區限制

您可以將工作區限制設定為低於（但不高於）您組織的限制：

* **支出限制：**&#x8A2D;定工作區的每月支出上限。若要設定，請前往 Claude Console 中的[工作區](https://platform.claude.com/settings/workspaces)頁面（`platform.claude.com/settings/workspaces`）並選擇工作區。在開啟的面板中，點擊**支出限制**。
* **速率限制：**&#x9650;制每分鐘請求數、每分鐘輸入 token 數或每分鐘輸出 token 數。若要設定這些限制，請前往 Claude Console 中的[速率限制](https://platform.claude.com/usage/limits)頁面，從**工作區**下拉選單中選擇工作區，然後點擊模型旁的**編輯**。

<Note>
  - 您無法在預設工作區上設定限制
  - 如果未設定，工作區限制與組織的限制相符
  - 即使工作區限制加總起來更多，組織範圍的限制始終適用
</Note>

有關速率限制及其運作方式的詳細資訊，請參閱[速率限制](https://platform.claude.com/docs/zh-TW/api/rate-limits)。您也可以使用[速率限制 API](https://platform.claude.com/docs/zh-TW/manage-claude/rate-limits-api) 以程式化方式讀取您目前的組織和工作區速率限制。

## 使用量和成本追蹤

使用[使用量和成本 API](https://platform.claude.com/docs/zh-TW/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"
```

歸因於預設工作區的使用量和成本的 `workspace_id` 值為 `null`。

## 常見使用案例

### 環境分隔

為開發、預備和生產建立獨立的工作區：

| 工作區 | 用途               |
| --- | ---------------- |
| 開發  | 使用較低速率限制進行測試和實驗  |
| 預備  | 使用類似生產的限制進行預生產測試 |
| 生產  | 具有完整速率限制和監控的即時流量 |

### 團隊或部門隔離

為不同團隊指派工作區以進行成本分配和存取控制：

* 具有開發者存取權限的**工程團隊**
* 擁有自己 API 金鑰的**資料科學團隊**
* 具有客戶工具有限存取權限的**支援團隊**

### 基於專案的組織

為特定專案或產品建立工作區，以分別追蹤使用量和成本。

## 最佳實踐

<Steps>
  <Step title="規劃您的工作區結構">
    在建立工作區之前，考慮您將如何組織工作區。思考計費、存取控制和使用量追蹤的需求。
  </Step>

  <Step title="使用有意義的名稱">
    清楚地命名工作區以指示其用途（例如「生產 - 客戶聊天機器人」或「開發 - 內部工具」）。
  </Step>

  <Step title="設定適當的限制">
    設定支出和速率限制以防止意外成本並確保公平的資源分配。
  </Step>

  <Step title="定期稽核存取權限">
    定期檢視工作區成員資格，以確保只有適當的使用者擁有存取權限。
  </Step>

  <Step title="監控使用量">
    使用[使用量和成本 API](https://platform.claude.com/docs/zh-TW/manage-claude/usage-cost-api) 追蹤工作區層級的消耗。
  </Step>
</Steps>

## 常見問題

<AccordionGroup>
  <Accordion title="什麼是預設工作區？">
    每個組織都有一個「預設工作區」，無法重新命名、封存或刪除。與每個工作區一樣，它具有 `wrkspc_` ID：API 會在 [`anthropic-workspace-id` 回應標頭](https://platform.claude.com/docs/zh-TW/manage-claude/workspaces#identify-the-workspace-behind-an-api-response)中傳回它，您也可以將它傳入 [Get Workspace](https://platform.claude.com/docs/zh-TW/api/organization/workspaces/retrieve) 和 [Update Workspace](https://platform.claude.com/docs/zh-TW/api/organization/workspaces/update)。它沒有自己的成員清單，因為其存取權限取決於每位成員的組織角色。只有在您傳入 `include_default=true` 時，它才會出現在 [List Workspaces](https://platform.claude.com/docs/zh-TW/api/organization/workspaces/list) 的結果中，而屬於它的 API 金鑰、使用量報告和成本報告的 `workspace_id` 顯示為 `null`，適用於所有工作區的 API 金鑰也是如此；API 金鑰的 `scope` 欄位可區分兩者，且對於屬於預設工作區的金鑰，該欄位會帶有其真實 ID。
  </Accordion>

  <Accordion title="什麼是 Claude Code 工作區？">
    當您組織的成員首次使用其 Console 帳戶登入 Claude Code 時，Anthropic 會自動建立 Claude Code 工作區。它將 Claude Code 的 API 金鑰、使用量和速率限制與您的其他工作負載隔離。有關詳細資訊，請參閱 [Claude Code 工作區](https://platform.claude.com/docs/zh-TW/manage-claude/workspaces#claude-code-workspace)。
  </Accordion>

  <Accordion title="工作區有限制嗎？">
    有。每個組織預設最多可以有 100 個工作區，已封存的工作區不計入此限制。如果您需要更多，請聯繫您的客戶團隊。
  </Accordion>

  <Accordion title="組織角色如何影響工作區存取？">
    組織管理員自動在所有工作區中獲得 Workspace Admin 角色。組織計費成員自動獲得 Workspace Billing 角色。組織使用者和開發者必須手動加入每個工作區。
  </Accordion>

  <Accordion title="工作區中可以指派哪些角色？">
    組織使用者和開發者可以被指派 Workspace Admin、Workspace Developer、Workspace Limited Developer 或 Workspace User 角色。Workspace Billing 角色無法手動指派；它繼承自擁有組織 `billing` 角色。
  </Accordion>

  <Accordion title="組織管理員或計費成員的工作區角色可以變更嗎？">
    組織管理員和計費成員在擁有這些組織角色時，其工作區角色無法變更，也無法從工作區中被移除（有一個例外：計費成員可以升級為 Workspace Admin 角色）。對於受此限制約束的其他所有人，請先變更其組織角色以變更其工作區存取權限。
  </Accordion>

  <Accordion title="當組織角色變更時，工作區存取會發生什麼？">
    如果組織管理員或計費成員被降級為使用者或開發者，他們將失去對所有工作區的存取權限，除了他們被手動指派角色的工作區。當使用者被提升為管理員或計費角色時，他們會自動獲得對所有工作區的存取權限。
  </Accordion>

  <Accordion title="當使用者從工作區中被移除時，API 金鑰會發生什麼？">
    行為取決於[金鑰類型](https://platform.claude.com/docs/zh-TW/manage-claude/authentication#key-types)。

    個人或服務帳戶金鑰在其使用者或服務帳戶從工作區中被移除後不久就會停止在該工作區中運作。即使建立服務帳戶金鑰的使用者被移除，該金鑰仍會繼續運作。工作區 API 金鑰會繼續運作。在 [Claude Code 工作區](https://platform.claude.com/docs/zh-TW/manage-claude/workspaces#claude-code-workspace)中，每個金鑰都綁定到建立它的成員，並在該成員被移除時停止運作。

    當使用者從組織中被移除時，個人金鑰會被封存。如果使用者被重新邀請，他們需要建立新金鑰；已封存的金鑰不會被還原。
  </Accordion>
</AccordionGroup>

## 另請參閱

* [Admin API](https://platform.claude.com/docs/zh-TW/manage-claude/admin-api)
* [Admin API 參考](https://platform.claude.com/docs/zh-TW/api/organization)
* [速率限制](https://platform.claude.com/docs/zh-TW/api/rate-limits)
* [使用量和成本 API](https://platform.claude.com/docs/zh-TW/manage-claude/usage-cost-api)