---
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/plugins-api)                                                                                                                                                                                                                                                      | 사용 불가                                                                                            | 베타로 사용 가능                                                                                                                                                      |
| [지출 한도](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는 `Authorization` 및 `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` 구성원의 권한은 소속 그룹에 연결된 사용자 지정 역할에서 비롯되므로, `managed`를 할당하려면 `write:members`에 더해 `write:rbac_groups` 범위가 필요합니다. 관리 역할(`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`이므로, 재시도하여 성능이 저하된 조회와 역할이 없는 그룹을 구분하세요.

## 버전 관리

모든 요청에 `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`가 `null`이 될 때까지 응답의 `next_page` 값을 다음 요청의 `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 레퍼런스의 [List users](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 레퍼런스의 [Get user](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 레퍼런스의 [Update user](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 레퍼런스의 [Remove user](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 레퍼런스의 [Create invite](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 레퍼런스의 [List invites](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 레퍼런스의 [Get invite](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 레퍼런스의 [Delete invite](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 레퍼런스의 [List groups](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 레퍼런스의 [Get group](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 레퍼런스의 [Create group](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 레퍼런스의 [Update group](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 레퍼런스의 [Delete group](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 레퍼런스의 [List group members](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 레퍼런스의 [Add group member](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 레퍼런스의 [Remove group member](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` 필드에서 읽으세요. Anthropic이 프로비저닝한 역할의 경우 `display_name`이 claude.ai에 표시되는 레이블과 다를 수 있으며, Anthropic이 이름을 변경할 수도 있습니다. 역할에 대한 지속적인 참조를 유지하려면 해당 역할의 `id`를 저장하세요.

### 역할 목록 조회

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

전체 매개변수 세부 정보와 응답 스키마는 API 레퍼런스의 [List roles](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 레퍼런스의 [Get role](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 레퍼런스의 [List role permissions](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 공급자가 소유하는, ID 공급자가 프로비저닝한 그룹(`source_type: "scim"`)과, 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>