---
title: Workspaces
url: https://platform.claude.com/docs/de/manage-claude/workspaces
description: Organisiere API-Keys, verwalte Teamzugriff und kontrolliere Kosten mit Workspaces.
---

Workspaces bieten eine Möglichkeit, deine API-Nutzung innerhalb einer Organisation zu organisieren. Verwende Workspaces, um verschiedene Projekte, Umgebungen oder Teams zu trennen und gleichzeitig eine zentralisierte Abrechnung und Verwaltung beizubehalten.

## Wie Workspaces funktionieren

Jede Organisation hat einen **Default Workspace**, der nicht umbenannt, archiviert oder gelöscht werden kann. Wenn du zusätzliche Workspaces erstellst, kannst du jedem davon Mitglieder, Service-Accounts, API-Keys und Ressourcenlimits zuweisen.

Wichtige Merkmale:

* **Workspace-Identifikatoren** verwenden das Präfix `wrkspc_` (zum Beispiel `wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ`)
* **Maximal 100 Workspaces** pro Organisation standardmäßig (archivierte Workspaces zählen nicht); kontaktiere dein Account-Team, wenn du mehr benötigst
* Der **Default Workspace** hat wie jeder andere Workspace eine `wrkspc_`-ID (zurückgegeben im [`anthropic-workspace-id`-Response-Header](https://platform.claude.com/docs/de/manage-claude/workspaces#identify-the-workspace-behind-an-api-response) und akzeptiert von [Get Workspace](https://platform.claude.com/docs/de/api/organization/workspaces/retrieve)), erscheint aber in den Ergebnissen von [List Workspaces](https://platform.claude.com/docs/de/api/organization/workspaces/list) nur, wenn du `include_default=true` übergibst, wobei API-Keys, Nutzungsberichte und Kostenberichte `null` als seine `workspace_id` anzeigen, ebenso wie API-Keys für alle Workspaces (das Feld `scope` eines API-Keys unterscheidet sie; bei einem an den Default Workspace gebundenen Key enthält es die echte ID)
* **API-Keys** können auf einen einzelnen Workspace beschränkt werden. In diesem Fall können sie nur auf Ressourcen innerhalb dieses Workspaces zugreifen. Einige API-Keys können Berechtigungen über mehrere Workspaces hinweg erhalten und stellen einen [Workspace-ID-Header](https://platform.claude.com/docs/de/manage-claude/authentication#select-a-workspace) bereit, um auf Ressourcen innerhalb dieses Workspaces zuzugreifen

### Claude Code Workspace

Wenn ein Mitglied deiner Organisation sich zum ersten Mal bei [Claude Code](https://code.claude.com/docs/en/overview) mit seinem Claude Console-Account anmeldet, erstellt Anthropic automatisch einen **Claude Code**-Workspace in der Organisation und fügt dieses Mitglied hinzu. Jedes nachfolgende Mitglied, das sich bei Claude Code anmeldet, wird auf dieselbe Weise hinzugefügt.

Der Claude Code Workspace hält den Claude Code-Traffic von deinen anderen API-Workloads getrennt:

* Claude Code erstellt bei der Anmeldung einen benutzerspezifischen API-Key in diesem Workspace. Du kannst darin keine Keys manuell über die Console erstellen.
* Ein Claude Code-Key funktioniert nicht mehr, wenn sein Besitzer aus dem Workspace oder der Organisation entfernt wird, anders als ein Workspace-Key.
* Die Claude Code-Nutzung unterliegt separaten Ratenlimits, und Admins können ihren Anteil an den Limits der Organisation auf der Seite [Rate limits](https://platform.claude.com/usage/limits) in der Claude Console begrenzen.
* Es ist der einzige Workspace, der benutzerspezifische monatliche Ausgabenlimits unterstützt.

<Warning>
  Das Archivieren des Claude Code Workspace deaktiviert die Claude Code-Anmeldung über die Console-Abrechnung für die gesamte Organisation.
</Warning>

## Workspace-Rollen und -Berechtigungen

Mitglieder können in jedem Workspace unterschiedliche Rollen haben, was eine feingranulare Zugriffskontrolle ermöglicht.

| Rolle                       | Berechtigungen                                                                                                                      |
| --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| Workspace User              | Nur Playground verwenden                                                                                                            |
| Workspace Limited Developer | API-Keys erstellen und verwalten, die API verwenden. Kann nicht auf Session-Tracing-Ansichten zugreifen oder Dateien herunterladen. |
| Workspace Developer         | API-Keys erstellen und verwalten, die API verwenden                                                                                 |
| Workspace Admin             | Volle Kontrolle über Workspace-Einstellungen und -Mitglieder                                                                        |
| Workspace Billing           | Workspace-Abrechnungsinformationen anzeigen (geerbt von der Organisations-Abrechnungsrolle)                                         |

### Rollenvererbung

* **Organisations-Admins** erhalten automatisch Workspace Admin-Zugriff auf alle Workspaces
* **Organisations-Abrechnungsmitglieder** erhalten automatisch Workspace Billing-Zugriff auf alle Workspaces
* **Organisations-Benutzer und -Entwickler** müssen jedem Workspace explizit hinzugefügt werden
* **Service-Accounts** werden auf der Seite [Service accounts](https://platform.claude.com/settings/service-accounts) (`platform.claude.com/settings/service-accounts`) in der Claude Console zu Workspaces hinzugefügt: Wähle **Add to workspace** im Menü des Accounts oder auf seiner eigenen Seite. Um die Accounts in einem Workspace zu sehen, filtere die Liste nach Workspace.

<Note>
  Die Workspace Billing-Rolle kann nicht manuell zugewiesen werden. Sie wird dadurch geerbt, dass man die Organisations-Abrechnungsrolle hat.
</Note>

## Workspaces verwalten

<Note>
  Nur Organisations-Admins können Workspaces erstellen. Organisations-Benutzer und -Entwickler müssen von einem Admin zu Workspaces hinzugefügt werden.
</Note>

### Verwendung der Console

Erstelle und verwalte Workspaces in der [Claude Console](https://platform.claude.com/settings/workspaces).

#### Einen Workspace erstellen

<Steps>
  <Step title="Workspace-Einstellungen öffnen">
    Gehe in der Claude Console zur Seite [Workspaces](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`).
  </Step>

  <Step title="Die Seite Create workspace öffnen">
    Klicke auf **Create workspace**, um die Seite [Create workspace](https://platform.claude.com/settings/workspaces/new) (`platform.claude.com/settings/workspaces/new`) in der Console zu öffnen.
  </Step>

  <Step title="Den Workspace konfigurieren">
    Gib einen Workspace-Namen ein und wähle eine Farbe zur visuellen Identifikation.
  </Step>

  <Step title="Den Workspace erstellen">
    Klicke auf **Create workspace**, um den Vorgang abzuschließen.
  </Step>
</Steps>

<Tip>
  Um in der Console zwischen Workspaces zu wechseln, öffne eine Seite, die zu einem Workspace gehört, wie [Files](https://platform.claude.com/files) (`platform.claude.com/files`), und verwende die Workspace-Auswahl in der Seitenleiste.
</Tip>

#### Workspace-Details bearbeiten

Um den Namen oder die Farbe eines Workspaces zu ändern:

1. Wähle den Workspace aus der Liste aus.
2. Öffne das Menü **More actions** (drei Punkte) und wähle **Edit details**.
3. Aktualisiere den Namen oder die Farbe und speichere deine Änderungen.

<Note>
  Der Default Workspace kann nicht umbenannt oder gelöscht werden.
</Note>

#### Mitglieder zu einem Workspace hinzufügen

1. Gehe in der Claude Console zur Seite [Members](https://platform.claude.com/settings/members) (`platform.claude.com/settings/members`).
2. Klicke auf **Add to workspace**.
3. Wähle den Workspace, das hinzuzufügende Organisationsmitglied und seine [Workspace-Rolle](https://platform.claude.com/docs/de/manage-claude/workspaces#workspace-roles-and-permissions).
4. Klicke zur Bestätigung auf **Add to workspace**.

#### Mitglieder aus einem Workspace entfernen

1. Wähle auf der Seite [Members](https://platform.claude.com/settings/members) in der Claude Console den Workspace aus dem Dropdown-Menü **Workspace** aus. Wenn dort **All** angezeigt wird, entfernt **Remove member** das Mitglied stattdessen aus deiner Organisation.
2. Öffne am Ende der Zeile des Mitglieds das Menü **More actions** (drei Punkte) und wähle **Remove member**.
3. Klicke zur Bestätigung auf **Remove**.

<Note>
  Organisations-Admins und Abrechnungsmitglieder können nicht aus Workspaces entfernt werden, solange sie diese Organisationsrollen innehaben.
</Note>

#### Workspace-Limits festlegen

Ratenlimits und Ausgabenlimits eines Workspaces legst du an unterschiedlichen Stellen fest:

* **Rate limits:** Wähle auf der Seite [Rate limits](https://platform.claude.com/usage/limits) in der Claude Console den Workspace aus dem Dropdown-Menü **Workspace** aus und klicke neben einem Modell auf **Edit**, um Limits für Anfragen pro Minute, Input-Tokens oder Output-Tokens festzulegen.
* **Spend limits:** Wähle auf der Seite [Workspaces](https://platform.claude.com/settings/workspaces) in der Claude Console den Workspace aus. Klicke im sich öffnenden Bereich auf **Spend limits**, um die monatlichen Ausgaben zu begrenzen und Benachrichtigungen zu konfigurieren, wenn die Ausgaben bestimmte Schwellenwerte erreichen.

#### Einen Workspace archivieren

Um einen Workspace zu archivieren, öffne sein Menü **More actions** (drei Punkte) und wähle **Archive workspace**. Das Archivieren:

* Bewahrt historische Daten für Berichte auf
* Deaktiviert den Workspace und archiviert jeden für ihn erstellten API-Key
* Kann nicht rückgängig gemacht werden

<Warning>
  Das Archivieren eines Workspaces archiviert jeden für diesen Workspace erstellten API-Key innerhalb von Sekunden (sie bleiben in der Admin-API als archiviert gelistet), und Multi-Workspace-Keys können nicht mehr darin agieren. Diese Aktion kann nicht rückgängig gemacht werden. Wenn du den [Claude Code Workspace](https://platform.claude.com/docs/de/manage-claude/workspaces#claude-code-workspace) archivierst, können sich Mitglieder deiner Organisation nicht mehr über die Console-Abrechnung bei Claude Code anmelden.
</Warning>

### Verwendung der Admin-API

Verwalte Workspaces programmatisch mit der [Admin-API](https://platform.claude.com/docs/de/manage-claude/admin-api).

<Note>
  Admin-API-Endpunkte akzeptieren einen [Admin-API-Key](https://platform.claude.com/docs/de/manage-claude/admin-api-keys), ein `org:admin`-OAuth-Token oder einen persönlichen oder Service-Account-Key, der nicht auf einen bestimmten Workspace beschränkt ist. Workspace-Keys funktionieren dort nicht. Siehe [Authentifizierung](https://platform.claude.com/docs/de/manage-claude/admin-api#authentication).
</Note>

Die folgenden SDK- und CLI-Beispiele erstellen den Standard-Client, der den Admin-API-Key aus der Umgebungsvariable `ANTHROPIC_API_KEY` liest; die SDKs stellen diese Endpunkte unter `client.organization.workspaces` (csharp, go: `client.Organization.Workspaces`; java: `client.organization().workspaces()`; php: `$client->organization->workspaces`) bereit. SDK-Listenmethoden rufen weitere Seiten bei Bedarf ab, daher legt `limit` die Seitengröße fest; die PHP-, Ruby- und curl-Beispiele geben eine Seite zurück.

Einen Workspace erstellen:

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

Workspaces auflisten:

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

Einen Workspace archivieren:

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

Vollständige Parameterdetails und Response-Schemas findest du in der [Workspaces-API-Referenz](https://platform.claude.com/docs/de/api/organization/workspaces/retrieve).

### Workspace-Mitglieder verwalten

Ein Mitglied zu einem Workspace hinzufügen:

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

Die Rolle eines Mitglieds aktualisieren:

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

Ein Mitglied aus einem Workspace entfernen:

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

Vollständige Parameterdetails findest du in der [Workspace-Members-API-Referenz](https://platform.claude.com/docs/de/api/organization/workspaces/members/retrieve).

## API-Keys und Ressourcen-Scoping

Jede Anfrage läuft in genau einem Workspace und kann nur auf Ressourcen innerhalb dieses Workspaces zugreifen. Welcher Workspace, hängt vom [Key-Typ](https://platform.claude.com/docs/de/manage-claude/authentication#key-types) ab:

* Ein **Workspace-Key** (ein veralteter Key ohne Besitzer) gehört zu dem Workspace, in dem er erstellt wurde, und läuft immer dort.
* Ein **persönlicher Key** oder **Service-Account-Key** agiert als sein Benutzer oder Service-Account. Ein Single-Workspace-Key läuft immer in dem Workspace, der bei seiner Erstellung gewählt wurde. Ein Multi-Workspace-Key läuft in dem Workspace, der durch den `anthropic-workspace-id`-Header jeder Anfrage benannt wird. Accounts müssen Zugriff auf den Workspace haben, um ihn zu verwenden.

Zu den auf Workspaces beschränkten Ressourcen gehören:

* **Dateien**, die über die [Files-API](https://platform.claude.com/docs/de/build-with-claude/files) erstellt wurden
* **Message Batches**, die über die [Batch-API](https://platform.claude.com/docs/de/build-with-claude/batch-processing) erstellt wurden
* **Skills**, die über die [Skills-API](https://platform.claude.com/docs/de/build-with-claude/skills-guide) erstellt wurden

Einige Ressourcen werden anders verwaltet:

* **[MCP-Tunnel](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/overview)** werden mit einem `workspace:manage_tunnels`-OAuth-Token verwaltet, das über [Workload Identity Federation](https://platform.claude.com/docs/de/manage-claude/workload-identity-federation) erhalten wird, nicht mit einem API-Key. Tunnel werden in einem Workspace erstellt, und die Console-Liste **MCP tunnels** sowie der Managed-Agent-Server-Picker zeigen nur Tunnel im aktuellen Workspace; das Limit von 10 aktiven Tunneln gilt organisationsweit. Die Tunnelverwaltung erfordert eine Rolle mit Tunnelverwaltungsberechtigungen; Organisationsentwickler können sie anzeigen, aber nicht ändern.
* **Workspaces** selbst und **Organisationsmitglieder** werden auf Organisationsebene über die [Admin-API](https://platform.claude.com/docs/de/manage-claude/admin-api) verwaltet, unter Verwendung eines Admin-API-Keys, eines `org:admin`-OAuth-Tokens oder eines persönlichen oder Service-Account-Keys, der nicht auf einen bestimmten Workspace beschränkt ist.

Um die Workspace-IDs deiner Organisation nachzuschlagen, rufe den Endpunkt [List Workspaces](https://platform.claude.com/docs/de/api/organization/workspaces/list) auf (übergib `include_default=true`, um den Default Workspace einzuschließen) oder finde sie in der [Claude Console](https://platform.claude.com/settings/workspaces).

<Note>
  [Prompt-Caches](https://platform.claude.com/docs/de/build-with-claude/prompt-caching) sind auf der Claude-API, der [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws) und [Microsoft Foundry](https://platform.claude.com/docs/de/build-with-claude/claude-in-microsoft-foundry) ebenfalls pro Workspace isoliert. Auf Amazon Bedrock und Google Cloud sind Prompt-Caches pro Organisation isoliert.
</Note>

## Den Workspace hinter einer API-Antwort identifizieren

Claude-API-Antworten enthalten einen `anthropic-workspace-id`-Header neben den [Response-Headern](https://platform.claude.com/docs/de/api/overview#response-headers) `request-id` und `anthropic-organization-id`. Sein Wert ist die mit `wrkspc_` präfixierte ID des Workspaces, zu dem der API-Key oder das Access-Token der Anfrage aufgelöst wurde, auch wenn dieser Workspace der Default Workspace ist. Zum Beispiel enthält eine erfolgreiche Antwort Header wie diese:

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

Der Header fehlt, wenn die Anmeldeinformation nicht zu einem Workspace aufgelöst wird (zum Beispiel bei Admin-API-Anfragen) oder wenn die Anfrage fehlschlägt, bevor die Authentifizierung abgeschlossen ist, etwa bei einem 401-Fehler.

Die folgenden Beispiele senden eine Messages-API-Anfrage und geben die Workspace-ID aus den Response-Headern aus:

<CodeGroup>
  ```bash cURL
  # -D - gibt die Antwort-Header aus; -o /dev/null verwirft den Body
  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 gibt die HTTP-Antwort, einschließlich der Anthropic-Workspace-Id,
  # Header, auf stderr aus; > /dev/null verbirgt den JSON-Body auf 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

  # Lies Response-Header in der Middleware pro Anfrage, die die
  # rohe HTTP-Response erhält, bevor das SDK sie parst
  workspace_id = nil
  read_workspace_id = lambda do |request, call_next|
    response = call_next.call(request)
    # Keys in response.headers sind kleingeschrieben
    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
```

Dieselben Accessoren lesen den Header auch von anderen Claude-API-Endpunkten, einschließlich der [Claude Managed Agents](https://platform.claude.com/docs/de/managed-agents/overview)-APIs. Lies zum Beispiel `anthropic-workspace-id` aus der Antwort, die [eine Session erstellt](https://platform.claude.com/docs/de/managed-agents/sessions), um festzuhalten, zu welchem Workspace die Session gehört.

Mit der Workspace-ID aus einer Antwort kannst du:

* Bestätigen, auf welche Nutzung, Kosten und [Ratenlimits](https://platform.claude.com/docs/de/api/rate-limits) welches Workspaces die Anfrage angerechnet wurde
* Sie abgleichen mit dem `workspace_id`-Feld in [Usage- und Cost-API](https://platform.claude.com/docs/de/manage-claude/usage-cost-api)-Berichten und auf [Admin-API](https://platform.claude.com/docs/de/manage-claude/admin-api)-Objekten wie API-Keys (beide melden `null` für den Default Workspace, ebenso wie API-Keys für All-Workspaces-Keys; das `scope`-Feld eines API-Keys unterscheidet die beiden und trägt für einen an einen Workspace gebundenen Key die echte ID dieses Workspaces)
* Prüfen, ob es die ID deines Default Workspace ist, indem du sie mit einem [Admin-API-Key](https://platform.claude.com/docs/de/manage-claude/admin-api-keys) an [Get Workspace](https://platform.claude.com/docs/de/api/organization/workspaces/retrieve) übergibst: Der Default Workspace wird mit `"name": "Default"` zurückgegeben, obwohl [List Workspaces](https://platform.claude.com/docs/de/api/organization/workspaces/list) ihn auslässt, sofern du nicht `include_default=true` übergibst
* Diesen Workspace in der [Console](https://platform.claude.com/settings/workspaces) öffnen, um die Ressourcen der Anfrage zu finden, wie Sessions, Dateien, Message Batches und Skills

## Workspace-Limits

Du kannst benutzerdefinierte Ausgaben- und Ratenlimits für jeden Workspace festlegen, um vor Überbeanspruchung zu schützen und eine faire Ressourcenverteilung sicherzustellen.

### Workspace-Limits festlegen

Du kannst Workspace-Limits niedriger (aber nicht höher) als die Limits deiner Organisation festlegen:

* **Spend limits:** Begrenze die monatlichen Ausgaben für einen Workspace. Um diese festzulegen, gehe in der Claude Console zur Seite [Workspaces](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`) und wähle den Workspace aus. Klicke im sich öffnenden Bereich auf **Spend limits**.
* **Rate limits:** Begrenze Anfragen pro Minute, Input-Tokens pro Minute oder Output-Tokens pro Minute. Um diese festzulegen, gehe in der Claude Console zur Seite [Rate limits](https://platform.claude.com/usage/limits), wähle den Workspace aus dem Dropdown-Menü **Workspace** aus und klicke neben einem Modell auf **Edit**.

<Note>
  - Du kannst keine Limits für den Default Workspace festlegen
  - Wenn nicht festgelegt, entsprechen die Workspace-Limits den Limits der Organisation
  - Organisationsweite Limits gelten immer, auch wenn die Workspace-Limits in Summe mehr ergeben
</Note>

Detaillierte Informationen zu Ratenlimits und deren Funktionsweise findest du unter [Ratenlimits](https://platform.claude.com/docs/de/api/rate-limits). Du kannst deine aktuellen Organisations- und Workspace-Ratenlimits auch programmatisch mit der [Rate-Limits-API](https://platform.claude.com/docs/de/manage-claude/rate-limits-api) auslesen.

## Nutzungs- und Kostenverfolgung

Verfolge Nutzung und Kosten nach Workspace mit der [Usage- und Cost-API](https://platform.claude.com/docs/de/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"
```

Nutzung und Kosten, die dem Default Workspace zugeordnet sind, haben einen `null`-Wert für `workspace_id`.

## Häufige Anwendungsfälle

### Umgebungstrennung

Erstelle separate Workspaces für Entwicklung, Staging und Produktion:

| Workspace   | Zweck                                                  |
| ----------- | ------------------------------------------------------ |
| Development | Testen und Experimentieren mit niedrigeren Ratenlimits |
| Staging     | Vorproduktionstests mit produktionsähnlichen Limits    |
| Production  | Live-Traffic mit vollen Ratenlimits und Monitoring     |

### Team- oder Abteilungsisolierung

Weise verschiedenen Teams Workspaces für Kostenzuordnung und Zugriffskontrolle zu:

* **Engineering-Team** mit Entwicklerzugriff
* **Data-Science-Team** mit eigenen API-Keys
* **Support-Team** mit eingeschränktem Zugriff für Kundentools

### Projektbasierte Organisation

Erstelle Workspaces für bestimmte Projekte oder Produkte, um Nutzung und Kosten separat zu verfolgen.

## Best Practices

<Steps>
  <Step title="Plane deine Workspace-Struktur">
    Überlege, wie du Workspaces organisieren wirst, bevor du sie erstellst. Denke an Abrechnungs-, Zugriffskontroll- und Nutzungsverfolgungsbedürfnisse.
  </Step>

  <Step title="Verwende aussagekräftige Namen">
    Benenne Workspaces klar, um ihren Zweck anzugeben (zum Beispiel „Production - Customer Chatbot" oder „Dev - Internal Tools").
  </Step>

  <Step title="Lege angemessene Limits fest">
    Konfiguriere Ausgaben- und Ratenlimits, um unerwartete Kosten zu vermeiden und eine faire Ressourcenverteilung sicherzustellen.
  </Step>

  <Step title="Überprüfe den Zugriff regelmäßig">
    Überprüfe die Workspace-Mitgliedschaft regelmäßig, um sicherzustellen, dass nur geeignete Benutzer Zugriff haben.
  </Step>

  <Step title="Überwache die Nutzung">
    Verwende die [Usage- und Cost-API](https://platform.claude.com/docs/de/manage-claude/usage-cost-api), um den Verbrauch auf Workspace-Ebene zu verfolgen.
  </Step>
</Steps>

## FAQ

<AccordionGroup>
  <Accordion title="Was ist der Default Workspace?">
    Jede Organisation hat einen „Default Workspace", der nicht umbenannt, archiviert oder gelöscht werden kann. Wie jeder Workspace hat er eine `wrkspc_`-ID: Die API gibt sie im [`anthropic-workspace-id`-Response-Header](https://platform.claude.com/docs/de/manage-claude/workspaces#identify-the-workspace-behind-an-api-response) zurück, und du kannst sie an [Get Workspace](https://platform.claude.com/docs/de/api/organization/workspaces/retrieve) und [Update Workspace](https://platform.claude.com/docs/de/api/organization/workspaces/update) übergeben. Er hat keine eigene Mitgliederliste, da sich der Zugriff darauf nach der Organisationsrolle jedes Mitglieds richtet. Er erscheint in den Ergebnissen von [List Workspaces](https://platform.claude.com/docs/de/api/organization/workspaces/list) nur, wenn du `include_default=true` übergibst, und API-Keys, Nutzungsberichte und Kostenberichte, die zu ihm gehören, zeigen `null` für `workspace_id` an, ebenso wie API-Keys für alle Workspaces; das Feld `scope` eines API-Keys unterscheidet die beiden und enthält bei einem Key, der zum Default Workspace gehört, dessen echte ID.
  </Accordion>

  <Accordion title="Was ist der Claude Code Workspace?">
    Anthropic erstellt den Claude Code Workspace automatisch, wenn sich ein Mitglied deiner Organisation zum ersten Mal mit seinem Console-Account bei Claude Code anmeldet. Er isoliert die API-Keys, die Nutzung und die Ratenlimits von Claude Code von deinen anderen Workloads. Siehe [Claude Code Workspace](https://platform.claude.com/docs/de/manage-claude/workspaces#claude-code-workspace) für Details.
  </Accordion>

  <Accordion title="Gibt es Limits für Workspaces?">
    Ja. Jede Organisation kann standardmäßig bis zu 100 Workspaces haben, und archivierte Workspaces zählen nicht zu diesem Limit. Wenn du mehr benötigst, kontaktiere dein Account-Team.
  </Accordion>

  <Accordion title="Wie wirken sich Organisationsrollen auf den Workspace-Zugriff aus?">
    Organisations-Admins erhalten automatisch die Workspace Admin-Rolle in allen Workspaces. Organisations-Abrechnungsmitglieder erhalten automatisch die Workspace Billing-Rolle. Organisations-Benutzer und -Entwickler müssen jedem Workspace manuell hinzugefügt werden.
  </Accordion>

  <Accordion title="Welche Rollen können in Workspaces zugewiesen werden?">
    Organisations-Benutzern und -Entwicklern können die Rollen Workspace Admin, Workspace Developer, Workspace Limited Developer oder Workspace User zugewiesen werden. Die Workspace Billing-Rolle kann nicht manuell zugewiesen werden; sie wird dadurch geerbt, dass man die Organisations-`billing`-Rolle hat.
  </Accordion>

  <Accordion title="Können die Workspace-Rollen von Organisations-Admin- oder Abrechnungsmitgliedern geändert werden?">
    Organisations-Admins und Abrechnungsmitglieder können ihre Workspace-Rollen nicht ändern lassen oder aus Workspaces entfernt werden, solange sie diese Organisationsrollen innehaben (mit einer Ausnahme: Abrechnungsmitglieder können auf eine Workspace Admin-Rolle hochgestuft werden). Für alle anderen, die von dieser Einschränkung betroffen sind, ändere zuerst ihre Organisationsrolle, um ihren Workspace-Zugriff zu ändern.
  </Accordion>

  <Accordion title="Was passiert mit dem Workspace-Zugriff, wenn sich Organisationsrollen ändern?">
    Wenn ein Organisations-Admin oder Abrechnungsmitglied zu einem Benutzer oder Entwickler herabgestuft wird, verliert er den Zugriff auf alle Workspaces außer denen, in denen ihm manuell Rollen zugewiesen wurden. Wenn Benutzer zu Admin- oder Abrechnungsrollen hochgestuft werden, erhalten sie automatischen Zugriff auf alle Workspaces.
  </Accordion>

  <Accordion title="Was passiert mit API-Keys, wenn ein Benutzer aus einem Workspace entfernt wird?">
    Das Verhalten hängt vom [Key-Typ](https://platform.claude.com/docs/de/manage-claude/authentication#key-types) ab.

    Ein persönlicher oder Service-Account-Key funktioniert in einem Workspace kurz nachdem sein Benutzer oder Service-Account daraus entfernt wurde nicht mehr. Ein Service-Account-Key funktioniert weiter, auch wenn der Benutzer, der ihn erstellt hat, entfernt wird. Workspace-API-Keys funktionieren weiterhin. Im [Claude Code Workspace](https://platform.claude.com/docs/de/manage-claude/workspaces#claude-code-workspace) ist jeder Key an das Mitglied gebunden, das ihn erstellt hat, und funktioniert nicht mehr, wenn dieses Mitglied entfernt wird.

    Persönliche Keys werden archiviert, wenn ihr Benutzer aus der Organisation entfernt wird. Wenn der Benutzer erneut eingeladen wird, muss er neue Keys erstellen; archivierte Keys werden nicht wiederhergestellt.
  </Accordion>
</AccordionGroup>

## Siehe auch

* [Admin-API](https://platform.claude.com/docs/de/manage-claude/admin-api)
* [Admin-API-Referenz](https://platform.claude.com/docs/de/api/organization)
* [Ratenlimits](https://platform.claude.com/docs/de/api/rate-limits)
* [Usage- und Cost-API](https://platform.claude.com/docs/de/manage-claude/usage-cost-api)