---
title: Рабочие пространства
url: https://platform.claude.com/docs/ru/manage-claude/workspaces
description: Организуйте ключи API, управляйте доступом команды и контролируйте расходы с помощью рабочих пространств.
---

«Workspaces» (рабочие пространства) предоставляют способ организовать использование API внутри организации. Используйте рабочие пространства, чтобы разделять различные проекты, среды или команды, сохраняя при этом централизованное выставление счетов и администрирование.

## Как работают рабочие пространства

В каждой организации есть **Default Workspace** (рабочее пространство по умолчанию), которое нельзя переименовать, архивировать или удалить. Когда вы создаёте дополнительные рабочие пространства, вы можете назначать каждому из них участников, сервисные аккаунты, ключи API и лимиты ресурсов.

Ключевые характеристики:

* **Идентификаторы рабочих пространств** используют префикс `wrkspc_` (например, `wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ`)
* **Максимум 100 рабочих пространств** на организацию по умолчанию (архивированные рабочие пространства не учитываются); свяжитесь с вашей аккаунт-командой, если вам нужно больше
* **Default Workspace** имеет идентификатор `wrkspc_`, как и любое другое рабочее пространство (он возвращается в [заголовке ответа `anthropic-workspace-id`](https://platform.claude.com/docs/ru/manage-claude/workspaces#identify-the-workspace-behind-an-api-response) и принимается методом [Get Workspace](https://platform.claude.com/docs/ru/api/organization/workspaces/retrieve)), но появляется в результатах [List Workspaces](https://platform.claude.com/docs/ru/api/organization/workspaces/list) только при передаче `include_default=true`, а ключи API, отчёты об использовании и отчёты о расходах показывают `null` в его поле `workspace_id`, как и ключи API, действующие во всех рабочих пространствах (поле `scope` ключа API позволяет их различить; для ключа, привязанного к Default Workspace, оно содержит реальный идентификатор)
* **Ключи API** могут быть ограничены одним рабочим пространством. В этом случае они могут получать доступ только к ресурсам внутри этого рабочего пространства. Некоторым ключам API могут быть предоставлены разрешения в нескольких рабочих пространствах, и они передают [заголовок с идентификатором рабочего пространства](https://platform.claude.com/docs/ru/manage-claude/authentication#select-a-workspace) для доступа к ресурсам внутри этого рабочего пространства

### Рабочее пространство Claude Code

Когда участник вашей организации впервые входит в [Claude Code](https://code.claude.com/docs/en/overview) со своей учётной записью Claude Console, Anthropic автоматически создаёт в организации рабочее пространство **Claude Code** и добавляет в него этого участника. Каждый последующий участник, который входит в Claude Code, добавляется таким же образом.

Рабочее пространство Claude Code отделяет трафик Claude Code от ваших остальных рабочих нагрузок API:

* Claude Code выпускает в этом рабочем пространстве отдельный ключ API для каждого пользователя при входе. Вы не можете создавать в нём ключи вручную из Console.
* Ключ Claude Code перестаёт работать, если его владелец удалён из рабочего пространства или организации, в отличие от ключа рабочего пространства.
* Для использования Claude Code действуют отдельные «rate limits» (ограничения скорости), и администраторы могут ограничить его долю в лимитах организации на странице [Rate limits](https://platform.claude.com/usage/limits) в Claude Console.
* Это единственное рабочее пространство, которое поддерживает ежемесячные лимиты расходов для отдельных пользователей.

<Warning>
  Архивирование рабочего пространства Claude Code отключает вход в Claude Code через биллинг Console для всей организации.
</Warning>

## Роли и разрешения в рабочих пространствах

Участники могут иметь разные роли в каждом рабочем пространстве, что обеспечивает детальный контроль доступа.

| Роль                        | Разрешения                                                                                                                              |
| --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| Workspace User              | Только использование playground                                                                                                         |
| Workspace Limited Developer | Создание и управление ключами API, использование API. Не может получать доступ к представлениям трассировки сессий или скачивать файлы. |
| Workspace Developer         | Создание и управление ключами API, использование API                                                                                    |
| Workspace Admin             | Полный контроль над настройками и участниками рабочего пространства                                                                     |
| Workspace Billing           | Просмотр платёжной информации рабочего пространства (наследуется от роли биллинга организации)                                          |

### Наследование ролей

* **Администраторы организации** автоматически получают доступ Workspace Admin ко всем рабочим пространствам
* **Участники организации с ролью биллинга** автоматически получают доступ Workspace Billing ко всем рабочим пространствам
* **Пользователи и разработчики организации** должны быть явно добавлены в каждое рабочее пространство
* **Сервисные аккаунты** добавляются в рабочие пространства на странице [Service accounts](https://platform.claude.com/settings/service-accounts) (`platform.claude.com/settings/service-accounts`) в Claude Console: выберите **Add to workspace** в меню аккаунта или на его собственной странице. Чтобы увидеть аккаунты в одном рабочем пространстве, отфильтруйте список по рабочему пространству.

<Note>
  Роль Workspace Billing нельзя назначить вручную. Она наследуется при наличии роли биллинга организации.
</Note>

## Управление рабочими пространствами

<Note>
  Только администраторы организации могут создавать рабочие пространства. Пользователи и разработчики организации должны быть добавлены в рабочие пространства администратором.
</Note>

### Использование Console

Создавайте рабочие пространства и управляйте ими в [Claude Console](https://platform.claude.com/settings/workspaces).

#### Создание рабочего пространства

<Steps>
  <Step title="Откройте настройки рабочих пространств">
    В Claude Console перейдите на страницу [Workspaces](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`).
  </Step>

  <Step title="Откройте страницу Create workspace">
    Нажмите **Create workspace**, чтобы открыть страницу [Create workspace](https://platform.claude.com/settings/workspaces/new) (`platform.claude.com/settings/workspaces/new`) в Console.
  </Step>

  <Step title="Настройте рабочее пространство">
    Введите название рабочего пространства и выберите цвет для визуальной идентификации.
  </Step>

  <Step title="Завершите создание рабочего пространства">
    Нажмите **Create workspace**, чтобы завершить.
  </Step>
</Steps>

<Tip>
  Чтобы переключаться между рабочими пространствами в Console, откройте страницу, принадлежащую рабочему пространству, например [Files](https://platform.claude.com/files) (`platform.claude.com/files`), и используйте селектор рабочих пространств на боковой панели.
</Tip>

#### Редактирование сведений о рабочем пространстве

Чтобы изменить название или цвет рабочего пространства:

1. Выберите рабочее пространство из списка.
2. Откройте меню **More actions** (три точки) и выберите **Edit details**.
3. Обновите название или цвет и сохраните изменения.

<Note>
  Default Workspace нельзя переименовать или удалить.
</Note>

#### Добавление участников в рабочее пространство

1. В Claude Console перейдите на страницу [Members](https://platform.claude.com/settings/members) (`platform.claude.com/settings/members`).
2. Нажмите **Add to workspace**.
3. Выберите рабочее пространство, участника организации, которого нужно добавить, и его [роль в рабочем пространстве](https://platform.claude.com/docs/ru/manage-claude/workspaces#workspace-roles-and-permissions).
4. Нажмите **Add to workspace** для подтверждения.

#### Удаление участников из рабочего пространства

1. На странице [Members](https://platform.claude.com/settings/members) в Claude Console выберите рабочее пространство в раскрывающемся меню **Workspace**. Если там отображается **All**, действие **Remove member** удалит участника из вашей организации, а не из рабочего пространства.
2. В конце строки участника откройте меню **More actions** (три точки) и выберите **Remove member**.
3. Нажмите **Remove** для подтверждения.

<Note>
  Администраторов организации и участников с ролью биллинга нельзя удалить из рабочих пространств, пока они занимают эти роли в организации.
</Note>

#### Установка лимитов рабочего пространства

Ограничения скорости и лимиты расходов рабочего пространства задаются в разных местах:

* **Ограничения скорости:** на странице [Rate limits](https://platform.claude.com/usage/limits) в Claude Console выберите рабочее пространство в раскрывающемся меню **Workspace** и нажмите **Edit** рядом с моделью, чтобы задать лимиты на количество запросов в минуту, входных токенов или выходных токенов.
* **Лимиты расходов:** на странице [Workspaces](https://platform.claude.com/settings/workspaces) в Claude Console выберите рабочее пространство. В открывшейся панели нажмите **Spend limits**, чтобы ограничить ежемесячные расходы и настроить оповещения при достижении расходами определённых порогов.

#### Архивирование рабочего пространства

Чтобы архивировать рабочее пространство, откройте его меню **More actions** (три точки) и выберите **Archive workspace**. Архивирование:

* Сохраняет исторические данные для отчётности
* Деактивирует рабочее пространство и архивирует все ключи API, созданные для него
* Не может быть отменено

<Warning>
  Архивирование рабочего пространства в течение нескольких секунд архивирует все ключи API, созданные для этого рабочего пространства (они остаются в списке Admin API как архивированные), а ключи для нескольких рабочих пространств больше не могут действовать в нём. Это действие нельзя отменить. Если вы архивируете [рабочее пространство Claude Code](https://platform.claude.com/docs/ru/manage-claude/workspaces#claude-code-workspace), участники вашей организации больше не смогут входить в Claude Code через биллинг Console.
</Warning>

### Использование Admin API

Управляйте рабочими пространствами программно с помощью [Admin API](https://platform.claude.com/docs/ru/manage-claude/admin-api).

<Note>
  Конечные точки Admin API принимают [ключ Admin API](https://platform.claude.com/docs/ru/manage-claude/admin-api-keys), OAuth-токен `org:admin` либо персональный ключ или ключ сервисного аккаунта, не ограниченный конкретным рабочим пространством. Ключи рабочих пространств там не работают. См. раздел [Аутентификация](https://platform.claude.com/docs/ru/manage-claude/admin-api#authentication).
</Note>

Следующие примеры SDK и CLI создают клиент по умолчанию, который считывает ключ Admin API из переменной окружения `ANTHROPIC_API_KEY`; SDK предоставляют эти конечные точки через `client.organization.workspaces` (csharp, go: `client.Organization.Workspaces`; java: `client.organization().workspaces()`; php: `$client->organization->workspaces`). Методы получения списков в SDK загружают последующие страницы по требованию, поэтому `limit` задаёт размер страницы; примеры для PHP, Ruby и curl возвращают одну страницу.

Создание рабочего пространства:

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

  ```bash CLI
  ant organization:workspaces create --name Production
  ```

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

  workspace = client.organization.workspaces.create(name="Production")

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

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

  const workspace = await client.organization.workspaces.create({ name: "Production" });

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

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

  var workspace = await client.Organization.Workspaces.Create(new()
  {
      Name = "Production"
  });

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

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

  workspace, err := client.Organization.Workspaces.New(context.Background(), anthropic.OrganizationWorkspaceNewParams{
  	Name: "Production",
  })
  if err != nil {
  	log.Fatal(err)
  }

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

  ```java Java
  import com.anthropic.models.organization.workspaces.WorkspaceCreateParams;

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

      var params = WorkspaceCreateParams.builder()
          .name("Production")
          .build();
      var workspace = client.organization().workspaces().create(params);

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

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

  $workspace = $client->organization->workspaces->create(
      name: 'Production',
  );

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

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

  workspace = client.organization.workspaces.create(name: "Production")

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

Получение списка рабочих пространств:

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

  ```bash CLI
  ant organization:workspaces list --limit 10 --include-archived=false
  ```

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

  workspaces = client.organization.workspaces.list(limit=10, include_archived=False)

  for workspace in workspaces:
      print(f"{workspace.id}: {workspace.name}")
  ```

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

  const workspaces = await client.organization.workspaces.list({
    limit: 10,
    include_archived: false
  });

  for await (const workspace of workspaces) {
    console.log(`${workspace.id}: ${workspace.name}`);
  }
  ```

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

  var workspaces = await client.Organization.Workspaces.List(new()
  {
      Limit = 10,
      IncludeArchived = false
  });

  await foreach (var workspace in workspaces.Paginate())
  {
      Console.WriteLine($"{workspace.ID}: {workspace.Name}");
  }
  ```

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

  workspaces := client.Organization.Workspaces.ListAutoPaging(context.Background(), anthropic.OrganizationWorkspaceListParams{
  	Limit:           anthropic.Int(10),
  	IncludeArchived: anthropic.Bool(false),
  })

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

  ```java Java
  import com.anthropic.models.organization.workspaces.WorkspaceListParams;

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

      var params = WorkspaceListParams.builder()
          .limit(10)
          .includeArchived(false)
          .build();
      var workspaces = client.organization().workspaces().list(params);

      for (var workspace : workspaces.autoPager()) {
          IO.println(workspace.id() + ": " + workspace.name());
      }
  }
  ```

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

  $workspaces = $client->organization->workspaces->list(
      limit: 10,
      includeArchived: false,
  );

  foreach ($workspaces->getItems() as $workspace) {
      echo "{$workspace->id}: {$workspace->name}\n";
  }
  ```

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

  workspaces = client.organization.workspaces.list(limit: 10, include_archived: false)

  workspaces.data.each do |workspace|
    puts "#{workspace.id}: #{workspace.name}"
  end
  ```
</CodeGroup>

Архивирование рабочего пространства:

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

  ```bash CLI
  ant organization:workspaces archive --workspace-id wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ
  ```

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

  workspace = client.organization.workspaces.archive("wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ")

  print(f"id: {workspace.id}")
  print(f"archived_at: {workspace.archived_at}")
  ```

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

  const workspace = await client.organization.workspaces.archive(
    "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"
  );

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

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

  var workspace = await client.Organization.Workspaces.Archive(
      "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"
  );

  Console.WriteLine($"id: {workspace.ID}");
  Console.WriteLine($"archived_at: {workspace.ArchivedAt:O}");
  ```

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

  workspace, err := client.Organization.Workspaces.Archive(context.Background(), "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ")
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("id: %s\n", workspace.ID)
  fmt.Printf("archived_at: %s\n", workspace.ArchivedAt)
  ```

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

  var workspace = client.organization().workspaces()
      .archive("wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ");

  IO.println("id: " + workspace.id());
  IO.println("archived_at: " + workspace.archivedAt().orElseThrow());
  ```

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

  $workspace = $client->organization->workspaces->archive(
      workspaceID: 'wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ',
  );

  echo "id: {$workspace->id}\n";
  echo "archived_at: {$workspace->archivedAt?->format(DATE_ATOM)}\n";
  ```

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

  workspace_id = "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"
  workspace = client.organization.workspaces.archive(workspace_id)

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

Полные сведения о параметрах и схемах ответов см. в [справочнике Workspaces API](https://platform.claude.com/docs/ru/api/organization/workspaces/retrieve).

### Управление участниками рабочего пространства

Добавление участника в рабочее пространство:

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

  ```bash CLI
  ant organization:workspaces:members add \
    --workspace-id wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ \
    --user-id user_01XyDMpzjS89pFZXqSFUBDr6 \
    --workspace-role workspace_developer
  ```

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

  member = client.organization.workspaces.members.add(
      "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
      user_id="user_01XyDMpzjS89pFZXqSFUBDr6",
      workspace_role="workspace_developer",
  )

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

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

  const member = await client.organization.workspaces.members.add(
    "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
    {
      user_id: "user_01XyDMpzjS89pFZXqSFUBDr6",
      workspace_role: "workspace_developer"
    }
  );

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

  ```csharp C#
  using Anthropic.Models.Organization.Workspaces;

  AnthropicClient client = new();

  var member = await client.Organization.Workspaces.Members.Add(
      "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
      new()
      {
          UserID = "user_01XyDMpzjS89pFZXqSFUBDr6",
          WorkspaceRole = NoBillingWorkspaceRole.WorkspaceDeveloper
      }
  );

  Console.WriteLine($"user_id: {member.UserID}");
  Console.WriteLine($"workspace_role: {member.WorkspaceRole.Raw()}");
  ```

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

  member, err := client.Organization.Workspaces.Members.Add(
  	context.Background(),
  	"wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
  	anthropic.OrganizationWorkspaceMemberAddParams{
  		UserID:        "user_01XyDMpzjS89pFZXqSFUBDr6",
  		WorkspaceRole: anthropic.NoBillingWorkspaceRoleWorkspaceDeveloper,
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }

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

  ```java Java
  import com.anthropic.models.organization.workspaces.NoBillingWorkspaceRole;
  import com.anthropic.models.organization.workspaces.members.MemberAddParams;

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

      var params = MemberAddParams.builder()
          .userId("user_01XyDMpzjS89pFZXqSFUBDr6")
          .workspaceRole(NoBillingWorkspaceRole.WORKSPACE_DEVELOPER)
          .build();
      var member = client.organization().workspaces().members()
          .add("wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ", params);

      IO.println("user_id: " + member.userId());
      IO.println("workspace_role: " + member.workspaceRole().asString());
  }
  ```

  ```php PHP
  use Anthropic\Organization\Workspaces\NoBillingWorkspaceRole;
  // ...

  $client = new Client();

  $member = $client->organization->workspaces->members->add(
      workspaceID: 'wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ',
      userID: 'user_01XyDMpzjS89pFZXqSFUBDr6',
      workspaceRole: NoBillingWorkspaceRole::WORKSPACE_DEVELOPER,
  );

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

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

  workspace_id = "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"
  member = client.organization.workspaces.members.add(
    workspace_id,
    user_id: "user_01XyDMpzjS89pFZXqSFUBDr6",
    workspace_role: :workspace_developer
  )

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

Обновление роли участника:

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

  ```bash CLI
  ant organization:workspaces:members update \
    --user-id user_01XyDMpzjS89pFZXqSFUBDr6 \
    --workspace-id wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ \
    --workspace-role workspace_admin
  ```

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

  member = client.organization.workspaces.members.update(
      "user_01XyDMpzjS89pFZXqSFUBDr6",
      workspace_id="wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
      workspace_role="workspace_admin",
  )

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

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

  const member = await client.organization.workspaces.members.update(
    "user_01XyDMpzjS89pFZXqSFUBDr6",
    {
      workspace_id: "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
      workspace_role: "workspace_admin"
    }
  );

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

  ```csharp C#
  using Anthropic.Models.Organization.Workspaces;

  AnthropicClient client = new();

  var member = await client.Organization.Workspaces.Members.Update(
      "user_01XyDMpzjS89pFZXqSFUBDr6",
      new()
      {
          WorkspaceID = "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
          WorkspaceRole = WorkspaceRole.WorkspaceAdmin
      }
  );

  Console.WriteLine($"user_id: {member.UserID}");
  Console.WriteLine($"workspace_role: {member.WorkspaceRole.Raw()}");
  ```

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

  member, err := client.Organization.Workspaces.Members.Update(
  	context.Background(),
  	"user_01XyDMpzjS89pFZXqSFUBDr6",
  	anthropic.OrganizationWorkspaceMemberUpdateParams{
  		WorkspaceID:   "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
  		WorkspaceRole: anthropic.WorkspaceRoleWorkspaceAdmin,
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }

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

  ```java Java
  import com.anthropic.models.organization.workspaces.WorkspaceRole;
  import com.anthropic.models.organization.workspaces.members.MemberUpdateParams;

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

      var params = MemberUpdateParams.builder()
          .workspaceId("wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ")
          .workspaceRole(WorkspaceRole.WORKSPACE_ADMIN)
          .build();
      var member = client.organization().workspaces().members()
          .update("user_01XyDMpzjS89pFZXqSFUBDr6", params);

      IO.println("user_id: " + member.userId());
      IO.println("workspace_role: " + member.workspaceRole().asString());
  }
  ```

  ```php PHP
  use Anthropic\Organization\Workspaces\WorkspaceRole;
  // ...

  $client = new Client();

  $member = $client->organization->workspaces->members->update(
      userID: 'user_01XyDMpzjS89pFZXqSFUBDr6',
      workspaceID: 'wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ',
      workspaceRole: WorkspaceRole::WORKSPACE_ADMIN,
  );

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

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

  user_id = "user_01XyDMpzjS89pFZXqSFUBDr6"
  member = client.organization.workspaces.members.update(
    user_id,
    workspace_id: "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
    workspace_role: :workspace_admin
  )

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

Удаление участника из рабочего пространства:

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

  ```bash CLI
  ant organization:workspaces:members remove \
    --user-id user_01XyDMpzjS89pFZXqSFUBDr6 \
    --workspace-id wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ
  ```

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

  removed_member = client.organization.workspaces.members.remove(
      "user_01XyDMpzjS89pFZXqSFUBDr6",
      workspace_id="wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
  )

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

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

  const removedMember = await client.organization.workspaces.members.remove(
    "user_01XyDMpzjS89pFZXqSFUBDr6",
    { workspace_id: "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ" }
  );

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

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

  var removedMember = await client.Organization.Workspaces.Members.Remove(
      "user_01XyDMpzjS89pFZXqSFUBDr6",
      new() { WorkspaceID = "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ" }
  );

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

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

  removedMember, err := client.Organization.Workspaces.Members.Remove(
  	context.Background(),
  	"user_01XyDMpzjS89pFZXqSFUBDr6",
  	anthropic.OrganizationWorkspaceMemberRemoveParams{
  		WorkspaceID: "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ",
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }

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

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

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

      var params = MemberRemoveParams.builder()
          .workspaceId("wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ")
          .build();
      var removedMember = client.organization().workspaces().members()
          .remove("user_01XyDMpzjS89pFZXqSFUBDr6", params);

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

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

  $removedMember = $client->organization->workspaces->members->remove(
      userID: 'user_01XyDMpzjS89pFZXqSFUBDr6',
      workspaceID: 'wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ',
  );

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

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

  user_id = "user_01XyDMpzjS89pFZXqSFUBDr6"
  removed_member = client.organization.workspaces.members.remove(
    user_id,
    workspace_id: "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"
  )

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

Полные сведения о параметрах см. в [справочнике Workspace Members API](https://platform.claude.com/docs/ru/api/organization/workspaces/members/retrieve).

## Ключи API и область действия ресурсов

Каждый запрос выполняется ровно в одном рабочем пространстве и может получать доступ только к ресурсам внутри этого рабочего пространства. Какое именно рабочее пространство — зависит от [типа ключа](https://platform.claude.com/docs/ru/manage-claude/authentication#key-types):

* **Ключ рабочего пространства** (устаревший ключ без владельца) принадлежит рабочему пространству, в котором он был создан, и всегда выполняется в нём.
* **Персональный ключ** или **ключ сервисного аккаунта** действует от имени своего пользователя или сервисного аккаунта. Ключ для одного рабочего пространства всегда выполняется в рабочем пространстве, выбранном при его создании. Ключ для нескольких рабочих пространств выполняется в рабочем пространстве, указанном в заголовке `anthropic-workspace-id` каждого запроса. Аккаунты должны иметь доступ к рабочему пространству, чтобы использовать его.

Ресурсы, ограниченные рабочими пространствами, включают:

* **Файлы**, созданные через [Files API](https://platform.claude.com/docs/ru/build-with-claude/files)
* **Пакеты сообщений**, созданные через [Batch API](https://platform.claude.com/docs/ru/build-with-claude/batch-processing)
* **Навыки (Skills)**, созданные через [Skills API](https://platform.claude.com/docs/ru/build-with-claude/skills-guide)

Некоторые ресурсы управляются иначе:

* **[MCP-туннели](https://platform.claude.com/docs/ru/agents-and-tools/mcp-tunnels/overview)** управляются с помощью OAuth-токена `workspace:manage_tunnels`, полученного через [Workload Identity Federation](https://platform.claude.com/docs/ru/manage-claude/workload-identity-federation), а не ключа API. Туннели создаются в рабочем пространстве, а список **MCP tunnels** в Console и средство выбора сервера Managed Agent показывают туннели только в текущем рабочем пространстве; ограничение в 10 активных туннелей действует на уровне всей организации. Управление туннелями требует роли с разрешениями на управление туннелями; разработчики организации могут просматривать их, но не изменять.
* Сами **рабочие пространства** и **участники организации** управляются на уровне организации через [Admin API](https://platform.claude.com/docs/ru/manage-claude/admin-api) с использованием ключа Admin API, OAuth-токена `org:admin` либо персонального ключа или ключа сервисного аккаунта, не ограниченного конкретным рабочим пространством.

Чтобы узнать идентификаторы рабочих пространств вашей организации, вызовите конечную точку [List Workspaces](https://platform.claude.com/docs/ru/api/organization/workspaces/list) (передайте `include_default=true`, чтобы включить Default Workspace) или найдите их в [Claude Console](https://platform.claude.com/settings/workspaces).

<Note>
  [Кэши подсказок](https://platform.claude.com/docs/ru/build-with-claude/prompt-caching) также изолированы по рабочим пространствам в Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/ru/build-with-claude/claude-platform-on-aws) и [Microsoft Foundry](https://platform.claude.com/docs/ru/build-with-claude/claude-in-microsoft-foundry). В Amazon Bedrock и Google Cloud кэши подсказок изолированы по организациям.
</Note>

## Определение рабочего пространства, стоящего за ответом API

Ответы Claude API включают заголовок `anthropic-workspace-id` наряду с [заголовками ответа](https://platform.claude.com/docs/ru/api/overview#response-headers) `request-id` и `anthropic-organization-id`. Его значение — идентификатор с префиксом `wrkspc_` того рабочего пространства, в которое разрешился ключ API или токен доступа запроса, в том числе когда этим рабочим пространством является Default Workspace. Например, успешный ответ включает такие заголовки:

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

Заголовок отсутствует, когда учётные данные не разрешаются в рабочее пространство (например, в запросах Admin API) или когда запрос завершается ошибкой до завершения аутентификации, например с ошибкой 401.

Следующие примеры отправляют запрос Messages API и выводят идентификатор рабочего пространства из заголовков ответа:

<CodeGroup>
  ```bash cURL
  # -D - выводит заголовки ответа; -o /dev/null отбрасывает тело
  curl -sS -D - -o /dev/null https://api.anthropic.com/v1/messages \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "content-type: application/json" \
    -d '{
      "model": "claude-opus-5-5",
      "max_tokens": 1024,
      "messages": [{"role": "user", "content": "Hello, Claude"}]
    }' | grep -i '^anthropic-workspace-id'
  ```

  ```bash CLI
  # --debug выводит HTTP-ответ, включая заголовок Anthropic-Workspace-Id,
  # в stderr; > /dev/null скрывает тело JSON в stdout
  ant --debug messages create \
    --model claude-opus-5-5 \
    --max-tokens 1024 \
    --message '{role: user, content: "Hello, Claude"}' > /dev/null
  ```

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

  response = client.messages.with_raw_response.create(
      model="claude-opus-5-5",
      max_tokens=1024,
      messages=[{"role": "user", "content": "Hello, Claude"}],
  )
  workspace_id = response.headers.get("anthropic-workspace-id")
  print(f"Workspace ID: {workspace_id}")
  ```

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

  const { response } = await client.messages
    .create({
      model: "claude-opus-5-5",
      max_tokens: 1024,
      messages: [{ role: "user", content: "Hello, Claude" }]
    })
    .withResponse();
  console.log("Workspace ID:", response.headers.get("anthropic-workspace-id"));
  ```

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

  using var response = await client.WithRawResponse.Messages.Create(new()
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 1024,
      Messages = [new() { Role = Role.User, Content = "Hello, Claude" }]
  });
  var workspaceId = response.GetHeaderValues("anthropic-workspace-id").First();
  Console.WriteLine($"Workspace ID: {workspaceId}");
  ```

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

  var response *http.Response
  _, err := client.Messages.New(
  	context.Background(),
  	anthropic.MessageNewParams{
  		Model:     anthropic.ModelClaudeOpus5_5,
  		MaxTokens: 1024,
  		Messages: []anthropic.MessageParam{
  			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")),
  		},
  	},
  	option.WithResponseInto(&response),
  )
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Println("Workspace ID:", response.Header.Get("anthropic-workspace-id"))
  ```

  ```java Java
  import com.anthropic.client.AnthropicClient;
  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
  import com.anthropic.core.http.HttpResponseFor;
  import com.anthropic.models.messages.Message;
  import com.anthropic.models.messages.MessageCreateParams;
  import com.anthropic.models.messages.Model;

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

      HttpResponseFor<Message> response = client.messages().withRawResponse().create(
          MessageCreateParams.builder()
              .model(Model.CLAUDE_OPUS_5_5)
              .maxTokens(1024)
              .addUserMessage("Hello, Claude")
              .build()
      );

      String workspaceId = response.headers().values("anthropic-workspace-id").getFirst();
      IO.println("Workspace ID: " + workspaceId);
  }
  ```

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

  $response = $client->messages->raw->create([
      'model' => Model::CLAUDE_OPUS_5_5,
      'maxTokens' => 1024,
      'messages' => [['role' => 'user', 'content' => 'Hello, Claude']],
  ]);
  echo 'Workspace ID: ' . $response->getHeaderLine('anthropic-workspace-id') . "\n";
  ```

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

  # Читайте заголовки ответа в промежуточном ПО уровня запроса, которое получает
  # необработанный HTTP-ответ до того, как SDK его разберёт
  workspace_id = nil
  read_workspace_id = lambda do |request, call_next|
    response = call_next.call(request)
    # Ключи в response.headers записаны в нижнем регистре
    workspace_id = response.headers["anthropic-workspace-id"]
    response
  end

  client.messages.create(
    model: Anthropic::Model::CLAUDE_OPUS_5_5,
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    request_options: { middleware: [read_workspace_id] }
  )
  puts "Workspace ID: #{workspace_id}"
  ```
</CodeGroup>

```text Output wrap
Workspace ID: wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ
```

Те же методы доступа считывают этот заголовок и из других конечных точек Claude API, включая API [Claude Managed Agents](https://platform.claude.com/docs/ru/managed-agents/overview). Например, считайте `anthropic-workspace-id` из ответа, который [создаёт сессию](https://platform.claude.com/docs/ru/managed-agents/sessions), чтобы зафиксировать, какому рабочему пространству принадлежит сессия.

Имея идентификатор рабочего пространства из ответа, вы можете:

* Подтвердить, в использование, расходы и [ограничения скорости](https://platform.claude.com/docs/ru/api/rate-limits) какого рабочего пространства был засчитан запрос
* Сопоставить его с полем `workspace_id` в отчётах [Usage and Cost API](https://platform.claude.com/docs/ru/manage-claude/usage-cost-api) и в объектах [Admin API](https://platform.claude.com/docs/ru/manage-claude/admin-api), таких как ключи API (и те, и другие сообщают `null` для Default Workspace, как и ключи API для ключей, действующих во всех рабочих пространствах; поле `scope` ключа API позволяет различить эти два случая и для ключа, привязанного к одному рабочему пространству, содержит реальный идентификатор этого рабочего пространства)
* Проверить, является ли он идентификатором вашего Default Workspace, передав его в [Get Workspace](https://platform.claude.com/docs/ru/api/organization/workspaces/retrieve) с [ключом Admin API](https://platform.claude.com/docs/ru/manage-claude/admin-api-keys): Default Workspace возвращается с `"name": "Default"`, хотя [List Workspaces](https://platform.claude.com/docs/ru/api/organization/workspaces/list) не включает его, если вы не передадите `include_default=true`
* Открыть это рабочее пространство в [Console](https://platform.claude.com/settings/workspaces), чтобы найти ресурсы запроса, такие как сессии, файлы, пакеты сообщений и навыки

## Лимиты рабочих пространств

Вы можете установить пользовательские лимиты расходов и ограничения скорости для каждого рабочего пространства, чтобы защититься от чрезмерного использования и обеспечить справедливое распределение ресурсов.

### Установка лимитов рабочего пространства

Вы можете установить лимиты рабочего пространства ниже (но не выше) лимитов вашей организации:

* **Лимиты расходов:** ограничьте ежемесячные расходы рабочего пространства. Чтобы задать их, перейдите на страницу [Workspaces](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`) в Claude Console и выберите рабочее пространство. В открывшейся панели нажмите **Spend limits**.
* **Ограничения скорости:** ограничьте количество запросов в минуту, входных токенов в минуту или выходных токенов в минуту. Чтобы задать их, перейдите на страницу [Rate limits](https://platform.claude.com/usage/limits) в Claude Console, выберите рабочее пространство в раскрывающемся меню **Workspace** и нажмите **Edit** рядом с моделью.

<Note>
  - Вы не можете устанавливать лимиты для Default Workspace
  - Если лимиты рабочего пространства не заданы, они совпадают с лимитами организации
  - Лимиты на уровне организации действуют всегда, даже если сумма лимитов рабочих пространств больше
</Note>

Подробную информацию об ограничениях скорости и о том, как они работают, см. в разделе [Ограничения скорости](https://platform.claude.com/docs/ru/api/rate-limits). Вы также можете программно считывать текущие ограничения скорости вашей организации и рабочих пространств с помощью [Rate Limits API](https://platform.claude.com/docs/ru/manage-claude/rate-limits-api).

## Отслеживание использования и расходов

Отслеживайте использование и расходы по рабочим пространствам с помощью [Usage and Cost API](https://platform.claude.com/docs/ru/manage-claude/usage-cost-api):

```bash cURL
curl "https://api.anthropic.com/v1/organizations/usage_report/messages?\
starting_at=2025-01-01T00:00:00Z&\
ending_at=2025-01-08T00:00:00Z&\
workspace_ids[]=wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ&\
group_by[]=workspace_id&\
bucket_width=1d" \
  -H "anthropic-version: 2023-06-01" \
  -H "x-api-key: $ANTHROPIC_ADMIN_KEY"
```

Использование и расходы, отнесённые к Default Workspace, имеют значение `null` в поле `workspace_id`.

## Распространённые сценарии использования

### Разделение сред

Создайте отдельные рабочие пространства для разработки, промежуточной среды и продакшена:

| Рабочее пространство | Назначение                                                         |
| -------------------- | ------------------------------------------------------------------ |
| Development          | Тестирование и эксперименты с более низкими ограничениями скорости |
| Staging              | Предпродакшен-тестирование с лимитами, близкими к продакшену       |
| Production           | Реальный трафик с полными ограничениями скорости и мониторингом    |

### Изоляция команд или отделов

Назначьте рабочие пространства разным командам для распределения расходов и контроля доступа:

* **Инженерная команда** с доступом разработчика
* **Команда data science** с собственными ключами API
* **Команда поддержки** с ограниченным доступом для клиентских инструментов

### Организация по проектам

Создавайте рабочие пространства для конкретных проектов или продуктов, чтобы отслеживать использование и расходы отдельно.

## Лучшие практики

<Steps>
  <Step title="Спланируйте структуру рабочих пространств">
    Продумайте, как вы будете организовывать рабочие пространства, прежде чем создавать их. Учитывайте потребности в биллинге, контроле доступа и отслеживании использования.
  </Step>

  <Step title="Используйте осмысленные названия">
    Называйте рабочие пространства понятно, чтобы отражать их назначение (например, «Production - Customer Chatbot» или «Dev - Internal Tools»).
  </Step>

  <Step title="Установите подходящие лимиты">
    Настройте лимиты расходов и ограничения скорости, чтобы предотвратить непредвиденные расходы и обеспечить справедливое распределение ресурсов.
  </Step>

  <Step title="Регулярно проверяйте доступ">
    Периодически пересматривайте состав участников рабочих пространств, чтобы доступ имели только соответствующие пользователи.
  </Step>

  <Step title="Отслеживайте использование">
    Используйте [Usage and Cost API](https://platform.claude.com/docs/ru/manage-claude/usage-cost-api) для отслеживания потребления на уровне рабочих пространств.
  </Step>
</Steps>

## Часто задаваемые вопросы

<AccordionGroup>
  <Accordion title="Что такое Default Workspace?">
    В каждой организации есть «Default Workspace», которое нельзя переименовать, архивировать или удалить. Как и у любого рабочего пространства, у него есть идентификатор `wrkspc_`: API возвращает его в [заголовке ответа `anthropic-workspace-id`](https://platform.claude.com/docs/ru/manage-claude/workspaces#identify-the-workspace-behind-an-api-response), и вы можете передавать его в [Get Workspace](https://platform.claude.com/docs/ru/api/organization/workspaces/retrieve) и [Update Workspace](https://platform.claude.com/docs/ru/api/organization/workspaces/update). У него нет собственного списка участников, поскольку доступ к нему определяется ролью каждого участника в организации. Оно появляется в результатах [List Workspaces](https://platform.claude.com/docs/ru/api/organization/workspaces/list) только при передаче `include_default=true`, а ключи API, отчёты об использовании и отчёты о расходах, относящиеся к нему, показывают `null` в `workspace_id`, как и ключи API, действующие во всех рабочих пространствах; поле `scope` ключа API позволяет различить эти два случая и для ключа, принадлежащего Default Workspace, содержит его реальный идентификатор.
  </Accordion>

  <Accordion title="Что такое рабочее пространство Claude Code?">
    Anthropic автоматически создаёт рабочее пространство Claude Code, когда участник вашей организации впервые входит в Claude Code со своей учётной записью Console. Оно изолирует ключи API, использование и ограничения скорости Claude Code от ваших остальных рабочих нагрузок. Подробности см. в разделе [Рабочее пространство Claude Code](https://platform.claude.com/docs/ru/manage-claude/workspaces#claude-code-workspace).
  </Accordion>

  <Accordion title="Есть ли ограничения на рабочие пространства?">
    Да. Каждая организация по умолчанию может иметь до 100 рабочих пространств, и архивированные рабочие пространства не учитываются в этом лимите. Если вам нужно больше, свяжитесь с вашей аккаунт-командой.
  </Accordion>

  <Accordion title="Как роли в организации влияют на доступ к рабочим пространствам?">
    Администраторы организации автоматически получают роль Workspace Admin во всех рабочих пространствах. Участники организации с ролью биллинга автоматически получают роль Workspace Billing. Пользователи и разработчики организации должны быть вручную добавлены в каждое рабочее пространство.
  </Accordion>

  <Accordion title="Какие роли можно назначать в рабочих пространствах?">
    Пользователям и разработчикам организации можно назначить роли Workspace Admin, Workspace Developer, Workspace Limited Developer или Workspace User. Роль Workspace Billing нельзя назначить вручную; она наследуется при наличии роли `billing` в организации.
  </Accordion>

  <Accordion title="Можно ли изменить роли в рабочих пространствах у администраторов организации или участников с ролью биллинга?">
    У администраторов организации и участников с ролью биллинга нельзя изменить роли в рабочих пространствах или удалить их из рабочих пространств, пока они занимают эти роли в организации (с одним исключением: участников с ролью биллинга можно повысить до роли Workspace Admin). Для всех остальных, на кого распространяется это ограничение, сначала измените их роль в организации, чтобы изменить их доступ к рабочим пространствам.
  </Accordion>

  <Accordion title="Что происходит с доступом к рабочим пространствам при изменении ролей в организации?">
    Если администратор организации или участник с ролью биллинга понижен до пользователя или разработчика, он теряет доступ ко всем рабочим пространствам, кроме тех, где ему были вручную назначены роли. Когда пользователи повышаются до ролей администратора или биллинга, они автоматически получают доступ ко всем рабочим пространствам.
  </Accordion>

  <Accordion title="Что происходит с ключами API, когда пользователя удаляют из рабочего пространства?">
    Поведение зависит от [типа ключа](https://platform.claude.com/docs/ru/manage-claude/authentication#key-types).

    Персональный ключ или ключ сервисного аккаунта перестаёт работать в рабочем пространстве вскоре после того, как его пользователь или сервисный аккаунт удалён из него. Ключ сервисного аккаунта продолжает работать, даже если пользователь, создавший его, удалён. Ключи API рабочего пространства продолжают работать. В [рабочем пространстве Claude Code](https://platform.claude.com/docs/ru/manage-claude/workspaces#claude-code-workspace) каждый ключ привязан к участнику, который его создал, и перестаёт работать, когда этот участник удалён.

    Персональные ключи архивируются, когда их пользователь удаляется из организации. Если пользователя приглашают повторно, ему нужно создать новые ключи; архивированные ключи не восстанавливаются.
  </Accordion>
</AccordionGroup>

## См. также

* [Admin API](https://platform.claude.com/docs/ru/manage-claude/admin-api)
* [Справочник Admin API](https://platform.claude.com/docs/ru/api/organization)
* [Ограничения скорости](https://platform.claude.com/docs/ru/api/rate-limits)
* [Usage and Cost API](https://platform.claude.com/docs/ru/manage-claude/usage-cost-api)