---
title: Espaces de travail
url: https://platform.claude.com/docs/fr/manage-claude/workspaces
description: Organisez les clés API, gérez l'accès des équipes et contrôlez les coûts avec les workspaces.
---

Les workspaces offrent un moyen d'organiser votre utilisation de l'API au sein d'une organisation. Utilisez les workspaces pour séparer différents projets, environnements ou équipes tout en maintenant une facturation et une administration centralisées.

## Fonctionnement des workspaces

Chaque organisation dispose d'un **Default Workspace** qui ne peut pas être renommé, archivé ou supprimé. Lorsque vous créez des workspaces supplémentaires, vous pouvez attribuer des membres, des comptes de service, des clés API et des limites de ressources à chacun.

Caractéristiques principales :

* **Les identifiants de workspace** utilisent le préfixe `wrkspc_` (par exemple, `wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ`)
* **Maximum de 100 workspaces** par organisation par défaut (les workspaces archivés ne comptent pas) ; contactez votre équipe de compte si vous en avez besoin de plus
* Le **Default Workspace** possède un ID `wrkspc_` comme tout autre workspace (renvoyé dans l'[en-tête de réponse `anthropic-workspace-id`](https://platform.claude.com/docs/fr/manage-claude/workspaces#identify-the-workspace-behind-an-api-response) et accepté par [Get Workspace](https://platform.claude.com/docs/fr/api/organization/workspaces/retrieve)), mais il n'apparaît dans les résultats de [List Workspaces](https://platform.claude.com/docs/fr/api/organization/workspaces/list) que lorsque vous passez `include_default=true`, et les clés API, les rapports d'utilisation et les rapports de coûts affichent `null` pour son `workspace_id`, tout comme les clés API valables pour tous les workspaces (le champ `scope` d'une clé API permet de les distinguer ; pour une clé liée au Default Workspace, il contient l'ID réel)
* **Les clés API** peuvent être limitées à un seul workspace. Dans ce cas, elles ne peuvent accéder qu'aux ressources de ce workspace. Certaines clés API peuvent se voir accorder des permissions sur plusieurs workspaces, et fournir un [en-tête d'ID de workspace](https://platform.claude.com/docs/fr/manage-claude/authentication#select-a-workspace) pour accéder aux ressources de ce workspace

### Workspace Claude Code

Lorsqu'un membre de votre organisation se connecte pour la première fois à [Claude Code](https://code.claude.com/docs/en/overview) avec son compte Claude Console, Anthropic crée automatiquement un workspace **Claude Code** dans l'organisation et y ajoute ce membre. Chaque membre suivant qui se connecte à Claude Code est ajouté de la même manière.

Le workspace Claude Code maintient le trafic Claude Code séparé de vos autres charges de travail API :

* Claude Code génère une clé API par utilisateur dans ce workspace lors de la connexion. Vous ne pouvez pas y créer de clés manuellement depuis la Console.
* Une clé Claude Code cesse de fonctionner si son propriétaire est retiré du workspace ou de l'organisation, contrairement à une clé de workspace.
* L'utilisation de Claude Code est soumise à des limites de débit distinctes, et les administrateurs peuvent plafonner sa part des limites de l'organisation sur la page [Limites de débit](https://platform.claude.com/usage/limits) de la Claude Console.
* C'est le seul workspace qui prend en charge les limites de dépenses mensuelles par utilisateur.

<Warning>
  L'archivage du workspace Claude Code désactive la connexion à Claude Code via la facturation Console pour toute l'organisation.
</Warning>

## Rôles et permissions des workspaces

Les membres peuvent avoir différents rôles dans chaque workspace, permettant un contrôle d'accès granulaire.

| Rôle                        | Permissions                                                                                                                  |
| --------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| Workspace User              | Utiliser uniquement le playground                                                                                            |
| Workspace Limited Developer | Créer et gérer des clés API, utiliser l'API. Ne peut pas accéder aux vues de traçage de session ni télécharger des fichiers. |
| Workspace Developer         | Créer et gérer des clés API, utiliser l'API                                                                                  |
| Workspace Admin             | Contrôle total sur les paramètres et les membres du workspace                                                                |
| Workspace Billing           | Consulter les informations de facturation du workspace (hérité du rôle de facturation de l'organisation)                     |

### Héritage des rôles

* **Les administrateurs d'organisation** reçoivent automatiquement l'accès Workspace Admin à tous les workspaces
* **Les membres de facturation de l'organisation** reçoivent automatiquement l'accès Workspace Billing à tous les workspaces
* **Les utilisateurs et développeurs de l'organisation** doivent être explicitement ajoutés à chaque workspace
* **Les comptes de service** sont ajoutés aux workspaces sur la page [Service accounts](https://platform.claude.com/settings/service-accounts) (`platform.claude.com/settings/service-accounts`) de la Claude Console : sélectionnez **Add to workspace** dans le menu du compte ou sur sa propre page. Pour voir les comptes d'un workspace, filtrez la liste par workspace.

<Note>
  Le rôle Workspace Billing ne peut pas être attribué manuellement. Il est hérité du fait de posséder le rôle de facturation de l'organisation.
</Note>

## Gestion des workspaces

<Note>
  Seuls les administrateurs d'organisation peuvent créer des workspaces. Les utilisateurs et développeurs de l'organisation doivent être ajoutés aux workspaces par un administrateur.
</Note>

### Utilisation de la Console

Créez et gérez les workspaces dans la [Claude Console](https://platform.claude.com/settings/workspaces).

#### Créer un workspace

<Steps>
  <Step title="Ouvrir les paramètres du workspace">
    Dans la Claude Console, accédez à la page [Workspaces](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`).
  </Step>

  <Step title="Ouvrir la page Create workspace">
    Cliquez sur **Create workspace** pour ouvrir la page [Create workspace](https://platform.claude.com/settings/workspaces/new) (`platform.claude.com/settings/workspaces/new`) dans la Console.
  </Step>

  <Step title="Configurer le workspace">
    Saisissez un nom de workspace et sélectionnez une couleur pour l'identification visuelle.
  </Step>

  <Step title="Créer le workspace">
    Cliquez sur **Create workspace** pour finaliser.
  </Step>
</Steps>

<Tip>
  Pour passer d'un workspace à un autre dans la Console, ouvrez une page qui appartient à un workspace, comme [Files](https://platform.claude.com/files) (`platform.claude.com/files`), et utilisez le sélecteur de workspace dans la barre latérale.
</Tip>

#### Modifier les détails d'un workspace

Pour modifier le nom ou la couleur d'un workspace :

1. Sélectionnez le workspace dans la liste.
2. Ouvrez le menu **More actions** (trois points) et sélectionnez **Edit details**.
3. Mettez à jour le nom ou la couleur et enregistrez vos modifications.

<Note>
  Le Default Workspace ne peut pas être renommé ou supprimé.
</Note>

#### Ajouter des membres à un workspace

1. Dans la Claude Console, accédez à la page [Members](https://platform.claude.com/settings/members) (`platform.claude.com/settings/members`).
2. Cliquez sur **Add to workspace**.
3. Sélectionnez le workspace, le membre de l'organisation à ajouter et son [rôle de workspace](https://platform.claude.com/docs/fr/manage-claude/workspaces#workspace-roles-and-permissions).
4. Cliquez sur **Add to workspace** pour confirmer.

#### Retirer des membres d'un workspace

1. Sur la page [Members](https://platform.claude.com/settings/members) de la Claude Console, sélectionnez le workspace dans le menu déroulant **Workspace**. S'il affiche **All**, **Remove member** retire plutôt le membre de votre organisation.
2. À la fin de la ligne du membre, ouvrez le menu **More actions** (trois points) et sélectionnez **Remove member**.
3. Cliquez sur **Remove** pour confirmer.

<Note>
  Les administrateurs d'organisation et les membres de facturation ne peuvent pas être retirés des workspaces tant qu'ils détiennent ces rôles d'organisation.
</Note>

#### Définir les limites du workspace

Vous définissez les limites de débit et les limites de dépenses d'un workspace à des endroits différents :

* **Limites de débit :** Sur la page [Limites de débit](https://platform.claude.com/usage/limits) de la Claude Console, sélectionnez le workspace dans le menu déroulant **Workspace** et cliquez sur **Edit** à côté d'un modèle pour définir des limites de requêtes par minute, de tokens d'entrée ou de tokens de sortie.
* **Limites de dépenses :** Sur la page [Workspaces](https://platform.claude.com/settings/workspaces) de la Claude Console, sélectionnez le workspace. Dans le panneau qui s'ouvre, cliquez sur **Spend limits** pour plafonner les dépenses mensuelles et configurer des alertes lorsque les dépenses atteignent certains seuils.

#### Archiver un workspace

Pour archiver un workspace, ouvrez son menu **More actions** (trois points) et sélectionnez **Archive workspace**. L'archivage :

* Préserve les données historiques pour les rapports
* Désactive le workspace et archive chaque clé API créée pour celui-ci
* Ne peut pas être annulé

<Warning>
  L'archivage d'un workspace archive chaque clé API créée pour ce workspace en quelques secondes (elles restent répertoriées dans l'Admin API comme archivées), et les clés multi-workspaces ne peuvent plus y agir. Cette action ne peut pas être annulée. Si vous archivez le [workspace Claude Code](https://platform.claude.com/docs/fr/manage-claude/workspaces#claude-code-workspace), les membres de votre organisation ne peuvent plus se connecter à Claude Code via la facturation Console.
</Warning>

### Utilisation de l'Admin API

Gérez les workspaces de manière programmatique à l'aide de l'[Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api).

<Note>
  Les endpoints de l'Admin API acceptent une [clé Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api-keys), un jeton OAuth `org:admin`, ou une clé de compte personnel ou de service qui n'est pas limitée à un workspace spécifique. Les clés de workspace ne fonctionnent pas ici. Consultez [Authentification](https://platform.claude.com/docs/fr/manage-claude/admin-api#authentication).
</Note>

Les exemples SDK et CLI suivants construisent le client par défaut, qui lit la clé Admin API depuis la variable d'environnement `ANTHROPIC_API_KEY` ; les SDK exposent ces endpoints sous `client.organization.workspaces` (csharp, go: `client.Organization.Workspaces`; java: `client.organization().workspaces()`; php: `$client->organization->workspaces`). Les méthodes de liste des SDK récupèrent les pages suivantes à la demande, donc `limit` définit la taille de page ; les exemples PHP, Ruby et curl renvoient une seule page.

Créer un workspace :

<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>

Lister les workspaces :

<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>

Archiver un workspace :

<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>

Pour obtenir tous les détails des paramètres et les schémas de réponse, consultez la [référence de l'API Workspaces](https://platform.claude.com/docs/fr/api/organization/workspaces/retrieve).

### Gestion des membres du workspace

Ajouter un membre à un workspace :

<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>

Mettre à jour le rôle d'un membre :

<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>

Retirer un membre d'un workspace :

<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>

Pour obtenir tous les détails des paramètres, consultez la [référence de l'API Workspace Members](https://platform.claude.com/docs/fr/api/organization/workspaces/members/retrieve).

## Clés API et portée des ressources

Chaque requête s'exécute dans exactement un workspace et ne peut accéder qu'aux ressources de ce workspace. Le workspace concerné dépend du [type de clé](https://platform.claude.com/docs/fr/manage-claude/authentication#key-types) :

* Une **clé de workspace** (une clé héritée sans propriétaire) appartient au workspace dans lequel elle a été créée et s'y exécute toujours.
* Une **clé personnelle** ou une **clé de compte de service** agit en tant que son utilisateur ou compte de service. Une clé à workspace unique s'exécute toujours dans le workspace choisi lors de sa création. Une clé multi-workspaces s'exécute dans le workspace nommé par l'en-tête `anthropic-workspace-id` de chaque requête. Les comptes doivent avoir accès au workspace pour l'utiliser.

Les ressources limitées aux workspaces incluent :

* **Les fichiers** créés via l'[API Files](https://platform.claude.com/docs/fr/build-with-claude/files)
* **Les lots de messages** créés via l'[API Batch](https://platform.claude.com/docs/fr/build-with-claude/batch-processing)
* **Les skills** créés via l'[API Skills](https://platform.claude.com/docs/fr/build-with-claude/skills-guide)

Certaines ressources sont gérées différemment :

* **[Les tunnels MCP](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/overview)** sont gérés avec un jeton OAuth `workspace:manage_tunnels` obtenu via la [Workload Identity Federation](https://platform.claude.com/docs/fr/manage-claude/workload-identity-federation), et non une clé API. Les tunnels sont créés dans un workspace, et la liste **MCP tunnels** de la Console ainsi que le sélecteur de serveur Managed Agent n'affichent que les tunnels du workspace actuel ; le plafond de 10 tunnels actifs s'applique à l'échelle de l'organisation. La gestion des tunnels nécessite un rôle avec des permissions de gestion des tunnels ; les développeurs de l'organisation peuvent les consulter mais pas les modifier.
* **Les workspaces** eux-mêmes et **les membres de l'organisation** sont gérés au niveau de l'organisation via l'[Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api), à l'aide d'une clé Admin API, d'un jeton OAuth `org:admin`, ou d'une clé de compte personnel ou de service qui n'est pas limitée à un workspace spécifique.

Pour connaître les ID des workspaces de votre organisation, appelez l'endpoint [List Workspaces](https://platform.claude.com/docs/fr/api/organization/workspaces/list) (passez `include_default=true` pour inclure le Default Workspace) ou trouvez-les dans la [Claude Console](https://platform.claude.com/settings/workspaces).

<Note>
  [Les caches de prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) sont également isolés par workspace sur l'API Claude, [Claude Platform on AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws) et [Microsoft Foundry](https://platform.claude.com/docs/fr/build-with-claude/claude-in-microsoft-foundry). Sur Amazon Bedrock et Google Cloud, les caches de prompts sont isolés par organisation.
</Note>

## Identifier le workspace derrière une réponse API

Les réponses de l'API Claude incluent un en-tête `anthropic-workspace-id` aux côtés des [en-têtes de réponse](https://platform.claude.com/docs/fr/api/overview#response-headers) `request-id` et `anthropic-organization-id`. Sa valeur est l'ID préfixé par `wrkspc_` du workspace auquel la clé API ou le jeton d'accès de la requête a été résolu, y compris lorsque ce workspace est le Default Workspace. Par exemple, une réponse réussie inclut des en-têtes comme ceux-ci :

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

L'en-tête est absent lorsque les identifiants ne se résolvent pas en un workspace (par exemple, sur les requêtes Admin API) ou lorsque la requête échoue avant la fin de l'authentification, comme une erreur 401.

Les exemples suivants envoient une requête à l'API Messages et affichent l'ID du workspace à partir des en-têtes de réponse :

<CodeGroup>
  ```bash cURL
  # -D - affiche les en-têtes de réponse ; -o /dev/null ignore le corps
  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 affiche la réponse HTTP, y compris l'en-tête Anthropic-Workspace-Id,
  # vers stderr ; > /dev/null masque le corps JSON sur 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

  # Lire les en-têtes de réponse dans le middleware par requête, qui reçoit la
  # réponse HTTP brute avant que le SDK ne l'analyse
  workspace_id = nil
  read_workspace_id = lambda do |request, call_next|
    response = call_next.call(request)
    # Les clés dans response.headers sont en minuscules
    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
```

Les mêmes accesseurs lisent l'en-tête à partir d'autres endpoints de l'API Claude également, y compris les API [Claude Managed Agents](https://platform.claude.com/docs/fr/managed-agents/overview). Par exemple, lisez `anthropic-workspace-id` à partir de la réponse qui [crée une session](https://platform.claude.com/docs/fr/managed-agents/sessions) pour enregistrer à quel workspace appartient la session.

Avec l'ID de workspace d'une réponse, vous pouvez :

* Confirmer à quel workspace l'utilisation, le coût et les [limites de débit](https://platform.claude.com/docs/fr/api/rate-limits) de la requête ont été comptabilisés
* Le comparer avec le champ `workspace_id` des rapports de l'[API Usage and Cost](https://platform.claude.com/docs/fr/manage-claude/usage-cost-api) et des objets de l'[Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api) tels que les clés API (les deux indiquent `null` pour le Default Workspace, comme le font aussi les clés API pour les clés tous-workspaces ; le champ `scope` d'une clé API permet de distinguer les deux et, pour une clé liée à un workspace, contient l'ID réel de ce workspace)
* Vérifier s'il s'agit de l'ID de votre Default Workspace en le passant à [Get Workspace](https://platform.claude.com/docs/fr/api/organization/workspaces/retrieve) avec une [clé Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api-keys) : le Default Workspace est renvoyé avec `"name": "Default"`, même si [List Workspaces](https://platform.claude.com/docs/fr/api/organization/workspaces/list) l'omet à moins que vous ne passiez `include_default=true`
* Ouvrir ce workspace dans la [Console](https://platform.claude.com/settings/workspaces) pour trouver les ressources de la requête, telles que les sessions, les fichiers, les lots de messages et les skills

## Limites des workspaces

Vous pouvez définir des limites de dépenses et de débit personnalisées pour chaque workspace afin de vous protéger contre la surutilisation et d'assurer une distribution équitable des ressources.

### Définir les limites des workspaces

Vous pouvez définir des limites de workspace inférieures (mais pas supérieures) aux limites de votre organisation :

* **Limites de dépenses :** Plafonnez les dépenses mensuelles d'un workspace. Pour les définir, accédez à la page [Workspaces](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`) de la Claude Console et sélectionnez le workspace. Dans le panneau qui s'ouvre, cliquez sur **Spend limits**.
* **Limites de débit :** Limitez les requêtes par minute, les tokens d'entrée par minute ou les tokens de sortie par minute. Pour les définir, accédez à la page [Limites de débit](https://platform.claude.com/usage/limits) de la Claude Console, sélectionnez le workspace dans le menu déroulant **Workspace** et cliquez sur **Edit** à côté d'un modèle.

<Note>
  - Vous ne pouvez pas définir de limites sur le Default Workspace
  - Si elles ne sont pas définies, les limites du workspace correspondent aux limites de l'organisation
  - Les limites à l'échelle de l'organisation s'appliquent toujours, même si les limites des workspaces totalisent davantage
</Note>

Pour des informations détaillées sur les limites de débit et leur fonctionnement, consultez [Limites de débit](https://platform.claude.com/docs/fr/api/rate-limits). Vous pouvez également lire les limites de débit actuelles de votre organisation et de vos workspaces de manière programmatique avec l'[API Rate Limits](https://platform.claude.com/docs/fr/manage-claude/rate-limits-api).

## Suivi de l'utilisation et des coûts

Suivez l'utilisation et les coûts par workspace à l'aide de l'[API Usage and Cost](https://platform.claude.com/docs/fr/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"
```

L'utilisation et les coûts attribués au Default Workspace ont une valeur `null` pour `workspace_id`.

## Cas d'usage courants

### Séparation des environnements

Créez des workspaces distincts pour le développement, la préproduction et la production :

| Workspace     | Objectif                                                                 |
| ------------- | ------------------------------------------------------------------------ |
| Développement | Tests et expérimentation avec des limites de débit plus basses           |
| Préproduction | Tests de préproduction avec des limites proches de la production         |
| Production    | Trafic en direct avec des limites de débit complètes et une surveillance |

### Isolation par équipe ou département

Attribuez des workspaces à différentes équipes pour l'allocation des coûts et le contrôle d'accès :

* **Équipe d'ingénierie** avec accès développeur
* **Équipe de data science** avec ses propres clés API
* **Équipe de support** avec un accès limité pour les outils clients

### Organisation par projet

Créez des workspaces pour des projets ou produits spécifiques afin de suivre l'utilisation et les coûts séparément.

## Bonnes pratiques

<Steps>
  <Step title="Planifiez la structure de vos workspaces">
    Réfléchissez à la manière dont vous organiserez les workspaces avant de les créer. Pensez aux besoins de facturation, de contrôle d'accès et de suivi de l'utilisation.
  </Step>

  <Step title="Utilisez des noms significatifs">
    Nommez clairement les workspaces pour indiquer leur objectif (par exemple, « Production - Customer Chatbot » ou « Dev - Internal Tools »).
  </Step>

  <Step title="Définissez des limites appropriées">
    Configurez des limites de dépenses et de débit pour éviter les coûts inattendus et assurer une distribution équitable des ressources.
  </Step>

  <Step title="Auditez l'accès régulièrement">
    Examinez périodiquement l'appartenance aux workspaces pour vous assurer que seuls les utilisateurs appropriés y ont accès.
  </Step>

  <Step title="Surveillez l'utilisation">
    Utilisez l'[API Usage and Cost](https://platform.claude.com/docs/fr/manage-claude/usage-cost-api) pour suivre la consommation au niveau du workspace.
  </Step>
</Steps>

## FAQ

<AccordionGroup>
  <Accordion title="Qu'est-ce que le Default Workspace ?">
    Chaque organisation dispose d'un « Default Workspace » qui ne peut être ni renommé, ni archivé, ni supprimé. Comme tout workspace, il possède un ID `wrkspc_` : l'API le renvoie dans l'[en-tête de réponse `anthropic-workspace-id`](https://platform.claude.com/docs/fr/manage-claude/workspaces#identify-the-workspace-behind-an-api-response), et vous pouvez le passer à [Get Workspace](https://platform.claude.com/docs/fr/api/organization/workspaces/retrieve) et à [Update Workspace](https://platform.claude.com/docs/fr/api/organization/workspaces/update). Il n'a pas de liste de membres propre, car l'accès à celui-ci dépend du rôle de chaque membre dans l'organisation. Il n'apparaît dans les résultats de [List Workspaces](https://platform.claude.com/docs/fr/api/organization/workspaces/list) que lorsque vous passez `include_default=true`, et les clés API, les rapports d'utilisation et les rapports de coûts qui lui appartiennent affichent `null` pour `workspace_id`, tout comme les clés API valables pour tous les workspaces ; le champ `scope` d'une clé API permet de distinguer les deux et, pour une clé qui appartient au Default Workspace, contient son ID réel.
  </Accordion>

  <Accordion title="Qu'est-ce que le workspace Claude Code ?">
    Anthropic crée automatiquement le workspace Claude Code la première fois qu'un membre de votre organisation se connecte à Claude Code avec son compte Console. Il isole les clés API, l'utilisation et les limites de débit de Claude Code de vos autres charges de travail. Consultez [Workspace Claude Code](https://platform.claude.com/docs/fr/manage-claude/workspaces#claude-code-workspace) pour plus de détails.
  </Accordion>

  <Accordion title="Y a-t-il des limites sur les workspaces ?">
    Oui. Chaque organisation peut avoir jusqu'à 100 workspaces par défaut, et les workspaces archivés ne comptent pas dans cette limite. Si vous en avez besoin de plus, contactez votre équipe de compte.
  </Accordion>

  <Accordion title="Comment les rôles d'organisation affectent-ils l'accès aux workspaces ?">
    Les administrateurs d'organisation obtiennent automatiquement le rôle Workspace Admin dans tous les workspaces. Les membres de facturation de l'organisation obtiennent automatiquement le rôle Workspace Billing. Les utilisateurs et développeurs de l'organisation doivent être ajoutés manuellement à chaque workspace.
  </Accordion>

  <Accordion title="Quels rôles peuvent être attribués dans les workspaces ?">
    Les utilisateurs et développeurs de l'organisation peuvent se voir attribuer les rôles Workspace Admin, Workspace Developer, Workspace Limited Developer ou Workspace User. Le rôle Workspace Billing ne peut pas être attribué manuellement ; il est hérité du fait de posséder le rôle `billing` de l'organisation.
  </Accordion>

  <Accordion title="Les rôles de workspace des administrateurs d'organisation ou des membres de facturation peuvent-ils être modifiés ?">
    Les administrateurs d'organisation et les membres de facturation ne peuvent pas voir leurs rôles de workspace modifiés ni être retirés des workspaces tant qu'ils détiennent ces rôles d'organisation (à une exception près : les membres de facturation peuvent être promus au rôle Workspace Admin). Pour toute autre personne concernée par cette contrainte, modifiez d'abord son rôle d'organisation pour changer son accès aux workspaces.
  </Accordion>

  <Accordion title="Qu'advient-il de l'accès aux workspaces lorsque les rôles d'organisation changent ?">
    Si un administrateur d'organisation ou un membre de facturation est rétrogradé au rang d'utilisateur ou de développeur, il perd l'accès à tous les workspaces sauf ceux où des rôles lui ont été attribués manuellement. Lorsque des utilisateurs sont promus aux rôles d'administrateur ou de facturation, ils obtiennent un accès automatique à tous les workspaces.
  </Accordion>

  <Accordion title="Qu'advient-il des clés API lorsqu'un utilisateur est retiré d'un workspace ?">
    Le comportement dépend du [type de clé](https://platform.claude.com/docs/fr/manage-claude/authentication#key-types).

    Une clé personnelle ou de compte de service cesse de fonctionner dans un workspace peu après que son utilisateur ou compte de service en est retiré. Une clé de compte de service continue de fonctionner même si l'utilisateur qui l'a créée est retiré. Les clés API de workspace continuent de fonctionner. Dans le [workspace Claude Code](https://platform.claude.com/docs/fr/manage-claude/workspaces#claude-code-workspace), chaque clé est liée au membre qui l'a créée et cesse de fonctionner lorsque ce membre est retiré.

    Les clés personnelles sont archivées lorsque leur utilisateur est retiré de l'organisation. Si l'utilisateur est réinvité, il doit créer de nouvelles clés ; les clés archivées ne sont pas restaurées.
  </Accordion>
</AccordionGroup>

## Voir aussi

* [Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api)
* [Référence de l'Admin API](https://platform.claude.com/docs/fr/api/organization)
* [Limites de débit](https://platform.claude.com/docs/fr/api/rate-limits)
* [API Usage and Cost](https://platform.claude.com/docs/fr/manage-claude/usage-cost-api)