---
title: Espacios de trabajo
url: https://platform.claude.com/docs/es/manage-claude/workspaces
description: Organiza claves de API, gestiona el acceso del equipo y controla los costos con workspaces.
---

Los workspaces proporcionan una forma de organizar el uso de tu API dentro de una organización. Usa workspaces para separar diferentes proyectos, entornos o equipos mientras mantienes la facturación y administración centralizadas.

## Cómo funcionan los workspaces

Cada organización tiene un **Default Workspace** que no se puede renombrar, archivar ni eliminar. Cuando creas workspaces adicionales, puedes asignar miembros, cuentas de servicio, claves de API y límites de recursos a cada uno.

Características clave:

* **Los identificadores de workspace** usan el prefijo `wrkspc_` (por ejemplo, `wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ`)
* **Máximo 100 workspaces** por organización de forma predeterminada (los workspaces archivados no cuentan); contacta a tu equipo de cuenta si necesitas más
* El **Default Workspace** tiene un ID `wrkspc_` como cualquier otro workspace (se devuelve en el [encabezado de respuesta `anthropic-workspace-id`](https://platform.claude.com/docs/es/manage-claude/workspaces#identify-the-workspace-behind-an-api-response) y lo acepta [Get Workspace](https://platform.claude.com/docs/es/api/organization/workspaces/retrieve)), pero aparece en los resultados de [List Workspaces](https://platform.claude.com/docs/es/api/organization/workspaces/list) solo cuando pasas `include_default=true`, y las claves de API, los informes de uso y los informes de costos muestran `null` en su `workspace_id`, al igual que las claves de API de todos los workspaces (el campo `scope` de una clave de API permite distinguirlas; para una clave vinculada al Default Workspace contiene el ID real)
* **Las claves de API** pueden limitarse a un solo workspace. En este caso, solo pueden acceder a recursos dentro de ese workspace. Algunas claves de API pueden recibir permisos en múltiples workspaces, y proporcionar un [encabezado de ID de workspace](https://platform.claude.com/docs/es/manage-claude/authentication#select-a-workspace) para acceder a recursos dentro de ese workspace

### Workspace de Claude Code

Cuando un miembro de tu organización inicia sesión por primera vez en [Claude Code](https://code.claude.com/docs/en/overview) con su cuenta de Claude Console, Anthropic crea automáticamente un workspace de **Claude Code** en la organización y agrega a ese miembro a él. Cada miembro posterior que inicia sesión en Claude Code se agrega de la misma manera.

El workspace de Claude Code mantiene el tráfico de Claude Code separado de tus otras cargas de trabajo de API:

* Claude Code genera una clave de API por usuario en este workspace al iniciar sesión. No puedes crear claves en él manualmente desde la Console.
* Una clave de Claude Code deja de funcionar si su propietario es eliminado del workspace o de la organización, a diferencia de una clave de workspace.
* El uso de Claude Code tiene límites de velocidad por separado, y los administradores pueden limitar su parte de los límites de la organización en la página [Límites de velocidad](https://platform.claude.com/usage/limits) de la Claude Console.
* Es el único workspace que admite límites de gasto mensual por usuario.

<Warning>
  Archivar el workspace de Claude Code deshabilita el inicio de sesión de Claude Code a través de la facturación de Console para toda la organización.
</Warning>

## Roles y permisos de workspace

Los miembros pueden tener diferentes roles en cada workspace, lo que permite un control de acceso detallado.

| Rol                         | Permisos                                                                                                                  |
| --------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| Workspace User              | Usar solo el playground                                                                                                   |
| Workspace Limited Developer | Crear y gestionar claves de API, usar la API. No puede acceder a las vistas de rastreo de sesiones ni descargar archivos. |
| Workspace Developer         | Crear y gestionar claves de API, usar la API                                                                              |
| Workspace Admin             | Control total sobre la configuración y los miembros del workspace                                                         |
| Workspace Billing           | Ver información de facturación del workspace (heredado del rol de facturación de la organización)                         |

### Herencia de roles

* **Los administradores de la organización** reciben automáticamente acceso de Workspace Admin a todos los workspaces
* **Los miembros de facturación de la organización** reciben automáticamente acceso de Workspace Billing a todos los workspaces
* **Los usuarios y desarrolladores de la organización** deben agregarse explícitamente a cada workspace
* **Las cuentas de servicio** se agregan a los workspaces en la página [Service accounts](https://platform.claude.com/settings/service-accounts) (`platform.claude.com/settings/service-accounts`) de la Claude Console: selecciona **Add to workspace** en el menú de la cuenta o en su propia página. Para ver las cuentas en un workspace, filtra la lista por workspace.

<Note>
  El rol de Workspace Billing no se puede asignar manualmente. Se hereda de tener el rol de facturación de la organización.
</Note>

## Gestión de workspaces

<Note>
  Solo los administradores de la organización pueden crear workspaces. Los usuarios y desarrolladores de la organización deben ser agregados a los workspaces por un administrador.
</Note>

### Usando la Console

Crea y gestiona workspaces en la [Claude Console](https://platform.claude.com/settings/workspaces).

#### Crear un workspace

<Steps>
  <Step title="Abre la configuración del workspace">
    En la Claude Console, ve a la página [Workspaces](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`).
  </Step>

  <Step title="Abre la página Create workspace">
    Haz clic en **Create workspace** para abrir la página [Create workspace](https://platform.claude.com/settings/workspaces/new) (`platform.claude.com/settings/workspaces/new`) en la Console.
  </Step>

  <Step title="Configura el workspace">
    Ingresa un nombre para el workspace y selecciona un color para identificarlo visualmente.
  </Step>

  <Step title="Crea el workspace">
    Haz clic en **Create workspace** para finalizar.
  </Step>
</Steps>

<Tip>
  Para cambiar entre workspaces en la Console, abre una página que pertenezca a un workspace, como [Files](https://platform.claude.com/files) (`platform.claude.com/files`), y usa el selector de workspace en la barra lateral.
</Tip>

#### Editar detalles del workspace

Para modificar el nombre o color de un workspace:

1. Selecciona el workspace de la lista.
2. Abre el menú **More actions** (tres puntos) y selecciona **Edit details**.
3. Actualiza el nombre o color y guarda tus cambios.

<Note>
  El Default Workspace no se puede renombrar ni eliminar.
</Note>

#### Agregar miembros a un workspace

1. En la Claude Console, ve a la página [Members](https://platform.claude.com/settings/members) (`platform.claude.com/settings/members`).
2. Haz clic en **Add to workspace**.
3. Selecciona el workspace, el miembro de la organización que quieres agregar y su [rol de workspace](https://platform.claude.com/docs/es/manage-claude/workspaces#workspace-roles-and-permissions).
4. Haz clic en **Add to workspace** para confirmar.

#### Eliminar miembros de un workspace

1. En la página [Members](https://platform.claude.com/settings/members) de la Claude Console, selecciona el workspace en el menú desplegable **Workspace**. Si muestra **All**, **Remove member** elimina al miembro de tu organización en su lugar.
2. Al final de la fila del miembro, abre el menú **More actions** (tres puntos) y selecciona **Remove member**.
3. Haz clic en **Remove** para confirmar.

<Note>
  Los administradores de la organización y los miembros de facturación no pueden ser eliminados de los workspaces mientras tengan esos roles de organización.
</Note>

#### Establecer límites de workspace

Los límites de velocidad y los límites de gasto de un workspace se establecen en lugares diferentes:

* **Límites de velocidad:** En la página [Límites de velocidad](https://platform.claude.com/usage/limits) de la Claude Console, selecciona el workspace en el menú desplegable **Workspace** y haz clic en **Edit** junto a un modelo para establecer límites de solicitudes por minuto, tokens de entrada o tokens de salida.
* **Límites de gasto:** En la página [Workspaces](https://platform.claude.com/settings/workspaces) de la Claude Console, selecciona el workspace. En el panel que se abre, haz clic en **Spend limits** para limitar el gasto mensual y configurar alertas cuando el gasto alcance ciertos umbrales.

#### Archivar un workspace

Para archivar un workspace, abre su menú **More actions** (tres puntos) y selecciona **Archive workspace**. Archivar:

* Preserva los datos históricos para informes
* Desactiva el workspace y archiva cada clave de API creada para él
* No se puede deshacer

<Warning>
  Archivar un workspace archiva cada clave de API creada para ese workspace en segundos (permanecen listadas en la Admin API como archivadas), y las claves de múltiples workspaces ya no pueden actuar en él. Esta acción no se puede deshacer. Si archivas el [workspace de Claude Code](https://platform.claude.com/docs/es/manage-claude/workspaces#claude-code-workspace), los miembros de tu organización ya no pueden iniciar sesión en Claude Code a través de la facturación de Console.
</Warning>

### Usando la Admin API

Gestiona workspaces de forma programática usando la [Admin API](https://platform.claude.com/docs/es/manage-claude/admin-api).

<Note>
  Los endpoints de la Admin API aceptan una [clave de Admin API](https://platform.claude.com/docs/es/manage-claude/admin-api-keys), un token OAuth `org:admin`, o una clave personal o de cuenta de servicio que no esté limitada a un workspace específico. Las claves de workspace no funcionan ahí. Consulta [Autenticación](https://platform.claude.com/docs/es/manage-claude/admin-api#authentication).
</Note>

Los siguientes ejemplos de SDK y CLI construyen el cliente predeterminado, que lee la clave de Admin API de la variable de entorno `ANTHROPIC_API_KEY`; los SDK exponen estos endpoints en `client.organization.workspaces` (csharp, go: `client.Organization.Workspaces`; java: `client.organization().workspaces()`; php: `$client->organization->workspaces`). Los métodos de listado de los SDK obtienen páginas adicionales bajo demanda, por lo que `limit` establece el tamaño de página; los ejemplos de PHP, Ruby y curl devuelven una página.

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

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

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

Para obtener detalles completos de los parámetros y los esquemas de respuesta, consulta la [referencia de la API de Workspaces](https://platform.claude.com/docs/es/api/organization/workspaces/retrieve).

### Gestión de miembros del workspace

Agregar un miembro a 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>

Actualizar el rol de un miembro:

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

Eliminar un miembro de 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>

Para obtener detalles completos de los parámetros, consulta la [referencia de la API de Workspace Members](https://platform.claude.com/docs/es/api/organization/workspaces/members/retrieve).

## Claves de API y alcance de recursos

Cada solicitud se ejecuta en exactamente un workspace y solo puede acceder a recursos dentro de ese workspace. Qué workspace depende del [tipo de clave](https://platform.claude.com/docs/es/manage-claude/authentication#key-types):

* Una **clave de workspace** (una clave heredada sin propietario) pertenece al workspace en el que se creó y siempre se ejecuta ahí.
* Una **clave personal** o **clave de cuenta de servicio** actúa como su usuario o cuenta de servicio. Una clave de un solo workspace siempre se ejecuta en el workspace elegido cuando se creó. Una clave de múltiples workspaces se ejecuta en el workspace nombrado por el encabezado `anthropic-workspace-id` de cada solicitud. Las cuentas deben tener acceso al workspace para usarlo.

Los recursos limitados a workspaces incluyen:

* **Archivos** creados a través de la [Files API](https://platform.claude.com/docs/es/build-with-claude/files)
* **Message Batches** creados a través de la [Batch API](https://platform.claude.com/docs/es/build-with-claude/batch-processing)
* **Skills** creados a través de la [Skills API](https://platform.claude.com/docs/es/build-with-claude/skills-guide)

Algunos recursos se gestionan de manera diferente:

* **[Los túneles MCP](https://platform.claude.com/docs/es/agents-and-tools/mcp-tunnels/overview)** se gestionan con un token OAuth `workspace:manage_tunnels` obtenido a través de [Workload Identity Federation](https://platform.claude.com/docs/es/manage-claude/workload-identity-federation), no con una clave de API. Los túneles se crean en un workspace, y la lista de **MCP tunnels** de la Console y el selector de servidor de Managed Agent muestran los túneles solo en el workspace actual; el límite de 10 túneles activos se aplica a toda la organización. La gestión de túneles requiere un rol con permisos de gestión de túneles; los desarrolladores de la organización pueden verlos pero no cambiarlos.
* **Los workspaces** en sí mismos y los **miembros de la organización** se gestionan a nivel de organización a través de la [Admin API](https://platform.claude.com/docs/es/manage-claude/admin-api), usando una clave de Admin API, un token OAuth `org:admin`, o una clave personal o de cuenta de servicio que no esté limitada a un workspace específico.

Para consultar los ID de workspace de tu organización, llama al endpoint [List Workspaces](https://platform.claude.com/docs/es/api/organization/workspaces/list) (pasa `include_default=true` para incluir el Default Workspace) o búscalos en la [Claude Console](https://platform.claude.com/settings/workspaces).

<Note>
  [Las cachés de prompts](https://platform.claude.com/docs/es/build-with-claude/prompt-caching) también están aisladas por workspace en la Claude API, [Claude Platform on AWS](https://platform.claude.com/docs/es/build-with-claude/claude-platform-on-aws) y [Microsoft Foundry](https://platform.claude.com/docs/es/build-with-claude/claude-in-microsoft-foundry). En Amazon Bedrock y Google Cloud, las cachés de prompts están aisladas por organización.
</Note>

## Identificar el workspace detrás de una respuesta de API

Las respuestas de la Claude API incluyen un encabezado `anthropic-workspace-id` junto con los [encabezados de respuesta](https://platform.claude.com/docs/es/api/overview#response-headers) `request-id` y `anthropic-organization-id`. Su valor es el ID con prefijo `wrkspc_` del workspace al que se resolvió la clave de API o el token de acceso de la solicitud, incluso cuando ese workspace es el Default Workspace. Por ejemplo, una respuesta exitosa incluye encabezados como estos:

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

El encabezado está ausente cuando la credencial no se resuelve a un workspace (por ejemplo, en solicitudes de la Admin API) o cuando la solicitud falla antes de que se complete la autenticación, como un error 401.

Los siguientes ejemplos envían una solicitud de la Messages API e imprimen el ID del workspace de los encabezados de respuesta:

<CodeGroup>
  ```bash cURL
  # -D - imprime los encabezados de respuesta; -o /dev/null descarta el cuerpo
  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 imprime la respuesta HTTP, incluyendo el Anthropic-Workspace-Id
  # encabezado, en stderr; > /dev/null oculta el cuerpo JSON en 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

  # Lee los encabezados de respuesta en el middleware por solicitud, que recibe la
  # respuesta HTTP sin procesar antes de que el SDK la analice
  workspace_id = nil
  read_workspace_id = lambda do |request, call_next|
    response = call_next.call(request)
    # Las claves en response.headers están en minúsculas
    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
```

Los mismos accesores leen el encabezado de otros endpoints de la Claude API también, incluyendo las APIs de [Claude Managed Agents](https://platform.claude.com/docs/es/managed-agents/overview). Por ejemplo, lee `anthropic-workspace-id` de la respuesta que [crea una sesión](https://platform.claude.com/docs/es/managed-agents/sessions) para registrar a qué workspace pertenece la sesión.

Con el ID del workspace de una respuesta, puedes:

* Confirmar hacia qué uso, costo y [límites de velocidad](https://platform.claude.com/docs/es/api/rate-limits) del workspace contó la solicitud
* Compararlo con el campo `workspace_id` en los informes de la [Usage and Cost API](https://platform.claude.com/docs/es/manage-claude/usage-cost-api) y en los objetos de la [Admin API](https://platform.claude.com/docs/es/manage-claude/admin-api) como las claves de API (ambos informan `null` para el Default Workspace, al igual que las claves de API para las claves de todos los workspaces; el campo `scope` de una clave de API distingue las dos y, para una clave vinculada a un workspace, lleva el ID real de ese workspace)
* Comprobar si es el ID de tu Default Workspace pasándolo a [Get Workspace](https://platform.claude.com/docs/es/api/organization/workspaces/retrieve) con una [clave de Admin API](https://platform.claude.com/docs/es/manage-claude/admin-api-keys): el Default Workspace se devuelve con `"name": "Default"`, aunque [List Workspaces](https://platform.claude.com/docs/es/api/organization/workspaces/list) lo omite a menos que pases `include_default=true`
* Abrir ese workspace en la [Console](https://platform.claude.com/settings/workspaces) para encontrar los recursos de la solicitud, como sesiones, archivos, lotes de mensajes y skills

## Límites de workspace

Puedes establecer límites personalizados de gasto y velocidad para cada workspace para protegerte contra el uso excesivo y garantizar una distribución justa de recursos.

### Establecer límites de workspace

Puedes establecer límites de workspace más bajos que (pero no más altos que) los límites de tu organización:

* **Límites de gasto:** Limita el gasto mensual de un workspace. Para establecerlos, ve a la página [Workspaces](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`) de la Claude Console y selecciona el workspace. En el panel que se abre, haz clic en **Spend limits**.
* **Límites de velocidad:** Limita las solicitudes por minuto, los tokens de entrada por minuto o los tokens de salida por minuto. Para establecerlos, ve a la página [Límites de velocidad](https://platform.claude.com/usage/limits) en la Claude Console, selecciona el workspace en el menú desplegable **Workspace** y haz clic en **Edit** junto a un modelo.

<Note>
  - No puedes establecer límites en el Default Workspace
  - Si no se establecen, los límites del workspace coinciden con los límites de la organización
  - Los límites de toda la organización siempre se aplican, incluso si los límites del workspace suman más
</Note>

Para obtener información detallada sobre los límites de velocidad y cómo funcionan, consulta [Límites de velocidad](https://platform.claude.com/docs/es/api/rate-limits). También puedes leer tus límites de velocidad actuales de organización y workspace de forma programática con la [Rate Limits API](https://platform.claude.com/docs/es/manage-claude/rate-limits-api).

## Seguimiento de uso y costos

Rastrea el uso y los costos por workspace usando la [Usage and Cost API](https://platform.claude.com/docs/es/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"
```

El uso y los costos atribuidos al Default Workspace tienen un valor `null` para `workspace_id`.

## Casos de uso comunes

### Separación de entornos

Crea workspaces separados para desarrollo, staging y producción:

| Workspace  | Propósito                                                              |
| ---------- | ---------------------------------------------------------------------- |
| Desarrollo | Pruebas y experimentación con límites de velocidad más bajos           |
| Staging    | Pruebas previas a producción con límites similares a los de producción |
| Producción | Tráfico en vivo con límites de velocidad completos y monitoreo         |

### Aislamiento de equipo o departamento

Asigna workspaces a diferentes equipos para la asignación de costos y el control de acceso:

* **Equipo de ingeniería** con acceso de desarrollador
* **Equipo de ciencia de datos** con sus propias claves de API
* **Equipo de soporte** con acceso limitado para herramientas de clientes

### Organización basada en proyectos

Crea workspaces para proyectos o productos específicos para rastrear el uso y los costos por separado.

## Mejores prácticas

<Steps>
  <Step title="Planifica la estructura de tu workspace">
    Considera cómo organizarás los workspaces antes de crearlos. Piensa en las necesidades de facturación, control de acceso y seguimiento de uso.
  </Step>

  <Step title="Usa nombres significativos">
    Nombra los workspaces claramente para indicar su propósito (por ejemplo, "Production - Customer Chatbot" o "Dev - Internal Tools").
  </Step>

  <Step title="Establece límites apropiados">
    Configura límites de gasto y velocidad para prevenir costos inesperados y garantizar una distribución justa de recursos.
  </Step>

  <Step title="Audita el acceso regularmente">
    Revisa la membresía del workspace periódicamente para garantizar que solo los usuarios apropiados tengan acceso.
  </Step>

  <Step title="Monitorea el uso">
    Usa la [Usage and Cost API](https://platform.claude.com/docs/es/manage-claude/usage-cost-api) para hacer un seguimiento del consumo a nivel de workspace.
  </Step>
</Steps>

## Preguntas frecuentes

<AccordionGroup>
  <Accordion title="¿Qué es el Default Workspace?">
    Cada organización tiene un "Default Workspace" que no se puede renombrar, archivar ni eliminar. Como todo workspace, tiene un ID `wrkspc_`: la API lo devuelve en el [encabezado de respuesta `anthropic-workspace-id`](https://platform.claude.com/docs/es/manage-claude/workspaces#identify-the-workspace-behind-an-api-response), y puedes pasarlo a [Get Workspace](https://platform.claude.com/docs/es/api/organization/workspaces/retrieve) y [Update Workspace](https://platform.claude.com/docs/es/api/organization/workspaces/update). No tiene una lista de miembros propia, porque el acceso a él depende del rol de organización de cada miembro. Aparece en los resultados de [List Workspaces](https://platform.claude.com/docs/es/api/organization/workspaces/list) solo cuando pasas `include_default=true`, y las claves de API, los informes de uso y los informes de costos que le pertenecen muestran `null` en `workspace_id`, al igual que las claves de API de todos los workspaces; el campo `scope` de una clave de API permite distinguir ambos casos y, para una clave que pertenece al Default Workspace, contiene su ID real.
  </Accordion>

  <Accordion title="¿Qué es el workspace de Claude Code?">
    Anthropic crea el workspace de Claude Code automáticamente la primera vez que un miembro de tu organización inicia sesión en Claude Code con su cuenta de Console. Aísla las claves de API, el uso y los límites de velocidad de Claude Code de tus otras cargas de trabajo. Consulta [Workspace de Claude Code](https://platform.claude.com/docs/es/manage-claude/workspaces#claude-code-workspace) para más detalles.
  </Accordion>

  <Accordion title="¿Hay límites en los workspaces?">
    Sí. Cada organización puede tener hasta 100 workspaces de forma predeterminada, y los workspaces archivados no cuentan para este límite. Si necesitas más, contacta a tu equipo de cuenta.
  </Accordion>

  <Accordion title="¿Cómo afectan los roles de organización al acceso al workspace?">
    Los administradores de la organización obtienen automáticamente el rol de Workspace Admin en todos los workspaces. Los miembros de facturación de la organización obtienen automáticamente el rol de Workspace Billing. Los usuarios y desarrolladores de la organización deben agregarse manualmente a cada workspace.
  </Accordion>

  <Accordion title="¿Qué roles se pueden asignar en los workspaces?">
    A los usuarios y desarrolladores de la organización se les pueden asignar los roles de Workspace Admin, Workspace Developer, Workspace Limited Developer o Workspace User. El rol de Workspace Billing no se puede asignar manualmente; se hereda de tener el rol `billing` de la organización.
  </Accordion>

  <Accordion title="¿Se pueden cambiar los roles de workspace de los administradores de la organización o los miembros de facturación?">
    Los administradores de la organización y los miembros de facturación no pueden tener sus roles de workspace cambiados ni ser eliminados de los workspaces mientras tengan esos roles de organización (con una excepción: los miembros de facturación pueden ser promovidos a un rol de Workspace Admin). Para todos los demás cubiertos por esta restricción, cambia primero su rol de organización para cambiar su acceso al workspace.
  </Accordion>

  <Accordion title="¿Qué sucede con el acceso al workspace cuando cambian los roles de organización?">
    Si un administrador de la organización o un miembro de facturación es degradado a usuario o desarrollador, pierde el acceso a todos los workspaces excepto aquellos donde se le asignaron roles manualmente. Cuando los usuarios son promovidos a roles de administrador o facturación, obtienen acceso automático a todos los workspaces.
  </Accordion>

  <Accordion title="¿Qué sucede con las claves de API cuando un usuario es eliminado de un workspace?">
    El comportamiento depende del [tipo de clave](https://platform.claude.com/docs/es/manage-claude/authentication#key-types).

    Una clave personal o de cuenta de servicio deja de funcionar en un workspace poco después de que su usuario o cuenta de servicio sea eliminado de él. Una clave de cuenta de servicio sigue funcionando incluso si el usuario que la creó es eliminado. Las claves de API de workspace continúan funcionando. En el [workspace de Claude Code](https://platform.claude.com/docs/es/manage-claude/workspaces#claude-code-workspace), cada clave está vinculada al miembro que la creó y deja de funcionar cuando ese miembro es eliminado.

    Las claves personales se archivan cuando su usuario es eliminado de la organización. Si el usuario es reinvitado, necesita crear nuevas claves; las claves archivadas no se restauran.
  </Accordion>
</AccordionGroup>

## Consulta también

* [Admin API](https://platform.claude.com/docs/es/manage-claude/admin-api)
* [Referencia de la Admin API](https://platform.claude.com/docs/es/api/organization)
* [Límites de velocidad](https://platform.claude.com/docs/es/api/rate-limits)
* [Usage and Cost API](https://platform.claude.com/docs/es/manage-claude/usage-cost-api)