---
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 jedes Plugin in deiner Claude Enterprise-Organisation erfassen, Plugins und neue Versionen aus deinen eigenen Pipelines veröffentlichen, festlegen, welche Version Mitgliedern bereitgestellt wird, bestimmen, wer welches Plugin nutzen kann, Plugin-Dateien zur Prüfung herunterladen und 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).
**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 Primary Owner 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.
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 (die SDKs und die `ant` CLI senden ihn für dich). Eine Anfrage ohne diesen Header gibt `404` zurück, genau so, als ob der Endpunkt nicht existieren würde.
## Endpunkte
Die API stellt 18 Endpunkte für fünf Ressourcen bereit:
| Ressource | Endpunkte |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Plugins**: alle 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`
`POST /v1/organizations/plugins`
`GET /v1/organizations/plugins/{plugin_id}`
`POST /v1/organizations/plugins/{plugin_id}`
`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`
`POST /v1/organizations/plugins/{plugin_id}/versions`
`GET /v1/organizations/plugins/{plugin_id}/versions/{version}`
`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`
`POST /v1/organizations/plugins/{plugin_id}/installation_settings/{target}`
`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`
`GET /v1/organizations/plugin_marketplaces/{marketplace_id}`
`POST /v1/organizations/plugin_marketplaces/{marketplace_id}`
`POST /v1/organizations/plugin_marketplaces/validate_repository`
`POST /v1/organizations/plugin_marketplaces/validate_archive` |
Dieses Release umfasst keine eigenständigen Skills (Skills, die ein Mitglied im Skills-Editor schreibt oder als einzelnen Skill in claude.ai hochlädt). Sie erscheinen nicht im Bestand und können hier nicht erstellt werden. Plugins, die Anthropic veröffentlicht, werden ebenfalls 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 Primary Owner erstellt unter [claude.ai > Organisationseinstellungen > API](https://claude.ai/admin-settings/api-access) einen Admin-API-Key mit dem Scope `read:plugins`, dem Scope `write:plugins` oder beiden. Siehe [Admin-API-Key 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: 2023-06-01` und `anthropic-beta: ce-plugins-2026-09-01`.
Die SDKs für Python, TypeScript, C#, Go, Java, PHP und Ruby stellen 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 verwenden den Standard-Client jedes SDK, der, wie die CLI, den Admin-API-Key aus der Umgebungsvariable `ANTHROPIC_API_KEY` liest; die curl-Beispiele lesen den Key aus derselben Variable und übergeben ihn im Header `x-api-key`. Wenn 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:
```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: 2023-06-01" \
-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
```
```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
Keys mit `read:plugins` und `write:plugins` lesen und schreiben nur in der Organisation, in der sie erstellt wurden. Wenn dein Unternehmen mehrere Claude-Organisationen hat, die unter einer übergeordneten Organisation verknüpft sind, kann ein Key mit `read:org_audit` oder `read:compliance_org_data`, den der Primary Owner der übergeordneten Organisation für alle verknüpften Organisationen erstellt hat (siehe [Admin-API-Key erstellen](https://platform.claude.com/docs/de/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization)), auch jede von ihnen lesen, die Zugriff auf diese API hat: Übergib die ID dieser Organisation 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 `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. |
| Command | 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 „served version" (bereitgestellte Version), also 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 erst bereitgestellt, nachdem ihr Scan mit `pass` oder `warn` abgeschlossen ist. Während eine Version wartet, verweist `served_version_id` auf eine frühere Version als `latest_version_id`. Frage nicht wiederholt ab, bis die beiden IDs übereinstimmen: Sie können 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 anschließend promoten. Damit deine Pipeline entscheidet, wann jeder Build bereitgestellt wird, pinne das Plugin einmalig, indem du `served_version_id` auf seine aktuelle Version setzt; promote ab dann jeden Build, der bereitgestellt werden soll. Bei aktiviertem Content-Scanning gibt dieses erste Pinnen `409 scan_pending` zurück, bis der Scan der aktuellen Version abgeschlossen ist, und `400 scan_failed`, wenn der Scan mit `fail` oder `unknown` abgeschlossen wurde oder fehlgeschlagen ist (`warn` wird akzeptiert). Ein gepinntes Plugin kann derzeit nicht wieder 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
„Installation settings" (**Installationseinstellungen**) legen fest, wer ein Plugin der Organisation nutzen 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`) übertragen 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 pro Gruppe haben (die Gruppen der rollenbasierten Zugriffskontrolle, die in der [Benutzerverwaltung](https://platform.claude.com/docs/de/manage-claude/user-management#groups) verwaltet werden). 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
„Shares" (**Freigaben**) legen fest, wer ein Plugin eines Mitglieds nutzen kann. Der Eigentümer 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 Scanning aktiviert ist, wird Mitgliedern ein Plugin nur bereitgestellt, wenn der Scan seiner bereitgestellten Version `completed` mit `pass` oder `warn` ist. Während der Scan läuft oder nachdem er fehlschlägt, einen Fehler hat oder zu keinem Ergebnis kommt, wird das Plugin Mitgliedern vorenthalten, und es wird keine frühere Version an seiner Stelle 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 Scan bestanden ist, und bleiben ohne es, wenn der Scan fehlschlägt. 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 Ergebnis kommt asynchron. Lies die Version, um es zu sehen; das Plugin-Objekt zeigt nur den Scan seiner bereitgestellten Version. Das Ändern der bereitgestellten Version auf eine Version, deren Scan noch läuft, gibt `409 scan_pending` zurück; auf eine, deren Scan fehlgeschlagen ist, `400 scan_failed`.
### 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) oder Einstellungen, die das Plugin auf die App des Mitglieds anwendet, oder enthält einen Skill, einen Command 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 und keine App-Einstellungen, und keine ihrer Markdown-Dateien genehmigt Tools vorab (zum Beispiel ein Plugin, das nur Skills, Commands und Agents enthält, keiner davon mit `allowed-tools`). |
`reach` berücksichtigt alles, was die Version deklariert, einschließlich Monitoren, LSP-Servern 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.
### 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.
* `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 `` enthalten darf. Zwei Skills oder zwei Commands 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 entpackte Archiv dürfen jeweils höchstens 200 MB groß sein; 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 mit 472 Zeichen und Datei- oder Ordnernamen mit 255 Zeichen.
* ZIP-Archive müssen DEFLATE- oder STORE-Komprimierung verwenden und dürfen weder verschlüsselt sein noch symbolische Links enthalten.
* Ein Marketplace enthält höchstens 500 Elemente, wobei seine Plugins und alle eigenständigen Skills, die Mitglieder darin aufbewahren, mitgezählt werden. Dieses Limit und das Limit von 5.000 Dateien sind aktuelle Werte, die erhöht werden können.
## Beispiel-Workflows
### Jeden Build aus einer Release-Pipeline veröffentlichen
Lade jeden getaggten Build aus der CI hoch und lass die Pipeline entscheiden, 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": ""}`. 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`, der einen für alle verknüpften Organisationen erstellten Key erfordert (siehe [Benutzerverwaltung](https://platform.claude.com/docs/de/manage-claude/user-management#groups)). Die nächsten Schritte benötigen `write:plugins`, der nur in der Organisation wirkt, in der sein Key erstellt wurde. Erstelle daher in einem Unternehmen mit mehreren verknüpften Organisationen diesen 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.
```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: 2023-06-01" \
-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}"
```
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 ihren Content-Scan nicht bestehen.
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 Durchlauf `reach` und `content_scan` jedes Plugins aus dieser Liste: Ein später eintreffendes Scan-Ergebnis verändert `updated_at` nicht. `updated_at` zeigt dir normalerweise, welche Plugins seit dem letzten Durchlauf neue Inhalte oder eine neue bereitgestellte Version haben (was einen erneuten Archiv-Download rechtfertigt). 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 Durchlauf. Die vollständige erneute Auflistung erkennt 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` `fail` oder `unknown` ist. 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 [Die 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` | `displayName`, `description` und `version` aus dem Manifest der bereitgestellten Version; jeweils `null`, wenn das Manifest keinen Wert deklariert. `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. Der Wert ist außerdem `null` für einen Wert, der nicht wie eine Versionsnummer aussieht, etwa `"latest"`, und für eine 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 vorkommen. `null`, wenn kein Ersteller erfasst ist, etwa bei aus Git synchronisierten Plugins. |
| `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, wenn sie gespeichert wird. Es ändert sich nicht bei Installationseinstellungen, Freigaben oder neuen Scan-Ergebnissen. |
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). Mitgliedern wird keine Version bereitgestellt, deren Scan `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), `fail` (etwas gefunden, das die Nutzung blockiert) oder `unknown` (kein Ergebnis). 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. |
| `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` | Ahmt Claudes Systemanweisungen nach 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. |
Eine `plugin_id` ohne das Präfix `plugin_` gibt `400` zurück. Eine `plugin_id`, die das Präfix trägt, aber nicht aufgelöst werden kann, zu einer anderen Organisation gehört oder auf einen eigenständigen Skill verweist, gibt `404` zurück.
### Plugins auflisten
`GET /v1/organizations/plugins` listet jedes Plugin 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` (mit dem Präfix `user_`; die Plugins eines Mitglieds, 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 UND 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`.
```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: 2023-06-01" \
-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
```
### Plugin erstellen
`POST /v1/organizations/plugins` erstellt in einem Aufruf ein organisationseigenes Plugin und seine erste Version; diese Version wird zur ausgelieferten 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 organisationseigener `manual`-Marketplace; standardmäßig dein Bibliotheks-Marketplace, der bei der ersten Verwendung erstellt wird) und `release_notes` (bis zu 5.000 Zeichen, im Versionsverlauf von claude.ai angezeigt und mit der Version zurückgegeben). `name`, `display_name`, `description` und `manifest_version` des Plugins stammen aus dem hochgeladenen Manifest, und der Upload muss die [Upload-Anforderungen](https://platform.claude.com/docs/de/manage-claude/plugins-api#upload-requirements) erfüllen. Wenn die Inhaltsprüfung aktiviert ist, ist `content_scan.status` in der Antwort `processing`, und das Ergebnis trifft asynchron ein. Gibt das Plugin zurück. Erfordert den Scope `write:plugins`.
Ein Archiv hochladen:
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/plugins" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-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 von Hand, damit das Archiv mit seinem Dateinamen gesendet wird,
// den der Upload erfordert.
var archive = MultipartField.>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}"
```
```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 bestimmten 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); wird eine Datei nur unter ihrem Basisnamen gesendet, wird das Manifest nicht gefunden. 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 einzelnes Archiv in den Marketplace hoch:
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/plugins" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-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 von PluginCreateParams nehmen einen Dateinamen für die ganze
// Liste, lade das Plugin daher stattdessen als ein Archiv hoch: ein einzelner, manuell erstellter
// Part mit dem Dateinamen des Archivs, den der Upload voraussetzt.
var archive = MultipartField.>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}"
```
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 das 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 500 Plugins und Skills. | Lade in einen `manual`-Marketplace hoch oder ändere stattdessen das Repository. |
| 409 `plugin_name_taken` | Der Name ist in diesem Marketplace bereits vergeben. | Fahre mit `details.plugin_id` fort (lade eine Version dafür hoch) oder ä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 noch. | Versuche es in Kürze erneut. |
| 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`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-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}"
```
### Ausgelieferte Version ändern
`POST /v1/organizations/plugins/{plugin_id}` ändert, welche Version eines organisationseigenen Plugins den 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 derzeit weder hier noch in claude.ai wieder gelöst werden (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 pinnt sie es dort, sodass spätere Uploads nicht mehr automatisch bereitgestellt werden. Das Pinnen beendet außerdem 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`.
```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: 2023-06-01" \
-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}"
```
```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 mitgliedseigenes Plugin sowie `409 scan_pending` oder `400 scan_failed` für eine Version, die nicht an Mitglieder ausgeliefert werden darf; 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 ausgelieferten 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 nicht mehr an Mitglieder ausgeliefert. Die Installationseinstellungen eines organisationseigenen Plugins werden mit ihm entfernt; die Freigaben eines mitgliedseigenen Plugins 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 organisationseigenes Plugin 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 [Eine Installationseinstellung festlegen](https://platform.claude.com/docs/de/manage-claude/plugins-api#set-an-installation-setting)). Ein mitgliedseigenes Plugin kann über diese API nur durch Löschen zurückgehalten werden, und nur, wenn sein Marketplace `manual` ist.
```bash cURL
curl -X DELETE "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-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}"
```
```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 ausgelieferten Version des Plugins (`display_name`, `description`, `manifest_version`, `content_scan`, `components`, `reach`) für diese Version wider, ergänzt um `release_notes` (wie beim Upload angegeben; 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`.
```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: 2023-06-01" \
-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
```
### Version erstellen
`POST /v1/organizations/plugins/{plugin_id}/versions` fügt einem organisationseigenen Plugin 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 [Ein 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`.
```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: 2023-06-01" \
-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 von Hand, damit das Archiv mit seinem Dateinamen gesendet wird,
// den der Upload erfordert.
var archive = MultipartField.>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}"
```
```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 mitgliedseigenes Plugin; 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 ausgelieferten 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`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL/versions/latest" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-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}"
```
### Dateien einer Version herunterladen
`GET /v1/organizations/plugins/{plugin_id}/versions/{version}/content` lädt die Dateien einer Version als gespeichertes `.zip`-Archiv herunter (`Content-Type: application/zip`). Das Archiv wird unabhängig vom Ergebnis der Inhaltsprüfung zurückgegeben, sodass du auch Versionen untersuchen kannst, die Mitgliedern vorenthalten werden. Es wird genau so ausgeliefert, wie es gespeichert ist, sodass du es bei einem organisationseigenen Plugin 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 `served_version_id` oder `latest_version_id` des Plugins aus oder löse `latest` mit `GET /v1/organizations/plugins/{plugin_id}/versions/latest` auf. Der Dateiname in `Content-Disposition` wird aus dem 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 **mitgliedseigenen** Plugins 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 organisationseigenen Plugins erzeugt keinen Eintrag.
```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: 2023-06-01" \
-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
// Response 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)
```
## Plugin-Installationseinstellungen
Diese Endpunkte gelten für organisationseigene Plugins. Für ein mitgliedseigenes Plugin, das stattdessen [Freigaben](https://platform.claude.com/docs/de/manage-claude/plugins-api#plugin-shares) hat, geben sie `404` zurück. `{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 [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 an ihr gespeichert (der Akteur steht im zugehörigen Activity-Ereignis `plugin_installation_preference_updated`).
### Installationseinstellungen eines Plugins auflisten
`GET /v1/organizations/plugins/{plugin_id}/installation_settings` listet die Einstellungen eines organisationseigenen Plugins 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`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL/installation_settings" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-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
```
### Installationseinstellung festlegen
`POST /v1/organizations/plugins/{plugin_id}/installation_settings/{target}` legt die Installationseinstellung eines Ziels für ein organisationseigenes Plugin 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 liefert 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.
```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: 2023-06-01" \
-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}"
```
```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"
}
```
### Eine Installationseinstellung entfernen
`DELETE /v1/organizations/plugins/{plugin_id}/installation_settings/{target}` entfernt die Installationseinstellung eines Ziels für ein organisationseigenes Plugin. 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, liefert `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`.
```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: 2023-06-01" \
-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}"
```
```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 mitgliedseigenen Plugins, 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 mitgliedseigenen Plugins 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 organisationseigenes Plugin 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`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/plugins/plugin_01Mr2wP7sU3aJ8vX5cY6nS9t/shares" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-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
```
```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 erstmals 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 ausgelieferten 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`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/plugin_marketplaces?owner_type=organization" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-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
```
### Marketplace abrufen
`GET /v1/organizations/plugin_marketplaces/{marketplace_id}` gibt einen Marketplace zurück. Erfordert den Scope `read:plugins`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/plugin_marketplaces/marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-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}"
```
### Standard-Installationseinstellung eines Marketplace festlegen
`POST /v1/organizations/plugin_marketplaces/{marketplace_id}` legt die Standard-Installationseinstellung eines organisationseigenen Marketplace 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`.
```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: 2023-06-01" \
-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}"
```
### 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 von dir hochgeladene `.zip`-Datei des Marketplace-Verzeichnisses. 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 würden. Die Prüfungen sind dieselben, die eine echte Synchronisierung durchführt. Probleme mit den Inhalten 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 Lesezugriff, und die beiden Endpunkte sind zusammen zusätzlich auf 10 Validierungen pro Minute pro Organisation begrenzt (siehe [Ratenlimits](https://platform.claude.com/docs/de/manage-claude/plugins-api#rate-limiting)); sie erzeugen keine Einträge im Activity Feed. Eine Validierung kann bis zu 120 Sekunden dauern, bevor sie zurückkehrt, setze das Timeout deines Clients also höher. Beide Endpunkte erfordern den Scope `read:plugins` oder `write:plugins` (`read:org_audit` und `read:compliance_org_data` gewähren diese nicht).
Das Repository und alle Plugin-Quellen außerhalb davon auf GitHub werden anonym gelesen, sodass ein privates Repository oder eine private Plugin-Quelle als nicht gefunden gemeldet wird. Plugin-Quellen auf anderen Hosts als GitHub werden nicht abgerufen; ein solches Plugin erhält normalerweise eine Warnung `marketplace_validate_source_not_checked` und wird geprüft, wenn der Marketplace tatsächlich synchronisiert wird. Ist das Repository ein Marketplace, den Anthropic in jede Organisation synchronisiert, oder benennt das Archiv einen solchen, gelten strengere Regeln: Jede Plugin-Quelle außerhalb des Marketplace muss auf einen vollständigen Commit-SHA fixiert sein, nicht fixierte Quellen oder Quellen auf nicht unterstützten Hosts werden als Plugin-Fehler gemeldet, und der gelesene Branch ist standardmäßig derjenige, aus dem dieser Marketplace synchronisiert wird.
`validate_repository` nimmt einen JSON-Body mit zwei Feldern entgegen: `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 weggelassen oder `null`, der Branch, den eine Synchronisierung lesen würde, in der Regel der Standard-Branch des Repositorys). `validate_archive` nimmt `multipart/form-data` mit genau einem Teil entgegen, `archive`, gesendet als Datei-Teil mit einem Dateinamen: eine `.zip`-Datei des Marketplace-Verzeichnisses, höchstens 32 MB groß, mit ihrem Inhalt im Stammverzeichnis oder in einem einzelnen Ordner verpackt (wie es der Download eines Git-Hosts erzeugt), nur mit DEFLATE- oder STORE-Komprimierung. Kein anderes Formularfeld wird akzeptiert.
Ein öffentliches Repository auf einem Branch validieren:
```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: 2023-06-01" \
-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}"
```
```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:
```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: 2023-06-01" \
-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 verlangt.
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}"
```
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 Anmeldedaten 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` meldet, dass der Branch nicht gefunden wurde. Bei `validate_archive`: Der Body ist nicht `multipart/form-data`, der Teil `archive` fehlt, ist mehrfach vorhanden oder wurde nicht als Datei-Teil mit 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 Eintrag in `plugin_errors` und `error_code` bei jeder Warnung. Hat ein Plugin mehrere Probleme, ist `error_code` der Code des ersten, und `error` fasst ihre Meldungen zusammen. Neue Codes können hinzukommen; ein unbekannter `manifest_error_code` bedeutet trotzdem, dass die Inhalte nicht validiert werden konnten, ein unbekannter Code bei einem `plugin_errors`-Eintrag bedeutet trotzdem, dass das Plugin übersprungen würde, und ein unbekannter Code bei einer Warnung bedeutet trotzdem, dass das Plugin synchronisiert würde. Diese Codes weisen auf vorübergehende Zustände hin, sodass dieselbe Anfrage später erfolgreich sein kann: `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 in der Regel `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** pro Organisation, und Schreibanfragen (Erstellen eines Plugins oder einer Version, Ändern der ausgelieferten Version, Löschen, Festlegen oder Entfernen einer Installationseinstellung und Aktualisieren eines Marketplace) teilen sich ein Limit von **60 Anfragen pro Minute** pro Organisation. Eine Marketplace-Validierung (über einen der beiden Endpunkte) zählt als Lesezugriff, und Validierungen sind zusätzlich auf 10 pro Minute pro 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 übrigen Admin-API-Limits deiner Organisation getrennt. 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 deren Limit von 10 pro Minute; bei einem `429` das Limit, das die Anfrage abgelehnt hat).
Ein Upload, eine Änderung der ausgelieferten 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 Standardstruktur, die unter [Fehler](https://platform.claude.com/docs/de/api/errors) dokumentiert ist. Gib die `request_id` aus dem Antworttext an, wenn du dich an den Support wendest.
| 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 bereits vergeben, ein Inhaltsscan läuft noch, 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 | Ein Plugin mit diesem Namen existiert bereits im Marketplace. `details.plugin_id` ist dieses Plugin. Wenn du eine Erstellung wiederholst, deren Antwort verloren gegangen ist, fahre mit diesem Plugin fort. Wenn `plugin_id` fehlt, ist der Name durch einen eigenständigen Skill belegt: Lade unter einem anderen Namen hoch oder lösche den Skill in claude.ai. |
| `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 Inhaltsscan der Version läuft noch. Wiederhole die Anfrage, sobald er abgeschlossen ist. |
| `scan_failed` | 400 | Der Inhaltsscan der Version ist fehlgeschlagen, hat einen Fehler verursacht oder zu keinem Ergebnis geführt, daher kann die Version 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). |
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, wiederhole sie: Die Wiederholung gibt `409 plugin_name_taken` mit der ID des Plugins in `details.plugin_id` zurück, und du fährst mit diesem Plugin fort. 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 Inhaltsscan abgeschlossen wird. |
Die Plugin-, Versions- und Marketplace-IDs in diesen Ereignissen sind dieselben IDs, die diese API zurückgibt. `plugin_installation_preference_updated` identifiziert das Plugin anhand seines `name` und seiner `marketplace_id` statt anhand seiner `id`.
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 einfach 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
Wo dein primärer Inhaber einen Key mit eingeschränktem Scope erstellt.
Die Gruppen-Endpunkte, die die in Installationseinstellungen verwendeten `rbac_group_`-IDs liefern.
Wo Plugin-Schreibvorgänge und Downloads von Mitglieder-Archiven erfasst werden.
Berichte zur Plugin- und Skill-Nutzung für Claude Enterprise.