---
title: 워크스페이스
url: https://platform.claude.com/docs/ko/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/ko/manage-claude/workspaces#identify-the-workspace-behind-an-api-response)로 반환되며 [Get Workspace](https://platform.claude.com/docs/ko/api/organization/workspaces/retrieve)에서 허용됨), [List Workspaces](https://platform.claude.com/docs/ko/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/ko/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 사용량은 별도로 "rate limit"(속도 제한)이 적용되며, 관리자는 Claude Console의 [Rate limits](https://platform.claude.com/usage/limits) 페이지에서 조직 제한 중 Claude Code가 차지하는 비율의 상한을 설정할 수 있습니다.
* 사용자별 월간 지출 한도를 지원하는 유일한 워크스페이스입니다.

<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**를 선택하세요. 한 워크스페이스의 계정을 보려면 목록을 워크스페이스별로 필터링하세요.

<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** 메뉴(점 세 개)를 열고 **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/ko/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** 메뉴(점 세 개)를 열고 **Remove member**를 선택하세요.
3. **Remove**를 클릭하여 확인하세요.

<Note>
  조직 관리자 및 청구 멤버는 해당 조직 역할을 보유하고 있는 동안 워크스페이스에서 제거할 수 없습니다.
</Note>

#### 워크스페이스 제한 설정

워크스페이스의 속도 제한과 지출 한도는 서로 다른 곳에서 설정합니다:

* **속도 제한:** Claude Console의 [Rate limits](https://platform.claude.com/usage/limits) 페이지에 있는 **Workspace** 드롭다운 메뉴에서 워크스페이스를 선택하고 모델 옆의 **Edit**를 클릭하여 분당 요청 수, 입력 토큰 또는 출력 토큰에 대한 제한을 설정하세요.
* **지출 한도:** Claude Console의 [Workspaces](https://platform.claude.com/settings/workspaces) 페이지에서 워크스페이스를 선택하세요. 열리는 패널에서 **Spend limits**를 클릭하여 월간 지출에 상한을 설정하고 지출이 특정 임계값에 도달할 때의 알림을 구성하세요.

#### 워크스페이스 보관

워크스페이스를 보관하려면 해당 워크스페이스의 **More actions** 메뉴(점 세 개)를 열고 **Archive workspace**를 선택하세요. 보관하면:

* 보고를 위한 기록 데이터를 보존합니다
* 워크스페이스를 비활성화하고 해당 워크스페이스에 대해 생성된 모든 API 키를 보관합니다
* 취소할 수 없습니다

<Warning>
  워크스페이스를 보관하면 해당 워크스페이스에 대해 생성된 모든 API 키가 몇 초 내에 보관되며(Admin API에서 보관됨으로 계속 나열됨), 다중 워크스페이스 키는 더 이상 해당 워크스페이스에서 작동할 수 없습니다. 이 작업은 취소할 수 없습니다. [Claude Code 워크스페이스](https://platform.claude.com/docs/ko/manage-claude/workspaces#claude-code-workspace)를 보관하면 조직의 멤버가 더 이상 Console 청구를 통해 Claude Code에 로그인할 수 없습니다.
</Warning>

### Admin API 사용

[Admin API](https://platform.claude.com/docs/ko/manage-claude/admin-api)를 사용하여 프로그래밍 방식으로 워크스페이스를 관리하세요.

<Note>
  Admin API 엔드포인트는 [Admin API 키](https://platform.claude.com/docs/ko/manage-claude/admin-api-keys), `org:admin` OAuth 토큰, 또는 특정 워크스페이스로 범위가 지정되지 않은 개인 또는 서비스 계정 키를 허용합니다. 워크스페이스 키는 여기서 작동하지 않습니다. [Authentication](https://platform.claude.com/docs/ko/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/ko/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/ko/api/organization/workspaces/members/retrieve)를 참조하세요.

## API 키 및 리소스 범위 지정

모든 요청은 정확히 하나의 워크스페이스에서 실행되며 해당 워크스페이스 내의 리소스에만 액세스할 수 있습니다. 어떤 워크스페이스인지는 [키 유형](https://platform.claude.com/docs/ko/manage-claude/authentication#key-types)에 따라 다릅니다:

* **워크스페이스 키**(소유자가 없는 레거시 키)는 생성된 워크스페이스에 속하며 항상 거기서 실행됩니다.
* **개인 키** 또는 **서비스 계정 키**는 해당 사용자 또는 서비스 계정으로 작동합니다. 단일 워크스페이스 키는 생성 시 선택된 워크스페이스에서 항상 실행됩니다. 다중 워크스페이스 키는 각 요청의 `anthropic-workspace-id` 헤더로 지정된 워크스페이스에서 실행됩니다. 계정은 워크스페이스를 사용하려면 해당 워크스페이스에 대한 액세스 권한이 있어야 합니다.

워크스페이스로 범위가 지정된 리소스에는 다음이 포함됩니다:

* [Files API](https://platform.claude.com/docs/ko/build-with-claude/files)를 통해 생성된 **파일**
* [Batch API](https://platform.claude.com/docs/ko/build-with-claude/batch-processing)를 통해 생성된 **Message Batches**
* [Skills API](https://platform.claude.com/docs/ko/build-with-claude/skills-guide)를 통해 생성된 **Skills**

일부 리소스는 다르게 관리됩니다:

* **[MCP 터널](https://platform.claude.com/docs/ko/agents-and-tools/mcp-tunnels/overview)**&#xC740; API 키가 아니라 [Workload Identity Federation](https://platform.claude.com/docs/ko/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/ko/manage-claude/admin-api)를 통해 조직 수준에서 관리됩니다.

조직의 워크스페이스 ID를 조회하려면 [List Workspaces](https://platform.claude.com/docs/ko/api/organization/workspaces/list) 엔드포인트를 호출하거나(Default Workspace를 포함하려면 `include_default=true`를 전달) [Claude Console](https://platform.claude.com/settings/workspaces)에서 찾으세요.

<Note>
  [프롬프트 캐시](https://platform.claude.com/docs/ko/build-with-claude/prompt-caching)도 Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/ko/build-with-claude/claude-platform-on-aws) 및 [Microsoft Foundry](https://platform.claude.com/docs/ko/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/ko/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는 Anthropic-Workspace-Id를 포함한 HTTP 응답을
  # 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/ko/managed-agents/overview) API를 포함한 다른 Claude API 엔드포인트에서도 헤더를 읽습니다. 예를 들어, [세션을 생성하는](https://platform.claude.com/docs/ko/managed-agents/sessions) 응답에서 `anthropic-workspace-id`를 읽어 세션이 속한 워크스페이스를 기록하세요.

응답의 워크스페이스 ID를 사용하여 다음을 수행할 수 있습니다:

* 요청이 어떤 워크스페이스의 사용량, 비용 및 [속도 제한](https://platform.claude.com/docs/ko/api/rate-limits)에 집계되었는지 확인
* [Usage and Cost API](https://platform.claude.com/docs/ko/manage-claude/usage-cost-api) 보고서 및 API 키와 같은 [Admin API](https://platform.claude.com/docs/ko/manage-claude/admin-api) 객체의 `workspace_id` 필드와 대조(둘 다 Default Workspace에 대해 `null`을 보고하며, API 키는 모든 워크스페이스 키에 대해서도 `null`을 보고합니다; API 키의 `scope` 필드로 둘을 구분하며, 하나의 워크스페이스에 바인딩된 키의 경우 해당 워크스페이스의 실제 ID를 가집니다)
* [Admin API 키](https://platform.claude.com/docs/ko/manage-claude/admin-api-keys)와 함께 [Get Workspace](https://platform.claude.com/docs/ko/api/organization/workspaces/retrieve)에 전달하여 Default Workspace의 ID인지 확인: [List Workspaces](https://platform.claude.com/docs/ko/api/organization/workspaces/list)는 `include_default=true`를 전달하지 않으면 Default Workspace를 생략하지만, 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**를 클릭하세요.
* **속도 제한:** 분당 요청 수, 분당 입력 토큰 또는 분당 출력 토큰을 제한합니다. 설정하려면 Claude Console의 [Rate limits](https://platform.claude.com/usage/limits) 페이지로 이동하여 **Workspace** 드롭다운 메뉴에서 워크스페이스를 선택하고 모델 옆의 **Edit**를 클릭하세요.

<Note>
  - Default Workspace에는 제한을 설정할 수 없습니다
  - 설정하지 않으면 워크스페이스 제한은 조직의 제한과 일치합니다
  - 워크스페이스 제한의 합계가 더 많더라도 조직 전체 제한이 항상 적용됩니다
</Note>

속도 제한 및 작동 방식에 대한 자세한 내용은 [속도 제한](https://platform.claude.com/docs/ko/api/rate-limits)을 참조하세요. [Rate Limits API](https://platform.claude.com/docs/ko/manage-claude/rate-limits-api)를 사용하여 현재 조직 및 워크스페이스 속도 제한을 프로그래밍 방식으로 읽을 수도 있습니다.

## 사용량 및 비용 추적

[Usage and Cost API](https://platform.claude.com/docs/ko/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/ko/manage-claude/usage-cost-api)를 사용하여 워크스페이스 수준의 사용량을 추적하세요.
  </Step>
</Steps>

## FAQ

<AccordionGroup>
  <Accordion title="Default Workspace란 무엇인가요?">
    모든 조직에는 이름 변경, 보관 또는 삭제가 불가능한 "Default Workspace"가 있습니다. 모든 워크스페이스와 마찬가지로 `wrkspc_` ID를 가집니다. API는 이 ID를 [`anthropic-workspace-id` 응답 헤더](https://platform.claude.com/docs/ko/manage-claude/workspaces#identify-the-workspace-behind-an-api-response)로 반환하며, 이를 [Get Workspace](https://platform.claude.com/docs/ko/api/organization/workspaces/retrieve) 및 [Update Workspace](https://platform.claude.com/docs/ko/api/organization/workspaces/update)에 전달할 수 있습니다. 이 워크스페이스에 대한 액세스는 각 멤버의 조직 역할을 따르므로 자체 멤버 목록이 없습니다. [List Workspaces](https://platform.claude.com/docs/ko/api/organization/workspaces/list) 결과에는 `include_default=true`를 전달할 때만 나타납니다. 또한 여기에 속한 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/ko/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/ko/manage-claude/authentication#key-types)에 따라 다릅니다.

    개인 또는 서비스 계정 키는 해당 사용자 또는 서비스 계정이 워크스페이스에서 제거된 직후 해당 워크스페이스에서 작동을 멈춥니다. 서비스 계정 키는 이를 생성한 사용자가 제거되더라도 계속 작동합니다. 워크스페이스 API 키는 계속 작동합니다. [Claude Code 워크스페이스](https://platform.claude.com/docs/ko/manage-claude/workspaces#claude-code-workspace)에서는 각 키가 이를 생성한 멤버에 바인딩되며 해당 멤버가 제거되면 작동을 멈춥니다.

    개인 키는 해당 사용자가 조직에서 제거되면 보관됩니다. 사용자가 다시 초대되면 새 키를 생성해야 합니다; 보관된 키는 복원되지 않습니다.
  </Accordion>
</AccordionGroup>

## 참고 항목

* [Admin API](https://platform.claude.com/docs/ko/manage-claude/admin-api)
* [Admin API 레퍼런스](https://platform.claude.com/docs/ko/api/organization)
* [속도 제한](https://platform.claude.com/docs/ko/api/rate-limits)
* [Usage and Cost API](https://platform.claude.com/docs/ko/manage-claude/usage-cost-api)