---
title: 사용자 관리
url: https://platform.claude.com/docs/ko/manage-claude/user-management
description: Admin API를 사용하여 Claude Enterprise 조직의 구성원을 관리합니다. 멤버를 나열하고 역할을 변경하며, 초대를 보내고 철회하고, 그룹을 관리하고, 사용자 지정 역할을 읽을 수 있습니다.
---

이 페이지에서는 [Admin API](https://platform.claude.com/docs/ko/api/beta/organization)를 사용하여 **Claude Enterprise**(claude.ai) 조직의 구성원을 프로그래밍 방식으로 관리하는 방법을 다룹니다. 멤버를 나열하고 이메일 주소로 조회하며, 멤버의 역할을 변경하고, 멤버를 제거하고, 초대를 보내고 철회하며, 엔터프라이즈의 그룹과 그 멤버십을 관리하고, 조직의 사용자 지정 역할을 읽을 수 있습니다. Claude Console(Claude Platform) 조직의 경우 [Claude Console용 Admin API 가이드](https://platform.claude.com/docs/ko/manage-claude/admin-api)를 참조하세요.

<Note>
  그룹 및 사용자 지정 역할 요청에는 `anthropic-beta: ce-user-management-2026-07-13` [베타 헤더](https://platform.claude.com/docs/ko/api/beta-headers)가 필요하지 않습니다. 여전히 이 헤더를 보내는 요청도 수락되며 동일하게 동작합니다.
</Note>

## 조직에서 사용할 수 있는 엔드포인트는 무엇인가요?

Admin API는 `https://api.anthropic.com/v1/organizations/` 아래에 있는 단일 엔드포인트 집합입니다. Claude Console 조직과 Claude Enterprise 조직은 [서로 다른 키](https://platform.claude.com/docs/ko/manage-claude/admin-api-keys)로 인증하며, 각각 엔드포인트의 서로 다른 하위 집합에 접근할 수 있습니다.

| 엔드포인트                                                                                                                                                                                                                                                                                                                      | Claude Console (Claude Platform)                                                                 | Claude Enterprise (claude.ai)                                                                                                                                  |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [멤버](https://platform.claude.com/docs/ko/manage-claude/user-management#members) 및 [초대](https://platform.claude.com/docs/ko/manage-claude/user-management#invites)                                                                                                                                                          | 사용 가능, [Admin API 가이드](https://platform.claude.com/docs/ko/manage-claude/admin-api) 참조           | 사용 가능(이 페이지)                                                                                                                                                   |
| [그룹](https://platform.claude.com/docs/ko/manage-claude/user-management#groups)                                                                                                                                                                                                                                             | 사용 불가                                                                                            | 사용 가능(이 페이지)                                                                                                                                                   |
| [사용자 지정 역할](https://platform.claude.com/docs/ko/manage-claude/user-management#custom-roles)                                                                                                                                                                                                                                | 사용 불가                                                                                            | 사용 가능, 읽기 전용(이 페이지)                                                                                                                                            |
| [지출 한도](https://platform.claude.com/docs/ko/manage-claude/spend-limits-api)                                                                                                                                                                                                                                                | 사용 불가                                                                                            | 사용 가능                                                                                                                                                          |
| 사용량 및 비용 보고서                                                                                                                                                                                                                                                                                                               | 사용 가능. [Usage and Cost API](https://platform.claude.com/docs/ko/manage-claude/usage-cost-api) 참조 | [Claude Enterprise Analytics API](https://platform.claude.com/docs/ko/manage-claude/analytics-api#get-access-to-the-claude-enterprise-analytics-api)를 통해 사용 가능 |
| [워크스페이스](https://platform.claude.com/docs/ko/manage-claude/workspaces), [API 키](https://platform.claude.com/docs/ko/manage-claude/admin-api#api-keys), [속도 제한](https://platform.claude.com/docs/ko/manage-claude/rate-limits-api) 및 [Admin API 가이드](https://platform.claude.com/docs/ko/manage-claude/admin-api)의 기타 엔드포인트 | 사용 가능                                                                                            | 사용 불가                                                                                                                                                          |

멤버와 초대는 두 조직 유형 모두에서 동일한 엔드포인트입니다. 이 페이지에서는 Claude Enterprise [조직 역할](https://platform.claude.com/docs/ko/manage-claude/user-management#organization-roles)을 포함하여 이들의 Claude Enterprise 동작을 문서화합니다. 그룹 및 사용자 지정 역할 엔드포인트는 Claude Enterprise에만 존재합니다.

<Check>
  **범위가 지정된 Admin API 키 필요**

  이 엔드포인트에는 `read:members` 범위(구성원 및 초대 `GET` 엔드포인트와 모든 사용자 지정 역할 엔드포인트. 별도의 역할 범위는 없음), `write:members` 범위(구성원 및 초대 `POST` 및 `DELETE` 엔드포인트), `read:rbac_groups` 범위(그룹 `GET` 엔드포인트) 또는 `write:rbac_groups` 범위(그룹 `POST` 및 `DELETE` 엔드포인트)를 가진 Admin API 키가 필요합니다. `managed` 역할을 할당하거나 초대에 그룹을 지정하려면 `write:members`에 더해 `write:rbac_groups`가 필요합니다. `read:org_audit` 범위(보안 감사 통합을 위한 읽기 전용 범위)를 가진 키도 이 페이지의 모든 `GET` 엔드포인트와 [Compliance API](https://platform.claude.com/docs/ko/manage-claude/compliance-api) 읽기 엔드포인트를 호출할 수 있습니다. 기본 소유자가 키를 생성하는 위치와 선택할 범위는 [Admin API 키 생성](https://platform.claude.com/docs/ko/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization)을 참조하세요. 모든 요청에서 [`anthropic-version`](https://platform.claude.com/docs/ko/api/versioning) 헤더와 함께 `x-api-key` 헤더에 키를 전달하세요.
</Check>

## 개요

이 페이지에서는 다섯 가지 리소스를 다룹니다.

| 리소스           | 엔드포인트                                                                                                                                                                                                                                                        | 용도                                                            |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------- |
| **멤버**        | `GET /v1/organizations/users`<br />`GET /v1/organizations/users/{user_id}`<br />`POST /v1/organizations/users/{user_id}`<br />`DELETE /v1/organizations/users/{user_id}`                                                                                     | 조직의 멤버를 나열하거나 이메일로 조회하고, 멤버의 역할을 변경하고, 멤버를 제거합니다.             |
| **초대**        | `POST /v1/organizations/invites`<br />`GET /v1/organizations/invites`<br />`GET /v1/organizations/invites/{invite_id}`<br />`DELETE /v1/organizations/invites/{invite_id}`                                                                                   | 사람을 조직에 초대하고, 초대 상태를 추적하고, 수락되기 전에 초대를 철회합니다.                 |
| **그룹**        | `GET /v1/organizations/rbac_groups`<br />`GET /v1/organizations/rbac_groups/{rbac_group_id}`<br />`POST /v1/organizations/rbac_groups`<br />`POST /v1/organizations/rbac_groups/{rbac_group_id}`<br />`DELETE /v1/organizations/rbac_groups/{rbac_group_id}` | 엔터프라이즈의 그룹과 각 그룹에 연결된 사용자 지정 역할을 조회하고, 그룹을 생성, 이름 변경 및 삭제합니다. |
| **그룹 멤버**     | `GET /v1/organizations/rbac_groups/{rbac_group_id}/members`<br />`POST /v1/organizations/rbac_groups/{rbac_group_id}/members`<br />`DELETE /v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}`                                                  | 그룹의 멤버를 조회하고, 멤버를 추가 및 제거합니다.                                 |
| **사용자 지정 역할** | `GET /v1/organizations/rbac_roles`<br />`GET /v1/organizations/rbac_roles/{rbac_role_id}`<br />`GET /v1/organizations/rbac_roles/{rbac_role_id}/permissions`                                                                                                 | 조직의 사용자 지정 역할과 각 역할이 부여하는 권한을 조회합니다.                          |

사용자 지정 역할과 그룹 연결은 [claude.ai 조직 설정](https://claude.ai/admin-settings)에서 관리됩니다. API는 이를 읽을 수 있지만 변경할 수는 없습니다.

## 빠른 시작

`ANTHROPIC_API_KEY` 환경 변수를 Admin API 키로 설정하세요. 이 페이지의 예제는 이 변수에서 키를 읽습니다. SDK와 `ant` CLI는 `x-api-key` 및 `anthropic-version` 헤더를 자동으로 전송합니다.

조직의 멤버를 최신순으로 나열합니다.

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

  ```bash CLI
  ant organization:users list --limit 20
  ```

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

  users = client.organization.users.list(limit=20)

  for user in users:
      print(f"{user.id}: {user.email} ({user.role})")
  ```

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

  const users = await client.organization.users.list({ limit: 20 });

  for await (const user of users) {
    console.log(`${user.id}: ${user.email} (${user.role})`);
  }
  ```

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

  var page = await client.Organization.Users.List(new() { Limit = 20 });

  await foreach (var user in page.Paginate())
  {
      Console.WriteLine($"{user.ID}: {user.Email} ({user.Role.Raw()})");
  }
  ```

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

  users := client.Organization.Users.ListAutoPaging(context.Background(), anthropic.OrganizationUserListParams{
  	Limit: anthropic.Int(20),
  })

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

  ```java Java
  import com.anthropic.models.organization.users.UserListParams;

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

      var params = UserListParams.builder()
          .limit(20)
          .build();
      var users = client.organization().users().list(params);

      for (var user : users.autoPager()) {
          IO.println(user.id() + ": " + user.email() + " (" + user.role().asString() + ")");
      }
  }
  ```

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

  $users = $client->organization->users->list(limit: 20);

  foreach ($users->pagingEachItem() as $user) {
      echo "{$user->id}: {$user->email} ({$user->role})\n";
  }
  ```

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

  users = client.organization.users.list(limit: 20)

  users.auto_paging_each do |user|
    puts "#{user.id}: #{user.email} (#{user.role})"
  end
  ```
</CodeGroup>

```json
{
  "data": [
    {
      "type": "user",
      "id": "user_01AbCdEfGhIjKlMnOpQrSt",
      "email": "jane@example.com",
      "name": "Jane Smith",
      "role": "user",
      "added_at": "2026-06-12T09:14:03Z"
    }
  ],
  "has_more": false,
  "first_id": "user_01AbCdEfGhIjKlMnOpQrSt",
  "last_id": "user_01AbCdEfGhIjKlMnOpQrSt"
}
```

## 핵심 개념

### 조직 역할

모든 멤버는 정확히 하나의 조직 역할을 가집니다. 읽기 요청은 멤버의 역할을 다음 다섯 가지 값 중 하나로 반환합니다.

| 역할                 | 의미                                       |
| ------------------ | ---------------------------------------- |
| `user`             | 표준 멤버입니다.                                |
| `managed`          | 소속 그룹에 연결된 사용자 지정 역할을 통해 권한이 부여되는 멤버입니다. |
| `owner`            | 조직 소유자입니다.                               |
| `membership_admin` | 조직의 멤버를 관리할 수 있는 멤버입니다.                  |
| `primary_owner`    | 조직의 기본 소유자입니다. 정확히 한 명만 존재합니다.           |

API는 초대 생성 및 역할 업데이트 시 `user` 및 `managed` 역할만 할당할 수 있습니다. `managed`를 할당하려면 `write:members`에 더해 `write:rbac_groups` 범위가 필요합니다. managed 멤버의 권한은 소속 그룹에 연결된 사용자 지정 역할에서 비롯되기 때문입니다. 관리 역할(`owner`, `membership_admin`, `primary_owner`)은 claude.ai 조직 설정에서 할당되며, 이러한 역할을 가진 멤버는 이 API를 통해 수정하거나 제거할 수 없습니다.

### 멤버와 초대

사람은 초대를 수락함으로써(또는 구성된 경우 조직의 싱글 사인온을 통해) 멤버가 됩니다. 초대를 생성하면 초대 이메일이 전송되며, 이후 초대는 수신자가 수락(`accepted`)하거나 서버가 할당한 `expires_at`이 지날 때(`expired`)까지 `pending`으로 표시됩니다. `pending` 초대만 철회할 수 있습니다. 대기 중인 초대의 이메일 주소나 역할을 변경하려면 철회한 후 새로 생성하세요.

조직의 플랜이 구매한 유한한 시트 풀에서 멤버를 할당하는 경우, 대기 중인 초대는 시트를 소비합니다. 초대 생성 엔드포인트는 시트 또는 티어 매개변수를 받지 않습니다. 시트는 가용성이 있는 가장 낮은 티어에서 자동으로 할당됩니다. 사용 가능한 시트가 없을 때 초대를 생성하면 시트를 구매하는 대신 400 오류로 실패합니다. 초대를 철회하거나, 만료되도록 두거나, 나중에 멤버를 제거하면 시트가 풀로 반환됩니다.

### 그룹과 역할

그룹은 멤버를 사용자 지정 역할에 연결합니다("role-based access control"(역할 기반 접근 제어)로, 엔드포인트 경로와 범위 이름의 `rbac`에 해당합니다). 그룹은 단일 조직이 아니라 엔터프라이즈 전체(상위 조직과 그 아래의 모든 조직)가 소유하므로, 그룹 범위(`read:rbac_groups` 및 `write:rbac_groups`)에는 연결된 모든 조직에 대해 생성된 키가 필요합니다. 각 그룹에는 `source_type`이 있으며, claude.ai에서 생성된 그룹은 `direct`, ID 공급자가 프로비저닝한 그룹은 `scim`입니다. 그룹의 `role_ids` 필드에는 그룹에 연결된 사용자 지정 역할의 ID가 나열됩니다. [사용자 지정 역할 엔드포인트](https://platform.claude.com/docs/ko/manage-claude/user-management#custom-roles)를 사용하여 이를 이름과 권한으로 확인하세요. 단, 역할 카탈로그는 조직별이고 그룹은 엔터프라이즈 전체에 걸쳐 있으므로, 엔터프라이즈의 다른 조직에 속한 역할을 조회하면 해당 키에 대해 404가 반환된다는 점에 유의하세요. 역할 데이터를 일시적으로 사용할 수 없는 경우 이 필드는 `[]`가 아닌 `null`이 되므로, 재시도하여 역할 데이터가 누락된 조회와 역할이 없는 그룹을 구분하세요. 지원 중단된 두 필드가 여전히 반환됩니다. 그룹의 `roles`는 항상 `role_ids`와 같고, 그룹 멤버의 `group_id`는 항상 `rbac_group_id`와 같습니다.

## 버전 관리

모든 요청에 `anthropic-version` 헤더를 전송하세요. 사용 가능한 버전은 [API 버전](https://platform.claude.com/docs/ko/api/versioning)을 참조하세요.

## 속도 제한

Admin API 엔드포인트는 조직당 **분당 100개 요청**의 한도를 공유합니다. 초대 생성은 대신 **시간당 1,200개 요청**의 자체 한도를 가집니다. 한도를 초과하는 요청은 **429 Too Many Requests**를 반환합니다.

## 페이지네이션

멤버 및 초대 목록은 ID 기반 페이지네이션을 사용합니다. `limit`(기본값 20, 최대 1000)과 `before_id` 또는 `after_id` 중 최대 하나를 전달하고, `has_more`가 `false`가 될 때까지 각 응답의 `first_id` 및 `last_id` 필드를 사용하여 페이지를 이동합니다. 그룹 및 사용자 지정 역할 목록은 대신 **불투명 커서**를 사용합니다. 응답의 `next_page` 값을 `next_page`가 `null`이 될 때까지 다음 요청의 `page` 매개변수로 변경 없이 전달합니다.

결과를 반복 처리할 때 SDK가 추가 페이지를 자동으로 가져오므로, `limit`은 전체 개수가 아니라 페이지 크기를 설정합니다. CLI에서 `--limit`은 멤버 및 초대 목록의 경우 전체 결과 수를 설정합니다. 그룹 및 역할 목록의 경우에는 페이지 크기를 설정합니다.

## 오류 응답

오류 응답은 [오류](https://platform.claude.com/docs/ko/api/errors)에 문서화된 표준 형식을 따릅니다.

## 멤버

### 멤버 나열

`GET /v1/organizations/users`는 조직의 멤버를 가장 최근에 추가된 순으로 반환합니다. 특정 멤버를 조회하려면 `email`로 필터링하세요. 일치는 대소문자를 구분하지 않으며 동일한 주소의 일반적인 변형을 허용합니다(예: `jane+hiring@example.com`은 `jane@example.com`과 일치합니다). `read:members` 범위가 필요합니다.

전체 매개변수 세부 정보와 응답 스키마는 API 레퍼런스의 [사용자 나열](https://platform.claude.com/docs/ko/api/organization/users/list)을 참조하세요.

<CodeGroup>
  ```bash cURL
  curl "https://api.anthropic.com/v1/organizations/users?email=jane@example.com" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01"
  ```

  ```bash CLI
  ant organization:users list --email jane@example.com
  ```

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

  users = client.organization.users.list(email="jane@example.com")

  for user in users:
      print(f"{user.id}: {user.email} ({user.role})")
  ```

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

  const users = await client.organization.users.list({ email: "jane@example.com" });

  for await (const user of users) {
    console.log(`${user.id}: ${user.email} (${user.role})`);
  }
  ```

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

  var page = await client.Organization.Users.List(new() { Email = "jane@example.com" });

  await foreach (var user in page.Paginate())
  {
      Console.WriteLine($"{user.ID}: {user.Email} ({user.Role.Raw()})");
  }
  ```

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

  users := client.Organization.Users.ListAutoPaging(context.Background(), anthropic.OrganizationUserListParams{
  	Email: anthropic.String("jane@example.com"),
  })

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

  ```java Java
  import com.anthropic.models.organization.users.UserListParams;

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

      var params = UserListParams.builder()
          .email("jane@example.com")
          .build();
      var users = client.organization().users().list(params);

      for (var user : users.autoPager()) {
          IO.println(user.id() + ": " + user.email() + " (" + user.role().asString() + ")");
      }
  }
  ```

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

  $users = $client->organization->users->list(email: 'jane@example.com');

  foreach ($users->pagingEachItem() as $user) {
      echo "{$user->id}: {$user->email} ({$user->role})\n";
  }
  ```

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

  users = client.organization.users.list(email: "jane@example.com")

  users.auto_paging_each do |user|
    puts "#{user.id}: #{user.email} (#{user.role})"
  end
  ```
</CodeGroup>

### 멤버 가져오기

`GET /v1/organizations/users/{user_id}`는 ID로 멤버 한 명을 반환합니다. `read:members` 범위가 필요합니다.

전체 매개변수 세부 정보와 응답 스키마는 API 레퍼런스의 [사용자 가져오기](https://platform.claude.com/docs/ko/api/organization/users/retrieve)를 참조하세요.

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

  ```bash CLI
  ant organization:users retrieve --user-id user_01AbCdEfGhIjKlMnOpQrSt
  ```

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

  user = client.organization.users.retrieve("user_01AbCdEfGhIjKlMnOpQrSt")

  print(f"id: {user.id}")
  print(f"email: {user.email}")
  print(f"role: {user.role}")
  ```

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

  const user = await client.organization.users.retrieve("user_01AbCdEfGhIjKlMnOpQrSt");

  console.log(`id: ${user.id}`);
  console.log(`email: ${user.email}`);
  console.log(`role: ${user.role}`);
  ```

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

  var user = await client.Organization.Users.Retrieve("user_01AbCdEfGhIjKlMnOpQrSt");

  Console.WriteLine($"id: {user.ID}");
  Console.WriteLine($"email: {user.Email}");
  Console.WriteLine($"role: {user.Role.Raw()}");
  ```

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

  user, err := client.Organization.Users.Get(context.Background(), "user_01AbCdEfGhIjKlMnOpQrSt")
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("id: %s\n", user.ID)
  fmt.Printf("email: %s\n", user.Email)
  fmt.Printf("role: %s\n", user.Role)
  ```

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

  var user = client.organization().users()
      .retrieve("user_01AbCdEfGhIjKlMnOpQrSt");

  IO.println("id: " + user.id());
  IO.println("email: " + user.email());
  IO.println("role: " + user.role().asString());
  ```

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

  $user = $client->organization->users->retrieve(
      userID: 'user_01AbCdEfGhIjKlMnOpQrSt',
  );

  echo "id: {$user->id}\n";
  echo "email: {$user->email}\n";
  echo "role: {$user->role}\n";
  ```

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

  user = client.organization.users.retrieve("user_01AbCdEfGhIjKlMnOpQrSt")

  puts "id: #{user.id}"
  puts "email: #{user.email}"
  puts "role: #{user.role}"
  ```
</CodeGroup>

### 멤버의 역할 변경

`POST /v1/organizations/users/{user_id}`는 멤버의 역할을 `user` 또는 `managed`로 설정합니다. 관리 역할(`owner`, `membership_admin` 또는 `primary_owner`)을 가진 멤버는 이 엔드포인트를 통해 변경할 수 없으며, 관리 역할을 할당할 수도 없습니다. 두 경우 모두 400을 반환하며, 이는 claude.ai 조직 설정에서 관리됩니다. 조직의 ID 공급자가 역할을 관리하는 경우(고급 SSO 또는 고급 SCIM 프로비저닝), 역할 업데이트는 400을 반환합니다. `write:members` 범위가 필요하며, 역할을 `managed`로 변경할 때는 `write:rbac_groups`도 필요합니다.

전체 매개변수 세부 정보와 응답 스키마는 API 레퍼런스의 [사용자 업데이트](https://platform.claude.com/docs/ko/api/organization/users/update)를 참조하세요.

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

  ```bash CLI
  ant organization:users update \
    --user-id user_01AbCdEfGhIjKlMnOpQrSt \
    --role managed
  ```

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

  user = client.organization.users.update("user_01AbCdEfGhIjKlMnOpQrSt", role="managed")

  print(f"id: {user.id}")
  print(f"role: {user.role}")
  ```

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

  const user = await client.organization.users.update("user_01AbCdEfGhIjKlMnOpQrSt", {
    role: "managed"
  });

  console.log(`id: ${user.id}`);
  console.log(`role: ${user.role}`);
  ```

  ```csharp C#
  using Anthropic.Models.Organization.Users;
  // ...

  AnthropicClient client = new();

  var user = await client.Organization.Users.Update(
      "user_01AbCdEfGhIjKlMnOpQrSt",
      new() { Role = Role.Managed }
  );

  Console.WriteLine($"id: {user.ID}");
  Console.WriteLine($"role: {user.Role.Raw()}");
  ```

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

  user, err := client.Organization.Users.Update(
  	context.Background(),
  	"user_01AbCdEfGhIjKlMnOpQrSt",
  	anthropic.OrganizationUserUpdateParams{
  		Role: anthropic.OrganizationUserUpdateParamsRoleManaged,
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("id: %s\n", user.ID)
  fmt.Printf("role: %s\n", user.Role)
  ```

  ```java Java
  import com.anthropic.models.organization.users.UserUpdateParams;

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

      var params = UserUpdateParams.builder()
          .role(UserUpdateParams.Role.MANAGED)
          .build();
      var user = client.organization().users()
          .update("user_01AbCdEfGhIjKlMnOpQrSt", params);

      IO.println("id: " + user.id());
      IO.println("role: " + user.role().asString());
  }
  ```

  ```php PHP
  use Anthropic\Organization\Users\UserUpdateParams\Role;
  // ...

  $client = new Client();

  $user = $client->organization->users->update(
      userID: 'user_01AbCdEfGhIjKlMnOpQrSt',
      role: Role::MANAGED,
  );

  echo "id: {$user->id}\n";
  echo "role: {$user->role}\n";
  ```

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

  user_id = "user_01AbCdEfGhIjKlMnOpQrSt"
  user = client.organization.users.update(user_id, role: :managed)

  puts "id: #{user.id}"
  puts "role: #{user.role}"
  ```
</CodeGroup>

### 멤버 제거

`DELETE /v1/organizations/users/{user_id}`는 조직에서 멤버를 제거하고, 해당 멤버가 차지하고 있던 구매 시트를 조직의 풀로 반환합니다. 관리 역할을 가진 멤버는 이 엔드포인트를 통해 제거할 수 없으며, ID 공급자가 멤버십을 관리하는 경우(SCIM) 제거는 400을 반환합니다. `write:members` 범위가 필요합니다.

전체 매개변수 세부 정보와 응답 스키마는 API 레퍼런스의 [사용자 제거](https://platform.claude.com/docs/ko/api/organization/users/remove)를 참조하세요.

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

  ```bash CLI
  ant organization:users remove --user-id user_01AbCdEfGhIjKlMnOpQrSt
  ```

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

  removed_user = client.organization.users.remove("user_01AbCdEfGhIjKlMnOpQrSt")

  print(f"id: {removed_user.id}")
  ```

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

  const removedUser = await client.organization.users.remove("user_01AbCdEfGhIjKlMnOpQrSt");

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

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

  var removedUser = await client.Organization.Users.Remove("user_01AbCdEfGhIjKlMnOpQrSt");

  Console.WriteLine($"id: {removedUser.ID}");
  ```

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

  removedUser, err := client.Organization.Users.Remove(context.Background(), "user_01AbCdEfGhIjKlMnOpQrSt")
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("id: %s\n", removedUser.ID)
  ```

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

  var removedUser = client.organization().users()
      .remove("user_01AbCdEfGhIjKlMnOpQrSt");

  IO.println("id: " + removedUser.id());
  ```

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

  $removedUser = $client->organization->users->remove(
      userID: 'user_01AbCdEfGhIjKlMnOpQrSt',
  );

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

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

  user_id = "user_01AbCdEfGhIjKlMnOpQrSt"
  removed_user = client.organization.users.remove(user_id)

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

```json
{
  "type": "user_deleted",
  "id": "user_01AbCdEfGhIjKlMnOpQrSt"
}
```

## 초대

### 초대 생성

`POST /v1/organizations/invites`는 초대 이메일을 발송하고 서버가 할당한 `expires_at`과 함께 초대를 반환합니다. `role`은 `user` 또는 `managed`여야 합니다. 해당 이메일 주소에 대한 대기 중인 초대가 이미 있거나 해당 주소가 이미 멤버에 속한 경우, 요청은 기존 리소스를 명시하며 400을 반환합니다. ID 공급자가 사용자를 자동으로 프로비저닝하는 조직(JIT 또는 SCIM)은 API를 통해 초대를 생성할 수 없습니다. `write:members` 범위가 필요하며, `role`이 `managed`인 경우 `write:rbac_groups`도 필요합니다.

유한한 시트 풀에서 멤버를 할당하는 플랜에서는 초대가 가용성이 있는 가장 낮은 티어에서 자동으로 시트를 가져갑니다. API는 티어 매개변수를 받지 않습니다. 사용 가능한 시트가 없으면 요청은 시트를 구매하는 대신 400 오류로 실패합니다. 조직의 플랜 관리를 통해 시트를 추가한 후 재시도하세요.

선택 사항인 `rbac_group_ids` 필드는 멤버가 수락할 때 할당할 그룹(`rbac_group_` 접두사가 붙은 ID)을 나열합니다. 비어 있지 않은 `rbac_group_ids`를 전달하려면 키에 `write:rbac_groups` 범위가 추가로 필요합니다. 그룹 할당은 그룹의 역할에 연결된 권한을 부여할 수 있기 때문입니다.

전체 매개변수 세부 정보와 응답 스키마는 API 레퍼런스의 [초대 생성](https://platform.claude.com/docs/ko/api/organization/invites/create)을 참조하세요.

<CodeGroup>
  ```bash cURL
  curl -X POST "https://api.anthropic.com/v1/organizations/invites" \
    -H "content-type: application/json" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -d '{
      "email": "newhire@example.com",
      "role": "managed",
      "rbac_group_ids": ["rbac_group_01UvWxYzAbCdEfGhIjKlMn"]
    }'
  ```

  ```bash CLI
  ant organization:invites create \
    --email newhire@example.com \
    --role managed \
    --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn
  ```

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

  invite = client.organization.invites.create(
      email="newhire@example.com",
      role="managed",
      rbac_group_ids=["rbac_group_01UvWxYzAbCdEfGhIjKlMn"],
  )

  print(f"id: {invite.id}")
  print(f"email: {invite.email}")
  print(f"status: {invite.status}")
  print(f"expires_at: {invite.expires_at}")
  ```

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

  const invite = await client.organization.invites.create({
    email: "newhire@example.com",
    role: "managed",
    rbac_group_ids: ["rbac_group_01UvWxYzAbCdEfGhIjKlMn"]
  });

  console.log(`id: ${invite.id}`);
  console.log(`email: ${invite.email}`);
  console.log(`status: ${invite.status}`);
  console.log(`expires_at: ${invite.expires_at}`);
  ```

  ```csharp C#
  using Anthropic.Models.Organization.Invites;
  // ...

  AnthropicClient client = new();

  var invite = await client.Organization.Invites.Create(new()
  {
      Email = "newhire@example.com",
      Role = Role.Managed,
      RbacGroupIds = ["rbac_group_01UvWxYzAbCdEfGhIjKlMn"]
  });

  Console.WriteLine($"id: {invite.ID}");
  Console.WriteLine($"email: {invite.Email}");
  Console.WriteLine($"status: {invite.Status.Raw()}");
  Console.WriteLine($"expires_at: {invite.ExpiresAt:O}");
  ```

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

  invite, err := client.Organization.Invites.New(context.Background(), anthropic.OrganizationInviteNewParams{
  	Email:        "newhire@example.com",
  	Role:         anthropic.OrganizationInviteNewParamsRoleManaged,
  	RBACGroupIDs: []string{"rbac_group_01UvWxYzAbCdEfGhIjKlMn"},
  })
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("id: %s\n", invite.ID)
  fmt.Printf("email: %s\n", invite.Email)
  fmt.Printf("status: %s\n", invite.Status)
  fmt.Printf("expires_at: %s\n", invite.ExpiresAt.Format(time.RFC3339))
  ```

  ```java Java
  import com.anthropic.models.organization.invites.InviteCreateParams;

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

      var params = InviteCreateParams.builder()
          .email("newhire@example.com")
          .role(InviteCreateParams.Role.MANAGED)
          .addRbacGroupId("rbac_group_01UvWxYzAbCdEfGhIjKlMn")
          .build();
      var invite = client.organization().invites().create(params);

      IO.println("id: " + invite.id());
      IO.println("email: " + invite.email());
      IO.println("status: " + invite.status().asString());
      IO.println("expires_at: " + invite.expiresAt());
  }
  ```

  ```php PHP
  use Anthropic\Organization\Invites\InviteCreateParams\Role;
  // ...

  $client = new Client();

  $invite = $client->organization->invites->create(
      email: 'newhire@example.com',
      role: Role::MANAGED,
      rbacGroupIDs: ['rbac_group_01UvWxYzAbCdEfGhIjKlMn'],
  );

  echo "id: {$invite->id}\n";
  echo "email: {$invite->email}\n";
  echo "status: {$invite->status}\n";
  echo "expires_at: {$invite->expiresAt->format(DATE_ATOM)}\n";
  ```

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

  invite = client.organization.invites.create(
    email: "newhire@example.com",
    role: :managed,
    rbac_group_ids: ["rbac_group_01UvWxYzAbCdEfGhIjKlMn"]
  )

  puts "id: #{invite.id}"
  puts "email: #{invite.email}"
  puts "status: #{invite.status}"
  puts "expires_at: #{invite.expires_at.iso8601}"
  ```
</CodeGroup>

```json
{
  "type": "invite",
  "id": "invite_01QrStUvWxYzAbCdEfGhIj",
  "email": "newhire@example.com",
  "role": "managed",
  "invited_at": "2026-07-06T16:20:11Z",
  "expires_at": "2026-07-27T16:20:11Z",
  "accepted_at": null,
  "status": "pending",
  "rbac_group_ids": ["rbac_group_01UvWxYzAbCdEfGhIjKlMn"]
}
```

### 초대 나열

`GET /v1/organizations/invites`는 `pending`, `accepted`, `expired` 상태 전체에 걸쳐 조직의 초대를 최신순으로 반환합니다. 상태 필터는 없습니다. `read:members` 범위가 필요합니다.

전체 매개변수 세부 정보와 응답 스키마는 API 레퍼런스의 [초대 나열](https://platform.claude.com/docs/ko/api/organization/invites/list)을 참조하세요.

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

  ```bash CLI
  ant organization:invites list --limit 20
  ```

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

  invites = client.organization.invites.list(limit=20)

  for invite in invites:
      print(f"{invite.id}: {invite.email} ({invite.status})")
  ```

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

  const invites = await client.organization.invites.list({ limit: 20 });

  for await (const invite of invites) {
    console.log(`${invite.id}: ${invite.email} (${invite.status})`);
  }
  ```

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

  var page = await client.Organization.Invites.List(new() { Limit = 20 });

  await foreach (var invite in page.Paginate())
  {
      Console.WriteLine($"{invite.ID}: {invite.Email} ({invite.Status.Raw()})");
  }
  ```

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

  invites := client.Organization.Invites.ListAutoPaging(context.Background(), anthropic.OrganizationInviteListParams{
  	Limit: anthropic.Int(20),
  })

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

  ```java Java
  import com.anthropic.models.organization.invites.InviteListParams;

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

      var params = InviteListParams.builder()
          .limit(20)
          .build();
      var invites = client.organization().invites().list(params);

      for (var invite : invites.autoPager()) {
          IO.println(invite.id() + ": " + invite.email() + " (" + invite.status().asString() + ")");
      }
  }
  ```

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

  $invites = $client->organization->invites->list(limit: 20);

  foreach ($invites->pagingEachItem() as $invite) {
      echo "{$invite->id}: {$invite->email} ({$invite->status})\n";
  }
  ```

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

  invites = client.organization.invites.list(limit: 20)

  invites.auto_paging_each do |invite|
    puts "#{invite.id}: #{invite.email} (#{invite.status})"
  end
  ```
</CodeGroup>

### 초대 가져오기

`GET /v1/organizations/invites/{invite_id}`는 ID로 초대 하나를 반환합니다. `read:members` 범위가 필요합니다.

전체 매개변수 세부 정보와 응답 스키마는 API 레퍼런스의 [초대 가져오기](https://platform.claude.com/docs/ko/api/organization/invites/retrieve)를 참조하세요.

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

  ```bash CLI
  ant organization:invites retrieve --invite-id invite_01QrStUvWxYzAbCdEfGhIj
  ```

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

  invite = client.organization.invites.retrieve("invite_01QrStUvWxYzAbCdEfGhIj")

  print(f"id: {invite.id}")
  print(f"email: {invite.email}")
  print(f"status: {invite.status}")
  ```

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

  const invite = await client.organization.invites.retrieve("invite_01QrStUvWxYzAbCdEfGhIj");

  console.log(`id: ${invite.id}`);
  console.log(`email: ${invite.email}`);
  console.log(`status: ${invite.status}`);
  ```

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

  var invite = await client.Organization.Invites.Retrieve("invite_01QrStUvWxYzAbCdEfGhIj");

  Console.WriteLine($"id: {invite.ID}");
  Console.WriteLine($"email: {invite.Email}");
  Console.WriteLine($"status: {invite.Status.Raw()}");
  ```

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

  invite, err := client.Organization.Invites.Get(context.Background(), "invite_01QrStUvWxYzAbCdEfGhIj")
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("id: %s\n", invite.ID)
  fmt.Printf("email: %s\n", invite.Email)
  fmt.Printf("status: %s\n", invite.Status)
  ```

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

  var invite = client.organization().invites()
      .retrieve("invite_01QrStUvWxYzAbCdEfGhIj");

  IO.println("id: " + invite.id());
  IO.println("email: " + invite.email());
  IO.println("status: " + invite.status().asString());
  ```

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

  $invite = $client->organization->invites->retrieve(
      inviteID: 'invite_01QrStUvWxYzAbCdEfGhIj',
  );

  echo "id: {$invite->id}\n";
  echo "email: {$invite->email}\n";
  echo "status: {$invite->status}\n";
  ```

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

  invite = client.organization.invites.retrieve("invite_01QrStUvWxYzAbCdEfGhIj")

  puts "id: #{invite.id}"
  puts "email: #{invite.email}"
  puts "status: #{invite.status}"
  ```
</CodeGroup>

### 초대 철회

`DELETE /v1/organizations/invites/{invite_id}`는 `pending` 초대를 철회하여 초대 이메일의 링크를 비활성화합니다. `accepted` 초대를 철회하면 400을 반환합니다(대신 멤버를 제거하세요). `expired` 초대를 철회하면 400을 반환합니다. `write:members` 범위가 필요합니다.

전체 매개변수 세부 정보와 응답 스키마는 API 레퍼런스의 [초대 삭제](https://platform.claude.com/docs/ko/api/organization/invites/delete)를 참조하세요.

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

  ```bash CLI
  ant organization:invites delete --invite-id invite_01QrStUvWxYzAbCdEfGhIj
  ```

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

  deleted_invite = client.organization.invites.delete("invite_01QrStUvWxYzAbCdEfGhIj")

  print(f"id: {deleted_invite.id}")
  ```

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

  const deletedInvite = await client.organization.invites.delete(
    "invite_01QrStUvWxYzAbCdEfGhIj"
  );

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

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

  var deletedInvite = await client.Organization.Invites.Delete("invite_01QrStUvWxYzAbCdEfGhIj");

  Console.WriteLine($"id: {deletedInvite.ID}");
  ```

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

  deletedInvite, err := client.Organization.Invites.Delete(context.Background(), "invite_01QrStUvWxYzAbCdEfGhIj")
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("id: %s\n", deletedInvite.ID)
  ```

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

  var deletedInvite = client.organization().invites()
      .delete("invite_01QrStUvWxYzAbCdEfGhIj");

  IO.println("id: " + deletedInvite.id());
  ```

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

  $deletedInvite = $client->organization->invites->delete(
      inviteID: 'invite_01QrStUvWxYzAbCdEfGhIj',
  );

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

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

  invite_id = "invite_01QrStUvWxYzAbCdEfGhIj"
  deleted_invite = client.organization.invites.delete(invite_id)

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

## 그룹

엔터프라이즈가 [claude.ai 조직 설정](https://claude.ai/admin-settings)에서 또는 이 API를 통해 직접 생성한 그룹(`source_type: "direct"`)은 이 섹션의 모든 엔드포인트를 지원합니다. ID 공급자가 프로비저닝한 그룹(`source_type: "scim"`)은 조회할 수는 있지만 수정할 수는 없습니다. SCIM 그룹의 이름을 변경하거나 삭제하거나 구성원을 변경하면 ID 공급자가 해당 그룹을 소유하므로 400이 반환됩니다.

### 그룹 나열

`GET /v1/organizations/rbac_groups`는 ID 공급자가 관리하는(`scim`) 그룹을 포함하여 엔터프라이즈의 그룹을 반환합니다. `read:rbac_groups` 범위가 필요합니다.

전체 매개변수 세부 정보 및 응답 스키마는 API 레퍼런스의 [그룹 나열](https://platform.claude.com/docs/ko/api/beta/organization/rbac_groups/list)을 참조하세요.

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

  ```bash CLI
  ant beta:organization:rbac-groups list --limit 20
  ```

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

  groups = client.beta.organization.rbac_groups.list(limit=20)

  for group in groups:
      print(f"{group.id}: {group.name} ({group.source_type})")
  ```

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

  const groups = await client.beta.organization.rbacGroups.list({ limit: 20 });

  for await (const group of groups) {
    console.log(`${group.id}: ${group.name} (${group.source_type})`);
  }
  ```

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

  var page = await client.Beta.Organization.RbacGroups.List(new() { Limit = 20 });

  await foreach (var group in page.Paginate())
  {
      Console.WriteLine($"{group.ID}: {group.Name} ({group.SourceType.Raw()})");
  }
  ```

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

  groups := client.Beta.Organization.RBACGroups.ListAutoPaging(context.Background(), anthropic.BetaOrganizationRBACGroupListParams{
  	Limit: anthropic.Int(20),
  })

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

  ```java Java
  import com.anthropic.models.beta.organization.rbacgroups.RbacGroupListParams;

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

      var params = RbacGroupListParams.builder()
          .limit(20)
          .build();
      var groups = client.beta().organization().rbacGroups().list(params);

      for (var group : groups.autoPager()) {
          IO.println(group.id() + ": " + group.name() + " (" + group.sourceType().asString() + ")");
      }
  }
  ```

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

  $groups = $client->beta->organization->rbacGroups->list(limit: 20);

  foreach ($groups->pagingEachItem() as $group) {
      echo "{$group->id}: {$group->name} ({$group->sourceType})\n";
  }
  ```

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

  groups = client.beta.organization.rbac_groups.list(limit: 20)

  groups.auto_paging_each do |group|
    puts "#{group.id}: #{group.name} (#{group.source_type})"
  end
  ```
</CodeGroup>

```json
{
  "data": [
    {
      "type": "rbac_group",
      "id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
      "name": "Engineering",
      "source_type": "direct",
      "role_ids": ["rbac_role_01CdEfGhIjKlMnOpQrStUv"],
      "roles": ["rbac_role_01CdEfGhIjKlMnOpQrStUv"],
      "created_at": "2026-03-18T10:01:42Z",
      "updated_at": "2026-05-02T08:55:09Z"
    }
  ],
  "has_more": false,
  "next_page": null
}
```

### 그룹 가져오기

`GET /v1/organizations/rbac_groups/{rbac_group_id}`는 ID로 그룹 하나를 반환합니다. `read:rbac_groups` 범위가 필요합니다.

전체 매개변수 세부 정보 및 응답 스키마는 API 레퍼런스의 [그룹 가져오기](https://platform.claude.com/docs/ko/api/beta/organization/rbac_groups/retrieve)를 참조하세요.

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

  ```bash CLI
  ant beta:organization:rbac-groups retrieve \
    --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn
  ```

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

  group = client.beta.organization.rbac_groups.retrieve(
      "rbac_group_01UvWxYzAbCdEfGhIjKlMn"
  )

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

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

  const group = await client.beta.organization.rbacGroups.retrieve(
    "rbac_group_01UvWxYzAbCdEfGhIjKlMn"
  );

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

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

  var group = await client.Beta.Organization.RbacGroups.Retrieve("rbac_group_01UvWxYzAbCdEfGhIjKlMn");

  Console.WriteLine($"id: {group.ID}");
  Console.WriteLine($"name: {group.Name}");
  Console.WriteLine($"source_type: {group.SourceType.Raw()}");
  ```

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

  group, err := client.Beta.Organization.RBACGroups.Get(context.Background(), "rbac_group_01UvWxYzAbCdEfGhIjKlMn")
  if err != nil {
  	log.Fatal(err)
  }

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

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

  var group = client.beta().organization().rbacGroups()
      .retrieve("rbac_group_01UvWxYzAbCdEfGhIjKlMn");

  IO.println("id: " + group.id());
  IO.println("name: " + group.name());
  IO.println("source_type: " + group.sourceType().asString());
  ```

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

  $group = $client->beta->organization->rbacGroups->retrieve(
      rbacGroupID: 'rbac_group_01UvWxYzAbCdEfGhIjKlMn',
  );

  echo "id: {$group->id}\n";
  echo "name: {$group->name}\n";
  echo "source_type: {$group->sourceType}\n";
  ```

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

  rbac_group_id = "rbac_group_01UvWxYzAbCdEfGhIjKlMn"
  group = client.beta.organization.rbac_groups.retrieve(rbac_group_id)

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

### 그룹 생성

`POST /v1/organizations/rbac_groups`는 지정된 `name`(1\~255자)으로 역할이나 멤버가 없는 그룹을 생성합니다. `write:rbac_groups` 범위가 필요합니다.

전체 매개변수 세부 정보 및 응답 스키마는 API 레퍼런스의 [그룹 생성](https://platform.claude.com/docs/ko/api/beta/organization/rbac_groups/create)을 참조하세요.

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

  ```bash CLI
  ant beta:organization:rbac-groups create --name Engineering
  ```

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

  group = client.beta.organization.rbac_groups.create(name="Engineering")

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

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

  const group = await client.beta.organization.rbacGroups.create({ name: "Engineering" });

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

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

  var group = await client.Beta.Organization.RbacGroups.Create(new()
  {
      Name = "Engineering"
  });

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

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

  group, err := client.Beta.Organization.RBACGroups.New(context.Background(), anthropic.BetaOrganizationRBACGroupNewParams{
  	Name: "Engineering",
  })
  if err != nil {
  	log.Fatal(err)
  }

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

  ```java Java
  import com.anthropic.models.beta.organization.rbacgroups.RbacGroupCreateParams;

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

      var params = RbacGroupCreateParams.builder()
          .name("Engineering")
          .build();
      var group = client.beta().organization().rbacGroups().create(params);

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

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

  $group = $client->beta->organization->rbacGroups->create(
      name: 'Engineering',
  );

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

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

  group = client.beta.organization.rbac_groups.create(name: "Engineering")

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

```json
{
  "type": "rbac_group",
  "id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
  "name": "Engineering",
  "source_type": "direct",
  "role_ids": [],
  "roles": [],
  "created_at": "2026-07-09T18:00:00Z",
  "updated_at": "2026-07-09T18:00:00Z"
}
```

### 그룹 이름 변경

`POST /v1/organizations/rbac_groups/{rbac_group_id}`는 그룹을 업데이트합니다. 이 엔드포인트로 변경할 수 있는 필드는 `name`뿐입니다. `write:rbac_groups` 범위가 필요합니다.

전체 매개변수 세부 정보 및 응답 스키마는 API 레퍼런스의 [그룹 업데이트](https://platform.claude.com/docs/ko/api/beta/organization/rbac_groups/update)를 참조하세요.

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

  ```bash CLI
  ant beta:organization:rbac-groups update \
    --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn \
    --name "Platform Engineering"
  ```

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

  group = client.beta.organization.rbac_groups.update(
      "rbac_group_01UvWxYzAbCdEfGhIjKlMn", name="Platform Engineering"
  )

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

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

  const group = await client.beta.organization.rbacGroups.update(
    "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
    { name: "Platform Engineering" }
  );

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

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

  var group = await client.Beta.Organization.RbacGroups.Update(
      "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
      new() { Name = "Platform Engineering" }
  );

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

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

  group, err := client.Beta.Organization.RBACGroups.Update(
  	context.Background(),
  	"rbac_group_01UvWxYzAbCdEfGhIjKlMn",
  	anthropic.BetaOrganizationRBACGroupUpdateParams{
  		Name: anthropic.String("Platform Engineering"),
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }

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

  ```java Java
  import com.anthropic.models.beta.organization.rbacgroups.RbacGroupUpdateParams;

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

      var params = RbacGroupUpdateParams.builder()
          .name("Platform Engineering")
          .build();
      var group = client.beta().organization().rbacGroups()
          .update("rbac_group_01UvWxYzAbCdEfGhIjKlMn", params);

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

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

  $group = $client->beta->organization->rbacGroups->update(
      rbacGroupID: 'rbac_group_01UvWxYzAbCdEfGhIjKlMn',
      name: 'Platform Engineering',
  );

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

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

  rbac_group_id = "rbac_group_01UvWxYzAbCdEfGhIjKlMn"
  group = client.beta.organization.rbac_groups.update(rbac_group_id, name: "Platform Engineering")

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

### 그룹 삭제

`DELETE /v1/organizations/rbac_groups/{rbac_group_id}`는 그룹을 삭제합니다. 그룹의 멤버는 각자의 조직 멤버로 남지만, 그룹에 연결된 역할의 권한을 잃게 되며, 그룹 [지출 한도](https://platform.claude.com/docs/ko/manage-claude/spend-limits-api)가 있었다면 더 이상 적용되지 않습니다. `write:rbac_groups` 범위가 필요합니다.

전체 매개변수 세부 정보 및 응답 스키마는 API 레퍼런스의 [그룹 삭제](https://platform.claude.com/docs/ko/api/beta/organization/rbac_groups/delete)를 참조하세요.

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

  ```bash CLI
  ant beta:organization:rbac-groups delete \
    --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn
  ```

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

  deleted_group = client.beta.organization.rbac_groups.delete(
      "rbac_group_01UvWxYzAbCdEfGhIjKlMn"
  )

  print(f"id: {deleted_group.id}")
  ```

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

  const deletedGroup = await client.beta.organization.rbacGroups.delete(
    "rbac_group_01UvWxYzAbCdEfGhIjKlMn"
  );

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

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

  var deletedGroup = await client.Beta.Organization.RbacGroups.Delete(
      "rbac_group_01UvWxYzAbCdEfGhIjKlMn"
  );

  Console.WriteLine($"id: {deletedGroup.ID}");
  ```

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

  deletedGroup, err := client.Beta.Organization.RBACGroups.Delete(context.Background(), "rbac_group_01UvWxYzAbCdEfGhIjKlMn")
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("id: %s\n", deletedGroup.ID)
  ```

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

  var deletedGroup = client.beta().organization().rbacGroups()
      .delete("rbac_group_01UvWxYzAbCdEfGhIjKlMn");

  IO.println("id: " + deletedGroup.id());
  ```

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

  $deletedGroup = $client->beta->organization->rbacGroups->delete(
      rbacGroupID: 'rbac_group_01UvWxYzAbCdEfGhIjKlMn',
  );

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

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

  rbac_group_id = "rbac_group_01UvWxYzAbCdEfGhIjKlMn"
  deleted_group = client.beta.organization.rbac_groups.delete(rbac_group_id)

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

```json
{
  "id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
  "type": "rbac_group_deleted"
}
```

### 그룹의 멤버 나열

`GET /v1/organizations/rbac_groups/{rbac_group_id}/members`는 그룹의 멤버(각각 `user_id` 및 이메일 포함)를 오래된 순서로 반환합니다. 엔터프라이즈 조직의 현재 멤버만 반환되므로, `has_more`가 `true`인 상태에서도 페이지에 `limit`보다 적은 항목이 포함될 수 있습니다. `read:rbac_groups` 범위가 필요합니다.

전체 매개변수 세부 정보 및 응답 스키마는 API 레퍼런스의 [그룹 멤버 나열](https://platform.claude.com/docs/ko/api/beta/organization/rbac_groups/members/list)을 참조하세요.

<CodeGroup>
  ```bash cURL
  curl "https://api.anthropic.com/v1/organizations/rbac_groups/rbac_group_01UvWxYzAbCdEfGhIjKlMn/members?limit=100" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01"
  ```

  ```bash CLI
  ant beta:organization:rbac-groups:members list \
    --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn \
    --limit 100
  ```

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

  members = client.beta.organization.rbac_groups.members.list(
      "rbac_group_01UvWxYzAbCdEfGhIjKlMn", limit=100
  )

  for member in members:
      print(f"{member.user_id}: {member.email}")
  ```

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

  const members = await client.beta.organization.rbacGroups.members.list(
    "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
    { limit: 100 }
  );

  for await (const member of members) {
    console.log(`${member.user_id}: ${member.email}`);
  }
  ```

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

  var page = await client.Beta.Organization.RbacGroups.Members.List(
      "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
      new() { Limit = 100 }
  );

  await foreach (var member in page.Paginate())
  {
      Console.WriteLine($"{member.UserID}: {member.Email}");
  }
  ```

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

  members := client.Beta.Organization.RBACGroups.Members.ListAutoPaging(
  	context.Background(),
  	"rbac_group_01UvWxYzAbCdEfGhIjKlMn",
  	anthropic.BetaOrganizationRBACGroupMemberListParams{
  		Limit: anthropic.Int(100),
  	},
  )

  for members.Next() {
  	member := members.Current()
  	fmt.Printf("%s: %s\n", member.UserID, member.Email)
  }
  if err := members.Err(); err != nil {
  	log.Fatal(err)
  }
  ```

  ```java Java
  import com.anthropic.models.beta.organization.rbacgroups.members.MemberListParams;

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

      var params = MemberListParams.builder()
          .limit(100)
          .build();
      var members = client.beta().organization().rbacGroups().members()
          .list("rbac_group_01UvWxYzAbCdEfGhIjKlMn", params);

      for (var member : members.autoPager()) {
          IO.println(member.userId() + ": " + member.email());
      }
  }
  ```

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

  $members = $client->beta->organization->rbacGroups->members->list(
      rbacGroupID: 'rbac_group_01UvWxYzAbCdEfGhIjKlMn',
      limit: 100,
  );

  foreach ($members->pagingEachItem() as $member) {
      echo "{$member->userID}: {$member->email}\n";
  }
  ```

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

  rbac_group_id = "rbac_group_01UvWxYzAbCdEfGhIjKlMn"
  members = client.beta.organization.rbac_groups.members.list(rbac_group_id, limit: 100)

  members.auto_paging_each do |member|
    puts "#{member.user_id}: #{member.email}"
  end
  ```
</CodeGroup>

```json
{
  "data": [
    {
      "type": "rbac_group_member",
      "rbac_group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
      "group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
      "user_id": "user_01AbCdEfGhIjKlMnOpQrSt",
      "email": "jane@example.com",
      "created_at": "2026-04-07T12:30:00Z"
    }
  ],
  "has_more": false,
  "next_page": null
}
```

### 그룹에 멤버 추가

`POST /v1/organizations/rbac_groups/{rbac_group_id}/members`는 `user_id`로 조직 멤버를 그룹에 추가합니다. 사용자는 이미 엔터프라이즈 조직 중 하나의 멤버여야 하며(그렇지 않으면 요청이 404를 반환합니다), 이미 그룹에 속한 사람을 추가하면 400이 반환됩니다. `scim` 그룹의 경우 멤버십은 ID 공급자에서 관리되므로 이 요청은 400을 반환합니다. 아직 가입하지 않은 사람에게 그룹을 할당하려면 대신 [초대 생성](https://platform.claude.com/docs/ko/manage-claude/user-management#create-an-invite) 시 `rbac_group_ids`를 사용하세요. `write:rbac_groups` 범위가 필요합니다.

전체 매개변수 세부 정보와 응답 스키마는 API 레퍼런스의 [그룹 멤버 추가](https://platform.claude.com/docs/ko/api/beta/organization/rbac_groups/members/add)를 참조하세요.

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

  ```bash CLI
  ant beta:organization:rbac-groups:members add \
    --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn \
    --user-id user_01AbCdEfGhIjKlMnOpQrSt
  ```

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

  member = client.beta.organization.rbac_groups.members.add(
      "rbac_group_01UvWxYzAbCdEfGhIjKlMn", user_id="user_01AbCdEfGhIjKlMnOpQrSt"
  )

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

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

  const member = await client.beta.organization.rbacGroups.members.add(
    "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
    { user_id: "user_01AbCdEfGhIjKlMnOpQrSt" }
  );

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

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

  var member = await client.Beta.Organization.RbacGroups.Members.Add(
      "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
      new() { UserID = "user_01AbCdEfGhIjKlMnOpQrSt" }
  );

  Console.WriteLine($"user_id: {member.UserID}");
  Console.WriteLine($"email: {member.Email}");
  ```

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

  member, err := client.Beta.Organization.RBACGroups.Members.Add(
  	context.Background(),
  	"rbac_group_01UvWxYzAbCdEfGhIjKlMn",
  	anthropic.BetaOrganizationRBACGroupMemberAddParams{
  		UserID: "user_01AbCdEfGhIjKlMnOpQrSt",
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }

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

  ```java Java
  import com.anthropic.models.beta.organization.rbacgroups.members.MemberAddParams;

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

      var params = MemberAddParams.builder()
          .userId("user_01AbCdEfGhIjKlMnOpQrSt")
          .build();
      var member = client.beta().organization().rbacGroups().members()
          .add("rbac_group_01UvWxYzAbCdEfGhIjKlMn", params);

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

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

  $member = $client->beta->organization->rbacGroups->members->add(
      rbacGroupID: 'rbac_group_01UvWxYzAbCdEfGhIjKlMn',
      userID: 'user_01AbCdEfGhIjKlMnOpQrSt',
  );

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

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

  rbac_group_id = "rbac_group_01UvWxYzAbCdEfGhIjKlMn"
  member = client.beta.organization.rbac_groups.members.add(
    rbac_group_id,
    user_id: "user_01AbCdEfGhIjKlMnOpQrSt"
  )

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

```json
{
  "type": "rbac_group_member",
  "rbac_group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
  "group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
  "user_id": "user_01AbCdEfGhIjKlMnOpQrSt",
  "email": "jane@example.com",
  "created_at": "2026-07-09T18:00:00Z"
}
```

### 그룹에서 멤버 제거

`DELETE /v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}`는 그룹에서 멤버를 제거하며, 해당 멤버는 조직의 멤버로 남습니다. 사용자가 그룹의 멤버가 아니면 요청은 404를 반환하고, 멤버십이 ID 공급자에서 관리되는 `scim` 그룹의 경우 400을 반환합니다. `write:rbac_groups` 범위가 필요합니다.

전체 매개변수 세부 정보와 응답 스키마는 API 레퍼런스의 [그룹 멤버 제거](https://platform.claude.com/docs/ko/api/beta/organization/rbac_groups/members/remove)를 참조하세요.

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

  ```bash CLI
  ant beta:organization:rbac-groups:members remove \
    --rbac-group-id rbac_group_01UvWxYzAbCdEfGhIjKlMn \
    --user-id user_01AbCdEfGhIjKlMnOpQrSt
  ```

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

  removed_member = client.beta.organization.rbac_groups.members.remove(
      "user_01AbCdEfGhIjKlMnOpQrSt", rbac_group_id="rbac_group_01UvWxYzAbCdEfGhIjKlMn"
  )

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

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

  const removedMember = await client.beta.organization.rbacGroups.members.remove(
    "user_01AbCdEfGhIjKlMnOpQrSt",
    { rbac_group_id: "rbac_group_01UvWxYzAbCdEfGhIjKlMn" }
  );

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

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

  var removedMember = await client.Beta.Organization.RbacGroups.Members.Remove(
      "user_01AbCdEfGhIjKlMnOpQrSt",
      new() { RbacGroupID = "rbac_group_01UvWxYzAbCdEfGhIjKlMn" }
  );

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

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

  removedMember, err := client.Beta.Organization.RBACGroups.Members.Remove(
  	context.Background(),
  	"user_01AbCdEfGhIjKlMnOpQrSt",
  	anthropic.BetaOrganizationRBACGroupMemberRemoveParams{
  		RBACGroupID: "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }

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

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

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

      var params = MemberRemoveParams.builder()
          .rbacGroupId("rbac_group_01UvWxYzAbCdEfGhIjKlMn")
          .build();
      var removedMember = client.beta().organization().rbacGroups().members()
          .remove("user_01AbCdEfGhIjKlMnOpQrSt", params);

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

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

  $removedMember = $client->beta->organization->rbacGroups->members->remove(
      userID: 'user_01AbCdEfGhIjKlMnOpQrSt',
      rbacGroupID: 'rbac_group_01UvWxYzAbCdEfGhIjKlMn',
  );

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

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

  rbac_group_id = "rbac_group_01UvWxYzAbCdEfGhIjKlMn"
  removed_member = client.beta.organization.rbac_groups.members.remove(
    "user_01AbCdEfGhIjKlMnOpQrSt",
    rbac_group_id: rbac_group_id
  )

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

```json
{
  "rbac_group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
  "group_id": "rbac_group_01UvWxYzAbCdEfGhIjKlMn",
  "user_id": "user_01AbCdEfGhIjKlMnOpQrSt",
  "type": "rbac_group_member_deleted"
}
```

## 사용자 지정 역할

사용자 지정 역할은 API를 통해 읽기 전용입니다. 이 엔드포인트는 조직의 사용자 지정 역할([claude.ai 조직 설정](https://claude.ai/admin-settings)에서 정의되거나 Anthropic이 프로비저닝한 역할)과 각 역할이 부여하는 권한을 카탈로그화합니다. 사용자 지정 역할 읽기는 `read:members` 범위를 사용하며(별도의 역할 범위는 없습니다) 조직 수준 키로 작동합니다. 그룹 엔드포인트와 달리 연결된 모든 조직에 대해 생성된 키가 필요하지 않으며, 반환되는 카탈로그는 해당 조직 자체의 것입니다.

역할의 이름은 `display_name` 필드에서 읽으세요. 지원 중단된 `name` 필드도 여전히 반환되며 항상 `display_name`과 같습니다. Anthropic이 프로비저닝한 역할의 경우 `display_name`이 claude.ai에 표시되는 레이블과 다를 수 있으며, Anthropic이 이름을 변경할 수도 있습니다. 역할에 대한 영구적인 참조를 유지하려면 해당 역할의 `id`를 저장하세요.

### 역할 나열

`GET /v1/organizations/rbac_roles`는 조직의 사용자 지정 역할을 반환합니다. `read:members` 범위가 필요합니다.

전체 매개변수 세부 정보 및 응답 스키마는 API 레퍼런스의 [역할 나열](https://platform.claude.com/docs/ko/api/beta/organization/rbac_roles/list)을 참조하세요.

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

  ```bash CLI
  ant beta:organization:rbac-roles list --limit 20
  ```

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

  roles = client.beta.organization.rbac_roles.list(limit=20)

  for role in roles:
      print(f"{role.id}: {role.display_name}")
  ```

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

  const roles = await client.beta.organization.rbacRoles.list({ limit: 20 });

  for await (const role of roles) {
    console.log(`${role.id}: ${role.display_name}`);
  }
  ```

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

  var page = await client.Beta.Organization.RbacRoles.List(new() { Limit = 20 });

  await foreach (var role in page.Paginate())
  {
      Console.WriteLine($"{role.ID}: {role.DisplayName}");
  }
  ```

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

  roles := client.Beta.Organization.RBACRoles.ListAutoPaging(context.Background(), anthropic.BetaOrganizationRBACRoleListParams{
  	Limit: anthropic.Int(20),
  })

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

  ```java Java
  import com.anthropic.models.beta.organization.rbacroles.RbacRoleListParams;

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

      var params = RbacRoleListParams.builder()
          .limit(20)
          .build();
      var roles = client.beta().organization().rbacRoles().list(params);

      for (var role : roles.autoPager()) {
          IO.println(role.id() + ": " + role.displayName());
      }
  }
  ```

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

  $roles = $client->beta->organization->rbacRoles->list(limit: 20);

  foreach ($roles->pagingEachItem() as $role) {
      echo "{$role->id}: {$role->displayName}\n";
  }
  ```

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

  roles = client.beta.organization.rbac_roles.list(limit: 20)

  roles.auto_paging_each do |role|
    puts "#{role.id}: #{role.display_name}"
  end
  ```
</CodeGroup>

```json
{
  "data": [
    {
      "type": "rbac_role",
      "id": "rbac_role_01CdEfGhIjKlMnOpQrStUv",
      "display_name": "Engineering base",
      "name": "Engineering base",
      "created_at": "2026-03-18T10:01:42Z",
      "updated_at": "2026-05-02T08:55:09Z"
    }
  ],
  "has_more": false,
  "next_page": null
}
```

### 역할 가져오기

`GET /v1/organizations/rbac_roles/{rbac_role_id}`는 ID로 역할 하나를 반환합니다. `read:members` 범위가 필요합니다.

전체 매개변수 세부 정보 및 응답 스키마는 API 레퍼런스의 [역할 가져오기](https://platform.claude.com/docs/ko/api/beta/organization/rbac_roles/retrieve)를 참조하세요.

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

  ```bash CLI
  ant beta:organization:rbac-roles retrieve \
    --rbac-role-id rbac_role_01CdEfGhIjKlMnOpQrStUv
  ```

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

  role = client.beta.organization.rbac_roles.retrieve("rbac_role_01CdEfGhIjKlMnOpQrStUv")

  print(f"id: {role.id}")
  print(f"display_name: {role.display_name}")
  ```

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

  const role = await client.beta.organization.rbacRoles.retrieve(
    "rbac_role_01CdEfGhIjKlMnOpQrStUv"
  );

  console.log(`id: ${role.id}`);
  console.log(`display_name: ${role.display_name}`);
  ```

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

  var role = await client.Beta.Organization.RbacRoles.Retrieve("rbac_role_01CdEfGhIjKlMnOpQrStUv");

  Console.WriteLine($"id: {role.ID}");
  Console.WriteLine($"display_name: {role.DisplayName}");
  ```

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

  role, err := client.Beta.Organization.RBACRoles.Get(context.Background(), "rbac_role_01CdEfGhIjKlMnOpQrStUv")
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("id: %s\n", role.ID)
  fmt.Printf("display_name: %s\n", role.DisplayName)
  ```

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

  var role = client.beta().organization().rbacRoles()
      .retrieve("rbac_role_01CdEfGhIjKlMnOpQrStUv");

  IO.println("id: " + role.id());
  IO.println("display_name: " + role.displayName());
  ```

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

  $role = $client->beta->organization->rbacRoles->retrieve(
      rbacRoleID: 'rbac_role_01CdEfGhIjKlMnOpQrStUv',
  );

  echo "id: {$role->id}\n";
  echo "display_name: {$role->displayName}\n";
  ```

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

  rbac_role_id = "rbac_role_01CdEfGhIjKlMnOpQrStUv"
  role = client.beta.organization.rbac_roles.retrieve(rbac_role_id)

  puts "id: #{role.id}"
  puts "display_name: #{role.display_name}"
  ```
</CodeGroup>

### 역할의 권한 나열

`GET /v1/organizations/rbac_roles/{rbac_role_id}/permissions`는 역할의 권한을 반환합니다. 각 권한은 `resource`(적용 대상: 조직의 제품 기능, 커넥터 도구, 커넥터 OAuth 범위, 단일 커넥터 또는 모든 커넥터)와 `action`(해당 리소스에 대해 부여하는 내용)의 쌍으로 구성됩니다. 조직에서 활성화되지 않은 기능에 대한 행은 생략되므로, `has_more`가 `true`인 상태에서도 페이지에 `limit`보다 적은 행이 포함될 수 있습니다. `read:members` 범위가 필요합니다.

두 가지 `action` 값은 특별한 주의가 필요합니다. action이 `capability_access_all`(모든 제품 기능) 또는 `capability_access_all_ga`(모든 안정적인 제품 기능, 즉 베타 또는 리서치 프리뷰로 표시되지 않은 모든 기능)인 `organization` 권한은 포괄적 부여(모델 접근이나 `permission_` 접두사가 붙은 관리자 패널 권한은 포함하지 않는 부여)이며, 확장되지 않고 해당 단일 행으로 나열됩니다. 역할이 부여하는 것을 집계할 때, 포괄적 행은 다른 행에 명시된 기능뿐만 아니라 해당 변형이 설명하는 모든 것을 포함하는 것으로 취급하세요.

전체 매개변수 세부 정보 및 응답 스키마는 API 레퍼런스의 [역할 권한 나열](https://platform.claude.com/docs/ko/api/beta/organization/rbac_roles/permissions/list)을 참조하세요.

<CodeGroup>
  ```bash cURL
  curl "https://api.anthropic.com/v1/organizations/rbac_roles/rbac_role_01CdEfGhIjKlMnOpQrStUv/permissions?limit=20" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01"
  ```

  ```bash CLI
  ant beta:organization:rbac-roles:permissions list \
    --rbac-role-id rbac_role_01CdEfGhIjKlMnOpQrStUv \
    --limit 20
  ```

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

  permissions = client.beta.organization.rbac_roles.permissions.list(
      "rbac_role_01CdEfGhIjKlMnOpQrStUv", limit=20
  )

  for permission in permissions:
      print(permission.action)
  ```

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

  const permissions = await client.beta.organization.rbacRoles.permissions.list(
    "rbac_role_01CdEfGhIjKlMnOpQrStUv",
    { limit: 20 }
  );

  for await (const permission of permissions) {
    console.log(permission.action);
  }
  ```

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

  var page = await client.Beta.Organization.RbacRoles.Permissions.List(
      "rbac_role_01CdEfGhIjKlMnOpQrStUv",
      new() { Limit = 20 }
  );

  await foreach (var permission in page.Paginate())
  {
      Console.WriteLine(permission.Action);
  }
  ```

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

  permissions := client.Beta.Organization.RBACRoles.Permissions.ListAutoPaging(
  	context.Background(),
  	"rbac_role_01CdEfGhIjKlMnOpQrStUv",
  	anthropic.BetaOrganizationRBACRolePermissionListParams{
  		Limit: anthropic.Int(20),
  	},
  )

  for permissions.Next() {
  	permission := permissions.Current()
  	fmt.Println(permission.Action)
  }
  if err := permissions.Err(); err != nil {
  	log.Fatal(err)
  }
  ```

  ```java Java
  import com.anthropic.models.beta.organization.rbacroles.permissions.PermissionListParams;

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

      var params = PermissionListParams.builder()
          .limit(20)
          .build();
      var permissions = client.beta().organization().rbacRoles().permissions()
          .list("rbac_role_01CdEfGhIjKlMnOpQrStUv", params);

      for (var permission : permissions.autoPager()) {
          IO.println(permission.action());
      }
  }
  ```

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

  $permissions = $client->beta->organization->rbacRoles->permissions->list(
      rbacRoleID: 'rbac_role_01CdEfGhIjKlMnOpQrStUv',
      limit: 20,
  );

  foreach ($permissions->pagingEachItem() as $permission) {
      echo "{$permission->action}\n";
  }
  ```

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

  rbac_role_id = "rbac_role_01CdEfGhIjKlMnOpQrStUv"
  permissions = client.beta.organization.rbac_roles.permissions.list(rbac_role_id, limit: 20)

  permissions.auto_paging_each do |permission|
    puts permission.action
  end
  ```
</CodeGroup>

```json
{
  "data": [
    {
      "type": "rbac_role_permission",
      "resource": {
        "type": "organization",
        "organization_id": "12345678-1234-5678-1234-567812345678"
      },
      "action": "capability_access_all_ga"
    },
    {
      "type": "rbac_role_permission",
      "resource": {
        "type": "connector_tool",
        "connector_id": "mcpsrv_01WxYzAbCdEfGhIjKlMnOp",
        "tool_name": "search_tickets"
      },
      "action": "use"
    }
  ],
  "has_more": false,
  "next_page": null
}
```

## 예시 워크플로

### 퇴사하는 직원 오프보딩

1. 이메일로 멤버를 조회합니다.

   <CodeGroup>
     ```bash cURL
     curl "https://api.anthropic.com/v1/organizations/users?email=departing@example.com" \
       -H "x-api-key: $ANTHROPIC_API_KEY" \
       -H "anthropic-version: 2023-06-01"
     ```

     ```bash CLI
     ant organization:users list --email departing@example.com
     ```

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

     users = client.organization.users.list(email="departing@example.com")

     for user in users:
         print(f"{user.id}: {user.email} ({user.role})")
     ```

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

     const users = await client.organization.users.list({ email: "departing@example.com" });

     for await (const user of users) {
       console.log(`${user.id}: ${user.email} (${user.role})`);
     }
     ```

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

     var page = await client.Organization.Users.List(new() { Email = "departing@example.com" });

     await foreach (var user in page.Paginate())
     {
         Console.WriteLine($"{user.ID}: {user.Email} ({user.Role.Raw()})");
     }
     ```

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

     users := client.Organization.Users.ListAutoPaging(context.Background(), anthropic.OrganizationUserListParams{
     	Email: anthropic.String("departing@example.com"),
     })

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

     ```java Java
     import com.anthropic.models.organization.users.UserListParams;

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

         var params = UserListParams.builder()
             .email("departing@example.com")
             .build();
         var users = client.organization().users().list(params);

         for (var user : users.autoPager()) {
             IO.println(user.id() + ": " + user.email() + " (" + user.role().asString() + ")");
         }
     }
     ```

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

     $users = $client->organization->users->list(email: 'departing@example.com');

     foreach ($users->pagingEachItem() as $user) {
         echo "{$user->id}: {$user->email} ({$user->role})\n";
     }
     ```

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

     users = client.organization.users.list(email: "departing@example.com")

     users.auto_paging_each do |user|
       puts "#{user.id}: #{user.email} (#{user.role})"
     end
     ```
   </CodeGroup>

2. 응답의 `id`를 사용하여 `DELETE /v1/organizations/users/{user_id}`로 제거합니다. 시트가 있었다면 풀로 반환됩니다.

3. 해당 사람이 아직 가입하지 않았다면 조회 결과에 멤버가 반환되지 않습니다. 대신 초대를 나열하고 해당 `pending` 초대를 철회하세요.

### 그룹 멤버십 감사

1. 그룹 목록을 조회하고 각 그룹의 `id`, `name`, `role_ids`를 기록합니다.

2. 민감한 역할을 가진 각 그룹에 대해 `GET /v1/organizations/rbac_groups/{rbac_group_id}/members`의 페이지를 넘기며 멤버 이메일을 ID 공급자의 명단과 비교합니다.

3. 더 이상 그룹에 속해서는 안 되는 멤버를 `DELETE /v1/organizations/rbac_groups/{rbac_group_id}/members/{user_id}`로 제거합니다. `scim` 그룹의 경우 대신 ID 공급자에서 변경하세요.

그룹 멤버십과 임시 지출 한도 상향을 결합한 워크플로는 Spend Limits API 페이지의 [인시던트 중 멤버의 지출 한도를 일시적으로 상향](https://platform.claude.com/docs/ko/manage-claude/spend-limits-api#temporarily-raise-a-members-spend-limit-during-an-incident)을 참조하세요.

## 자주 묻는 질문

### 이것은 Admin API와 다른 API인가요?

아닙니다. 멤버 및 초대 엔드포인트는 Claude Console 조직이 사용하는 것과 동일한 `/v1/organizations/` 엔드포인트입니다. 이 페이지에서는 이들의 Claude Enterprise 동작을 문서화합니다. 그룹 및 사용자 지정 역할 엔드포인트는 동일한 API의 일부이며 Claude Enterprise 조직에만 존재합니다. [가용성 표](https://platform.claude.com/docs/ko/manage-claude/user-management#which-endpoints-can-your-organization-use)에서 각 조직 유형이 호출할 수 있는 엔드포인트를 확인할 수 있습니다.

### API를 통해 소유자 또는 멤버십 관리자 역할을 할당할 수 있나요?

아닙니다. API는 초대 생성 및 역할 업데이트 시 `user`와 `managed`만 할당합니다. 관리 역할은 claude.ai 조직 설정에서 할당되며, 이러한 역할을 가진 멤버는 API를 통해 수정하거나 제거할 수 없습니다.

### API를 통해 그룹을 생성하거나 수정할 수 있나요?

예, `write:rbac_groups` 범위가 있으면 가능합니다. 그룹을 생성하고, 이름을 변경하고, 삭제하며, 멤버를 추가하거나 제거할 수 있습니다. API가 변경할 수 없는 두 가지가 있습니다. ID 공급자가 프로비저닝한 그룹(`source_type: "scim"`)은 이름과 멤버십을 ID 공급자가 소유하며, 사용자 지정 역할은 claude.ai 조직 설정에서 관리됩니다(API는 이를 [읽습니다](https://platform.claude.com/docs/ko/manage-claude/user-management#custom-roles)).

### 수락되지 않은 초대가 시트를 소비하나요?

유한한 시트 풀이 있는 플랜에서는 그렇습니다. `pending` 초대는 시트를 점유합니다. 초대를 철회하거나 만료되도록 두면 시트가 해제됩니다. 시트 풀이 없는 플랜에서는 초대가 아무것도 소비하지 않습니다.

### 우리 조직은 싱글 사인온을 사용합니다. 어떤 작업이 작동하나요?

ID 공급자가 사용자를 자동으로 프로비저닝하는 경우(JIT 또는 SCIM) 초대 생성은 400을 반환합니다. 역할을 관리하는 경우(고급 SSO 또는 고급 SCIM 프로비저닝) 역할 업데이트는 400을 반환합니다. 멤버십을 관리하는 경우(SCIM 프로비저닝) 멤버 제거는 400을 반환합니다. 읽기는 이와 관계없이 작동합니다.

### Admin API 키를 생성한 사람이 떠나면 키는 어떻게 되나요?

키는 계속 작동합니다. Admin API 키는 개별 사용자가 아닌 조직에 범위가 지정되며, claude.ai에서 생성된 키는 만료되지 않습니다. 생성자를 조직에서 제거하거나 ID 공급자를 통해 프로비저닝을 해제하면 생성자 본인의 접근은 종료되지만, 그들이 생성한 키는 종료되지 않습니다. 역할을 하향 조정해도 키는 변경되지 않습니다. 각 키는 원래 범위로 활성 상태를 유지합니다. Admin API 키를 생성한 사람을 오프보딩할 때는 [claude.ai > 조직 설정 > API](https://claude.ai/admin-settings/api-access)의 **Keys** 섹션에서 해당 키를 삭제하고 대체 키를 생성하세요.

## 참고 항목

<CardGroup cols={2}>
  <Card title="Admin API 키 생성" href="https://platform.claude.com/docs/ko/manage-claude/admin-api-keys">
    기본 소유자가 범위가 지정된 키를 생성하는 위치와 선택할 범위.
  </Card>

  <Card title="Compliance API" href="https://platform.claude.com/docs/ko/manage-claude/compliance-api">
    조직 전체의 활동을 감사하고 사용자 콘텐츠를 검색하거나 삭제합니다.
  </Card>

  <Card title="Analytics API" href="https://platform.claude.com/docs/ko/manage-claude/analytics-api">
    Claude Enterprise를 위한 사용자별 및 시간 버킷별 사용량 및 비용 보고.
  </Card>

  <Card title="Spend Limits API" href="https://platform.claude.com/docs/ko/manage-claude/spend-limits-api">
    멤버별 지출 한도를 설정하고 상향 요청을 검토합니다.
  </Card>
</CardGroup>