---
title: ワークスペース
url: https://platform.claude.com/docs/ja/manage-claude/workspaces
description: APIキーを整理し、チームアクセスを管理し、ワークスペースでコストを制御します。
---

ワークスペースは、組織内でのAPI使用を整理する方法を提供します。ワークスペースを使用して、一元化された請求と管理を維持しながら、異なるプロジェクト、環境、またはチームを分離します。

## ワークスペースの仕組み

すべての組織には、名前の変更、アーカイブ、削除ができない**Default Workspace**があります。追加のワークスペースを作成すると、メンバー、サービスアカウント、APIキー、リソース制限をそれぞれに割り当てることができます。

主な特徴:

* **ワークスペース識別子**は`wrkspc_`プレフィックスを使用します（例: `wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ`）
* デフォルトで組織ごとに**最大100ワークスペース**（アーカイブされたワークスペースはカウントされません）。さらに必要な場合はアカウントチームにお問い合わせください
* **Default Workspace**は他のワークスペースと同様に`wrkspc_` IDを持ちます（[`anthropic-workspace-id`レスポンスヘッダー](https://platform.claude.com/docs/ja/manage-claude/workspaces#identify-the-workspace-behind-an-api-response)で返され、[Get Workspace](https://platform.claude.com/docs/ja/api/organization/workspaces/retrieve)で受け付けられます）が、[List Workspaces](https://platform.claude.com/docs/ja/api/organization/workspaces/list)の結果には`include_default=true`を渡した場合にのみ表示されます。また、APIキー、使用状況レポート、コストレポートではその`workspace_id`が`null`と表示されます。すべてのワークスペースを対象とするAPIキーも同様です（APIキーの`scope`フィールドで両者を区別でき、Default Workspaceにバインドされたキーの場合は実際のIDが含まれます）
* **APIキー**は単一のワークスペースにスコープを設定できます。この場合、そのワークスペース内のリソースにのみアクセスできます。一部のAPIキーは複数のワークスペースにわたる権限を付与でき、そのワークスペース内のリソースにアクセスするために[ワークスペースIDヘッダー](https://platform.claude.com/docs/ja/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の[Rate limits](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の[Service accounts](https://platform.claude.com/settings/service-accounts)ページ（`platform.claude.com/settings/service-accounts`）でワークスペースに追加します。アカウントのメニューまたはアカウント自体のページで**Add to workspace**を選択してください。1つのワークスペース内のアカウントを確認するには、リストをワークスペースでフィルタリングします。

<Note>
  Workspace Billingロールは手動で割り当てることはできません。組織の請求ロールを持つことから継承されます。
</Note>

## ワークスペースの管理

<Note>
  組織管理者のみがワークスペースを作成できます。組織ユーザーと開発者は管理者によってワークスペースに追加される必要があります。
</Note>

### Consoleの使用

[Claude Console](https://platform.claude.com/settings/workspaces)でワークスペースを作成および管理します。

#### ワークスペースの作成

<Steps>
  <Step title="ワークスペース設定を開く">
    Claude Consoleで、[Workspaces](https://platform.claude.com/settings/workspaces)ページ（`platform.claude.com/settings/workspaces`）に移動します。
  </Step>

  <Step title="Create workspaceページを開く">
    **Create workspace**をクリックして、Consoleの[Create workspace](https://platform.claude.com/settings/workspaces/new)ページ（`platform.claude.com/settings/workspaces/new`）を開きます。
  </Step>

  <Step title="ワークスペースを設定する">
    ワークスペース名を入力し、視覚的に識別するための色を選択します。
  </Step>

  <Step title="ワークスペースの作成を完了する">
    **Create workspace**をクリックして確定します。
  </Step>
</Steps>

<Tip>
  Consoleでワークスペースを切り替えるには、[Files](https://platform.claude.com/files)（`platform.claude.com/files`）など、ワークスペースに属するページを開き、サイドバーのワークスペースピッカーを使用します。
</Tip>

#### ワークスペースの詳細を編集する

ワークスペースの名前または色を変更するには:

1. リストからワークスペースを選択します。
2. **More actions**メニュー（3つのドット）を開き、**Edit details**を選択します。
3. 名前または色を更新し、変更を保存します。

<Note>
  Default Workspaceは名前の変更や削除ができません。
</Note>

#### ワークスペースにメンバーを追加する

1. Claude Consoleで、[Members](https://platform.claude.com/settings/members)ページ（`platform.claude.com/settings/members`）に移動します。
2. **Add to workspace**をクリックします。
3. ワークスペース、追加する組織メンバー、およびその[ワークスペースロール](https://platform.claude.com/docs/ja/manage-claude/workspaces#workspace-roles-and-permissions)を選択します。
4. **Add to workspace**をクリックして確定します。

#### ワークスペースからメンバーを削除する

1. Claude Consoleの[Members](https://platform.claude.com/settings/members)ページで、**Workspace**ドロップダウンメニューからワークスペースを選択します。**All**と表示されている場合、**Remove member**を実行すると、メンバーはワークスペースではなく組織から削除されます。
2. メンバーの行の末尾で**More actions**メニュー（3つのドット）を開き、**Remove member**を選択します。
3. **Remove**をクリックして確定します。

<Note>
  組織管理者と請求メンバーは、それらの組織ロールを保持している間はワークスペースから削除できません。
</Note>

#### ワークスペースの制限を設定する

ワークスペースのレート制限と支出制限は、それぞれ異なる場所で設定します:

* **レート制限：** Claude Consoleの[Rate limits](https://platform.claude.com/usage/limits)ページで、**Workspace**ドロップダウンメニューからワークスペースを選択し、モデルの横にある**Edit**をクリックして、1分あたりのリクエスト数、入力トークン数、または出力トークン数の制限を設定します。
* **支出制限：** Claude Consoleの[Workspaces](https://platform.claude.com/settings/workspaces)ページで、ワークスペースを選択します。開いたパネルで**Spend limits**をクリックして、月間支出に上限を設定し、支出が特定のしきい値に達したときのアラートを設定します。

#### ワークスペースをアーカイブする

ワークスペースをアーカイブするには、その**More actions**メニュー（3つのドット）を開き、**Archive workspace**を選択します。アーカイブすると:

* レポート用に履歴データを保持します
* ワークスペースを無効化し、そのために作成されたすべてのAPIキーをアーカイブします
* 元に戻すことはできません

<Warning>
  ワークスペースをアーカイブすると、そのワークスペース用に作成されたすべてのAPIキーが数秒以内にアーカイブされ（Admin APIではアーカイブ済みとしてリストに残ります）、マルチワークスペースキーはそこで動作できなくなります。このアクションは元に戻せません。[Claude Codeワークスペース](https://platform.claude.com/docs/ja/manage-claude/workspaces#claude-code-workspace)をアーカイブすると、組織のメンバーはConsole請求を通じてClaude Codeにサインインできなくなります。
</Warning>

### Admin APIの使用

[Admin API](https://platform.claude.com/docs/ja/manage-claude/admin-api)を使用してプログラムでワークスペースを管理します。

<Note>
  Admin APIエンドポイントは、[Admin APIキー](https://platform.claude.com/docs/ja/manage-claude/admin-api-keys)、`org:admin` OAuthトークン、または特定のワークスペースにスコープされていない個人またはサービスアカウントキーを受け入れます。ワークスペースキーはそこでは機能しません。[認証](https://platform.claude.com/docs/ja/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の例は1ページを返します。

ワークスペースを作成する:

<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/ja/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/ja/api/organization/workspaces/members/retrieve)を参照してください。

## APIキーとリソースのスコープ

すべてのリクエストは正確に1つのワークスペースで実行され、そのワークスペース内のリソースにのみアクセスできます。どのワークスペースかは[キータイプ](https://platform.claude.com/docs/ja/manage-claude/authentication#key-types)によって異なります:

* **ワークスペースキー**（所有者のないレガシーキー）は、作成されたワークスペースに属し、常にそこで実行されます。
* **個人キー**または**サービスアカウントキー**は、そのユーザーまたはサービスアカウントとして動作します。単一ワークスペースキーは、作成時に選択されたワークスペースで常に実行されます。マルチワークスペースキーは、各リクエストの`anthropic-workspace-id`ヘッダーで指定されたワークスペースで実行されます。アカウントはそれを使用するためにワークスペースへのアクセス権を持っている必要があります。

ワークスペースにスコープされるリソースには以下が含まれます:

* [Files API](https://platform.claude.com/docs/ja/build-with-claude/files)を通じて作成された**ファイル**
* [Batch API](https://platform.claude.com/docs/ja/build-with-claude/batch-processing)を通じて作成された**Message Batches**
* [Skills API](https://platform.claude.com/docs/ja/build-with-claude/skills-guide)を通じて作成された**Skills**

一部のリソースは異なる方法で管理されます:

* **[MCPトンネル](https://platform.claude.com/docs/ja/agents-and-tools/mcp-tunnels/overview)**&#x306F;、APIキーではなく、[Workload Identity Federation](https://platform.claude.com/docs/ja/manage-claude/workload-identity-federation)を通じて取得した`workspace:manage_tunnels` OAuthトークンで管理されます。トンネルはワークスペース内で作成され、Consoleの**MCP tunnels**リストとManaged Agentサーバーピッカーは現在のワークスペース内のトンネルのみを表示します。アクティブなトンネル10個の上限は組織全体に適用されます。トンネル管理にはトンネル管理権限を持つロールが必要です。組織開発者は表示できますが変更はできません。
* **ワークスペース**自体と**組織メンバー**は、Admin APIキー、`org:admin` OAuthトークン、または特定のワークスペースにスコープされていない個人またはサービスアカウントキーを使用して、[Admin API](https://platform.claude.com/docs/ja/manage-claude/admin-api)を通じて組織レベルで管理されます。

組織のワークスペースIDを調べるには、[List Workspaces](https://platform.claude.com/docs/ja/api/organization/workspaces/list)エンドポイントを呼び出す（Default Workspaceを含めるには`include_default=true`を渡します）か、[Claude Console](https://platform.claude.com/settings/workspaces)で確認してください。

<Note>
  [プロンプトキャッシュ](https://platform.claude.com/docs/ja/build-with-claude/prompt-caching)も、Claude API、[Claude Platform on AWS](https://platform.claude.com/docs/ja/build-with-claude/claude-platform-on-aws)、および[Microsoft Foundry](https://platform.claude.com/docs/ja/build-with-claude/claude-in-microsoft-foundry)ではワークスペースごとに分離されます。Amazon BedrockおよびGoogle Cloudでは、プロンプトキャッシュは組織ごとに分離されます。
</Note>

## APIレスポンスの背後にあるワークスペースを特定する

Claude APIレスポンスには、`request-id`および`anthropic-organization-id`[レスポンスヘッダー](https://platform.claude.com/docs/ja/api/overview#response-headers)とともに`anthropic-workspace-id`ヘッダーが含まれます。その値は、リクエストのAPIキーまたはアクセストークンが解決したワークスペースの`wrkspc_`プレフィックス付きIDで、そのワークスペースがDefault Workspaceである場合も含まれます。たとえば、成功したレスポンスには次のようなヘッダーが含まれます:

```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 Managed Agents](https://platform.claude.com/docs/ja/managed-agents/overview) APIを含む他のClaude APIエンドポイントからもヘッダーを読み取ります。たとえば、[セッションを作成する](https://platform.claude.com/docs/ja/managed-agents/sessions)レスポンスから`anthropic-workspace-id`を読み取って、セッションがどのワークスペースに属するかを記録します。

レスポンスからのワークスペースIDを使用すると、次のことができます:

* リクエストがどのワークスペースの使用状況、コスト、[レート制限](https://platform.claude.com/docs/ja/api/rate-limits)にカウントされたかを確認する
* [Usage and Cost API](https://platform.claude.com/docs/ja/manage-claude/usage-cost-api)レポートの`workspace_id`フィールドや、APIキーなどの[Admin API](https://platform.claude.com/docs/ja/manage-claude/admin-api)オブジェクトと照合する（どちらもDefault Workspaceには`null`を報告します。APIキーは全ワークスペースキーについても同様です。APIキーの`scope`フィールドで両者を区別し、1つのワークスペースにバインドされたキーの場合はそのワークスペースの実際のIDを保持します）
* [Admin APIキー](https://platform.claude.com/docs/ja/manage-claude/admin-api-keys)を使用して[Get Workspace](https://platform.claude.com/docs/ja/api/organization/workspaces/retrieve)に渡すことで、それがDefault WorkspaceのIDかどうかを確認する：[List Workspaces](https://platform.claude.com/docs/ja/api/organization/workspaces/list)では`include_default=true`を渡さない限り省略されますが、Default Workspaceは`"name": "Default"`として返されます
* [Console](https://platform.claude.com/settings/workspaces)でそのワークスペースを開いて、セッション、ファイル、メッセージバッチ、スキルなどのリクエストのリソースを見つける

## ワークスペースの制限

各ワークスペースにカスタムの支出制限とレート制限を設定して、過剰使用を防ぎ、公平なリソース分配を確保できます。

### ワークスペースの制限を設定する

ワークスペースの制限は、組織の制限より低く（ただし高くはできません）設定できます:

* **支出制限：** ワークスペースの月間支出に上限を設定します。設定するには、Claude Consoleの[Workspaces](https://platform.claude.com/settings/workspaces)ページ（`platform.claude.com/settings/workspaces`）に移動し、ワークスペースを選択します。開いたパネルで**Spend limits**をクリックします。
* **レート制限:** 1分あたりのリクエスト数、1分あたりの入力トークン数、または1分あたりの出力トークン数を制限します。設定するには、Claude Consoleの[Rate limits](https://platform.claude.com/usage/limits)ページに移動し、**Workspace**ドロップダウンメニューからワークスペースを選択して、モデルの横にある**Edit**をクリックします。

<Note>
  - Default Workspaceには制限を設定できません
  - 設定されていない場合、ワークスペースの制限は組織の制限と一致します
  - ワークスペースの制限の合計がそれを超える場合でも、組織全体の制限が常に適用されます
</Note>

レート制限とその仕組みに関する詳細情報については、[レート制限](https://platform.claude.com/docs/ja/api/rate-limits)を参照してください。[Rate Limits API](https://platform.claude.com/docs/ja/manage-claude/rate-limits-api)を使用して、現在の組織およびワークスペースのレート制限をプログラムで読み取ることもできます。

## 使用状況とコストの追跡

[Usage and Cost API](https://platform.claude.com/docs/ja/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"
```

Default Workspaceに帰属する使用状況とコストは、`workspace_id`に`null`値を持ちます。

## 一般的なユースケース

### 環境の分離

開発、ステージング、本番用に別々のワークスペースを作成します:

| ワークスペース     | 目的                       |
| ----------- | ------------------------ |
| Development | より低いレート制限でのテストと実験        |
| Staging     | 本番に近い制限での本番前テスト          |
| Production  | 完全なレート制限と監視を備えたライブトラフィック |

### チームまたは部門の分離

コスト配分とアクセス制御のために、異なるチームにワークスペースを割り当てます:

* 開発者アクセスを持つ**エンジニアリングチーム**
* 独自のAPIキーを持つ**データサイエンスチーム**
* 顧客ツール用の限定アクセスを持つ**サポートチーム**

### プロジェクトベースの組織化

特定のプロジェクトや製品のワークスペースを作成して、使用状況とコストを個別に追跡します。

## ベストプラクティス

<Steps>
  <Step title="ワークスペース構造を計画する">
    作成する前に、ワークスペースをどのように整理するかを検討します。請求、アクセス制御、使用状況追跡のニーズについて考えます。
  </Step>

  <Step title="意味のある名前を使用する">
    ワークスペースの目的を示すように明確に名前を付けます（たとえば、「Production - Customer Chatbot」や「Dev - Internal Tools」）。
  </Step>

  <Step title="適切な制限を設定する">
    予期しないコストを防ぎ、公平なリソース分配を確保するために、支出制限とレート制限を設定します。
  </Step>

  <Step title="定期的にアクセスを監査する">
    適切なユーザーのみがアクセスできるように、ワークスペースのメンバーシップを定期的に確認します。
  </Step>

  <Step title="使用状況を監視する">
    [Usage and Cost API](https://platform.claude.com/docs/ja/manage-claude/usage-cost-api)を使用して、ワークスペースレベルの消費量を追跡します。
  </Step>
</Steps>

## よくある質問

<AccordionGroup>
  <Accordion title="Default Workspaceとは何ですか？">
    すべての組織には、名前の変更、アーカイブ、削除ができない「Default Workspace」があります。すべてのワークスペースと同様に`wrkspc_` IDを持ちます。APIは[`anthropic-workspace-id`レスポンスヘッダー](https://platform.claude.com/docs/ja/manage-claude/workspaces#identify-the-workspace-behind-an-api-response)でこのIDを返し、[Get Workspace](https://platform.claude.com/docs/ja/api/organization/workspaces/retrieve)や[Update Workspace](https://platform.claude.com/docs/ja/api/organization/workspaces/update)に渡すことができます。Default Workspaceへのアクセスは各メンバーの組織ロールに従うため、独自のメンバーリストはありません。[List Workspaces](https://platform.claude.com/docs/ja/api/organization/workspaces/list)の結果には`include_default=true`を渡した場合にのみ表示されます。また、Default Workspaceに属するAPIキー、使用状況レポート、コストレポートでは`workspace_id`が`null`と表示されます。すべてのワークスペースを対象とするAPIキーも同様です。APIキーの`scope`フィールドで両者を区別でき、Default Workspaceに属するキーの場合は実際のIDが含まれます。
  </Accordion>

  <Accordion title="Claude Codeワークスペースとは何ですか？">
    Anthropicは、組織のメンバーが初めてConsoleアカウントでClaude Codeにサインインしたときに、Claude Codeワークスペースを自動的に作成します。これはClaude CodeのAPIキー、使用状況、レート制限を他のワークロードから分離します。詳細については[Claude Codeワークスペース](https://platform.claude.com/docs/ja/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="組織管理者または請求メンバーのワークスペースロールを変更できますか？">
    組織管理者と請求メンバーは、それらの組織ロールを保持している間はワークスペースロールを変更したり、ワークスペースから削除したりすることはできません（1つの例外があります: 請求メンバーはWorkspace Adminロールにアップグレードできます）。この制約の対象となる他のすべての人については、ワークスペースアクセスを変更するには、まず組織ロールを変更します。
  </Accordion>

  <Accordion title="組織ロールが変更されたときにワークスペースアクセスはどうなりますか？">
    組織管理者または請求メンバーがユーザーまたは開発者に降格された場合、手動でロールが割り当てられたワークスペースを除くすべてのワークスペースへのアクセスを失います。ユーザーが管理者または請求ロールに昇格されると、すべてのワークスペースへの自動アクセスを取得します。
  </Accordion>

  <Accordion title="ユーザーがワークスペースから削除されたときにAPIキーはどうなりますか？">
    動作は[キータイプ](https://platform.claude.com/docs/ja/manage-claude/authentication#key-types)によって異なります。

    個人またはサービスアカウントキーは、そのユーザーまたはサービスアカウントがワークスペースから削除された直後にそのワークスペースで機能しなくなります。サービスアカウントキーは、それを作成したユーザーが削除されても機能し続けます。ワークスペースAPIキーは機能し続けます。[Claude Codeワークスペース](https://platform.claude.com/docs/ja/manage-claude/workspaces#claude-code-workspace)では、各キーはそれを作成したメンバーにバインドされており、そのメンバーが削除されると機能しなくなります。

    個人キーは、そのユーザーが組織から削除されるとアーカイブされます。ユーザーが再招待された場合、新しいキーを作成する必要があります。アーカイブされたキーは復元されません。
  </Accordion>
</AccordionGroup>

## 関連項目

* [Admin API](https://platform.claude.com/docs/ja/manage-claude/admin-api)
* [Admin APIリファレンス](https://platform.claude.com/docs/ja/api/organization)
* [レート制限](https://platform.claude.com/docs/ja/api/rate-limits)
* [Usage and Cost API](https://platform.claude.com/docs/ja/manage-claude/usage-cost-api)