---
title: Plugins-API
url: https://platform.claude.com/docs/de/manage-claude/plugins-api
description: "Erfasse und verwalte die Plugins in deiner Claude Enterprise-Organisation: Lade Plugins und Versionen hoch, wähle die Version, die Mitgliedern bereitgestellt wird, lege fest, wer welches Plugin nutzen kann, lade Plugin-Dateien zur Prüfung herunter und validiere einen Marketplace, bevor du ihn verbindest."
---

Mit der Plugins API kannst du Folgendes tun:

* Die Plugins in deiner Claude Enterprise-Organisation inventarisieren
* Plugins und neue Versionen aus deinen eigenen Pipelines veröffentlichen
* Auswählen, welche Version Mitgliedern bereitgestellt wird
* Steuern, wer jedes Plugin verwenden kann
* Plugin-Dateien zur Prüfung herunterladen
* Einen Git-Marketplace prüfen, bevor du ihn verbindest

Berichte zur *Nutzung* von Plugins (welche Plugins und Skills Mitglieder nutzen und wie oft) findest du unter [Analytics-APIs](https://platform.claude.com/docs/de/manage-claude/analytics-api).

<Check>
  **Admin-API-Key mit Scope erforderlich**

  Diese Endpunkte erfordern einen Admin-API-Key mit dem Scope `read:plugins` (für `GET`-Endpunkte, einschließlich Archiv-Downloads) oder dem Scope `write:plugins` (für `POST`- und `DELETE`-Endpunkte, mit Ausnahme der Marketplace-Validierung, die beide Scopes erlauben); Details findest du unter [Scopes](https://platform.claude.com/docs/de/manage-claude/plugins-api#scopes), einschließlich zweier weiterer Lese-Scopes, die ebenfalls funktionieren. Unter [Admin-API-Key erstellen](https://platform.claude.com/docs/de/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization) erfährst du, wo dein Haupteigentümer einen solchen Key erstellt. Übergib den Key bei jeder Anfrage im Header `x-api-key`, zusammen mit dem Header [`anthropic-version`](https://platform.claude.com/docs/de/api/versioning) und dem Beta-Header aus dem folgenden Hinweis.
</Check>

<Note>
  Die Plugins-API befindet sich in der **Beta** und ist nur für Claude Enterprise-Organisationen verfügbar. Sie ist nicht für Claude Platform-Organisationen (Claude Console) verfügbar und auch nicht für Organisationen, bei denen HIPAA-Readiness aktiviert ist.

  Jede Anfrage muss den [Beta-Header](https://platform.claude.com/docs/de/api/beta-headers) `anthropic-beta: ce-plugins-2026-09-01` enthalten (das SDK und die `ant` CLI senden ihn für dich). Eine Anfrage ohne ihn gibt `404` zurück, genau so, als ob der Endpunkt nicht existieren würde.
</Note>

## Endpunkte

Die API stellt 18 Endpunkte für fünf Ressourcen bereit:

| Ressource                                                                                                                                                                                         | Endpunkte                                                                                                                                                                                                                                                                                                                 |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Plugins:** die Plugins der Organisation auflisten, ein neues hochladen, eines abrufen, die Version wählen, die Mitgliedern bereitgestellt wird (Rollback oder Promotion), eines löschen         | `GET /v1/organizations/plugins`<br />`POST /v1/organizations/plugins`<br />`GET /v1/organizations/plugins/{plugin_id}`<br />`POST /v1/organizations/plugins/{plugin_id}`<br />`DELETE /v1/organizations/plugins/{plugin_id}`                                                                                              |
| **Plugin-Versionen:** den Versionsverlauf eines Plugins auflisten, eine neue Version hochladen, eine abrufen, die Dateien einer Version herunterladen                                             | `GET /v1/organizations/plugins/{plugin_id}/versions`<br />`POST /v1/organizations/plugins/{plugin_id}/versions`<br />`GET /v1/organizations/plugins/{plugin_id}/versions/{version}`<br />`GET /v1/organizations/plugins/{plugin_id}/versions/{version}/content`                                                           |
| **Installationseinstellungen:** lesen, wer ein organisationseigenes Plugin nutzen kann, dies für die gesamte Organisation oder für eine Gruppe festlegen, eine der beiden Einstellungen entfernen | `GET /v1/organizations/plugins/{plugin_id}/installation_settings`<br />`POST /v1/organizations/plugins/{plugin_id}/installation_settings/{target}`<br />`DELETE /v1/organizations/plugins/{plugin_id}/installation_settings/{target}`                                                                                     |
| **Freigaben:** lesen, mit wem ein Mitglied sein eigenes Plugin geteilt hat (nur lesend)                                                                                                           | `GET /v1/organizations/plugins/{plugin_id}/shares`                                                                                                                                                                                                                                                                        |
| **Plugin-Marketplaces:** die ID eines Marketplace finden, einen abrufen, die Standard-Installationseinstellung für seine Plugins festlegen, Marketplace-Inhalte vor dem Verbinden prüfen          | `GET /v1/organizations/plugin_marketplaces`<br />`GET /v1/organizations/plugin_marketplaces/{marketplace_id}`<br />`POST /v1/organizations/plugin_marketplaces/{marketplace_id}`<br />`POST /v1/organizations/plugin_marketplaces/validate_repository`<br />`POST /v1/organizations/plugin_marketplaces/validate_archive` |

Plugins, die Anthropic veröffentlicht, werden nicht erfasst; ihre Nutzung wird von den [Analytics-APIs](https://platform.claude.com/docs/de/manage-claude/analytics-api) gemeldet. Marketplaces werden in claude.ai erstellt, mit Repositories verbunden und gelöscht, nicht über diese API.

## Voraussetzungen

* Deine Organisation muss einen Claude Enterprise-Plan haben.
* Dein Haupteigentümer erstellt einen Admin-API-Key mit dem Scope `read:plugins`, dem Scope `write:plugins` oder beiden unter [claude.ai > Organisationseinstellungen > API](https://claude.ai/admin-settings/api-access). Siehe [Key für eine Claude Enterprise-Organisation erstellen](https://platform.claude.com/docs/de/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization).
* Jede Anfrage enthält drei Header: `x-api-key`, `anthropic-version: 2026-10-21` und `anthropic-beta: ce-plugins-2026-09-01`.

In Python, TypeScript, C#, Go, Java, PHP und Ruby stellt das SDK diese Endpunkte unter `client.beta.organization` (csharp, go: `client.Beta.Organization`; java: `client.beta().organization()`; php: `$client->beta->organization`) bereit und die [`ant` CLI](https://platform.claude.com/docs/de/cli-sdks-libraries/cli/quickstart) unter `ant beta:organization`; sie senden die Header `anthropic-version` und `anthropic-beta` für dich. Die Beispiele auf dieser Seite lesen den Admin-API-Key aus der Umgebungsvariable `ANTHROPIC_API_KEY`. Wo ein SDK oder die CLI weitere Seiten für dich abruft, legt `limit` die Seitengröße fest, nicht die Gesamtzahl (siehe [Paginierung](https://platform.claude.com/docs/de/manage-claude/plugins-api#pagination)).

API-Keys gehören der Organisation und funktionieren weiter, nachdem die Person, die sie erstellt hat, die Organisation verlässt. Teile sie nicht und checke sie nicht in die Versionskontrolle ein.

## Schnellstart

Liste die Plugins in den eigenen Marketplaces deiner Organisation auf, die neuesten zuerst:

<CodeGroup>
  ```bash cURL
  curl "https://api.anthropic.com/v1/organizations/plugins?owner_type=organization&limit=20" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01"
  ```

  ```bash CLI
  ant beta:organization:plugins list --owner-type organization --limit 20
  ```

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

  plugins = client.beta.organization.plugins.list(owner_type="organization", limit=20)

  # Ruft bei Bedarf automatisch weitere Seiten ab.
  for plugin in plugins:
      print(f"{plugin.id}: {plugin.name}")
  ```

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

  const plugins = await client.beta.organization.plugins.list({
    owner_type: "organization",
    limit: 20
  });

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

  ```csharp C#
  using Anthropic.Models.Beta.Organization.Plugins;

  AnthropicClient client = new();

  var page = await client.Beta.Organization.Plugins.List(
      new() { OwnerType = OwnerType.Organization, Limit = 20 }
  );

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

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

  plugins := client.Beta.Organization.Plugins.ListAutoPaging(context.Background(), anthropic.BetaOrganizationPluginListParams{
  	OwnerType: anthropic.BetaOrganizationPluginListParamsOwnerTypeOrganization,
  	Limit:     anthropic.Int(20),
  })

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

  ```java Java
  import com.anthropic.models.beta.organization.plugins.PluginListParams;

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

      var params = PluginListParams.builder()
          .ownerType(PluginListParams.OwnerType.ORGANIZATION)
          .limit(20)
          .build();
      var plugins = client.beta().organization().plugins().list(params);

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

  ```php PHP
  use Anthropic\Beta\Organization\Plugins\PluginListParams\OwnerType;
  // ...

  $client = new Client();

  $plugins = $client->beta->organization->plugins->list(
      limit: 20,
      ownerType: OwnerType::ORGANIZATION,
  );

  // Nur diese Seite; für die nächste rufe list() erneut mit page: $plugins->nextPage auf.
  foreach ($plugins->getItems() as $plugin) {
      echo "{$plugin->id}: {$plugin->name}\n";
  }
  ```

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

  page = client.beta.organization.plugins.list(owner_type: :organization, limit: 20)

  page.auto_paging_each do |plugin|
    puts "#{plugin.id}: #{plugin.name}"
  end
  ```
</CodeGroup>

```json
{
  "data": [
    {
      "type": "plugin",
      "id": "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
      "name": "sales-toolkit",
      "display_name": "Sales Toolkit",
      "description": "Account research and call prep for the sales team.",
      "served_version_id": "pluginver_01Km7tL4pR9xF5sU2zV3jP6q",
      "served_version_pinned": true,
      "latest_version_id": "pluginver_01Jd5sK2nQ8wE4rT6yU1iO3p",
      "manifest_version": "1.4.0",
      "owner": { "type": "organization" },
      "marketplace_id": "marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r",
      "created_by": { "type": "api_actor", "api_key_id": "apikey_01Nq9vN6rT2zH7uW4bX5mR8s" },
      "organization_installation_preference": "available",
      "organization_installation_preference_inherited": true,
      "content_scan": { "status": "completed", "assessment": "pass", "reason": null },
      "components": [
        {
          "type": "skill",
          "name": "account-research",
          "description": "Researches a customer account before a call."
        },
        { "type": "mcp_server", "name": "crm", "description": null }
      ],
      "reach": "remote",
      "created_at": "2026-09-01T17:04:11Z",
      "updated_at": "2026-09-15T14:12:30Z"
    }
  ],
  "next_page": "page_xK9f2LqT7vNw3pRzBd8sHy"
}
```

In diesem Beispiel ist das Plugin auf eine frühere Version festgelegt: Eine neuere Version (`latest_version_id`) ist gespeichert, wird aber noch nicht bereitgestellt.

## Scopes

| Scope                      | Gewährt                                                                                                                                                                                                                                                                                                                                                                                                               |
| -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `read:plugins`             | Jeden `GET`-Endpunkt auf dieser Seite, einschließlich Archiv-Downloads, sowie die Marketplace-Validierung.                                                                                                                                                                                                                                                                                                            |
| `write:plugins`            | Jeden `POST`- und `DELETE`-Endpunkt auf dieser Seite: ein Plugin erstellen, eine Version erstellen, die bereitgestellte Version ändern, ein Plugin löschen, Installationseinstellungen festlegen und entfernen und den Standard eines Marketplace festlegen, sowie die Marketplace-Validierung. Er gewährt keine Lesezugriffe.                                                                                        |
| `read:org_audit`           | Ein reiner Lese-Scope für Sicherheitsaudit-Integrationen: jeden `GET`-Endpunkt auf dieser Seite, einschließlich Archiv-Downloads, sowie die Lese-Endpunkte der [Benutzerverwaltung](https://platform.claude.com/docs/de/manage-claude/user-management) und der [Compliance-API](https://platform.claude.com/docs/de/manage-claude/compliance-api). Er gewährt weder die Marketplace-Validierung noch Schreibzugriffe. |
| `read:compliance_org_data` | Der Scope der Compliance-API für Organisationsmetadaten (Namen, Typen, Rollen und Gruppen) und effektive Einstellungen. Gewährt jeden `GET`-Endpunkt auf dieser Seite, genau wie `read:org_audit`, sodass ein Compliance Access Key Plugins ohne einen zweiten Key lesen kann. Er gewährt weder die Marketplace-Validierung noch Schreibzugriffe.                                                                     |

Ein Key kann mehrere Scopes haben. Eine Integration, die ein Plugin hochlädt und es anschließend wieder liest, benötigt sowohl `read:plugins` als auch `write:plugins`. Überall dort, wo diese Seite angibt, dass ein Endpunkt den Scope `read:plugins` erfordert, funktioniert auch ein Key mit `read:org_audit` oder `read:compliance_org_data`.

### Zugriff auf die Plugin-Dateien von Mitgliedern

Jeder dieser Lese-Scopes (`read:plugins`, `read:org_audit` und `read:compliance_org_data`) kann die Dateien von Plugins in den persönlichen Marketplaces von Mitgliedern herunterladen, einschließlich Dateien, die die Admin-Einstellungen von claude.ai nicht anzeigen, und ein an deine übergeordnete Organisation gebundener Key mit `read:org_audit` oder `read:compliance_org_data` kann dies in jeder darunterliegenden Organisation tun, die Zugriff auf diese API hat, indem er `organization_id` übergibt (siehe [Eine andere Organisation unter derselben übergeordneten Organisation lesen](https://platform.claude.com/docs/de/manage-claude/plugins-api#reading-another-organization-under-the-same-parent)). Jeder solche Download erzeugt ein `claude_plugin_archive_accessed`-Ereignis im [Activity Feed der Compliance-API](https://platform.claude.com/docs/de/manage-claude/compliance-activity-feed), das den Key, das Plugin, die Version und das Mitglied identifiziert (siehe [Activity-Feed-Ereignisse](https://platform.claude.com/docs/de/manage-claude/plugins-api#activity-feed-events)). Downloads von Plugins der Organisation werden nicht erfasst.

### Eine andere Organisation unter derselben übergeordneten Organisation lesen

`read:plugins`- und `write:plugins`-Keys lesen und schreiben nur in der Organisation, in der sie erstellt wurden. Manche Unternehmen haben mehrere Claude-Organisationen, die unter einer übergeordneten Organisation verknüpft sind. Ein [für alle verknüpften Organisationen erstellter](https://platform.claude.com/docs/de/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization) `read:org_audit`- oder `read:compliance_org_data`-Key kann auch jede verknüpfte Organisation lesen, die Zugriff auf diese API hat. Um eine davon zu lesen, übergib ihre ID im Query-Parameter `organization_id` bei einem beliebigen `GET`-Endpunkt auf dieser Seite. Die ID ist die Organisations-UUID, die in den Einstellungen von claude.ai angezeigt wird (ihre Form mit dem Präfix `org_` wird ebenfalls akzeptiert). Ohne den Parameter liest der Key die Organisation, in der er erstellt wurde. Ein Key ohne eigene Organisation muss immer `organization_id` übergeben. Ein `404` bedeutet, dass die angegebene Organisation nicht unter der übergeordneten Organisation des Keys liegt oder die API für sie nicht verfügbar ist; ein Wert, der weder eine UUID noch eine `org_`-ID ist, gibt `400` zurück. Jeder andere Key, der eine andere Organisation als seine eigene angibt, erhält `404`. Schreibvorgänge akzeptieren `organization_id` nicht.

## Wichtige Konzepte

### Plugins und Komponenten

Ein **Plugin** ist ein Paket, das Claude für die Mitglieder deiner Organisation erweitert. Es enthält eine beliebige Kombination dieser Komponenten:

| Komponente | Was sie ist                                                                                                                     |
| ---------- | ------------------------------------------------------------------------------------------------------------------------------- |
| Skill      | Anweisungen und Dateien, die Claude lädt, wenn eine Aufgabe sie erfordert.                                                      |
| Befehl     | Ein gespeicherter Prompt, den ein Mitglied ausführt, indem es `/` gefolgt vom Namen des Commands eingibt.                       |
| Agent      | Ein Hilfsassistent mit eigenen Anweisungen, an den Claude einen Teil einer Aufgabe übergeben kann.                              |
| Hook       | Ein Befehl, der automatisch ausgeführt wird, wenn in einer Sitzung ein Ereignis eintritt, etwa bevor Claude ein Tool verwendet. |
| MCP-Server | Eine Verbindung von Claude zu Tools und Daten in einem anderen System (Model Context Protocol).                                 |
| CLI        | Ein Kommandozeilenprogramm, das Claude über das Plugin ausführen darf.                                                          |

Jedes Plugin hat ein Manifest unter `.claude-plugin/plugin.json`. Der `name` des Manifests wird zum `name` des Plugins: ein kleingeschriebener Bezeichner, der innerhalb seines Marketplace eindeutig ist.

### Marketplaces

Ein **Marketplace** ist ein Container für Plugins. Jeder Marketplace hat einen Eigentümer und eine Quelle.

* **Eigentümer.** Die Organisation besitzt ihre Marketplaces. Jedes Mitglied kann außerdem persönliche Marketplaces haben.
* **Quelle.** `manual` bedeutet, dass Plugins hochgeladen werden, in claude.ai oder, bei einem Marketplace der Organisation, über diese API. `github`, `gitlab` und `public_git` bedeuten, dass Plugins aus einem Git-Repository synchronisiert werden, das der Eigentümer verbunden hat. In einen synchronisierten Marketplace kann nichts hochgeladen werden, und diese API kann seine Plugins nicht löschen, weil die nächste Synchronisierung jede dieser Änderungen rückgängig machen würde. Ändere stattdessen das Repository.

Der **„library marketplace“ (Bibliotheks-Marketplace)** deiner Organisation ist der `manual`-Marketplace der Organisation, in den Uploads gehen, wenn du keinen Marketplace angibst. Er wird erstellt, wenn zum ersten Mal etwas in ihn hochgeladen wird.

### Plugins der Organisation und Plugins von Mitgliedern

Das Feld `owner.type` eines Plugins gibt an, in wessen Marketplace es sich befindet:

* `organization`: Du kannst es über diese API verwalten, mit der Ausnahme, dass ein Plugin in einem aus Git synchronisierten Marketplace hier keine Uploads erhalten und nicht gelöscht werden kann.
* `user`: Es befindet sich im persönlichen Marketplace eines Mitglieds. Du kannst seine Details lesen und seine Dateien herunterladen und es löschen, wenn sein Marketplace `manual` ist. Das Hochladen von Versionen und das Wählen der bereitgestellten Version geben `403` zurück. Freigaben werden ausschließlich vom Mitglied in claude.ai verwaltet.

Das Entfernen eines Mitglieds aus der Organisation entfernt seine Plugins nicht. Sie bleiben unter der `user_id` des Mitglieds im Inventar, und der Filter `owner_user_id` findet sie weiterhin, sodass du die Inhalte eines ausgeschiedenen Mitglieds prüfen und entfernen kannst. Sie werden aus dem Inventar entfernt, wenn das Konto des Mitglieds gelöscht wird.

### Versionen und die bereitgestellte Version

Jeder Upload erzeugt eine neue, unveränderliche **Version**, unabhängig davon, ob er über diese API, über claude.ai oder durch eine Git-Synchronisierung erfolgt. Ein Plugin hat zwei Zeiger auf seine Versionen:

* `latest_version_id`: die neueste Version
* `served_version_id`: die Version, die Mitgliedern bereitgestellt wird

Standardmäßig ist `served_version_pinned` `false`: Die bereitgestellte Version folgt normalerweise der neuesten. Wenn das Content-Scanning aktiviert ist, kann eine in claude.ai gespeicherte Version auf ihren Content-Scan **warten**: Sie wird gespeichert, aber nicht sofort bereitgestellt. Diese Seite verwendet „warten“ nur für eine in claude.ai gespeicherte Version, nicht für eine, die ein Mitglied oder ein Administrator in ein Plugin veröffentlicht. Solange das Scanning aktiviert ist, wird eine wartende Version nur bereitgestellt, wenn ihr `content_scan` `completed` mit `pass` oder `warn` lautet. Während eine Version wartet, benennt `served_version_id` eine frühere Version als `latest_version_id`. Frage nicht so lange ab, bis die beiden IDs übereinstimmen: Sie könnten unterschiedlich bleiben, zum Beispiel wenn der Scan fehlschlägt.

Das Wählen einer Version mit `POST /v1/organizations/plugins/{plugin_id}` **pinnt** das Plugin (`served_version_pinned: true`). Dasselbe gilt, wenn ein Administrator in claude.ai eine Version wählt oder die Anfrage eines Mitglieds annimmt, in das Plugin zu veröffentlichen. Ab dann werden neue Uploads gespeichert und setzen `latest_version_id` weiter, aber Mitglieder behalten die gepinnte Version, bis du `served_version_id` auf eine andere Version setzt. Bei einem Plugin, dessen zwei Zeiger sich unterscheiden, gibt es eine gespeicherte Version, die nicht bereitgestellt wird.

So kann eine Release-Pipeline jeden Build hochladen, testen und dann hochstufen. Damit deine Pipeline bestimmt, wann jeder Build bereitgestellt wird, pinne das Plugin einmal, indem du `served_version_id` auf seine aktuelle Version setzt; stufe danach jeden Build hoch, der bereitgestellt werden soll. Bei aktiviertem Content-Scanning gibt dieses erste Pinnen `409 scan_pending` zurück, solange der `content_scan` der aktuellen Version `processing` lautet, und `400 scan_failed`, wenn der Scan `fail`, `unknown` oder `errored` lautet (`warn` wird akzeptiert). Ein gepinntes Plugin kann nicht entpinnt werden, weder hier noch in claude.ai.

Für ein Rollback setzt du `served_version_id` auf eine frühere Version. Ein Roll-forward funktioniert auf dieselbe Weise.

Diese Regeln beschreiben Plugins der Organisation. Die bereitgestellte Version eines Plugins eines Mitglieds wird von dessen Eigentümer in claude.ai gesteuert.

### Installationseinstellungen

**Installationseinstellungen** bestimmen, wer ein Plugin der Organisation verwenden kann. Jede Einstellung hat einen von vier Werten, die in den Feldern mit dem Namen `installation_preference` (und, bei den Plugin- und Marketplace-Objekten, `organization_installation_preference` und `default_installation_preference`) übermittelt werden:

| Wert            | Mitglieder sehen                                           |
| --------------- | ---------------------------------------------------------- |
| `required`      | Das Plugin ist installiert und kann nicht entfernt werden. |
| `auto_install`  | Das Plugin ist installiert und kann entfernt werden.       |
| `available`     | Das Plugin kann auf Wunsch installiert werden.             |
| `not_available` | Das Plugin ist ausgeblendet.                               |

Ein Plugin kann eine organisationsweite Einstellung und eine Einstellung für jede Gruppe haben (die Gruppen der rollenbasierten Zugriffskontrolle, [verwaltet in der Benutzerverwaltung](https://platform.claude.com/docs/de/manage-claude/user-management#groups)). Ein Mitglied erhält einen Wert nach diesen Regeln:

1. Der organisationsweite Wert ist die eigene organisationsweite Einstellung des Plugins, falls vorhanden, andernfalls der Standard seines Marketplace, andernfalls `not_available`. Das Plugin meldet diesen Wert in `organization_installation_preference`, mit `organization_installation_preference_inherited: true`, solange er aus dem Marketplace-Standard stammt.
2. Ein Mitglied, das keiner Gruppe mit einer Einstellung für das Plugin angehört, erhält den organisationsweiten Wert.
3. Ein Mitglied, das einer oder mehreren Gruppen mit einer Einstellung angehört, erhält stattdessen die freizügigste Einstellung dieser Gruppen, in der Rangfolge `required`, `auto_install`, `available`, `not_available`.

Die Einstellung einer Gruppe ersetzt den organisationsweiten Wert für ihre Mitglieder; sie ergänzt ihn nicht. Wenn der organisationsweite Wert zum Beispiel `required` ist und die Pilot-Gruppe `available` hat, erhalten Pilot-Mitglieder `available`. Wenn du ein Plugin von einer Pilotgruppe auf die gesamte Organisation ausweitest, lege den organisationsweiten Wert fest und entferne dann die Einstellung der Gruppe. Das Festlegen des organisationsweiten Werts beendet die Vererbung des Marketplace-Standards für das Plugin; [das Entfernen der organisationsweiten Einstellung](https://platform.claude.com/docs/de/manage-claude/plugins-api#remove-an-installation-setting) setzt das Plugin auf diesen Standard zurück.

Ein über diese API erstelltes Plugin hat anfangs keine eigenen Einstellungen und erbt daher den Standard seines Marketplace: `not_available`, sofern niemand einen Standard festgelegt hat. Das Löschen einer Gruppe entfernt ihre Einstellungen aus allen Plugins.

### Freigaben

**Freigaben** bestimmen, wer ein Plugin eines Mitglieds verwenden kann. Der Owner gibt es in claude.ai für alle Mitglieder, für eine Gruppe oder für namentlich genannte Mitglieder frei. Diese API listet Freigaben auf, kann sie aber nicht ändern.

Wenn deine Organisation eine Art der Freigabe in ihren claude.ai-Einstellungen deaktiviert hat, erscheinen Freigaben dieser Art weiterhin in der Liste, gewähren aber niemandem Zugriff, solange diese Einstellung deaktiviert ist; die Liste selbst zeigt nicht an, ob das der Fall ist.

### Content-Scanning

„Content scanning“ (Inhaltsprüfung) ist eine Organisationseinstellung in claude.ai. Wenn sie aktiviert ist, werden neu gespeicherte Versionen gescannt (claude.ai nimmt einige davon aus), und das Ergebnis wird in `content_scan` gemeldet; eine Version, die nicht gescannt wurde, zum Beispiel eine, die vor dem Aktivieren des Scannings gespeichert wurde, hat `content_scan: null`. Scanning wird Organisationen, die kundenverwaltete Verschlüsselungsschlüssel oder Zero Data Retention verwenden, nicht angeboten.

Solange das Scanning aktiviert ist, wird Mitgliedern ein Plugin nur bereitgestellt, wenn der Scan seiner bereitgestellten Version `completed` mit `pass` oder `warn` ist. Solange der Scan `processing` oder `errored` ist oder `fail` oder `unknown` lautet, wird das Plugin Mitgliedern vorenthalten, und an seiner Stelle wird keine frühere Version bereitgestellt. Eine Version, die nie gescannt wurde (`content_scan: null`), wird normal bereitgestellt.

Eine Version, die du über diese API hochlädst, wartet nie auf ihren Content-Scan. Wenn sie zur bereitgestellten Version wird, verlieren Mitglieder das Plugin, bis ihr `content_scan` `completed` mit `pass` oder `warn` lautet. Wenn Mitglieder die aktuelle Version behalten sollen, während eine neue gescannt wird, pinne das Plugin zuerst (siehe [Versionen und die bereitgestellte Version](https://platform.claude.com/docs/de/manage-claude/plugins-api#versions-and-the-served-version)).

Während eine in claude.ai gespeicherte Version auf ihren Scan wartet, ändert sich die bereitgestellte Version nicht. Wenn dein API-Upload zur bereitgestellten Version wird, endet jedes Warten: Die wartende Version wird nur bereitgestellt, wenn jemand sie auswählt. Um den Scan einer wartenden Version zu sehen, lies die Version (siehe [Die Versionen eines Plugins auflisten](https://platform.claude.com/docs/de/manage-claude/plugins-api#list-a-plugins-versions)).

Nach einem Upload ist `content_scan.status` `processing`, und das Urteil trifft asynchron ein. Lies die Version, um es zu sehen; das Plugin-Objekt zeigt nur den Scan seiner bereitgestellten Version. Während das Scanning aktiviert ist, gibt das Ändern der bereitgestellten Version auf eine Version, deren `content_scan` `processing` lautet, `409 scan_pending` zurück, und das Ändern auf eine, deren Scan `fail`, `unknown` oder `errored` lautet, gibt `400 scan_failed` zurück.

#### In claude.ai zugelassene fehlgeschlagene Scans

In claude.ai können Organisationseigentümer eine Version zulassen, deren Scan fehlgeschlagen ist. Dasselbe können Mitglieder, deren [benutzerdefinierte Rolle](https://platform.claude.com/docs/de/manage-claude/user-management#custom-roles) **Bibliotheken** verwalten darf. Diese API kann diesen Scan dann als `completed` mit `warn` und dem `reason` des fehlgeschlagenen Scans melden. Solange sie das tut, gelten die Regeln für `warn`: Die Version kann Mitgliedern bereitgestellt werden, und du kannst sie zur bereitgestellten Version machen. Nichts in der Antwort zeigt, dass sie zugelassen wurde, daher ist ein `warn` entweder eine Warnung oder ein fehlgeschlagener Scan, der zugelassen wurde. Das Zulassen einer Version, deren Scan `warn` lautet, ändert ihren `content_scan` nicht. Wenn eine Version nicht mehr zugelassen ist, meldet diese API das Urteil ihres neuesten abgeschlossenen Scans. Eine bereitgestellte Version, deren Scan dann `fail` oder `unknown` lautet, wird Mitgliedern vorenthalten.

### Reichweite

`reach` („reach“, Reichweite) fasst in einem Wert zusammen, wie weit eine Version auf den Rechnern der Mitglieder und darüber hinaus reicht:

| Wert         | Bedeutung                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `remote`     | Deklariert einen MCP-Server oder eine CLI, unabhängig davon, was sie sonst noch deklariert.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `privileged` | Deklariert keinen MCP-Server und keine CLI, aber einen Hook, einen Monitor (einen Hintergrundbefehl, der während einer Sitzung weiterläuft), einen LSP-Server (Language Server Protocol), einen Workflow (ein Skript, das Claude Code ausführen kann; jede Datei in einem `workflows/`-Ordner im Stammverzeichnis des Plugins zählt als Workflow) oder Einstellungen, die das Plugin auf die App des Mitglieds anwendet, oder enthält einen Skill, einen Befehl oder eine andere Markdown-Datei, deren Frontmatter Tools vorab genehmigt (`allowed-tools`). Diese laufen oder wirken auf dem eigenen Computer des Mitglieds. |
| `contained`  | Deklariert keinen MCP-Server, keine CLI, keinen Hook, keinen Monitor, keinen LSP-Server, keinen Workflow und keine App-Einstellungen, und keine ihrer Markdown-Dateien genehmigt Tools vorab (zum Beispiel ein Plugin, das nur Skills, Befehle und Agenten enthält, keiner davon mit `allowed-tools`).                                                                                                                                                                                                                                                                                                                       |

`reach` berücksichtigt alles, was die Version deklariert, einschließlich Monitoren, LSP-Servern, Workflows und App-Einstellungen, die `components` nicht auflistet, sodass eine Version mit einer leeren `components`-Liste dennoch `privileged` sein kann. Der Wert ist `null` für eine Version, die gespeichert wurde, bevor Komponenten erfasst wurden, und für eine Version, deren Reichweite nicht bestimmt werden konnte, weil die `SKILL.md` eines ihrer Skills oder eine ihrer Command-Dateien nicht gelesen werden konnte; behandle `null` als nicht klassifiziert. Der Wert wird normalerweise beim Speichern einer Version nach den zu diesem Zeitpunkt geltenden Regeln ermittelt. Eine ältere Version kann daher `contained` sein, während dieselben Dateien, wenn sie heute gespeichert würden, `privileged` wären.

### Anforderungen an Uploads

Uploads folgen denselben Regeln wie Plugin-Uploads in claude.ai, sodass an beiden Stellen dieselben Archive akzeptiert werden.

* Der Upload ist entweder ein einzelnes `.zip`- oder `.plugin`-Archiv oder eine Menge einzelner Dateien. Ein Archiv darf alles in einen einzigen Ordner auf oberster Ebene einschließen.
* Er muss genau ein Manifest unter `.claude-plugin/plugin.json` enthalten, das einen `name` deklarieren muss. Eine einzelne `SKILL.md` ohne Manifest wird abgelehnt.
* Eine `SKILL.md` auf oberster Ebene, deren Frontmatter Plugin-Komponenten deklariert, wird mit dem Manifest zusammengeführt; `plugin.json` hat Vorrang, wo beide einen Wert festlegen. Eine `description`, die das Manifest aus dieser `SKILL.md` übernimmt, wird auf ihre ersten 500 Zeichen gekürzt.
* `name` darf Kleinbuchstaben (aus jedem Alphabet), Ziffern und Bindestriche enthalten, bis zu 64 Zeichen. Großbuchstaben, Leerzeichen, Unterstriche und andere Satzzeichen werden abgelehnt.
* `displayName` hat höchstens 64 Zeichen und `description` höchstens 500.
* Jede `SKILL.md` benötigt gültiges YAML-Frontmatter mit `name` und `description`, von denen keines XML-Tags wie `<example>` enthalten darf. Zwei Skills oder zwei Befehle dürfen nicht denselben Namen haben.
* Keine Datei darf sich in einem `bin/`-Verzeichnis auf oberster Ebene befinden.
* Keine verschachtelten `.zip`-Dateien. Paketierte MCP-Server (`.mcpb`, `.dxt`) sind erlaubt.
* Dateipfade müssen relativ sein, dürfen kein `..` enthalten und nur Buchstaben, Ziffern, Leerzeichen und `_ . - / ( ) ,` verwenden.
* Der Request-Body und das unkomprimierte Archiv sind jeweils höchstens 200 MB groß; ein Request-Body über dem Limit gibt `413` (`request_too_large`) statt `400` zurück. Ein Upload hat höchstens 5.000 Dateien, eine Pfadtiefe von 12, Pfade von 472 Zeichen und Datei- oder Ordnernamen von 255 Zeichen.
* ZIP-Archive müssen DEFLATE- oder STORE-Komprimierung verwenden und dürfen weder verschlüsselt sein noch symbolische Links enthalten.
* Ein Upload, der ein Plugin erstellt, gibt `400` zurück, sobald der Marketplace 1.000 Plugins enthält. Plugins, die diese API nicht auflistet, zählen ebenfalls mit, sodass das Limit erreicht werden kann, während [Plugins auflisten](https://platform.claude.com/docs/de/manage-claude/plugins-api#list-plugins) in diesem Marketplace weniger als 1.000 anzeigt. Anthropic kann das Limit von 5.000 Dateien erhöhen.

## Beispiel-Workflows

### Jeden Build aus einer Release-Pipeline veröffentlichen

Lade jeden getaggten Build aus der CI hoch und lass die Pipeline bestimmen, wann ein Build bereitgestellt wird.

1. Finde den Marketplace, in den hochgeladen werden soll, mit `GET /v1/organizations/plugin_marketplaces?owner_type=organization`, oder lass `marketplace_id` weg, um den Bibliotheks-Marketplace zu verwenden.
2. Beim ersten Release [erstellst du das Plugin](https://platform.claude.com/docs/de/manage-claude/plugins-api#create-a-plugin) mit `POST /v1/organizations/plugins`. Bei jedem späteren Release notierst du die `latest_version_id` des Plugins und [lädst dann eine Version hoch](https://platform.claude.com/docs/de/manage-claude/plugins-api#create-a-version) mit `POST /v1/organizations/plugins/{plugin_id}/versions`. Wenn die Antwort auf den Upload verloren geht, lies das Plugin und wiederhole den Upload nur, wenn `latest_version_id` unverändert ist (siehe [Uploads wiederholen](https://platform.claude.com/docs/de/manage-claude/plugins-api#retrying-uploads)).
3. Damit Mitglieder die aktuelle Version behalten, während jeder neue Build geprüft wird, pinne das Plugin einmalig, indem du `served_version_id` auf seine aktuelle Version setzt. Ab dann wird jeder Upload gespeichert, ohne bereitgestellt zu werden, und das Pinnen kann nicht rückgängig gemacht werden: Jeder Build, der bereitgestellt werden soll, benötigt Schritt 5.
4. Wenn Content-Scanning aktiviert ist, frage `GET /v1/organizations/plugins/{plugin_id}/versions/{version}` ab, bis `content_scan.status` nicht mehr `processing` ist, und promote nur, wenn der Status `completed` mit `pass` oder `warn` ist.
5. [Promote den Build](https://platform.claude.com/docs/de/manage-claude/plugins-api#change-the-served-version) mit `POST /v1/organizations/plugins/{plugin_id}` und `{"served_version_id": "<the new version's ID>"}`. Für ein Rollback sendest du auf dieselbe Weise die ID der vorherigen Version.

### Ein Plugin zuerst für eine Pilotgruppe und dann für alle ausrollen

1. Ermittle die ID der Pilotgruppe mit `GET /v1/organizations/rbac_groups`. Dieser Aufruf benötigt den Scope `read:rbac_groups` (siehe [Gruppen und Rollen in der Benutzerverwaltung](https://platform.claude.com/docs/de/manage-claude/user-management#groups-and-roles)). Die nächsten Schritte benötigen `write:plugins`, das nur auf die Organisation wirkt, in der sein Key erstellt wurde. Erstelle daher in einem Unternehmen mit mehreren verknüpften Organisationen einen einzigen Key in der Organisation, die das Plugin enthält, und gib ihm beide Scopes, oder verwende für diese Schritte einen zweiten dort erstellten Key.

2. [Gib der Gruppe eine eigene Einstellung](https://platform.claude.com/docs/de/manage-claude/plugins-api#set-an-installation-setting), zum Beispiel `auto_install`, mit `POST /v1/organizations/plugins/{plugin_id}/installation_settings/{target}`, wobei `{target}` die `rbac_group_`-ID der Gruppe ist, während der organisationsweite Wert `not_available` bleibt. Nur die Mitglieder der Gruppe erhalten das Plugin.

3. Wenn der Pilot endet, lege den organisationsweiten Wert mit dem folgenden Aufruf fest und entferne dann die Einstellung der Gruppe, damit die Gruppe wieder der Organisation folgt. Das Festlegen des organisationsweiten Werts beendet die Vererbung des Marketplace-Standards für das Plugin; [das Entfernen der organisationsweiten Einstellung](https://platform.claude.com/docs/de/manage-claude/plugins-api#remove-an-installation-setting) setzt das Plugin später auf diesen Standard zurück.

   <CodeGroup>
     ```bash cURL
     curl -X POST "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL/installation_settings/organization" \
       -H "content-type: application/json" \
       -H "x-api-key: $ANTHROPIC_API_KEY" \
       -H "anthropic-version: 2026-10-21" \
       -H "anthropic-beta: ce-plugins-2026-09-01" \
       -d '{"installation_preference": "required"}'
     ```

     ```bash CLI
     ant beta:organization:plugins:installation-settings set \
       --plugin-id plugin_01Hq3vX8kZcN2mB7pR4tY9wL \
       --target organization \
       --installation-preference required
     ```

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

     setting = client.beta.organization.plugins.installation_settings.set(
         "organization",
         plugin_id="plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
         installation_preference="required",
     )

     print(f"plugin_id: {setting.plugin_id}")
     print(f"installation_preference: {setting.installation_preference}")
     ```

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

     const setting = await client.beta.organization.plugins.installationSettings.set(
       "organization",
       {
         plugin_id: "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
         installation_preference: "required"
       }
     );

     console.log(`plugin_id: ${setting.plugin_id}`);
     console.log(`installation_preference: ${setting.installation_preference}`);
     ```

     ```csharp C#
     using Anthropic.Models.Beta.Organization.Plugins.InstallationSettings;

     AnthropicClient client = new();

     var setting = await client.Beta.Organization.Plugins.InstallationSettings.Set(
         "organization",
         new()
         {
             PluginID = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
             InstallationPreference = InstallationPreference.Required,
         }
     );

     Console.WriteLine($"plugin_id: {setting.PluginID}");
     Console.WriteLine($"installation_preference: {setting.InstallationPreference.Raw()}");
     ```

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

     setting, err := client.Beta.Organization.Plugins.InstallationSettings.Set(
     	context.Background(),
     	"organization",
     	anthropic.BetaOrganizationPluginInstallationSettingSetParams{
     		PluginID:               "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
     		InstallationPreference: anthropic.BetaOrganizationPluginInstallationSettingSetParamsInstallationPreferenceRequired,
     	},
     )
     if err != nil {
     	log.Fatal(err)
     }

     fmt.Printf("plugin_id: %s\n", setting.PluginID)
     fmt.Printf("installation_preference: %s\n", setting.InstallationPreference)
     ```

     ```java Java
     import com.anthropic.models.beta.organization.plugins.installationsettings.InstallationSettingSetParams;

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

         var params = InstallationSettingSetParams.builder()
             .pluginId("plugin_01Hq3vX8kZcN2mB7pR4tY9wL")
             .installationPreference(InstallationSettingSetParams.InstallationPreference.REQUIRED)
             .build();
         var setting = client.beta().organization().plugins().installationSettings()
             .set("organization", params);

         IO.println("plugin_id: " + setting.pluginId());
         IO.println("installation_preference: " + setting.installationPreference().asString());
     }
     ```

     ```php PHP
     use Anthropic\Beta\Organization\Plugins\InstallationSettings\InstallationSettingSetParams\InstallationPreference;
     // ...

     $client = new Client();

     $setting = $client->beta->organization->plugins->installationSettings->set(
         target: 'organization',
         pluginID: 'plugin_01Hq3vX8kZcN2mB7pR4tY9wL',
         installationPreference: InstallationPreference::REQUIRED,
     );

     echo "plugin_id: {$setting->pluginID}\n";
     echo "installation_preference: {$setting->installationPreference}\n";
     ```

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

     plugin_id = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
     setting = client.beta.organization.plugins.installation_settings.set(
       "organization",
       plugin_id: plugin_id,
       installation_preference: :required
     )

     puts "plugin_id: #{setting.plugin_id}"
     puts "installation_preference: #{setting.installation_preference}"
     ```
   </CodeGroup>

   Entferne dann die Einstellung der Gruppe mit `DELETE /v1/organizations/plugins/{plugin_id}/installation_settings/{target}`, wobei `{target}` die ID der Gruppe ist. Die Einstellung einer Gruppe ersetzt den organisationsweiten Wert für ihre Mitglieder, statt ihn zu ergänzen, sodass eine verbliebene Gruppeneinstellung `available` diese Mitglieder auf `available` halten würde.

### Einen Sicherheitsbestand synchron halten

Führe einen nächtlichen Job aus, der Plugins markiert, die über die Sitzung des Mitglieds hinausreichen oder deren Content-Scan `warn`, `fail` oder `unknown` lautet.

1. Blättere durch [`GET /v1/organizations/plugins?limit=100`](https://platform.claude.com/docs/de/manage-claude/plugins-api#list-plugins), bis `next_page` `null` ist (siehe [Paginierung](https://platform.claude.com/docs/de/manage-claude/plugins-api#pagination)). Lies bei jedem Lauf `reach` und `content_scan` jedes Plugins aus dieser Liste: Eine Änderung allein an `content_scan`, etwa ein später eintreffendes Urteil, verändert `updated_at` nicht. `updated_at` zeigt dir normalerweise, welche Plugins seit dem letzten Lauf neue Inhalte oder eine neue bereitgestellte Version haben (was einen erneuten Archiv-Download lohnt). Eine wartende Version (siehe [Versionen und die bereitgestellte Version](https://platform.claude.com/docs/de/manage-claude/plugins-api#versions-and-the-served-version)) verändert `updated_at`, wenn sie zur bereitgestellten Version wird, nicht unbedingt, wenn sie gespeichert wird. Um eine solche zu bemerken, vergleiche `latest_version_id` mit dem Wert aus deinem letzten Lauf. Das vollständige erneute Auflisten erfasst auch Entfernungen, weil ein durch eine Git-Synchronisierung oder eine Kontolöschung entferntes Plugin ohne Ereignis verschwindet.
2. Markiere jedes Plugin, dessen `reach` `remote` ist (es deklariert einen MCP-Server oder eine CLI) oder dessen `content_scan.assessment` `warn`, `fail` oder `unknown` ist. Ein `warn` kann auch ein [fehlgeschlagener Scan sein, der in claude.ai zugelassen wurde](https://platform.claude.com/docs/de/manage-claude/plugins-api#failed-scans-allowed-in-claude-ai). Lass `warn` nur weg, wenn du jeden dort zugelassenen fehlgeschlagenen Scan akzeptierst. Diese Felder beschreiben die bereitgestellte Version. Um auch eine neuere, nicht bereitgestellte Version zu prüfen, liste die Versionen des Plugins auf, wenn sich `latest_version_id` von `served_version_id` unterscheidet (siehe [Versionen eines Plugins auflisten](https://platform.claude.com/docs/de/manage-claude/plugins-api#list-a-plugins-versions)).
3. Lade für jedes markierte Plugin das Archiv der bereitgestellten Version zur Prüfung mit `GET /v1/organizations/plugins/{plugin_id}/versions/{served_version_id}/content` herunter (siehe [Die Dateien einer Version herunterladen](https://platform.claude.com/docs/de/manage-claude/plugins-api#download-a-versions-files)). Lade außerdem jede nicht bereitgestellte Version, die den Test aus Schritt 2 erfüllt, anhand ihrer ID herunter.
4. Um Mitgliedern ein Plugin während der Prüfung zu entziehen, findest du unter [Plugin löschen](https://platform.claude.com/docs/de/manage-claude/plugins-api#delete-a-plugin) die umkehrbare (für Plugins der Organisation) und die dauerhafte Option.

## Plugins

Das Plugin-Objekt beschreibt ein Plugin in einem der Marketplaces deiner Organisation oder im persönlichen Marketplace eines Mitglieds (die Antwort im [Schnellstart](https://platform.claude.com/docs/de/manage-claude/plugins-api#quick-start) zeigt ein vollständiges Objekt). Seine Felder `display_name`, `description`, `manifest_version`, `content_scan`, `components` und `reach` beschreiben seine **bereitgestellte** Version, sodass ein einziger Listenaufruf zeigt, was Mitgliedern bereitgestellt wird.

| Feld                                                                                     | Beschreibung                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `id`                                                                                     | Mit dem Präfix `plugin_`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `name`                                                                                   | Aus dem Manifest. Eindeutig innerhalb seines Marketplace, nicht organisationsweit. Fest für ein Plugin der Organisation; ändert sich, wenn ein Mitglied sein eigenes Plugin in claude.ai umbenennt.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `display_name`, `description`, `manifest_version`                                        | Die Manifest-Felder `displayName`, `description` und `version` der bereitgestellten Version; jedes ist `null`, wenn das Manifest keines deklariert. `description` kann die `description` eines Skills statt der des Manifests sein (nach dieser Tabelle beschrieben). `manifest_version` wird für die Anzeige normalisiert: Ein führendes `v` oder `V` wird entfernt, sodass eine Manifest-`version` von `"v1.4.0"` als `"1.4.0"` zurückgegeben wird. Es ist außerdem `null` bei einem Wert, der nicht wie eine Versionsnummer aussieht, etwa `"latest"`, sowie bei einer Plugin-Version, die erstellt wurde, bevor claude.ai im August 2026 begann, dieses Feld zu erfassen. Ein Upload wird nie wegen seiner `version` abgelehnt, und `manifest_version` ist nicht eindeutig. |
| `served_version_id`, `latest_version_id`                                                 | Mit dem Präfix `pluginver_`: die Version, die Mitgliedern bereitgestellt wird, und die neueste Version. Siehe [Versionen und die bereitgestellte Version](https://platform.claude.com/docs/de/manage-claude/plugins-api#versions-and-the-served-version).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `served_version_pinned`                                                                  | `false`, bis das Plugin gepinnt wird (siehe [Versionen und die bereitgestellte Version](https://platform.claude.com/docs/de/manage-claude/plugins-api#versions-and-the-served-version)); ab dann `true`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `owner`                                                                                  | `{"type": "organization"}` oder `{"type": "user", "user_id": "user_..."}` für den persönlichen Marketplace eines Mitglieds.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `marketplace_id`                                                                         | Mit dem Präfix `marketplace_`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `created_by`                                                                             | Wer das Plugin erstellt hat: `{"type": "user_actor", "user_id": "user_...", "email_address": "..."}` für eine Person in claude.ai (`email_address` kann `null` sein) oder `{"type": "api_actor", "api_key_id": "apikey_..."}` für einen API-Key. Andere Akteurtypen können auftreten. `null`, wenn kein Ersteller erfasst ist, etwa bei Plugins, die aus Git synchronisiert wurden.                                                                                                                                                                                                                                                                                                                                                                                             |
| `organization_installation_preference`, `organization_installation_preference_inherited` | Plugins der Organisation: der organisationsweite Wert und ob er aus dem Standard des Marketplace stammt (siehe [Installationseinstellungen](https://platform.claude.com/docs/de/manage-claude/plugins-api#installation-settings)). Plugins von Mitgliedern: beide `null`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `content_scan`                                                                           | Das Scan-Ergebnis der bereitgestellten Version, ein Objekt mit `status`, `assessment` und `reason` (im Anschluss an diese Tabelle beschrieben). `null`, wenn sie nie gescannt wurde.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `components`                                                                             | Die Komponenten der bereitgestellten Version, jeweils `{"type", "name", "description"}`, wobei `type` einer der Werte `skill`, `mcp_server`, `command`, `agent`, `hook` oder `cli` ist, aufgelistet in dieser Typreihenfolge und dann nach Name. Bei einem MCP-Server ist `name` sein Schlüssel im Manifest; bei einem Hook das Ereignis, bei dem er ausgeführt wird; bei einer CLI der Name der ausführbaren Datei. `description` ist bei MCP-Servern, Hooks und CLIs immer `null`. `null`, wenn nicht erfasst.                                                                                                                                                                                                                                                                |
| `reach`                                                                                  | `contained`, `privileged` oder `remote`. Siehe [Reichweite](https://platform.claude.com/docs/de/manage-claude/plugins-api#reach).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| `updated_at`                                                                             | Ändert sich, wenn sich die bereitgestellte Version ändert, wenn das Plugin gepinnt wird, und normalerweise, wenn eine neue Version gespeichert wird. Eine wartende Version (siehe [Versionen und die bereitgestellte Version](https://platform.claude.com/docs/de/manage-claude/plugins-api#versions-and-the-served-version)) ändert es, wenn sie zur bereitgestellten Version wird, nicht unbedingt beim Speichern. Es ändert sich nicht bei Installationseinstellungen, Freigaben oder einer alleinigen Änderung an `content_scan`.                                                                                                                                                                                                                                           |

`description` ist nicht immer die des Manifests. Eine `description`, die das Manifest aus einer `SKILL.md` auf oberster Ebene übernimmt, wird auf ihre ersten 500 Zeichen gekürzt (siehe [Anforderungen an Uploads](https://platform.claude.com/docs/de/manage-claude/plugins-api#upload-requirements)). Wenn die `description` des Manifests aus den ersten 500 Zeichen genau einer eindeutigen Skill-`description` in `components` besteht, gibt die API stattdessen diese Skill-`description` zurück. Daraus folgt:

* Eine `description`, die du liest, kann länger als 500 Zeichen sein, das Limit für ein hochgeladenes Manifest. Ein Upload, dessen `plugin.json` eine solche `description` setzt, gibt `400` zurück.
* In den [Dateien, die du herunterlädst](https://platform.claude.com/docs/de/manage-claude/plugins-api#download-a-versions-files), kann `.claude-plugin/plugin.json` eine andere oder gar keine `description` haben.

Das `content_scan`-Objekt:

| Feld         | Beschreibung                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `status`     | `processing`, während der Scan läuft, `completed`, wenn er abgeschlossen ist, oder `errored`, wenn er nicht abgeschlossen werden konnte (oder gelegentlich, wenn sein Ergebnis für diese Antwort nicht gelesen werden konnte; in diesem Fall kann ein späterer Lesevorgang es melden). Gemeldet wird der neueste abgeschlossene Scan, falls vorhanden. Mitgliedern wird keine Version bereitgestellt, deren `status` `processing` oder `errored` ist; wenn du den Inhalt erneut als neue Version hochlädst, wird er neu gescannt. |
| `assessment` | Gesetzt, wenn `status` `completed` ist: `pass` (nichts gefunden), `warn` (etwas gefunden, das die Nutzung nicht blockiert, oder ein [fehlgeschlagener Scan, der in claude.ai zugelassen wurde](https://platform.claude.com/docs/de/manage-claude/plugins-api#failed-scans-allowed-in-claude-ai)), `fail` (etwas gefunden, das die Nutzung blockiert) oder `unknown` (kein Urteil). Andernfalls `null`.                                                                                                                            |
| `reason`     | Bei `warn` und `fail` das Hauptproblem aus der folgenden Liste. Andernfalls `null`, und ebenfalls `null` bei einem älteren Scan, der vor der Erfassung von Gründen durchgeführt wurde.                                                                                                                                                                                                                                                                                                                                            |

<Accordion title="Werte für den Grund des Content-Scans">
  | `reason`                          | Bedeutung                                                                                                                                                      |
  | --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
  | `covert-usage-telemetry`          | Weist Claude an, Informationen über das Mitglied oder seine Nutzung an eine externe Adresse zu senden, ohne es darüber zu informieren.                         |
  | `undisclosed-data-destination`    | Sendet Dateien, E-Mails, Dokumente oder andere Inhalte an ein festes externes Ziel, das dem Mitglied nicht angezeigt wird und das es nicht kontrolliert.       |
  | `remote-code-instruction-loader`  | Weist Claude an, externe Inhalte herunterzuladen und auszuführen oder deren Anweisungen zu befolgen, die sich nach der Installation des Plugins ändern können. |
  | `credential-exposure`             | Enthält aktive Zugangsdaten oder sammelt Zugangsdaten oder Tokens aus der Umgebung des Mitglieds.                                                              |
  | `guardrail-tampering`             | Schwächt die Schutzmaßnahmen des Mitglieds, zum Beispiel indem jede Berechtigungsabfrage vorab genehmigt wird.                                                 |
  | `system-prompt-spoofing`          | Imitiert Claudes Systemanweisungen oder versucht, sie zu ersetzen.                                                                                             |
  | `covert-record-tampering`         | Ändert, verbirgt oder löscht unbemerkt Informationen, die das Mitglied sonst sehen würde.                                                                      |
  | `covert-behavior-override`        | Ändert Claudes Verhalten über den Zweck des Plugins hinaus und verbirgt die Änderung vor dem Mitglied.                                                         |
  | `hidden-code-execution`           | Führt mitgelieferten Code aus und weist Claude dabei an, nicht offenzulegen, was dieser tut.                                                                   |
  | `undisclosed-promotion-injection` | Fügt nicht offengelegte Werbeinhalte in Claudes Ausgabe ein.                                                                                                   |
  | `hidden-identity-gate`            | Ändert oder beendet sein Verhalten abhängig davon, welches Konto es ausführt, ohne den Grund anzugeben.                                                        |
  | `destructive-persistence`         | Kann die Dateien des Mitglieds löschen oder beschädigen oder Programme installieren, die nach dem Plugin bestehen bleiben.                                     |
  | `unanalyzable-binary`             | Enthält ein kompiliertes oder unlesbares Programm, sodass der Scan nicht überprüfen konnte, was es tut.                                                        |
  | `other`                           | Jedes andere Problem, einschließlich eines, das neuer als diese Liste ist.                                                                                     |
</Accordion>

Eine `plugin_id` ohne das Präfix `plugin_` gibt `400` zurück. Eine `plugin_id`, die das Präfix trägt, aber nicht im Bestand deiner Organisation enthalten ist, gibt `404` zurück.

### Plugins auflisten

`GET /v1/organizations/plugins` listet die Plugins in deiner Organisation auf, in den Marketplaces der Organisation und in den persönlichen Marketplaces der Mitglieder, absteigend sortiert nach `created_at`. Filtere nach `owner_type` (`organization` oder `user`), `owner_user_id` (eine ID mit dem Präfix `user_`, die die Plugins eines Mitglieds findet, auch nachdem das Mitglied die Organisation verlassen hat), `marketplace_id` sowie `created_at[gte]`, `created_at[gt]`, `created_at[lte]`, `created_at[lt]` (RFC-3339-Zeitstempel). Filter werden mit AND kombiniert. Eine `marketplace_id` oder `owner_user_id`, die in deiner Organisation nichts findet, gibt eine leere Seite zurück, keinen Fehler. Die Antwort hat die im [Schnellstart](https://platform.claude.com/docs/de/manage-claude/plugins-api#quick-start) gezeigte Form. Erfordert den Scope `read:plugins`.

<CodeGroup>
  ```bash cURL
  curl "https://api.anthropic.com/v1/organizations/plugins?owner_type=organization&limit=20" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01"
  ```

  ```bash CLI
  ant beta:organization:plugins list --owner-type organization --limit 20
  ```

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

  plugins = client.beta.organization.plugins.list(owner_type="organization", limit=20)

  # Ruft bei Bedarf automatisch weitere Seiten ab.
  for plugin in plugins:
      print(f"{plugin.id}: {plugin.name}")
  ```

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

  const plugins = await client.beta.organization.plugins.list({
    owner_type: "organization",
    limit: 20
  });

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

  ```csharp C#
  using Anthropic.Models.Beta.Organization.Plugins;

  AnthropicClient client = new();

  var page = await client.Beta.Organization.Plugins.List(
      new() { OwnerType = OwnerType.Organization, Limit = 20 }
  );

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

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

  plugins := client.Beta.Organization.Plugins.ListAutoPaging(context.Background(), anthropic.BetaOrganizationPluginListParams{
  	OwnerType: anthropic.BetaOrganizationPluginListParamsOwnerTypeOrganization,
  	Limit:     anthropic.Int(20),
  })

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

  ```java Java
  import com.anthropic.models.beta.organization.plugins.PluginListParams;

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

      var params = PluginListParams.builder()
          .ownerType(PluginListParams.OwnerType.ORGANIZATION)
          .limit(20)
          .build();
      var plugins = client.beta().organization().plugins().list(params);

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

  ```php PHP
  use Anthropic\Beta\Organization\Plugins\PluginListParams\OwnerType;
  // ...

  $client = new Client();

  $plugins = $client->beta->organization->plugins->list(
      limit: 20,
      ownerType: OwnerType::ORGANIZATION,
  );

  // Nur diese Seite; für die nächste rufe list() erneut mit page: $plugins->nextPage auf.
  foreach ($plugins->getItems() as $plugin) {
      echo "{$plugin->id}: {$plugin->name}\n";
  }
  ```

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

  page = client.beta.organization.plugins.list(owner_type: :organization, limit: 20)

  page.auto_paging_each do |plugin|
    puts "#{plugin.id}: #{plugin.name}"
  end
  ```
</CodeGroup>

### Plugin erstellen

`POST /v1/organizations/plugins` erstellt ein Plugin im Besitz der Organisation und seine erste Version in einem Aufruf; die Version wird zur bereitgestellten Version. Der Body ist `multipart/form-data`: `files[]` ist entweder ein einzelnes `.zip`- oder `.plugin`-Archiv oder ein Teil pro Datei, wobei der Dateiname jedes Teils der Pfad der Datei innerhalb des Plugins ist (zum Beispiel `.claude-plugin/plugin.json`). Optionale Felder sind `marketplace_id` (ein `manual`-Marketplace im Besitz der Organisation oder standardmäßig dein Bibliotheks-Marketplace, der bei der ersten Verwendung erstellt wird) und `release_notes` (bis zu 5.000 Zeichen, angezeigt im Versionsverlauf von claude.ai und bei der Version zurückgegeben). Die Felder `name`, `display_name`, `description` und `manifest_version` des Plugins stammen aus den hochgeladenen Dateien, und der Upload muss die [Upload-Anforderungen](https://platform.claude.com/docs/de/manage-claude/plugins-api#upload-requirements) erfüllen. Wenn das Content-Scanning aktiviert ist, ist `content_scan.status` in der Antwort `processing`, und das Urteil kommt asynchron. Gibt das Plugin zurück. Erfordert den Scope `write:plugins`.

Ein Archiv hochladen:

<CodeGroup>
  ```bash cURL
  curl -X POST "https://api.anthropic.com/v1/organizations/plugins" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01" \
    -F "files[]=@dist/sales-toolkit.zip" \
    -F "release_notes=First release"
  ```

  ```bash CLI
  ant beta:organization:plugins create \
    --file dist/sales-toolkit.zip \
    --release-notes "First release"
  ```

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

  with open("dist/sales-toolkit.zip", "rb") as archive:
      plugin = client.beta.organization.plugins.create(
          files=[archive],
          release_notes="First release",
      )

  print(f"id: {plugin.id}")
  print(f"served_version_id: {plugin.served_version_id}")
  ```

  ```typescript TypeScript
  import fs from "node:fs";

  const client = new Anthropic();

  const plugin = await client.beta.organization.plugins.create({
    files: [fs.createReadStream("dist/sales-toolkit.zip")],
    release_notes: "First release"
  });

  console.log(`id: ${plugin.id}`);
  console.log(`served_version_id: ${plugin.served_version_id}`);
  ```

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

  var plugin = await client.Beta.Organization.Plugins.Create(
      new()
      {
          Files = [File.OpenRead("dist/sales-toolkit.zip")],
          ReleaseNotes = "First release",
      }
  );

  Console.WriteLine($"id: {plugin.ID}");
  Console.WriteLine($"served_version_id: {plugin.ServedVersionID}");
  ```

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

  archive, err := os.Open("dist/sales-toolkit.zip")
  if err != nil {
  	log.Fatal(err)
  }
  defer archive.Close()

  plugin, err := client.Beta.Organization.Plugins.New(context.Background(), anthropic.BetaOrganizationPluginNewParams{
  	Files:        []io.Reader{archive},
  	ReleaseNotes: anthropic.String("First release"),
  })
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("id: %s\n", plugin.ID)
  fmt.Printf("served_version_id: %s\n", plugin.ServedVersionID)
  ```

  ```java Java
  import com.anthropic.core.MultipartField;
  import com.anthropic.models.beta.organization.plugins.PluginCreateParams;

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

      // Baue den `files[]`-Teil manuell, damit das Archiv mit seinem Dateinamen gesendet wird,
      // den der Upload erfordert.
      var archive = MultipartField.<List<InputStream>>builder()
          .value(List.of(Files.newInputStream(Path.of("dist/sales-toolkit.zip"))))
          .filename("sales-toolkit.zip")
          .contentType("application/octet-stream")
          .build();
      var params = PluginCreateParams.builder()
          .files(archive)
          .releaseNotes("First release")
          .build();
      var plugin = client.beta().organization().plugins().create(params);

      IO.println("id: " + plugin.id());
      IO.println("served_version_id: " + plugin.servedVersionId());
  }
  ```

  ```php PHP
  use Anthropic\Core\FileParam;

  $client = new Client();

  $plugin = $client->beta->organization->plugins->create(
      files: [
          FileParam::fromResource(fopen('dist/sales-toolkit.zip', 'r')),
      ],
      releaseNotes: 'First release',
  );

  echo "id: {$plugin->id}\n";
  echo "served_version_id: {$plugin->servedVersionID}\n";
  ```

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

  plugin = client.beta.organization.plugins.create(
    files: [Pathname("dist/sales-toolkit.zip")],
    release_notes: "First release"
  )

  puts "id: #{plugin.id}"
  puts "served_version_id: #{plugin.served_version_id}"
  ```
</CodeGroup>

```json
{
  "type": "plugin",
  "id": "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
  "name": "sales-toolkit",
  "display_name": "Sales Toolkit",
  "description": "Account research and call prep for the sales team.",
  "served_version_id": "pluginver_01Km7tL4pR9xF5sU2zV3jP6q",
  "served_version_pinned": false,
  "latest_version_id": "pluginver_01Km7tL4pR9xF5sU2zV3jP6q",
  "manifest_version": "1.4.0",
  "owner": { "type": "organization" },
  "marketplace_id": "marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r",
  "created_by": { "type": "api_actor", "api_key_id": "apikey_01Nq9vN6rT2zH7uW4bX5mR8s" },
  "organization_installation_preference": "available",
  "organization_installation_preference_inherited": true,
  "content_scan": { "status": "processing", "assessment": null, "reason": null },
  "components": [
    {
      "type": "skill",
      "name": "account-research",
      "description": "Researches a customer account before a call."
    },
    { "type": "mcp_server", "name": "crm", "description": null }
  ],
  "reach": "remote",
  "created_at": "2026-09-01T17:04:11Z",
  "updated_at": "2026-09-01T17:04:11Z"
}
```

Einzelne Dateien in einen benannten Marketplace hochladen. Hänge jede Datei unter ihrem Pfad innerhalb des Plugins an (das Suffix `;filename=` im cURL-Beispiel, die Dateinamen-Argumente in den SDK-Beispielen); eine Datei, die nur unter ihrem Basisnamen gesendet wird, führt dazu, dass das Manifest nicht gefunden wird. Die TypeScript- und Java-SDKs sowie die `ant`-CLI können Dateien noch nicht unter einem Pfad anhängen, daher laden diese Beispiele das Plugin stattdessen als ein Archiv in den Marketplace hoch:

<CodeGroup>
  ```bash cURL
  curl -X POST "https://api.anthropic.com/v1/organizations/plugins" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01" \
    -F "files[]=@.claude-plugin/plugin.json;filename=.claude-plugin/plugin.json" \
    -F "files[]=@skills/account-research/SKILL.md;filename=skills/account-research/SKILL.md" \
    -F "marketplace_id=marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r"
  ```

  ```bash CLI
  # Die CLI sendet jede Datei nur unter ihrem Basisnamen,
  # lade das Plugin daher stattdessen als ein Archiv hoch.
  ant beta:organization:plugins create \
    --file dist/sales-toolkit.zip \
    --marketplace-id marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r
  ```

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

  # Ein (filename, file)-Tupel behält den Pfad jeder Datei im Plugin bei;
  # ein reines Dateiobjekt würde nur unter seinem Basisnamen gesendet.
  with (
      open(".claude-plugin/plugin.json", "rb") as manifest,
      open("skills/account-research/SKILL.md", "rb") as skill_md,
  ):
      plugin = client.beta.organization.plugins.create(
          files=[
              (".claude-plugin/plugin.json", manifest),
              ("skills/account-research/SKILL.md", skill_md),
          ],
          marketplace_id="marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r",
      )

  print(f"id: {plugin.id}")
  print(f"served_version_id: {plugin.served_version_id}")
  ```

  ```typescript TypeScript
  import fs from "node:fs";

  const client = new Anthropic();

  // Das TypeScript-SDK sendet jede Datei unter ihrem Basisnamen,
  // lade das Plugin daher als ein einziges Archiv hoch.
  const plugin = await client.beta.organization.plugins.create({
    files: [fs.createReadStream("dist/sales-toolkit.zip")],
    marketplace_id: "marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r"
  });

  console.log(`id: ${plugin.id}`);
  console.log(`served_version_id: ${plugin.served_version_id}`);
  ```

  ```csharp C#
  using Anthropic.Core;

  AnthropicClient client = new();

  // FileName behält den Pfad jeder Datei innerhalb des Plugins bei; ohne ihn wird ein FileStream
  // nur unter seinem Basisnamen gesendet.
  var plugin = await client.Beta.Organization.Plugins.Create(
      new()
      {
          Files =
          [
              new BinaryContent
              {
                  Stream = File.OpenRead(".claude-plugin/plugin.json"),
                  FileName = ".claude-plugin/plugin.json",
              },
              new BinaryContent
              {
                  Stream = File.OpenRead("skills/account-research/SKILL.md"),
                  FileName = "skills/account-research/SKILL.md",
              },
          ],
          MarketplaceID = "marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r",
      }
  );

  Console.WriteLine($"id: {plugin.ID}");
  Console.WriteLine($"served_version_id: {plugin.ServedVersionID}");
  ```

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

  manifest, err := os.Open(".claude-plugin/plugin.json")
  if err != nil {
  	log.Fatal(err)
  }
  defer manifest.Close()

  skillMd, err := os.Open("skills/account-research/SKILL.md")
  if err != nil {
  	log.Fatal(err)
  }
  defer skillMd.Close()

  // anthropic.File behält den Pfad jeder Datei im Plugin als Dateinamen des Parts bei;
  // ein bloßes *os.File würde unter seinem Basisnamen gesendet und das Manifest nicht gefunden.
  plugin, err := client.Beta.Organization.Plugins.New(context.Background(), anthropic.BetaOrganizationPluginNewParams{
  	Files: []io.Reader{
  		anthropic.File(manifest, ".claude-plugin/plugin.json", "application/json"),
  		anthropic.File(skillMd, "skills/account-research/SKILL.md", "text/markdown"),
  	},
  	MarketplaceID: anthropic.String("marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r"),
  })
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("id: %s\n", plugin.ID)
  fmt.Printf("served_version_id: %s\n", plugin.ServedVersionID)
  ```

  ```java Java
  import com.anthropic.core.MultipartField;
  import com.anthropic.models.beta.organization.plugins.PluginCreateParams;

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

      // Die `files`-Setter auf PluginCreateParams nehmen einen Dateinamen für die ganze
      // Liste, lade das Plugin daher stattdessen als ein Archiv hoch: ein einzelner, manuell erstellter
      // Teil mit dem Dateinamen des Archivs, den der Upload erfordert.
      var archive = MultipartField.<List<InputStream>>builder()
          .value(List.of(Files.newInputStream(Path.of("dist/sales-toolkit.zip"))))
          .filename("sales-toolkit.zip")
          .contentType("application/octet-stream")
          .build();
      var params = PluginCreateParams.builder()
          .files(archive)
          .marketplaceId("marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r")
          .build();
      var plugin = client.beta().organization().plugins().create(params);

      IO.println("id: " + plugin.id());
      IO.println("served_version_id: " + plugin.servedVersionId());
  }
  ```

  ```php PHP
  use Anthropic\Core\FileParam;

  $client = new Client();

  $plugin = $client->beta->organization->plugins->create(
      files: [
          FileParam::fromResource(
              fopen('.claude-plugin/plugin.json', 'r'),
              filename: '.claude-plugin/plugin.json',
          ),
          FileParam::fromResource(
              fopen('skills/account-research/SKILL.md', 'r'),
              filename: 'skills/account-research/SKILL.md',
          ),
      ],
      marketplaceID: 'marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r',
  );

  echo "id: {$plugin->id}\n";
  echo "served_version_id: {$plugin->servedVersionID}\n";
  ```

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

  # Ein FilePart mit filename: behält den Pfad jeder Datei im Plugin bei;
  # ein bloßer Pathname würde nur unter seinem Basisnamen gesendet.
  plugin = client.beta.organization.plugins.create(
    files: [
      Anthropic::FilePart.new(
        Pathname(".claude-plugin/plugin.json"),
        filename: ".claude-plugin/plugin.json"
      ),
      Anthropic::FilePart.new(
        Pathname("skills/account-research/SKILL.md"),
        filename: "skills/account-research/SKILL.md"
      )
    ],
    marketplace_id: "marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r"
  )

  puts "id: #{plugin.id}"
  puts "served_version_id: #{plugin.served_version_id}"
  ```
</CodeGroup>

Neben einem `400` für einen Upload, der gegen die [Upload-Anforderungen](https://platform.claude.com/docs/de/manage-claude/plugins-api#upload-requirements) verstößt (`413` für einen Request-Body über 200 MB), und den gemeinsamen Antworten (ein `403`, wenn `marketplace_id` der persönliche Marketplace eines Mitglieds ist; siehe [Fehlerantworten](https://platform.claude.com/docs/de/manage-claude/plugins-api#error-responses)) kann ein Erstellen fehlschlagen mit:

| Status                     | Ursache                                                                                                                                                                                               | Vorgehen                                                                                                                                                                                                                                                                           |
| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 404                        | `marketplace_id` ist kein Marketplace deiner Organisation.                                                                                                                                            | Entnimm die ID aus [Marketplaces auflisten](https://platform.claude.com/docs/de/manage-claude/plugins-api#list-marketplaces).                                                                                                                                                      |
| 400                        | Der Marketplace wird aus Git synchronisiert oder enthält bereits 1.000 Plugins (siehe [Anforderungen an Uploads](https://platform.claude.com/docs/de/manage-claude/plugins-api#upload-requirements)). | Lade in einen anderen `manual`-Marketplace hoch oder ändere stattdessen das Repository.                                                                                                                                                                                            |
| 409 `plugin_name_taken`    | Der Name ist in diesem Marketplace bereits vergeben.                                                                                                                                                  | Lade nur dann eine Version zu `details.plugin_id` hoch, wenn es das Plugin ist, das du aktualisieren wolltest, denn jemand anderes könnte es erstellt haben. Andernfalls oder wenn `details.plugin_id` fehlt, lade unter einem anderen Namen hoch (ändere den `name` im Manifest). |
| 409 `skill_name_taken`     | Das Plugin kommt in den Bibliotheks-Marketplace, und einer seiner Skills trägt den Namen eines Organisations-Skills.                                                                                  | Benenne den Skill um oder entferne den Organisations-Skill in claude.ai.                                                                                                                                                                                                           |
| 409 (kein `error_code`)    | Ein anderer Upload mit demselben Namen in denselben Marketplace läuft, oder ein Plugin, das diese API nicht auflistet, belegt den Namen.                                                              | Versuche es mit Backoff erneut. Wenn der `409` länger als einige Minuten bestehen bleibt, lade unter einem anderen Namen hoch (ändere den `name` im Manifest).                                                                                                                     |
| 503 `registration_pending` | Das Plugin wurde erstellt, aber seine Registrierung wurde nicht abgeschlossen.                                                                                                                        | Sende die Anfrage nicht erneut; lade dieselben Dateien als Version von `details.plugin_id` hoch (siehe [Uploads wiederholen](https://platform.claude.com/docs/de/manage-claude/plugins-api#retrying-uploads)).                                                                     |

### Plugin abrufen

`GET /v1/organizations/plugins/{plugin_id}` gibt ein Plugin zurück. Erfordert den Scope `read:plugins`.

<CodeGroup>
  ```bash cURL
  curl "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01"
  ```

  ```bash CLI
  ant beta:organization:plugins retrieve \
    --plugin-id plugin_01Hq3vX8kZcN2mB7pR4tY9wL
  ```

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

  plugin = client.beta.organization.plugins.retrieve("plugin_01Hq3vX8kZcN2mB7pR4tY9wL")

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

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

  const plugin = await client.beta.organization.plugins.retrieve(
    "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  );

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

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

  var plugin = await client.Beta.Organization.Plugins.Retrieve("plugin_01Hq3vX8kZcN2mB7pR4tY9wL");

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

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

  plugin, err := client.Beta.Organization.Plugins.Get(
  	context.Background(),
  	"plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
  	anthropic.BetaOrganizationPluginGetParams{},
  )
  if err != nil {
  	log.Fatal(err)
  }

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

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

  var plugin = client.beta().organization().plugins()
      .retrieve("plugin_01Hq3vX8kZcN2mB7pR4tY9wL");

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

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

  $plugin = $client->beta->organization->plugins->retrieve(
      pluginID: 'plugin_01Hq3vX8kZcN2mB7pR4tY9wL',
  );

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

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

  plugin_id = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  plugin = client.beta.organization.plugins.retrieve(plugin_id)

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

### Bereitgestellte Version ändern

`POST /v1/organizations/plugins/{plugin_id}` ändert, welche Version eines Plugins im Besitz der Organisation Mitgliedern bereitgestellt wird. Übergib eine frühere Version, um zurückzurollen, oder eine neuere, um einen Build hochzustufen, der gespeichert, aber nicht bereitgestellt wurde. Dadurch wird das Plugin gepinnt, und ein gepinntes Plugin kann nicht entpinnt werden, weder hier noch in claude.ai (siehe [Versionen und die bereitgestellte Version](https://platform.claude.com/docs/de/manage-claude/plugins-api#versions-and-the-served-version)). Das einzige aktualisierbare Feld ist `served_version_id`, und es ist erforderlich. Die Änderung erreicht die Mitglieder, bevor die Antwort zurückkommt, und erstellt keine Version. Wenn das Content-Scanning aktiviert ist, muss die Version eine sein, die Mitgliedern bereitgestellt werden kann (siehe [Content-Scanning](https://platform.claude.com/docs/de/manage-claude/plugins-api#content-scanning)). Die Übergabe der bereits bereitgestellten Version bei einem gepinnten Plugin ändert nichts; bei einem nicht gepinnten Plugin wird es damit auf diese Version gepinnt, sodass spätere Uploads nicht mehr automatisch bereitgestellt werden. Das Pinnen beendet auch jedes Warten: Eine Version, die auf ihren Content-Scan gewartet hat, bleibt gespeichert und wird nur bereitgestellt, wenn jemand sie auswählt. Gibt das Plugin zurück. Erfordert den Scope `write:plugins`.

<CodeGroup>
  ```bash cURL
  curl -X POST "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL" \
    -H "content-type: application/json" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01" \
    -d '{"served_version_id": "pluginver_01Jd5sK2nQ8wE4rT6yU1iO3p"}'
  ```

  ```bash CLI
  ant beta:organization:plugins update \
    --plugin-id plugin_01Hq3vX8kZcN2mB7pR4tY9wL \
    --served-version-id pluginver_01Jd5sK2nQ8wE4rT6yU1iO3p
  ```

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

  plugin = client.beta.organization.plugins.update(
      "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
      served_version_id="pluginver_01Jd5sK2nQ8wE4rT6yU1iO3p",
  )

  print(f"id: {plugin.id}")
  print(f"served_version_id: {plugin.served_version_id}")
  ```

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

  const plugin = await client.beta.organization.plugins.update(
    "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
    { served_version_id: "pluginver_01Jd5sK2nQ8wE4rT6yU1iO3p" }
  );

  console.log(`id: ${plugin.id}`);
  console.log(`served_version_id: ${plugin.served_version_id}`);
  ```

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

  var plugin = await client.Beta.Organization.Plugins.Update(
      "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
      new() { ServedVersionID = "pluginver_01Jd5sK2nQ8wE4rT6yU1iO3p" }
  );

  Console.WriteLine($"id: {plugin.ID}");
  Console.WriteLine($"served_version_id: {plugin.ServedVersionID}");
  ```

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

  plugin, err := client.Beta.Organization.Plugins.Update(
  	context.Background(),
  	"plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
  	anthropic.BetaOrganizationPluginUpdateParams{
  		ServedVersionID: "pluginver_01Jd5sK2nQ8wE4rT6yU1iO3p",
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("id: %s\n", plugin.ID)
  fmt.Printf("served_version_id: %s\n", plugin.ServedVersionID)
  ```

  ```java Java
  import com.anthropic.models.beta.organization.plugins.PluginUpdateParams;

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

      var params = PluginUpdateParams.builder()
          .servedVersionId("pluginver_01Jd5sK2nQ8wE4rT6yU1iO3p")
          .build();
      var plugin = client.beta().organization().plugins()
          .update("plugin_01Hq3vX8kZcN2mB7pR4tY9wL", params);

      IO.println("id: " + plugin.id());
      IO.println("served_version_id: " + plugin.servedVersionId());
  }
  ```

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

  $plugin = $client->beta->organization->plugins->update(
      pluginID: 'plugin_01Hq3vX8kZcN2mB7pR4tY9wL',
      servedVersionID: 'pluginver_01Jd5sK2nQ8wE4rT6yU1iO3p',
  );

  echo "id: {$plugin->id}\n";
  echo "served_version_id: {$plugin->servedVersionID}\n";
  ```

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

  plugin_id = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  plugin = client.beta.organization.plugins.update(
    plugin_id,
    served_version_id: "pluginver_01Jd5sK2nQ8wE4rT6yU1iO3p"
  )

  puts "id: #{plugin.id}"
  puts "served_version_id: #{plugin.served_version_id}"
  ```
</CodeGroup>

```json
{
  "type": "plugin",
  "id": "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
  "name": "sales-toolkit",
  "display_name": "Sales Toolkit",
  "description": "Account research and call prep for the sales team.",
  "served_version_id": "pluginver_01Jd5sK2nQ8wE4rT6yU1iO3p",
  "served_version_pinned": true,
  "latest_version_id": "pluginver_01Jd5sK2nQ8wE4rT6yU1iO3p",
  "manifest_version": "1.5.0",
  "owner": { "type": "organization" },
  "marketplace_id": "marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r",
  "created_by": { "type": "api_actor", "api_key_id": "apikey_01Nq9vN6rT2zH7uW4bX5mR8s" },
  "organization_installation_preference": "available",
  "organization_installation_preference_inherited": true,
  "content_scan": { "status": "completed", "assessment": "pass", "reason": null },
  "components": [
    {
      "type": "skill",
      "name": "account-research",
      "description": "Researches a customer account before a call."
    },
    { "type": "mcp_server", "name": "crm", "description": null },
    {
      "type": "command",
      "name": "call-prep",
      "description": "Builds a one-page brief for an upcoming call."
    }
  ],
  "reach": "remote",
  "created_at": "2026-09-01T17:04:11Z",
  "updated_at": "2026-09-16T10:02:45Z"
}
```

Neben den gemeinsamen Antworten (ein `403` für ein Plugin im Besitz eines Mitglieds sowie `409 scan_pending` oder `400 scan_failed` für eine Version, die Mitgliedern nicht bereitgestellt werden kann; siehe [Fehlerantworten](https://platform.claude.com/docs/de/manage-claude/plugins-api#error-responses)) kann die Anfrage fehlschlagen mit:

| Status                  | Ursache                                                                                                                                                      | Vorgehen                                                                                                                                       |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| 400                     | Der Body lässt `served_version_id` weg, setzt es auf `null` oder enthält ein anderes Feld; oder dem Wert fehlt das Präfix `pluginver_` oder er ist `latest`. | Sende genau `{"served_version_id": "pluginver_..."}`.                                                                                          |
| 404                     | `served_version_id` ist keine Version dieses Plugins.                                                                                                        | Entnimm die ID aus [Versionen eines Plugins auflisten](https://platform.claude.com/docs/de/manage-claude/plugins-api#list-a-plugins-versions). |
| 409 (kein `error_code`) | Ein Upload zu diesem Plugin oder eine andere Änderung der bereitgestellten Version läuft noch.                                                               | Versuche es in Kürze erneut.                                                                                                                   |
| 409 `skill_name_taken`  | Das Plugin befindet sich im Bibliotheks-Marketplace, und die Version enthält einen Skill, dessen Namen inzwischen ein Organisations-Skill verwendet.         | Wähle eine andere Version oder benenne einen der Skills um.                                                                                    |

### Plugin löschen

`DELETE /v1/organizations/plugins/{plugin_id}` löscht ein Plugin und alle seine Versionen dauerhaft, genau wie das Löschen durch einen Administrator in claude.ai. Es funktioniert für jedes Plugin in einem `manual`-Marketplace, einschließlich des Plugins eines Mitglieds, selbst wenn dieses Mitglied die Organisation inzwischen verlassen hat. Wenn das Löschen zurückkehrt, sind das Plugin, seine Versionen und deren Dateien aus allen Lesezugriffen verschwunden, und es wird Mitgliedern nicht mehr bereitgestellt. Die Installationseinstellungen eines Plugins im Besitz der Organisation werden mit ihm entfernt; die Freigaben eines Plugins im Besitz eines Mitglieds werden zurückgezogen, und es verschwindet auch für seinen Eigentümer. Ein Plugin in einem aus Git synchronisierten Marketplace gibt `400` zurück: Entferne es aus dem Repository oder entferne den Marketplace in claude.ai. Erfordert den Scope `write:plugins`.

Das Löschen kann nicht rückgängig gemacht werden, und es gibt kein Löschen pro Version. Um ein Plugin im Besitz der Organisation stattdessen umkehrbar zurückzuhalten, setze seine organisationsweite Installationseinstellung auf `not_available` (ein Plugin, das den Standard seines Marketplace geerbt hat, erhält eine eigene Einstellung, und [das Entfernen dieser organisationsweiten Einstellung](https://platform.claude.com/docs/de/manage-claude/plugins-api#remove-an-installation-setting) bringt das Plugin später zum Standard zurück), und entferne jede Gruppeneinstellung, die `GET /v1/organizations/plugins/{plugin_id}/installation_settings` auflistet (oder setze sie auf `not_available`), da die Einstellung einer Gruppe den organisationsweiten Wert für ihre Mitglieder überschreibt. Sende diese Schreibvorgänge nacheinander, nicht parallel (siehe [Installationseinstellung festlegen](https://platform.claude.com/docs/de/manage-claude/plugins-api#set-an-installation-setting)). Ein Plugin im Besitz eines Mitglieds kann über diese API nur durch Löschen zurückgehalten werden, und nur, wenn sein Marketplace `manual` ist.

<CodeGroup>
  ```bash cURL
  curl -X DELETE "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01"
  ```

  ```bash CLI
  ant beta:organization:plugins delete --plugin-id plugin_01Hq3vX8kZcN2mB7pR4tY9wL
  ```

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

  deleted_plugin = client.beta.organization.plugins.delete(
      "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  )

  print(f"id: {deleted_plugin.id}")
  ```

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

  const deletedPlugin = await client.beta.organization.plugins.delete(
    "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  );

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

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

  var deletedPlugin = await client.Beta.Organization.Plugins.Delete(
      "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  );

  Console.WriteLine($"id: {deletedPlugin.ID}");
  ```

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

  deletedPlugin, err := client.Beta.Organization.Plugins.Delete(
  	context.Background(),
  	"plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
  	anthropic.BetaOrganizationPluginDeleteParams{},
  )
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("id: %s\n", deletedPlugin.ID)
  ```

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

  var deletedPlugin = client.beta().organization().plugins()
      .delete("plugin_01Hq3vX8kZcN2mB7pR4tY9wL");

  IO.println("id: " + deletedPlugin.id());
  ```

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

  $deletedPlugin = $client->beta->organization->plugins->delete(
      pluginID: 'plugin_01Hq3vX8kZcN2mB7pR4tY9wL',
  );

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

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

  plugin_id = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  deleted_plugin = client.beta.organization.plugins.delete(plugin_id)

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

```json
{ "type": "plugin_deleted", "id": "plugin_01Hq3vX8kZcN2mB7pR4tY9wL" }
```

## Plugin-Versionen

Eine Plugin-Version ist ein unveränderlicher Snapshot der Dateien eines Plugins aus einem Upload (die Antwort von [Version erstellen](https://platform.claude.com/docs/de/manage-claude/plugins-api#create-a-version) zeigt ein vollständiges Objekt). Ihre Felder spiegeln die Felder der bereitgestellten Version des Plugins (`display_name`, `description`, `manifest_version`, `content_scan`, `components`, `reach`) für diese Version wider, zuzüglich `release_notes` (wie beim Upload angegeben und im Versionsverlauf von claude.ai angezeigt) und `created_by` (wer sie hochgeladen hat).

Eine `{version}` ohne das Präfix `pluginver_` gibt `400` zurück (außer dem Literal `latest`, wo angegeben). Eine, die das Präfix trägt, aber keine Version dieses Plugins bezeichnet, gibt `404` zurück.

### Versionen eines Plugins auflisten

`GET /v1/organizations/plugins/{plugin_id}/versions` listet die Versionen eines Plugins auf, absteigend nach `created_at` sortiert; das erste Element ist die Version, die `latest_version_id` bezeichnet. `limit` liegt zwischen 1 und 1.000. Erfordert den Scope `read:plugins`.

<CodeGroup>
  ```bash cURL
  curl "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL/versions?limit=50" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01"
  ```

  ```bash CLI
  ant beta:organization:plugins:versions list \
    --plugin-id plugin_01Hq3vX8kZcN2mB7pR4tY9wL \
    --limit 50
  ```

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

  versions = client.beta.organization.plugins.versions.list(
      "plugin_01Hq3vX8kZcN2mB7pR4tY9wL", limit=50
  )

  # Ruft bei Bedarf automatisch weitere Seiten ab.
  for version in versions:
      print(f"{version.id}: {version.manifest_version}")
  ```

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

  const versions = await client.beta.organization.plugins.versions.list(
    "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
    { limit: 50 }
  );

  for await (const version of versions) {
    console.log(`${version.id}: ${version.manifest_version}`);
  }
  ```

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

  var page = await client.Beta.Organization.Plugins.Versions.List(
      "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
      new() { Limit = 50 }
  );

  await foreach (var version in page.Paginate())
  {
      Console.WriteLine($"{version.ID}: {version.ManifestVersion}");
  }
  ```

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

  versions := client.Beta.Organization.Plugins.Versions.ListAutoPaging(
  	context.Background(),
  	"plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
  	anthropic.BetaOrganizationPluginVersionListParams{
  		Limit: anthropic.Int(50),
  	},
  )

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

  ```java Java
  import com.anthropic.models.beta.organization.plugins.versions.VersionListParams;

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

      var params = VersionListParams.builder()
          .limit(50)
          .build();
      var versions = client.beta().organization().plugins().versions()
          .list("plugin_01Hq3vX8kZcN2mB7pR4tY9wL", params);

      for (var version : versions.autoPager()) {
          IO.println(version.id() + ": " + version.manifestVersion().orElse(null));
      }
  }
  ```

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

  $versions = $client->beta->organization->plugins->versions->list(
      pluginID: 'plugin_01Hq3vX8kZcN2mB7pR4tY9wL',
      limit: 50,
  );

  // Nur diese Seite; für die nächste rufe list() erneut mit page: $versions->nextPage auf.
  foreach ($versions->getItems() as $version) {
      echo "{$version->id}: {$version->manifestVersion}\n";
  }
  ```

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

  plugin_id = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  page = client.beta.organization.plugins.versions.list(plugin_id, limit: 50)

  page.auto_paging_each do |version|
    puts "#{version.id}: #{version.manifest_version}"
  end
  ```
</CodeGroup>

### Version erstellen

`POST /v1/organizations/plugins/{plugin_id}/versions` fügt einem Plugin im Besitz der Organisation in einem `manual`-Marketplace eine Version hinzu. Der Body ist `multipart/form-data`, mit denselben Feldern `files[]` und `release_notes`, denselben [Upload-Anforderungen](https://platform.claude.com/docs/de/manage-claude/plugins-api#upload-requirements) sowie denselben Datei-, Manifest-, Archiv- und Größenfehlern wie bei [Plugin erstellen](https://platform.claude.com/docs/de/manage-claude/plugins-api#create-a-plugin). Der hochgeladene Name (der `name` des Manifests) muss dem `name` des Plugins entsprechen. Wenn das Plugin nicht gepinnt ist, wird die neue Version normalerweise bereitgestellt, sobald sie gespeichert ist; wenn es gepinnt ist, wird die Version gespeichert, aber nicht bereitgestellt, bis du die bereitgestellte Version auf sie änderst. Vergleiche zur Überprüfung die `id` der Antwort mit der `served_version_id` des Plugins. Gibt die Version zurück. Erfordert den Scope `write:plugins`.

<CodeGroup>
  ```bash cURL
  curl -X POST "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL/versions" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01" \
    -F "files[]=@dist/sales-toolkit.zip" \
    -F "release_notes=Adds the call-prep command."
  ```

  ```bash CLI
  ant beta:organization:plugins:versions create \
    --plugin-id plugin_01Hq3vX8kZcN2mB7pR4tY9wL \
    --file dist/sales-toolkit.zip \
    --release-notes "Adds the call-prep command."
  ```

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

  with open("dist/sales-toolkit.zip", "rb") as archive:
      version = client.beta.organization.plugins.versions.create(
          "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
          files=[archive],
          release_notes="Adds the call-prep command.",
      )

  print(f"id: {version.id}")
  print(f"manifest_version: {version.manifest_version}")
  ```

  ```typescript TypeScript
  import fs from "node:fs";

  const client = new Anthropic();

  const version = await client.beta.organization.plugins.versions.create(
    "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
    {
      files: [fs.createReadStream("dist/sales-toolkit.zip")],
      release_notes: "Adds the call-prep command."
    }
  );

  console.log(`id: ${version.id}`);
  console.log(`manifest_version: ${version.manifest_version}`);
  ```

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

  var version = await client.Beta.Organization.Plugins.Versions.Create(
      "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
      new()
      {
          Files = [File.OpenRead("dist/sales-toolkit.zip")],
          ReleaseNotes = "Adds the call-prep command.",
      }
  );

  Console.WriteLine($"id: {version.ID}");
  Console.WriteLine($"manifest_version: {version.ManifestVersion}");
  ```

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

  archive, err := os.Open("dist/sales-toolkit.zip")
  if err != nil {
  	log.Fatal(err)
  }
  defer archive.Close()

  version, err := client.Beta.Organization.Plugins.Versions.New(
  	context.Background(),
  	"plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
  	anthropic.BetaOrganizationPluginVersionNewParams{
  		Files:        []io.Reader{archive},
  		ReleaseNotes: anthropic.String("Adds the call-prep command."),
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("id: %s\n", version.ID)
  fmt.Printf("manifest_version: %s\n", version.ManifestVersion)
  ```

  ```java Java
  import com.anthropic.core.MultipartField;
  import com.anthropic.models.beta.organization.plugins.versions.VersionCreateParams;

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

      // Baue den `files[]`-Teil manuell, damit das Archiv mit seinem Dateinamen gesendet wird,
      // den der Upload erfordert.
      var archive = MultipartField.<List<InputStream>>builder()
          .value(List.of(Files.newInputStream(Path.of("dist/sales-toolkit.zip"))))
          .filename("sales-toolkit.zip")
          .contentType("application/octet-stream")
          .build();
      var params = VersionCreateParams.builder()
          .files(archive)
          .releaseNotes("Adds the call-prep command.")
          .build();
      var version = client.beta().organization().plugins().versions()
          .create("plugin_01Hq3vX8kZcN2mB7pR4tY9wL", params);

      IO.println("id: " + version.id());
      IO.println("manifest_version: " + version.manifestVersion().orElse(null));
  }
  ```

  ```php PHP
  use Anthropic\Core\FileParam;

  $client = new Client();

  $version = $client->beta->organization->plugins->versions->create(
      pluginID: 'plugin_01Hq3vX8kZcN2mB7pR4tY9wL',
      files: [
          FileParam::fromResource(fopen('dist/sales-toolkit.zip', 'r')),
      ],
      releaseNotes: 'Adds the call-prep command.',
  );

  echo "id: {$version->id}\n";
  echo "manifest_version: {$version->manifestVersion}\n";
  ```

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

  plugin_id = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  version = client.beta.organization.plugins.versions.create(
    plugin_id,
    files: [Pathname("dist/sales-toolkit.zip")],
    release_notes: "Adds the call-prep command."
  )

  puts "id: #{version.id}"
  puts "manifest_version: #{version.manifest_version}"
  ```
</CodeGroup>

```json
{
  "type": "plugin_version",
  "id": "pluginver_01Jd5sK2nQ8wE4rT6yU1iO3p",
  "plugin_id": "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
  "display_name": "Sales Toolkit",
  "description": "Account research and call prep for the sales team.",
  "manifest_version": "1.5.0",
  "release_notes": "Adds the call-prep command.",
  "created_by": { "type": "api_actor", "api_key_id": "apikey_01Nq9vN6rT2zH7uW4bX5mR8s" },
  "content_scan": { "status": "processing", "assessment": null, "reason": null },
  "components": [
    {
      "type": "skill",
      "name": "account-research",
      "description": "Researches a customer account before a call."
    },
    { "type": "mcp_server", "name": "crm", "description": null },
    {
      "type": "command",
      "name": "call-prep",
      "description": "Builds a one-page brief for an upcoming call."
    }
  ],
  "reach": "remote",
  "created_at": "2026-09-15T14:12:30Z"
}
```

Neben einem `400` für einen Upload, der gegen die [Upload-Anforderungen](https://platform.claude.com/docs/de/manage-claude/plugins-api#upload-requirements) verstößt (`413` für einen Request-Body über 200 MB), und den gemeinsamen Antworten (ein `403` für ein Plugin im Besitz eines Mitglieds; siehe [Fehlerantworten](https://platform.claude.com/docs/de/manage-claude/plugins-api#error-responses)) kann die Anfrage fehlschlagen mit:

| Status                     | Ursache                                                                                                                               | Vorgehen                                                                                                                                                                                      |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 400                        | Das Plugin befindet sich in einem aus Git synchronisierten Marketplace, oder der hochgeladene Name weicht von dem des Plugins ab.     | Ändere stattdessen das Repository oder korrigiere den `name` im Manifest.                                                                                                                     |
| 409 (kein `error_code`)    | Ein anderer Upload zu diesem Plugin oder eine Änderung der bereitgestellten Version läuft noch.                                       | Versuche es in Kürze erneut.                                                                                                                                                                  |
| 409 `skill_name_taken`     | Das Plugin befindet sich im Bibliotheks-Marketplace, und die Version fügt einen Skill mit dem Namen eines Organisations-Skills hinzu. | Benenne den Skill um oder entferne den Organisations-Skill in claude.ai.                                                                                                                      |
| 503 `registration_pending` | Die Version wurde gespeichert, aber ihre Registrierung wurde nicht abgeschlossen.                                                     | Sende dieselbe Anfrage erneut, wenn die Antwort `x-should-retry: true` enthält (siehe [Uploads wiederholen](https://platform.claude.com/docs/de/manage-claude/plugins-api#retrying-uploads)). |

### Version abrufen

`GET /v1/organizations/plugins/{plugin_id}/versions/{version}` gibt eine Version zurück. `{version}` ist eine Versions-ID oder `latest` für die Version, die `latest_version_id` zum Zeitpunkt der Anfrage bezeichnet. Erfordert den Scope `read:plugins`.

<CodeGroup>
  ```bash cURL
  curl "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL/versions/latest" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01"
  ```

  ```bash CLI
  ant beta:organization:plugins:versions retrieve \
    --plugin-id plugin_01Hq3vX8kZcN2mB7pR4tY9wL \
    --version latest
  ```

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

  version = client.beta.organization.plugins.versions.retrieve(
      "latest",
      plugin_id="plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
  )

  print(f"id: {version.id}")
  print(f"manifest_version: {version.manifest_version}")
  ```

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

  const version = await client.beta.organization.plugins.versions.retrieve("latest", {
    plugin_id: "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  });

  console.log(`id: ${version.id}`);
  console.log(`manifest_version: ${version.manifest_version}`);
  ```

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

  var version = await client.Beta.Organization.Plugins.Versions.Retrieve(
      "latest",
      new() { PluginID = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL" }
  );

  Console.WriteLine($"id: {version.ID}");
  Console.WriteLine($"manifest_version: {version.ManifestVersion}");
  ```

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

  version, err := client.Beta.Organization.Plugins.Versions.Get(
  	context.Background(),
  	"latest",
  	anthropic.BetaOrganizationPluginVersionGetParams{
  		PluginID: "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("id: %s\n", version.ID)
  fmt.Printf("manifest_version: %s\n", version.ManifestVersion)
  ```

  ```java Java
  import com.anthropic.models.beta.organization.plugins.versions.VersionRetrieveParams;

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

      var params = VersionRetrieveParams.builder()
          .pluginId("plugin_01Hq3vX8kZcN2mB7pR4tY9wL")
          .build();
      var version = client.beta().organization().plugins().versions()
          .retrieve("latest", params);

      IO.println("id: " + version.id());
      IO.println("manifest_version: " + version.manifestVersion().orElse(null));
  }
  ```

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

  $version = $client->beta->organization->plugins->versions->retrieve(
      version: 'latest',
      pluginID: 'plugin_01Hq3vX8kZcN2mB7pR4tY9wL',
  );

  echo "id: {$version->id}\n";
  echo "manifest_version: {$version->manifestVersion}\n";
  ```

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

  plugin_id = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  version = client.beta.organization.plugins.versions.retrieve("latest", plugin_id: plugin_id)

  puts "id: #{version.id}"
  puts "manifest_version: #{version.manifest_version}"
  ```
</CodeGroup>

### Dateien einer Version herunterladen

`GET /v1/organizations/plugins/{plugin_id}/versions/{version}/content` lädt die Dateien einer Version als das gespeicherte `.zip`-Archiv herunter (`Content-Type: application/zip`). Das Archiv wird unabhängig vom Ergebnis des Content-Scans zurückgegeben, sodass du Versionen untersuchen kannst, die Mitgliedern vorenthalten werden. Es wird genau so ausgeliefert, wie es gespeichert ist, sodass du es bei einem Plugin im Besitz der Organisation in einem `manual`-Marketplace unverändert als neue Version erneut hochladen kannst, sofern es die aktuellen Upload-Anforderungen erfüllt. `{version}` muss eine Versions-ID sein, nicht `latest`: Lies zuerst die `served_version_id` oder `latest_version_id` des Plugins oder löse `latest` mit `GET /v1/organizations/plugins/{plugin_id}/versions/latest` auf. Der Dateiname in `Content-Disposition` wird vom Namen des Plugins abgeleitet und ist nicht eindeutig; benenne gespeicherte Dateien nach Plugin- und Versions-ID. Erfordert den Scope `read:plugins`.

Das Herunterladen des Archivs eines Plugins **im Besitz eines Mitglieds** erzeugt ein `claude_plugin_archive_accessed`-Ereignis im Activity Feed der Compliance API, das den Key (als `api_actor`), das Plugin und seinen Marketplace, die Version und das besitzende Mitglied per ID identifiziert; es enthält keine Namen. Das Herunterladen des Archivs eines Plugins im Besitz der Organisation erzeugt keinen Eintrag.

<CodeGroup>
  ```bash cURL
  curl "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL/versions/pluginver_01Km7tL4pR9xF5sU2zV3jP6q/content" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01" \
    -o plugin_01Hq3vX8kZcN2mB7pR4tY9wL_pluginver_01Km7tL4pR9xF5sU2zV3jP6q.zip
  ```

  ```bash CLI
  ant beta:organization:plugins:versions download \
    --plugin-id plugin_01Hq3vX8kZcN2mB7pR4tY9wL \
    --version pluginver_01Km7tL4pR9xF5sU2zV3jP6q \
    --output plugin_01Hq3vX8kZcN2mB7pR4tY9wL_pluginver_01Km7tL4pR9xF5sU2zV3jP6q.zip
  ```

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

  plugin_id = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  version_id = "pluginver_01Km7tL4pR9xF5sU2zV3jP6q"

  with client.beta.organization.plugins.versions.with_streaming_response.download(
      version_id,
      plugin_id=plugin_id,
  ) as response:
      response.stream_to_file(f"{plugin_id}_{version_id}.zip")
  ```

  ```typescript TypeScript
  import { writeFile } from "node:fs/promises";

  const client = new Anthropic();

  const pluginId = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL";
  const versionId = "pluginver_01Km7tL4pR9xF5sU2zV3jP6q";

  const response = await client.beta.organization.plugins.versions.download(versionId, {
    plugin_id: pluginId
  });
  if (!response.body) {
    throw new Error("The download returned no body");
  }

  await writeFile(`${pluginId}_${versionId}.zip`, response.body);
  ```

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

  using var response = await client.Beta.Organization.Plugins.Versions.Download(
      "pluginver_01Km7tL4pR9xF5sU2zV3jP6q",
      new() { PluginID = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL" }
  );

  using var content = await response.ReadAsStream();
  using var file = File.Create(
      "plugin_01Hq3vX8kZcN2mB7pR4tY9wL_pluginver_01Km7tL4pR9xF5sU2zV3jP6q.zip"
  );
  await content.CopyToAsync(file);
  ```

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

  response, err := client.Beta.Organization.Plugins.Versions.Download(
  	context.Background(),
  	"pluginver_01Km7tL4pR9xF5sU2zV3jP6q",
  	anthropic.BetaOrganizationPluginVersionDownloadParams{
  		PluginID: "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }
  defer response.Body.Close()

  out, err := os.Create("plugin_01Hq3vX8kZcN2mB7pR4tY9wL_pluginver_01Km7tL4pR9xF5sU2zV3jP6q.zip")
  if err != nil {
  	log.Fatal(err)
  }
  defer out.Close()

  if _, err := io.Copy(out, response.Body); err != nil {
  	log.Fatal(err)
  }
  ```

  ```java Java
  import com.anthropic.core.http.HttpResponse;
  import com.anthropic.models.beta.organization.plugins.versions.VersionDownloadParams;

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

      var params = VersionDownloadParams.builder()
          .pluginId("plugin_01Hq3vX8kZcN2mB7pR4tY9wL")
          .build();
      try (HttpResponse response = client.beta().organization().plugins().versions()
              .download("pluginver_01Km7tL4pR9xF5sU2zV3jP6q", params)) {
          Files.copy(
              response.body(),
              Path.of("plugin_01Hq3vX8kZcN2mB7pR4tY9wL_pluginver_01Km7tL4pR9xF5sU2zV3jP6q.zip"),
              StandardCopyOption.REPLACE_EXISTING);
      }
  }
  ```

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

  // download() würde das gesamte Archiv als einen String zurückgeben, also nimm die rohe
  // Antwort und kopiere ihren Body in Chunks auf die Festplatte.
  $response = $client->beta->organization->plugins->versions->raw->download(
      version: 'pluginver_01Km7tL4pR9xF5sU2zV3jP6q',
      params: ['pluginID' => 'plugin_01Hq3vX8kZcN2mB7pR4tY9wL'],
  );

  $archive = $response->getBody();
  $file = fopen('plugin_01Hq3vX8kZcN2mB7pR4tY9wL_pluginver_01Km7tL4pR9xF5sU2zV3jP6q.zip', 'wb');
  while (!$archive->eof()) {
      fwrite($file, $archive->read(1024 * 1024));
  }
  fclose($file);
  ```

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

  plugin_id = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  version_id = "pluginver_01Km7tL4pR9xF5sU2zV3jP6q"
  archive = client.beta.organization.plugins.versions.download(version_id, plugin_id: plugin_id)

  # Das SDK gibt das Archiv bereits in den Speicher eingelesen als StringIO zurück.
  File.binwrite("#{plugin_id}_#{version_id}.zip", archive.string)
  ```
</CodeGroup>

## Plugin-Installationseinstellungen

Diese Endpunkte gelten für Plugins im Besitz der Organisation. Sie geben `404` für ein Plugin im Besitz eines Mitglieds zurück, das stattdessen Freigaben hat (siehe [Plugin-Freigaben](https://platform.claude.com/docs/de/manage-claude/plugins-api#plugin-shares)). `{target}` ist das Literal `organization` für die organisationsweite Einstellung des Plugins oder die `rbac_group_`-ID einer Gruppe für die Einstellung dieser Gruppe; jeder andere Wert gibt `400` zurück. Gruppen-IDs stammen aus `GET /v1/organizations/rbac_groups` (Scope `read:rbac_groups`; siehe [Gruppen in der Benutzerverwaltung](https://platform.claude.com/docs/de/manage-claude/user-management#groups)). Eine Einstellung hat keine eigene `id`: Sie wird über `(plugin_id, target)` adressiert, und es wird kein Akteur darauf erfasst (der Akteur befindet sich in ihrem Aktivitätsereignis `plugin_installation_preference_updated`).

### Installationseinstellungen eines Plugins auflisten

`GET /v1/organizations/plugins/{plugin_id}/installation_settings` listet die Einstellungen eines Plugins im Besitz der Organisation auf, absteigend nach `created_at` sortiert: seine eigene organisationsweite Einstellung (fehlt, solange es den Standard seines Marketplace erbt) und die Einstellung jeder Gruppe. Filtere nach `target_type` (`organization` oder `rbac_group`). Erfordert den Scope `read:plugins`.

<CodeGroup>
  ```bash cURL
  curl "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL/installation_settings" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01"
  ```

  ```bash CLI
  ant beta:organization:plugins:installation-settings list \
    --plugin-id plugin_01Hq3vX8kZcN2mB7pR4tY9wL
  ```

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

  settings = client.beta.organization.plugins.installation_settings.list(
      "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  )

  # Ruft bei Bedarf automatisch weitere Seiten ab.
  for setting in settings:
      print(f"{setting.plugin_id}: {setting.installation_preference}")
  ```

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

  const settings = await client.beta.organization.plugins.installationSettings.list(
    "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  );

  for await (const setting of settings) {
    console.log(`${setting.plugin_id}: ${setting.installation_preference}`);
  }
  ```

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

  var page = await client.Beta.Organization.Plugins.InstallationSettings.List(
      "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  );

  await foreach (var setting in page.Paginate())
  {
      Console.WriteLine($"{setting.PluginID}: {setting.InstallationPreference.Raw()}");
  }
  ```

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

  settings := client.Beta.Organization.Plugins.InstallationSettings.ListAutoPaging(
  	context.Background(),
  	"plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
  	anthropic.BetaOrganizationPluginInstallationSettingListParams{},
  )

  for settings.Next() {
  	setting := settings.Current()
  	fmt.Printf("%s: %s\n", setting.PluginID, setting.InstallationPreference)
  }
  if err := settings.Err(); err != nil {
  	log.Fatal(err)
  }
  ```

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

  var settings = client.beta().organization().plugins().installationSettings()
      .list("plugin_01Hq3vX8kZcN2mB7pR4tY9wL");

  for (var setting : settings.autoPager()) {
      IO.println(setting.pluginId() + ": " + setting.installationPreference().asString());
  }
  ```

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

  $settings = $client->beta->organization->plugins->installationSettings->list(
      pluginID: 'plugin_01Hq3vX8kZcN2mB7pR4tY9wL',
  );

  // Nur diese Seite; für die nächste rufe list() erneut mit page: $settings->nextPage auf.
  foreach ($settings->getItems() as $setting) {
      echo "{$setting->pluginID}: {$setting->installationPreference}\n";
  }
  ```

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

  plugin_id = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  page = client.beta.organization.plugins.installation_settings.list(plugin_id)

  page.auto_paging_each do |setting|
    puts "#{setting.plugin_id}: #{setting.installation_preference}"
  end
  ```
</CodeGroup>

### Installationseinstellung festlegen

`POST /v1/organizations/plugins/{plugin_id}/installation_settings/{target}` legt die Installationseinstellung eines Ziels für ein Plugin im Besitz der Organisation fest, indem sie erstellt oder der bereits vorhandene Wert geändert wird. Das einzige Feld des Bodys ist `installation_preference` (`required`, `auto_install`, `available` oder `not_available`), und es ist erforderlich. Das Festlegen des Werts, den das Ziel bereits hat, ändert nichts. Das Festlegen des Ziels `organization` beendet das Erben des Marketplace-Standards durch das Plugin (`organization_installation_preference_inherited` wird `false`), selbst wenn der Wert dem Standard entspricht, sodass das Plugin späteren Änderungen am Marketplace-Standard nicht mehr folgt. Um das Plugin zum Standard seines Marketplace zurückzubringen, [entferne die organisationsweite Einstellung](https://platform.claude.com/docs/de/manage-claude/plugins-api#remove-an-installation-setting); Gruppeneinstellungen sind davon nicht betroffen. Ein Gruppenziel muss eine Gruppe sein, die deine Organisation in `GET /v1/organizations/rbac_groups` sehen kann, andernfalls gibt die Anfrage `404` zurück. Die Änderung verändert nicht das `updated_at` des Plugins; sie wird im Activity Feed aufgezeichnet. Gibt die Einstellung zurück. Erfordert den Scope `write:plugins`.

Sende die Schreibvorgänge für Installationseinstellungen eines Plugins einzeln nacheinander. Treffen mehrere Schreibvorgänge für dasselbe Plugin gleichzeitig ein, verarbeitet der Server sie nacheinander und kann einige davon mit `503` beantworten, statt sie anzuwenden. Dieses `503` enthält `x-should-retry: true`, und der Schreibvorgang kann gefahrlos wiederholt werden: Warte ein bis zwei Sekunden und sende ihn dann erneut.

<CodeGroup>
  ```bash cURL
  curl -X POST "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL/installation_settings/rbac_group_01F3xQqQzXyWvUtSrQpOnMlK" \
    -H "content-type: application/json" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01" \
    -d '{"installation_preference": "available"}'
  ```

  ```bash CLI
  ant beta:organization:plugins:installation-settings set \
    --plugin-id plugin_01Hq3vX8kZcN2mB7pR4tY9wL \
    --target rbac_group_01F3xQqQzXyWvUtSrQpOnMlK \
    --installation-preference available
  ```

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

  setting = client.beta.organization.plugins.installation_settings.set(
      "rbac_group_01F3xQqQzXyWvUtSrQpOnMlK",
      plugin_id="plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
      installation_preference="available",
  )

  print(f"plugin_id: {setting.plugin_id}")
  print(f"installation_preference: {setting.installation_preference}")
  ```

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

  const setting = await client.beta.organization.plugins.installationSettings.set(
    "rbac_group_01F3xQqQzXyWvUtSrQpOnMlK",
    {
      plugin_id: "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
      installation_preference: "available"
    }
  );

  console.log(`plugin_id: ${setting.plugin_id}`);
  console.log(`installation_preference: ${setting.installation_preference}`);
  ```

  ```csharp C#
  using Anthropic.Models.Beta.Organization.Plugins.InstallationSettings;

  AnthropicClient client = new();

  var setting = await client.Beta.Organization.Plugins.InstallationSettings.Set(
      "rbac_group_01F3xQqQzXyWvUtSrQpOnMlK",
      new()
      {
          PluginID = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
          InstallationPreference = InstallationPreference.Available,
      }
  );

  Console.WriteLine($"plugin_id: {setting.PluginID}");
  Console.WriteLine($"installation_preference: {setting.InstallationPreference.Raw()}");
  ```

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

  setting, err := client.Beta.Organization.Plugins.InstallationSettings.Set(
  	context.Background(),
  	"rbac_group_01F3xQqQzXyWvUtSrQpOnMlK",
  	anthropic.BetaOrganizationPluginInstallationSettingSetParams{
  		PluginID:               "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
  		InstallationPreference: anthropic.BetaOrganizationPluginInstallationSettingSetParamsInstallationPreferenceAvailable,
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("plugin_id: %s\n", setting.PluginID)
  fmt.Printf("installation_preference: %s\n", setting.InstallationPreference)
  ```

  ```java Java
  import com.anthropic.models.beta.organization.plugins.installationsettings.InstallationSettingSetParams;

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

      var params = InstallationSettingSetParams.builder()
          .pluginId("plugin_01Hq3vX8kZcN2mB7pR4tY9wL")
          .installationPreference(InstallationSettingSetParams.InstallationPreference.AVAILABLE)
          .build();
      var setting = client.beta().organization().plugins().installationSettings()
          .set("rbac_group_01F3xQqQzXyWvUtSrQpOnMlK", params);

      IO.println("plugin_id: " + setting.pluginId());
      IO.println("installation_preference: " + setting.installationPreference().asString());
  }
  ```

  ```php PHP
  use Anthropic\Beta\Organization\Plugins\InstallationSettings\InstallationSettingSetParams\InstallationPreference;
  // ...

  $client = new Client();

  $setting = $client->beta->organization->plugins->installationSettings->set(
      target: 'rbac_group_01F3xQqQzXyWvUtSrQpOnMlK',
      pluginID: 'plugin_01Hq3vX8kZcN2mB7pR4tY9wL',
      installationPreference: InstallationPreference::AVAILABLE,
  );

  echo "plugin_id: {$setting->pluginID}\n";
  echo "installation_preference: {$setting->installationPreference}\n";
  ```

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

  plugin_id = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  group_id = "rbac_group_01F3xQqQzXyWvUtSrQpOnMlK"
  setting = client.beta.organization.plugins.installation_settings.set(
    group_id,
    plugin_id: plugin_id,
    installation_preference: :available
  )

  puts "plugin_id: #{setting.plugin_id}"
  puts "installation_preference: #{setting.installation_preference}"
  ```
</CodeGroup>

```json
{
  "type": "plugin_installation_setting",
  "plugin_id": "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
  "target": { "type": "rbac_group", "rbac_group_id": "rbac_group_01F3xQqQzXyWvUtSrQpOnMlK" },
  "installation_preference": "available",
  "created_at": "2026-09-02T10:00:00Z",
  "updated_at": "2026-09-02T10:00:00Z"
}
```

### Installationseinstellung entfernen

`DELETE /v1/organizations/plugins/{plugin_id}/installation_settings/{target}` entfernt die Installationseinstellung eines Ziels für ein Plugin im Besitz der Organisation. Mit `{target}` gleich `organization` entfernt es die eigene organisationsweite Einstellung des Plugins. Das Plugin erbt dann wieder den Standard seines Marketplace (`organization_installation_preference_inherited` wird `true`) und folgt späteren Änderungen an diesem Standard; Gruppeneinstellungen sind davon nicht betroffen. Mit der `rbac_group_`-ID einer Gruppe entfernt es die Einstellung dieser Gruppe: Die Mitglieder der Gruppe fallen auf den organisationsweiten Wert oder auf die Einstellung einer anderen ihrer Gruppen zurück. Ein Ziel, das keine eigene Einstellung hat, gibt `404` zurück; das schließt das Ziel `organization` eines Plugins ein, das bereits den Standard seines Marketplace erbt. Die Änderung verändert nicht das `updated_at` des Plugins; sie wird im Activity Feed aufgezeichnet. Die Antwort enthält den zusammengesetzten Schlüssel anstelle einer `id`; für das Ziel `organization` ist ihr `target` `{"type": "organization"}`. Erfordert den Scope `write:plugins`.

<CodeGroup>
  ```bash cURL
  curl -X DELETE "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL/installation_settings/rbac_group_01F3xQqQzXyWvUtSrQpOnMlK" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01"
  ```

  ```bash CLI
  ant beta:organization:plugins:installation-settings remove \
    --plugin-id plugin_01Hq3vX8kZcN2mB7pR4tY9wL \
    --target rbac_group_01F3xQqQzXyWvUtSrQpOnMlK
  ```

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

  removed_setting = client.beta.organization.plugins.installation_settings.remove(
      "rbac_group_01F3xQqQzXyWvUtSrQpOnMlK",
      plugin_id="plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
  )

  print(f"plugin_id: {removed_setting.plugin_id}")
  ```

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

  const removedSetting = await client.beta.organization.plugins.installationSettings.remove(
    "rbac_group_01F3xQqQzXyWvUtSrQpOnMlK",
    { plugin_id: "plugin_01Hq3vX8kZcN2mB7pR4tY9wL" }
  );

  console.log(`plugin_id: ${removedSetting.plugin_id}`);
  ```

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

  var removedSetting = await client.Beta.Organization.Plugins.InstallationSettings.Remove(
      "rbac_group_01F3xQqQzXyWvUtSrQpOnMlK",
      new() { PluginID = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL" }
  );

  Console.WriteLine($"plugin_id: {removedSetting.PluginID}");
  ```

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

  removedSetting, err := client.Beta.Organization.Plugins.InstallationSettings.Remove(
  	context.Background(),
  	"rbac_group_01F3xQqQzXyWvUtSrQpOnMlK",
  	anthropic.BetaOrganizationPluginInstallationSettingRemoveParams{
  		PluginID: "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("plugin_id: %s\n", removedSetting.PluginID)
  ```

  ```java Java
  import com.anthropic.models.beta.organization.plugins.installationsettings.InstallationSettingRemoveParams;

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

      var params = InstallationSettingRemoveParams.builder()
          .pluginId("plugin_01Hq3vX8kZcN2mB7pR4tY9wL")
          .build();
      var removedSetting = client.beta().organization().plugins().installationSettings()
          .remove("rbac_group_01F3xQqQzXyWvUtSrQpOnMlK", params);

      IO.println("plugin_id: " + removedSetting.pluginId());
  }
  ```

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

  $removedSetting = $client->beta->organization->plugins->installationSettings->remove(
      target: 'rbac_group_01F3xQqQzXyWvUtSrQpOnMlK',
      pluginID: 'plugin_01Hq3vX8kZcN2mB7pR4tY9wL',
  );

  echo "plugin_id: {$removedSetting->pluginID}\n";
  ```

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

  plugin_id = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  group_id = "rbac_group_01F3xQqQzXyWvUtSrQpOnMlK"
  removed_setting = client.beta.organization.plugins.installation_settings.remove(
    group_id,
    plugin_id: plugin_id
  )

  puts "plugin_id: #{removed_setting.plugin_id}"
  ```
</CodeGroup>

```json
{
  "type": "plugin_installation_setting_deleted",
  "plugin_id": "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
  "target": { "type": "rbac_group", "rbac_group_id": "rbac_group_01F3xQqQzXyWvUtSrQpOnMlK" }
}
```

## Plugin-Freigaben

Freigaben gibt es nur bei Plugins im Besitz von Mitgliedern, und sie sind in dieser API schreibgeschützt (siehe [Freigaben](https://platform.claude.com/docs/de/manage-claude/plugins-api#shares)).

### Freigaben eines Plugins auflisten

`GET /v1/organizations/plugins/{plugin_id}/shares` listet auf, für wen der Eigentümer eines Plugins im Besitz eines Mitglieds es freigegeben hat, absteigend nach `granted_at` sortiert: alle Mitglieder (`organization`), eine Gruppe (`rbac_group`) oder ein namentlich genanntes Mitglied (`organization_member`). Filtere nach `target_type`. Ein Plugin, das sein Eigentümer nicht freigegeben hat, gibt eine leere Liste zurück; ein Plugin im Besitz der Organisation gibt `404` zurück. Freigaben sind in dieser API schreibgeschützt, und eine aufgelistete Freigabe gewährt nur Zugriff, solange diese Art der Freigabe für deine Organisation in claude.ai aktiviert ist (siehe [Freigaben](https://platform.claude.com/docs/de/manage-claude/plugins-api#shares)). `granted_at` ist der Zeitpunkt, zu dem die Freigabe erteilt wurde; ändert der Eigentümer die Freigabe später in claude.ai, ist es der Zeitpunkt dieser Änderung. Erfordert den Scope `read:plugins`.

<CodeGroup>
  ```bash cURL
  curl "https://api.anthropic.com/v1/organizations/plugins/plugin_01Mr2wP7sU3aJ8vX5cY6nS9t/shares" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01"
  ```

  ```bash CLI
  ant beta:organization:plugins:shares list \
    --plugin-id plugin_01Mr2wP7sU3aJ8vX5cY6nS9t
  ```

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

  shares = client.beta.organization.plugins.shares.list("plugin_01Mr2wP7sU3aJ8vX5cY6nS9t")

  # Ruft bei Bedarf automatisch weitere Seiten ab.
  for share in shares:
      print(f"plugin_id: {share.plugin_id}")
  ```

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

  const shares = await client.beta.organization.plugins.shares.list(
    "plugin_01Mr2wP7sU3aJ8vX5cY6nS9t"
  );

  for await (const share of shares) {
    console.log(`plugin_id: ${share.plugin_id}`);
  }
  ```

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

  var page = await client.Beta.Organization.Plugins.Shares.List("plugin_01Mr2wP7sU3aJ8vX5cY6nS9t");

  await foreach (var share in page.Paginate())
  {
      Console.WriteLine($"plugin_id: {share.PluginID}");
  }
  ```

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

  shares := client.Beta.Organization.Plugins.Shares.ListAutoPaging(
  	context.Background(),
  	"plugin_01Mr2wP7sU3aJ8vX5cY6nS9t",
  	anthropic.BetaOrganizationPluginShareListParams{},
  )

  for shares.Next() {
  	share := shares.Current()
  	fmt.Printf("plugin_id: %s\n", share.PluginID)
  }
  if err := shares.Err(); err != nil {
  	log.Fatal(err)
  }
  ```

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

  var shares = client.beta().organization().plugins().shares()
      .list("plugin_01Mr2wP7sU3aJ8vX5cY6nS9t");

  for (var share : shares.autoPager()) {
      IO.println("plugin_id: " + share.pluginId());
  }
  ```

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

  $shares = $client->beta->organization->plugins->shares->list(
      pluginID: 'plugin_01Mr2wP7sU3aJ8vX5cY6nS9t',
  );

  // Nur diese Seite; für die nächste rufe list() erneut mit page: $shares->nextPage auf.
  foreach ($shares->getItems() as $share) {
      echo "plugin_id: {$share->pluginID}\n";
  }
  ```

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

  plugin_id = "plugin_01Mr2wP7sU3aJ8vX5cY6nS9t"
  page = client.beta.organization.plugins.shares.list(plugin_id)

  page.auto_paging_each do |share|
    puts "plugin_id: #{share.plugin_id}"
  end
  ```
</CodeGroup>

```json
{
  "data": [
    {
      "type": "plugin_share",
      "plugin_id": "plugin_01Mr2wP7sU3aJ8vX5cY6nS9t",
      "target": { "type": "organization_member", "user_id": "user_01WCz9BvGLdMYRUMmcAxMWvW" },
      "granted_at": "2026-08-20T15:12:00Z"
    }
  ],
  "next_page": null
}
```

## Plugin-Marketplaces

Diese API liest [Marketplaces](https://platform.claude.com/docs/de/manage-claude/plugins-api#marketplaces) und legt die Standard-Installationseinstellung eines Organisations-Marketplace fest; die Marketplaces selbst werden in claude.ai erstellt, mit einem Repository verbunden und gelöscht.

```json
{
  "type": "plugin_marketplace",
  "id": "marketplace_01VbNcMxZaSdFgHjKlQwErTy",
  "name": "engineering-tools",
  "owner": { "type": "organization" },
  "source": "github",
  "sync_status": "success",
  "last_sync_ended_at": "2026-09-10T22:15:03Z",
  "last_sync_read_sha": "9fceb02d0ae598e95dc970b74767f19372d61af8",
  "default_installation_preference": "available",
  "created_at": "2026-06-12T08:45:00Z"
}
```

| Feld                              | Beschreibung                                                                                                                                                                                                                                                                            |
| --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `name`                            | Der Name des Marketplace. Bleibt während seiner gesamten Lebensdauer unverändert.                                                                                                                                                                                                       |
| `owner`                           | Gleiche Struktur wie beim Plugin.                                                                                                                                                                                                                                                       |
| `source`                          | `manual`, `github`, `gitlab` oder `public_git`. Siehe [Marketplaces](https://platform.claude.com/docs/de/manage-claude/plugins-api#marketplaces).                                                                                                                                       |
| `sync_status`                     | Ergebnis der letzten Synchronisierung: `success`, `in_progress`, `failed_content`, `failed_transient`, `failed_auth` oder `failed_limits`. `null`, bis zum ersten Mal eine Synchronisierung versucht wird, was bei einem Marketplace mit der Quelle `manual` nie geschieht.             |
| `last_sync_ended_at`              | Wann der letzte Synchronisierungsversuch abgeschlossen wurde, unabhängig von seinem Ergebnis; bei einem verbundenen Repository, das noch nicht synchronisiert wurde, der Zeitpunkt, zu dem der Marketplace erstellt wurde. `null` für einen Marketplace, der nicht synchronisiert wird. |
| `last_sync_read_sha`              | Der Commit, den die letzte Synchronisierung aus dem Repository gelesen hat. Nicht unbedingt der Commit, aus dem die bereitgestellten Versionen stammen. `null` für einen Marketplace, der nicht synchronisiert wird.                                                                    |
| `default_installation_preference` | Organisations-Marketplaces: der organisationsweite Wert für jedes darin enthaltene Plugin ohne eigene Einstellung (`not_available`, falls nie gesetzt). Persönliche Marketplaces: `null`.                                                                                               |

Eine `marketplace_id` ohne das Präfix `marketplace_` gibt `400` zurück. Eine, die das Präfix trägt, aber nicht aufgelöst werden kann oder zu einer anderen Organisation gehört, gibt `404` zurück.

### Marketplaces auflisten

`GET /v1/organizations/plugin_marketplaces` listet die Marketplaces deiner Organisation und die persönlichen Marketplaces der Mitglieder auf, absteigend nach `created_at` sortiert. Verwende diesen Endpunkt, um die ID eines Marketplace zu ermitteln, damit du die Plugin-Liste danach filtern oder in ihn hochladen kannst, noch bevor er ein Plugin enthält. Der Bibliotheks-Marketplace erscheint, sobald darin erstmals etwas erstellt wurde, in claude.ai oder über diese API. Filtere nach `owner_type` (`organization` oder `user`) und `source`. `limit` liegt zwischen 1 und 1.000. Erfordert den Scope `read:plugins`.

<CodeGroup>
  ```bash cURL
  curl "https://api.anthropic.com/v1/organizations/plugin_marketplaces?owner_type=organization" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01"
  ```

  ```bash CLI
  ant beta:organization:plugin-marketplaces list --owner-type organization
  ```

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

  marketplaces = client.beta.organization.plugin_marketplaces.list(
      owner_type="organization"
  )

  # Ruft bei Bedarf automatisch weitere Seiten ab.
  for marketplace in marketplaces:
      print(f"{marketplace.id}: {marketplace.name}")
  ```

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

  const marketplaces = await client.beta.organization.pluginMarketplaces.list({
    owner_type: "organization"
  });

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

  ```csharp C#
  using Anthropic.Models.Beta.Organization.PluginMarketplaces;

  AnthropicClient client = new();

  var page = await client.Beta.Organization.PluginMarketplaces.List(
      new() { OwnerType = OwnerType.Organization }
  );

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

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

  marketplaces := client.Beta.Organization.PluginMarketplaces.ListAutoPaging(
  	context.Background(),
  	anthropic.BetaOrganizationPluginMarketplaceListParams{
  		OwnerType: anthropic.BetaOrganizationPluginMarketplaceListParamsOwnerTypeOrganization,
  	},
  )

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

  ```java Java
  import com.anthropic.models.beta.organization.pluginmarketplaces.PluginMarketplaceListParams;

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

      var params = PluginMarketplaceListParams.builder()
          .ownerType(PluginMarketplaceListParams.OwnerType.ORGANIZATION)
          .build();
      var marketplaces = client.beta().organization().pluginMarketplaces().list(params);

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

  ```php PHP
  use Anthropic\Beta\Organization\PluginMarketplaces\PluginMarketplaceListParams\OwnerType;
  // ...

  $client = new Client();

  $marketplaces = $client->beta->organization->pluginMarketplaces->list(
      ownerType: OwnerType::ORGANIZATION,
  );

  // Nur diese Seite; für die nächste rufe list() erneut mit page: $marketplaces->nextPage auf.
  foreach ($marketplaces->getItems() as $marketplace) {
      echo "{$marketplace->id}: {$marketplace->name}\n";
  }
  ```

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

  page = client.beta.organization.plugin_marketplaces.list(owner_type: :organization)

  page.auto_paging_each do |marketplace|
    puts "#{marketplace.id}: #{marketplace.name}"
  end
  ```
</CodeGroup>

### Marketplace abrufen

`GET /v1/organizations/plugin_marketplaces/{marketplace_id}` gibt einen Marketplace zurück. Erfordert den Scope `read:plugins`.

<CodeGroup>
  ```bash cURL
  curl "https://api.anthropic.com/v1/organizations/plugin_marketplaces/marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01"
  ```

  ```bash CLI
  ant beta:organization:plugin-marketplaces retrieve \
    --marketplace-id marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r
  ```

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

  marketplace = client.beta.organization.plugin_marketplaces.retrieve(
      "marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r"
  )

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

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

  const marketplace = await client.beta.organization.pluginMarketplaces.retrieve(
    "marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r"
  );

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

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

  var marketplace = await client.Beta.Organization.PluginMarketplaces.Retrieve(
      "marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r"
  );

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

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

  marketplace, err := client.Beta.Organization.PluginMarketplaces.Get(
  	context.Background(),
  	"marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r",
  	anthropic.BetaOrganizationPluginMarketplaceGetParams{},
  )
  if err != nil {
  	log.Fatal(err)
  }

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

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

  var marketplace = client.beta().organization().pluginMarketplaces()
      .retrieve("marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r");

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

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

  $marketplace = $client->beta->organization->pluginMarketplaces->retrieve(
      marketplaceID: 'marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r',
  );

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

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

  marketplace_id = "marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r"
  marketplace = client.beta.organization.plugin_marketplaces.retrieve(marketplace_id)

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

### Standard-Installationseinstellung eines Marketplace festlegen

`POST /v1/organizations/plugin_marketplaces/{marketplace_id}` legt die Standard-Installationseinstellung eines Marketplace im Besitz der Organisation fest. Jedes Plugin im Marketplace ohne eigene organisationsweite Einstellung meldet diesen Standard als seine `organization_installation_preference`, einschließlich später hinzugefügter Plugins. Dies funktioniert für `manual`- und synchronisierte Marketplaces; der persönliche Marketplace eines Mitglieds gibt `403` zurück. Das einzige aktualisierbare Feld ist `default_installation_preference`, und es ist erforderlich. Es kann nicht wieder auf `null` gesetzt werden: Sobald ein Marketplace einen Standard hat, behält er einen, wie in claude.ai. Eine Änderung wird als ein einzelnes `marketplace_updated`-Ereignis ohne Ereignisse pro Plugin erfasst und verändert `updated_at` keines Plugins. Das Setzen des bereits gesetzten Werts ändert nichts, mit einer Ausnahme: Ein Marketplace, dessen Standard nie gesetzt wurde, meldet `not_available`, hat aber keine Einstellung, sodass sein erster Schreibvorgang (selbst `not_available`) als Änderung zählt. Gibt den Marketplace zurück. Erfordert den Scope `write:plugins`.

<CodeGroup>
  ```bash cURL
  curl -X POST "https://api.anthropic.com/v1/organizations/plugin_marketplaces/marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r" \
    -H "content-type: application/json" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01" \
    -d '{"default_installation_preference": "available"}'
  ```

  ```bash CLI
  ant beta:organization:plugin-marketplaces update \
    --marketplace-id marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r \
    --default-installation-preference available
  ```

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

  marketplace = client.beta.organization.plugin_marketplaces.update(
      "marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r",
      default_installation_preference="available",
  )

  print(f"id: {marketplace.id}")
  print(f"default_installation_preference: {marketplace.default_installation_preference}")
  ```

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

  const marketplace = await client.beta.organization.pluginMarketplaces.update(
    "marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r",
    { default_installation_preference: "available" }
  );

  console.log(`id: ${marketplace.id}`);
  console.log(`default_installation_preference: ${marketplace.default_installation_preference}`);
  ```

  ```csharp C#
  using Anthropic.Models.Beta.Organization.PluginMarketplaces;

  AnthropicClient client = new();

  var marketplace = await client.Beta.Organization.PluginMarketplaces.Update(
      "marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r",
      new() { DefaultInstallationPreference = DefaultInstallationPreference.Available }
  );

  Console.WriteLine($"id: {marketplace.ID}");
  Console.WriteLine(
      $"default_installation_preference: {marketplace.DefaultInstallationPreference?.Raw()}"
  );
  ```

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

  marketplace, err := client.Beta.Organization.PluginMarketplaces.Update(
  	context.Background(),
  	"marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r",
  	anthropic.BetaOrganizationPluginMarketplaceUpdateParams{
  		DefaultInstallationPreference: anthropic.BetaOrganizationPluginMarketplaceUpdateParamsDefaultInstallationPreferenceAvailable,
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("id: %s\n", marketplace.ID)
  fmt.Printf("default_installation_preference: %s\n", marketplace.DefaultInstallationPreference)
  ```

  ```java Java
  import com.anthropic.models.beta.organization.pluginmarketplaces.PluginMarketplaceUpdateParams;

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

      var params = PluginMarketplaceUpdateParams.builder()
          .defaultInstallationPreference(PluginMarketplaceUpdateParams.DefaultInstallationPreference.AVAILABLE)
          .build();
      var marketplace = client.beta().organization().pluginMarketplaces()
          .update("marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r", params);

      IO.println("id: " + marketplace.id());
      IO.println("default_installation_preference: "
          + marketplace.defaultInstallationPreference().map(preference -> preference.asString()).orElse(null));
  }
  ```

  ```php PHP
  use Anthropic\Beta\Organization\PluginMarketplaces\PluginMarketplaceUpdateParams\DefaultInstallationPreference;
  // ...

  $client = new Client();

  $marketplace = $client->beta->organization->pluginMarketplaces->update(
      marketplaceID: 'marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r',
      defaultInstallationPreference: DefaultInstallationPreference::AVAILABLE,
  );

  echo "id: {$marketplace->id}\n";
  echo "default_installation_preference: {$marketplace->defaultInstallationPreference}\n";
  ```

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

  marketplace_id = "marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r"
  marketplace = client.beta.organization.plugin_marketplaces.update(
    marketplace_id,
    default_installation_preference: :available
  )

  puts "id: #{marketplace.id}"
  puts "default_installation_preference: #{marketplace.default_installation_preference}"
  ```
</CodeGroup>

### Marketplace-Inhalte validieren

Zwei Endpunkte melden, was eine Synchronisierung der angegebenen Marketplace-Inhalte bewirken würde, ohne etwas zu verbinden oder zu speichern: `POST /v1/organizations/plugin_marketplaces/validate_repository` liest ein öffentliches GitHub-Repository, und `POST /v1/organizations/plugin_marketplaces/validate_archive` liest eine `.zip`-Datei des Marketplace-Verzeichnisses, die du hochlädst. Beide geben denselben Bericht zurück: ob `marketplace.json` wohlgeformt ist, welche Plugins übersprungen würden und warum, und welche Plugins synchronisiert würden, wobei einige Inhalte ausgelassen werden. Die Prüfungen sind dieselben, die eine echte Synchronisierung ausführt. Probleme mit dem Inhalt werden im Bericht zurückgegeben, nicht als HTTP-Fehler: Die Anfrage ist mit `valid: false` erfolgreich, selbst wenn das Repository oder Archiv überhaupt nicht gelesen werden kann. Eine Validierung zählt als Lesevorgang, und die beiden Endpunkte zusammen sind zusätzlich auf 10 Validierungen pro Minute für jede Organisation begrenzt (siehe [Ratenlimits](https://platform.claude.com/docs/de/manage-claude/plugins-api#rate-limiting)); sie zeichnen nichts im Activity Feed auf. Eine Validierung kann bis zu 120 Sekunden dauern, bevor sie zurückkehrt, setze daher das Timeout deines Clients auf einen höheren Wert. Beide Endpunkte erfordern den Scope `read:plugins` oder `write:plugins` (`read:org_audit` und `read:compliance_org_data` gewähren diese nicht).

Die Validierung liest das Repository anonym. Dasselbe gilt für jede Plugin-Quelle, die sich auf GitHub, aber außerhalb des Repositorys befindet. Infolgedessen meldet die Validierung ein privates Repository oder eine private Plugin-Quelle als nicht gefunden oder als eine GitHub-Anmeldung erfordernd. Wenn die Validierung meldet, dass eine GitHub-Anmeldung erforderlich ist, lautet der Berichtscode `marketplace_repo_sign_in_required`.

Die Validierung ruft keine Plugin-Quellen auf anderen Hosts als GitHub ab. Ein Plugin mit einer solchen Quelle erhält normalerweise eine Warnung `marketplace_validate_source_not_checked` und wird geprüft, wenn der Marketplace tatsächlich synchronisiert wird.

Die Validierung wendet strengere Regeln auf einen Marketplace an, den Anthropic in jede Organisation synchronisiert. `validate_repository` wendet sie an, wenn das Repository ein solcher Marketplace ist. `validate_archive` wendet sie an, wenn das Archiv einen solchen Marketplace benennt. Die strengeren Regeln lauten wie folgt:

* Jede Plugin-Quelle außerhalb des Marketplace muss auf einen vollständigen Commit-SHA festgelegt sein.
* Die Validierung meldet nicht festgelegte Quellen und Quellen auf nicht unterstützten Hosts als Plugin-Fehler.
* Bei `validate_repository` ist der Branch, den die Validierung liest, standardmäßig der Branch, von dem aus der Marketplace synchronisiert wird.

`validate_repository` akzeptiert einen JSON-Body mit zwei Feldern: `repository_url`, die `https://`-URL eines öffentlichen Repositorys auf github.com (erforderlich), und `ref`, ein Branch-Name oder ein vollständiger 40-stelliger Commit-SHA (optional). Wenn `ref` weggelassen wird oder `null` ist, wird standardmäßig der Branch verwendet, den eine Synchronisierung lesen würde, normalerweise der Standard-Branch des Repositorys. `validate_archive` akzeptiert `multipart/form-data` mit genau einem Teil, `archive`, gesendet als Dateiteil mit einem Dateinamen. Die Datei ist eine `.zip`-Datei des Marketplace-Verzeichnisses, höchstens 32 MB groß, die nur DEFLATE- oder STORE-Komprimierung verwendet. Der Inhalt des Archivs liegt im Stammverzeichnis oder ist in einen Ordner eingebettet (wie ihn der Download eines Git-Hosts erzeugt). Kein anderes Formularfeld wird akzeptiert.

Ein öffentliches Repository auf einem Branch validieren:

<CodeGroup>
  ```bash cURL
  curl -X POST "https://api.anthropic.com/v1/organizations/plugin_marketplaces/validate_repository" \
    -H "content-type: application/json" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01" \
    -d '{"repository_url": "https://github.com/example-org/claude-plugins", "ref": "release-candidate"}'
  ```

  ```bash CLI
  ant beta:organization:plugin-marketplaces validate-repository \
    --repository-url https://github.com/example-org/claude-plugins \
    --ref release-candidate
  ```

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

  report = client.beta.organization.plugin_marketplaces.validate_repository(
      repository_url="https://github.com/example-org/claude-plugins",
      ref="release-candidate",
  )

  print(f"valid: {str(report.valid).lower()}")
  print(f"total_plugin_count: {report.total_plugin_count}")
  ```

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

  const report = await client.beta.organization.pluginMarketplaces.validateRepository({
    repository_url: "https://github.com/example-org/claude-plugins",
    ref: "release-candidate"
  });

  console.log(`valid: ${report.valid}`);
  console.log(`total_plugin_count: ${report.total_plugin_count}`);
  ```

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

  var report = await client.Beta.Organization.PluginMarketplaces.ValidateRepository(
      new()
      {
          RepositoryUrl = "https://github.com/example-org/claude-plugins",
          Ref = "release-candidate",
      }
  );

  Console.WriteLine($"valid: {report.Valid.ToString().ToLowerInvariant()}");
  Console.WriteLine($"total_plugin_count: {report.TotalPluginCount}");
  ```

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

  report, err := client.Beta.Organization.PluginMarketplaces.ValidateRepository(
  	context.Background(),
  	anthropic.BetaOrganizationPluginMarketplaceValidateRepositoryParams{
  		RepositoryURL: "https://github.com/example-org/claude-plugins",
  		Ref:           anthropic.String("release-candidate"),
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("valid: %t\n", report.Valid)
  fmt.Printf("total_plugin_count: %d\n", report.TotalPluginCount)
  ```

  ```java Java
  import com.anthropic.models.beta.organization.pluginmarketplaces.PluginMarketplaceValidateRepositoryParams;

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

      var params = PluginMarketplaceValidateRepositoryParams.builder()
          .repositoryUrl("https://github.com/example-org/claude-plugins")
          .ref("release-candidate")
          .build();
      var report = client.beta().organization().pluginMarketplaces().validateRepository(params);

      IO.println("valid: " + report.valid());
      IO.println("total_plugin_count: " + report.totalPluginCount());
  }
  ```

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

  $report = $client->beta->organization->pluginMarketplaces->validateRepository(
      repositoryURL: 'https://github.com/example-org/claude-plugins',
      ref: 'release-candidate',
  );

  echo 'valid: ' . ($report->valid ? 'true' : 'false') . "\n";
  echo "total_plugin_count: {$report->totalPluginCount}\n";
  ```

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

  report = client.beta.organization.plugin_marketplaces.validate_repository(
    repository_url: "https://github.com/example-org/claude-plugins",
    ref: "release-candidate"
  )

  puts "valid: #{report.valid}"
  puts "total_plugin_count: #{report.total_plugin_count}"
  ```
</CodeGroup>

```json
{
  "type": "plugin_marketplace_validation_report",
  "valid": false,
  "ref": "release-candidate",
  "commit_sha": "9fceb02d0ae598e95dc970b74767f19372d61af8",
  "total_plugin_count": 3,
  "manifest_error": null,
  "manifest_error_code": null,
  "plugin_errors": [
    {
      "name": "deploy-helper",
      "error": "The plugin has a top-level bin/ directory.",
      "error_code": "marketplace_sync_bin_directory_not_allowed"
    }
  ],
  "plugin_warnings": [
    {
      "name": "release-notes",
      "warnings": [
        {
          "message": "plugin.json has unrecognized top-level keys: owners",
          "error_code": "marketplace_sync_plugin_unrecognized_keys"
        }
      ]
    }
  ]
}
```

| Feld                                    | Beschreibung                                                                                                                                                                                                                                                                                                          |
| --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `valid`                                 | `true`, wenn `marketplace.json` wohlgeformt ist und kein Plugin übersprungen würde. Warnungen machen es nicht zu `false`.                                                                                                                                                                                             |
| `ref`                                   | Der gelesene Branch, mit Namen; `null`, wenn kein Branch angegeben und der Standard-Branch gelesen wurde, bei einem Commit-SHA oder bei einem Archiv.                                                                                                                                                                 |
| `commit_sha`                            | Der validierte Commit. Bei einem von einem Git-Host heruntergeladenen Archiv der Commit, den der Host im Kommentarfeld der ZIP-Datei vermerkt hat, falls vorhanden (nicht verifiziert).                                                                                                                               |
| `total_plugin_count`                    | Wie viele Plugins `marketplace.json` deklariert; `0`, wenn sie nicht gelesen werden konnte.                                                                                                                                                                                                                           |
| `manifest_error`, `manifest_error_code` | Gesetzt, wenn nichts validiert werden konnte: Die Quelle konnte nicht gelesen werden, oder `marketplace.json` fehlt, ist fehlerhaft oder überschreitet ein Limit. Eine Validierung, die nicht innerhalb von 120 Sekunden abgeschlossen wurde, meldet `manifest_error_code: "marketplace_validate_deadline_exceeded"`. |
| `plugin_errors`                         | Ein `{name, error, error_code}` pro Plugin, das eine Synchronisierung überspringen würde.                                                                                                                                                                                                                             |
| `plugin_warnings`                       | Ein `{name, warnings: [{message, error_code}]}` pro Plugin, das synchronisiert würde, wobei einige Inhalte ausgelassen würden.                                                                                                                                                                                        |

Validiere stattdessen eine lokale Kopie des Marketplace-Verzeichnisses als `.zip`; die Antwort ist derselbe Bericht:

<CodeGroup>
  ```bash cURL
  curl -X POST "https://api.anthropic.com/v1/organizations/plugin_marketplaces/validate_archive" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2026-10-21" \
    -H "anthropic-beta: ce-plugins-2026-09-01" \
    -F "archive=@marketplace.zip"
  ```

  ```bash CLI
  ant beta:organization:plugin-marketplaces validate-archive \
    --archive marketplace.zip
  ```

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

  with open("marketplace.zip", "rb") as archive:
      report = client.beta.organization.plugin_marketplaces.validate_archive(
          archive=archive
      )

  print(f"valid: {str(report.valid).lower()}")
  print(f"total_plugin_count: {report.total_plugin_count}")
  ```

  ```typescript TypeScript
  import fs from "node:fs";

  const client = new Anthropic();

  const report = await client.beta.organization.pluginMarketplaces.validateArchive({
    archive: fs.createReadStream("marketplace.zip")
  });

  console.log(`valid: ${report.valid}`);
  console.log(`total_plugin_count: ${report.total_plugin_count}`);
  ```

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

  var report = await client.Beta.Organization.PluginMarketplaces.ValidateArchive(
      new() { Archive = File.OpenRead("marketplace.zip") }
  );

  Console.WriteLine($"valid: {report.Valid.ToString().ToLowerInvariant()}");
  Console.WriteLine($"total_plugin_count: {report.TotalPluginCount}");
  ```

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

  archive, err := os.Open("marketplace.zip")
  if err != nil {
  	log.Fatal(err)
  }
  defer archive.Close()

  report, err := client.Beta.Organization.PluginMarketplaces.ValidateArchive(
  	context.Background(),
  	anthropic.BetaOrganizationPluginMarketplaceValidateArchiveParams{
  		Archive: archive,
  	},
  )
  if err != nil {
  	log.Fatal(err)
  }

  fmt.Printf("valid: %t\n", report.Valid)
  fmt.Printf("total_plugin_count: %d\n", report.TotalPluginCount)
  ```

  ```java Java
  import com.anthropic.models.beta.organization.pluginmarketplaces.PluginMarketplaceValidateArchiveParams;

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

      // Übergib einen Path, damit der `archive`-Teil mit einem Dateinamen gesendet wird, den dieser Endpunkt erfordert.
      var params = PluginMarketplaceValidateArchiveParams.builder()
          .archive(Path.of("marketplace.zip"))
          .build();
      var report = client.beta().organization().pluginMarketplaces().validateArchive(params);

      IO.println("valid: " + report.valid());
      IO.println("total_plugin_count: " + report.totalPluginCount());
  }
  ```

  ```php PHP
  use Anthropic\Core\FileParam;

  $client = new Client();

  $report = $client->beta->organization->pluginMarketplaces->validateArchive(
      archive: FileParam::fromResource(fopen('marketplace.zip', 'r')),
  );

  echo 'valid: ' . ($report->valid ? 'true' : 'false') . "\n";
  echo "total_plugin_count: {$report->totalPluginCount}\n";
  ```

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

  report = client.beta.organization.plugin_marketplaces.validate_archive(
    archive: Pathname("marketplace.zip")
  )

  puts "valid: #{report.valid}"
  puts "total_plugin_count: #{report.total_plugin_count}"
  ```
</CodeGroup>

Probleme mit den Inhalten lassen die Anfrage nie fehlschlagen. Abgesehen von den Antworten, die alle Endpunkte gemeinsam haben (ein `403` für einen Key, der nur `read:org_audit` oder `read:compliance_org_data` hat; siehe [Fehlerantworten](https://platform.claude.com/docs/de/manage-claude/plugins-api#error-responses) und [Ratenlimits](https://platform.claude.com/docs/de/manage-claude/plugins-api#rate-limiting)), kann die Anfrage selbst fehlschlagen mit:

| Status | Ursache                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Vorgehen                                                                  |
| ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- |
| 400    | Bei `validate_repository`: Der Body ist kein JSON-Objekt; `repository_url` fehlt, ist länger als 2.048 Zeichen, enthält Zugangsdaten oder hat nicht die Form `https://github.com/{owner}/{repo}` (ein `.git`-Suffix wird akzeptiert; ein anderer Host, ein längerer Pfad wie `/tree/main` einer Branch-Seite oder ein anderer Port als 443 oder 80 nicht); `ref` ist leer, ist länger als 255 Zeichen, enthält `..` oder enthält ein anderes Zeichen als ASCII-Buchstaben, Ziffern, `.`, `_`, `-`, `+` und `/`; oder ein anderes Feld ist vorhanden. Ein `ref`, das diese Prüfungen besteht, aber einen Branch benennt, den das Repository nicht hat, wird nicht abgelehnt: Die Anfrage ist mit `valid: false` erfolgreich, und `manifest_error` gibt an, dass der Branch nicht gefunden wurde. Bei `validate_archive`: Der Body ist nicht `multipart/form-data`, der Teil `archive` fehlt, ist wiederholt oder wurde nicht als Dateiteil mit einem Dateinamen gesendet, oder ein anderes Formularfeld ist vorhanden. | Korrigiere die Anfrage und sende sie erneut.                              |
| 413    | Bei `validate_archive`: Der Teil `archive` oder die deklarierte Body-Länge der Anfrage überschreitet 32 MB.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | Validiere stattdessen das Repository per URL oder verkleinere das Archiv. |

#### Berichtscodes

Jeder Befund in einem Bericht hat einen stabilen Code: `manifest_error_code`, wenn nichts validiert werden konnte, `error_code` bei jedem `plugin_errors`-Eintrag und `error_code` bei jeder Warnung. Wenn ein Plugin mehrere Probleme hat, ist `error_code` der Code des ersten, und `error` fügt ihre Meldungen zusammen. Neue Codes können hinzugefügt werden; ein unbekannter `manifest_error_code` bedeutet weiterhin, dass der Inhalt nicht validiert werden konnte, einer bei einem `plugin_errors`-Eintrag bedeutet weiterhin, dass das Plugin übersprungen würde, und einer bei einer Warnung bedeutet weiterhin, dass das Plugin synchronisiert würde. Diese Codes zeigen vorübergehende Zustände an, sodass dieselbe Anfrage später erfolgreich sein könnte: `marketplace_host_rate_limited`, `marketplace_host_server_error`, `marketplace_host_timeout`, `marketplace_host_unreachable`, `marketplace_repo_access_denied`, `marketplace_sync_transient_fetch_budget_exhausted`, `marketplace_validate_network_error` und normalerweise `marketplace_validate_deadline_exceeded`.

## Unbekannte Werte

Jeder String-Wert auf dieser Seite (Komponententypen, `reach`, Scan-Felder, Marketplace-`source`, Fehlercodes) kann jederzeit neue Werte erhalten. Behandle einen Wert, den du nicht kennst, wie jeden anderen unbekannten String, statt einen Fehler auszulösen.

## Ratenlimits

Leseanfragen (jeder `GET`-Endpunkt auf dieser Seite) teilen sich ein Limit von **300 Anfragen pro Minute** für jede Organisation. Schreibanfragen (Erstellen eines Plugins oder einer Version, Ändern der bereitgestellten Version, Löschen, Setzen oder Entfernen einer Installationseinstellung und Aktualisieren eines Marketplace) teilen sich ein Limit von **60 Anfragen pro Minute** für jede Organisation. Eine Marketplace-Validierung (beide Endpunkte) zählt als Lesevorgang, und Validierungen sind zusätzlich auf 10 pro Minute für jede Organisation über beide Endpunkte hinweg begrenzt; beide Limits werden geprüft, bevor der Request-Body gelesen wird. Diese Limits werden über alle Keys deiner Organisation hinweg gezählt und sind von den anderen Admin API-Limits deiner Organisation getrennt. Ein Lesevorgang, der `organization_id` übergibt, wird auf das Limit der Organisation angerechnet, in der der Key erstellt wurde, oder auf das der übergeordneten Organisation, wenn der Key keine eigene Organisation hat. Anfragen über einem Limit geben **429 Too Many Requests** mit einem `retry-after`-Header zurück. Antworten enthalten `anthropic-ratelimit-requests-*`-Header für das jeweils geltende Limit (bei der Marketplace-Validierung ihr Limit von 10 pro Minute; bei einem `429` das Limit, das die Anfrage abgelehnt hat).

Ein Upload, eine Änderung der bereitgestellten Version oder eine Validierung kann außerdem `429` mit `retry-after` zurückgeben, wenn der Dienst kurzzeitig keine Kapazität für einen weiteren Vorgang hat, und ein Upload gibt `429` zurück, wenn deine Organisation ihre Rate für die Inhaltsprüfung überschritten hat. Behandle all diese Fälle gleich: Warte die in `retry-after` angegebene Zeit ab und versuche es dann erneut. Unabhängig von diesen Limits solltest du Schreibvorgänge für Installationseinstellungen desselben Plugins einzeln nacheinander senden: Treffen mehrere gleichzeitig ein, können einige mit `503` und `x-should-retry: true` beantwortet werden, und diese können nach ein bis zwei Sekunden gefahrlos erneut gesendet werden (siehe [Installationseinstellung festlegen](https://platform.claude.com/docs/de/manage-claude/plugins-api#set-an-installation-setting)).

## Paginierung

Listen-Endpunkte verwenden einen **opaken Cursor**. Die erste Anfrage gibt bis zu `limit` Zeilen sowie einen `next_page`-Cursor zurück; übergib den Cursor unverändert als `page`-Parameter bei der nächsten Anfrage und wiederhole dies, bis `next_page` `null` ist. Behandle den Cursor-String als opak: Parse, verändere oder konstruiere ihn nicht selbst. [Plugins auflisten](https://platform.claude.com/docs/de/manage-claude/plugins-api#list-plugins) kann eine Seite mit weniger als `limit` Plugins oder gar keinen zurückgeben, während `next_page` noch gesetzt ist. Fordere daher weiter Seiten an, bis `next_page` `null` ist. Die Listen-Iteratoren der Python-, TypeScript-, C#-, Go-, Java- und Ruby-SDKs sowie die CLI (außer mit `--format raw`) erledigen das für dich. Sie fordern die nächste Seite an, solange `next_page` gesetzt ist, sodass eine kurze oder leere Seite sie nicht beendet. In PHP und curl forderst du jede Seite selbst an und übergibst ihr `next_page` als `page`.

`limit` ist standardmäßig 20 und hat ein Minimum von 1. Das Maximum beträgt 100 für Plugins, Installationseinstellungen und Freigaben sowie 1.000 für Versionen und Marketplaces. Jede Liste ist mit den neuesten Einträgen zuerst sortiert.

## Fehlerantworten

Fehlerantworten folgen der Standardform, die in [Claude API-Fehler](https://platform.claude.com/docs/de/api/errors) dokumentiert ist. Gib die `request_id` aus dem Antwort-Body an, wenn du den Support kontaktierst.

| Status | Bedeutung                                                                                                                                                                                                                                                                                                                                                            |
| ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 400    | Ungültige Eingabe, oder der Vorgang gilt nicht für dieses Plugin oder diesen Marketplace (siehe den Abschnitt des jeweiligen Endpunkts). Wird auch für einen Query-Parameter zurückgegeben, den der Endpunkt nicht erkennt, sowie für eine Organisation, die keine Claude Enterprise-Organisation ist (`this endpoint is not supported for this organization type`). |
| 401    | Der Header `x-api-key` fehlt, oder der Key wird nicht erkannt.                                                                                                                                                                                                                                                                                                       |
| 403    | Dem Key fehlt der erforderliche Scope, oder die Anfrage lädt in das Plugin oder den persönlichen Marketplace eines Mitglieds hoch, ändert dessen bereitgestellte Version oder legt dessen Standard fest. (Das Löschen des Plugins eines Mitglieds ist erlaubt.)                                                                                                      |
| 404    | Ressource nicht gefunden. Wird auch zurückgegeben, wenn in der Anfrage der `anthropic-beta`-Wert fehlt oder die API für deine Organisation nicht aktiviert ist, sodass die Endpunkte als nicht existent erscheinen.                                                                                                                                                  |
| 409    | Ein Name ist vergeben, der `content_scan` einer Version lautet `processing`, oder ein konkurrierender Upload ist im Gange.                                                                                                                                                                                                                                           |
| 413    | Der Anfragetext überschreitet die Größenbeschränkung: 200 MB für einen Upload, 32 MB für die Marketplace-Validierung.                                                                                                                                                                                                                                                |
| 429    | „Rate limit“ (Ratenlimit) überschritten. Siehe [Ratenlimits](https://platform.claude.com/docs/de/manage-claude/plugins-api#rate-limiting).                                                                                                                                                                                                                           |
| 500    | Interner Fehler.                                                                                                                                                                                                                                                                                                                                                     |
| 503    | Vorübergehend. Wird auch zurückgegeben, wenn mehrere Schreibvorgänge für Installationseinstellungen eines Plugins gleichzeitig eintreffen; sende diese nacheinander. Wiederhole die Anfrage mit „backoff“ (schrittweise verlängerter Wartezeit), außer bei `registration_pending` (siehe die folgende Tabelle).                                                      |

Wenn ein Status mehrere Ursachen hat, die du unterschiedlich behandeln würdest, enthält der Fehler zusätzlich `error.details.error_code` sowie `error.details.plugin_id` oder `error.details.plugin_version_id`, wenn die Ursache eines davon betrifft:

```json
{
  "type": "error",
  "error": {
    "type": "invalid_request_error",
    "message": "...",
    "details": {
      "error_code": "plugin_name_taken",
      "plugin_id": "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
    }
  },
  "request_id": "req_018EeWyXxfu5pfWkrYcMdjWG"
}
```

| `error_code`                                    | Status | Bedeutung und Vorgehen                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| ----------------------------------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `plugin_name_taken`                             | 409    | Der Marketplace enthält diesen Namen bereits. `details.plugin_id` ist das Plugin, das ihn belegt, und möglicherweise hat es jemand anderes erstellt. Um herauszufinden, wer, [rufe das Plugin ab](https://platform.claude.com/docs/de/manage-claude/plugins-api#get-a-plugin) und lies sein `created_by`, das `null` ist, wenn kein Ersteller erfasst ist. Lade nur dann Versionen dorthin hoch, wenn es das Plugin ist, das du aktualisieren wolltest. Andernfalls oder wenn `plugin_id` fehlt, lade unter einem anderen Namen hoch. |
| `skill_name_taken`                              | 409    | Das Plugin befindet sich im Bibliotheks-Marketplace, und einer seiner Skills hat denselben Namen wie ein Organisations-Skill (ein Skill, den ein Administrator in claude.ai für die gesamte Organisation hochgeladen hat). `details.skill_name` nennt ihn. Benenne einen der beiden um oder entferne ihn.                                                                                                                                                                                                                             |
| `registration_pending`                          | 503    | Die Dateien wurden gespeichert, aber die Skills des Plugins konnten den Mitgliedern noch nicht zur Verfügung gestellt werden. Siehe [Uploads wiederholen](https://platform.claude.com/docs/de/manage-claude/plugins-api#retrying-uploads).                                                                                                                                                                                                                                                                                            |
| `scan_pending`                                  | 409    | Der `content_scan` der Version lautet `processing`. Versuche es erneut, sobald der Scan abgeschlossen ist.                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `scan_failed`                                   | 400    | Der `content_scan` der Version lautet `fail`, `unknown` oder `errored`, daher kann sie nicht bereitgestellt werden. Wähle eine andere Version.                                                                                                                                                                                                                                                                                                                                                                                        |
| `cmek_key_disabled`, `cmek_key_network_blocked` | 400    | Der kundenverwaltete Verschlüsselungsschlüssel deiner Organisation ist nicht verfügbar. Siehe [Kundenverwaltete Verschlüsselungsschlüssel](https://platform.claude.com/docs/de/manage-claude/plugins-api#customer-managed-encryption-keys).                                                                                                                                                                                                                                                                                           |
| `unsupported_charset`                           | 400    | Bei einem Upload oder `validate_archive` benennt der `Content-Type`-Header der Anfrage einen anderen Zeichensatz als UTF-8, ISO-8859-1 oder US-ASCII. Sende die Anfrage ohne Zeichensatz oder mit einem dieser Zeichensätze.                                                                                                                                                                                                                                                                                                          |

Es können neue Codes hinzukommen. Behandle einen Code, den du nicht kennst, so wie seinen Status.

### Uploads wiederholen

Kein Endpunkt akzeptiert einen `Idempotency-Key`. Das Ändern der bereitgestellten Version, das Setzen einer Installationseinstellung und das Setzen eines Marketplace-Standards können gefahrlos wiederholt werden. Ein wiederholtes Löschen oder ein wiederholtes Entfernen einer Installationseinstellung gibt `404` zurück.

Ein Upload, der einen Fehler zurückgibt, hat nichts gespeichert, mit einer Ausnahme: `503` mit `error_code: "registration_pending"`. Nach dem Speichern der Dateien eines Uploads registriert der Server die Skills der neuen Version bei claude.ai, wodurch sie für Mitglieder nutzbar werden; `registration_pending` bedeutet, dass die Dateien gespeichert wurden, dieser letzte Schritt aber nicht abgeschlossen wurde. Ein erneuter Upload derselben Dateien schließt ihn ab (und speichert eine weitere, identische Version):

* Bei `POST /v1/organizations/plugins` *wurde* das Plugin erstellt, und die Antwort enthält `x-should-retry: false`: Sende die Erstellung nicht erneut (ein erneutes Senden gibt `409 plugin_name_taken` zurück); lade stattdessen dieselben Dateien als Version von `details.plugin_id` hoch.
* Bei `POST /v1/organizations/plugins/{plugin_id}/versions` *wurde* die Version gespeichert (`details.plugin_version_id`); sende dieselbe Anfrage erneut, wenn die Antwort `x-should-retry: true` enthält, und nicht, wenn sie `false` enthält.

Wenn die Antwort einer Erstellung verloren geht, sende die Erstellung erneut. Ein `409 plugin_name_taken` bedeutet entweder, dass der erste Versuch das Plugin gespeichert hat, oder dass der Name bereits vergeben war. Deine verloren gegangene Erstellung hat das Plugin in `details.plugin_id` nur dann angelegt, wenn dessen `created_by` ein `api_actor` mit der `api_key_id` deines Keys ist. Prüfe das, bevor du dorthin hochlädst (siehe `plugin_name_taken` in der vorherigen Tabelle). Das Wiederholen einer Versionserstellung, deren Antwort verloren gegangen ist, speichert eine zweite, identische Version. Um das zu vermeiden, notiere vor jedem Upload die `latest_version_id` des Plugins; wenn eine Antwort verloren geht, lies das Plugin aus und wiederhole die Anfrage nur, wenn `latest_version_id` unverändert ist.

## Activity Feed-Ereignisse

Jeder Schreibvorgang über diese API wird im [Compliance API Activity Feed](https://platform.claude.com/docs/de/manage-claude/compliance-activity-feed) deiner Organisation erfasst und dem API-Key als `api_actor` mit dessen `apikey_`-ID zugeordnet. Derselbe Akteur erscheint in `created_by` bei den Plugins und Versionen, die der Key erstellt.

| Ereignis                                 | Ausgelöst, wenn                                                                                                                                                                                                                |
| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `claude_plugin_created`                  | Ein Plugin durch einen Upload (hier oder in claude.ai) oder durch eine angenommene Veröffentlichungsanfrage erstellt wird. Ein durch eine Git-Synchronisierung erstelltes Plugin löst nur `claude_plugin_version_created` aus. |
| `claude_plugin_version_created`          | Eine Version gespeichert wird. Durch eine Git-Synchronisierung gespeicherte Versionen werden einem `system_actor` zugeordnet.                                                                                                  |
| `claude_plugin_updated`                  | Eine neue Version in ein bestehendes Plugin hochgeladen wird.                                                                                                                                                                  |
| `claude_plugin_served_version_updated`   | Sich die bereitgestellte Version ändert.                                                                                                                                                                                       |
| `claude_plugin_deleted`                  | Ein Plugin einzeln gelöscht wird, hier oder in claude.ai.                                                                                                                                                                      |
| `plugin_installation_preference_updated` | Eine Installationseinstellung festgelegt oder entfernt wird.                                                                                                                                                                   |
| `marketplace_created`                    | Der erste Upload den Bibliotheks-Marketplace erstellt.                                                                                                                                                                         |
| `marketplace_updated`                    | Sich die Standard-Installationseinstellung eines Marketplace ändert oder ein Administrator oder Inhaber in claude.ai eine Synchronisierung startet.                                                                            |
| `marketplace_deleted`                    | Ein Marketplace zusammen mit seinen Plugins in claude.ai gelöscht wird (keine Ereignisse pro Plugin).                                                                                                                          |
| `claude_plugin_archive_accessed`         | Das Archiv eines Plugins, das einem Mitglied gehört, heruntergeladen wird.                                                                                                                                                     |
| `claude_plugin_security_scan_completed`  | Ein Content-Scan abgeschlossen wird.                                                                                                                                                                                           |

Die Plugin-, Versions- und Marketplace-IDs in diesen Ereignissen sind dieselben IDs, die diese API zurückgibt. Ein Ereignis kann auch einen Marketplace nennen, den diese API nicht auflistet, etwa einen Marketplace mit Plugins, die Anthropic veröffentlicht. `plugin_installation_preference_updated` identifiziert das Plugin anhand seines `name` und seiner `marketplace_id` statt seiner `id`. In `claude_plugin_security_scan_completed` ist `plugin_version` keine Versions-ID, und kein Feld einer [Plugin-Version](https://platform.claude.com/docs/de/manage-claude/plugins-api#plugin-versions) entspricht ihr.

Das Ändern des Standards eines Marketplace erfasst ein einzelnes `marketplace_updated`-Ereignis und keine Ereignisse pro Plugin, obwohl es den Wert jedes Plugins ändert, das den Standard erbt. Lesevorgänge werden nicht erfasst, mit Ausnahme von Downloads des Archivs eines Plugins, das einem Mitglied gehört. Ein Schreibvorgang, der nichts ändert, erfasst nichts.

In claude.ai erteilte oder entzogene Freigaben erscheinen im Feed als `role_assignment_granted`- und `role_assignment_revoked`-Ereignisse. Diese API meldet keine Löschungen: Ein gelöschtes Plugin fehlt in der nächsten Liste. Ein Plugin, das durch eine Git-Synchronisierung, durch das Löschen seines Marketplace (ein einzelnes `marketplace_deleted`-Ereignis) oder durch das Löschen des Kontos eines Mitglieds oder der Organisation entfernt wird, löst kein Ereignis pro Plugin aus. Rufe daher regelmäßig den vollständigen Bestand erneut ab, um Entfernungen zu erkennen.

## Kundenverwaltete Verschlüsselungsschlüssel

Wenn deine Organisation einen [„customer-managed encryption key“ (kundenverwalteten Verschlüsselungsschlüssel)](https://platform.claude.com/docs/de/manage-claude/cmek) verwendet, werden `description`, `release_notes`, `components` und die Dateien einer Version damit verschlüsselt. Solange der Schlüssel nicht verfügbar ist:

* Lese- und Listenvorgänge sind weiterhin erfolgreich, wobei `description`, `release_notes` und `components` als `null` zurückgegeben werden.
* Archiv-Downloads, Erstellungen, Versionserstellungen und Änderungen der bereitgestellten Version geben `400` mit `cmek_key_disabled` oder `cmek_key_network_blocked` zurück.
* Das Löschen eines Plugins im Bibliotheks-Marketplace gibt `400 cmek_key_disabled` zurück und löscht nichts, da seine Skills zuerst aus claude.ai zurückgezogen werden müssen und dafür der Schlüssel benötigt wird. Andere Löschvorgänge, Installationseinstellungen und Marketplace-Standards funktionieren normal.

Die Wiederherstellung des Schlüssels hebt all diese Einschränkungen auf.

## Siehe auch

<CardGroup cols={2}>
  <Card title="Einen Admin-API-Key erstellen" href="https://platform.claude.com/docs/de/manage-claude/admin-api-keys">
    Wo dein primärer Inhaber einen Key mit eingeschränktem Scope erstellt.
  </Card>

  <Card title="Benutzerverwaltung" href="https://platform.claude.com/docs/de/manage-claude/user-management">
    Die Gruppen-Endpunkte, die die in Installationseinstellungen verwendeten `rbac_group_`-IDs liefern.
  </Card>

  <Card title="Compliance API Activity Feed" href="https://platform.claude.com/docs/de/manage-claude/compliance-activity-feed">
    Wo Plugin-Schreibvorgänge und Downloads von Mitglieder-Archiven erfasst werden.
  </Card>

  <Card title="Analytics-APIs" href="https://platform.claude.com/docs/de/manage-claude/analytics-api">
    Berichte zur Plugin- und Skill-Nutzung für Claude Enterprise.
  </Card>
</CardGroup>
