---
title: API Plugins
url: https://platform.claude.com/docs/fr/manage-claude/plugins-api
description: "Inventoriez et gérez les plugins de votre organisation Claude Enterprise : téléversez des plugins et des versions, choisissez la version servie aux membres, contrôlez qui peut utiliser chaque plugin, téléchargez les fichiers des plugins pour examen et validez une marketplace avant de la connecter."
---
L'API Plugins vous permet d'inventorier chaque plugin de votre organisation Claude Enterprise, de publier des plugins et de nouvelles versions depuis vos propres pipelines, de choisir la version servie aux membres, de contrôler qui peut utiliser chaque plugin, de télécharger les fichiers des plugins pour examen et de vérifier une « marketplace » (place de marché) Git avant de la connecter.
Pour les rapports d'*utilisation* des plugins (quels plugins et quelles skills les membres utilisent, et à quelle fréquence), consultez les [API Analytics](https://platform.claude.com/docs/fr/manage-claude/analytics-api).
**Clé API Admin avec portée requise**
Ces points de terminaison nécessitent une clé API Admin dotée du « scope » (portée) `read:plugins` (pour les points de terminaison `GET`, y compris les téléchargements d'archives) ou de la portée `write:plugins` (pour les points de terminaison `POST` et `DELETE`, à l'exception de la validation de marketplace, que l'une ou l'autre portée autorise) ; la section [Portées](https://platform.claude.com/docs/fr/manage-claude/plugins-api#scopes) donne les détails, y compris deux autres portées de lecture qui fonctionnent également. Consultez [Créer une clé API Admin](https://platform.claude.com/docs/fr/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization) pour savoir où votre propriétaire principal en crée une. Transmettez la clé dans l'en-tête `x-api-key` à chaque requête, avec l'en-tête [`anthropic-version`](https://platform.claude.com/docs/fr/api/versioning) et l'en-tête bêta indiqué dans la note suivante.
L'API Plugins est en **bêta** et n'est disponible que pour les organisations Claude Enterprise. Elle n'est pas disponible pour les organisations Claude Platform (Claude Console), ni pour les organisations pour lesquelles la conformité HIPAA est activée.
Chaque requête doit inclure l'[en-tête bêta](https://platform.claude.com/docs/fr/api/beta-headers) `anthropic-beta: ce-plugins-2026-09-01` (les SDK et la CLI `ant` l'envoient pour vous). Une requête sans cet en-tête renvoie `404`, exactement comme si le point de terminaison n'existait pas.
## Points de terminaison
L'API expose 18 points de terminaison répartis sur cinq ressources :
| Ressource | Points de terminaison |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Plugins** : lister tous les plugins de l'organisation, en téléverser un nouveau, en consulter un, choisir la version servie aux membres (revenir en arrière ou promouvoir), en supprimer un | `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}` |
| **Versions de plugin** : lister l'historique des versions d'un plugin, téléverser une nouvelle version, en consulter une, télécharger les fichiers d'une version | `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` |
| **Paramètres d'installation** : lire qui peut utiliser un plugin appartenant à l'organisation, le définir pour toute l'organisation ou pour un groupe, supprimer l'un ou l'autre paramètre | `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}` |
| **Partages** : lire avec qui un membre a partagé son propre plugin (lecture seule) | `GET /v1/organizations/plugins/{plugin_id}/shares` |
| **Marketplaces de plugins** : trouver l'ID d'une marketplace, en consulter une, définir le paramètre d'installation par défaut de ses plugins, vérifier le contenu d'une marketplace avant de la connecter | `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` |
Cette version n'inclut pas les skills autonomes (les skills qu'un membre rédige dans l'éditeur de skills ou téléverse en tant que skill unique dans claude.ai). Elles n'apparaissent pas dans l'inventaire et ne peuvent pas être créées ici. Les plugins publiés par Anthropic ne sont pas non plus inventoriés ; leur utilisation est rapportée par les [API Analytics](https://platform.claude.com/docs/fr/manage-claude/analytics-api). Les marketplaces sont créées, connectées à des dépôts et supprimées dans claude.ai, et non via cette API.
## Prérequis
* Votre organisation doit disposer d'un forfait Claude Enterprise.
* Votre propriétaire principal crée une clé API Admin dotée de la portée `read:plugins`, de la portée `write:plugins`, ou des deux, dans [claude.ai > Organization settings > API](https://claude.ai/admin-settings/api-access). Consultez [Créer une clé API Admin](https://platform.claude.com/docs/fr/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization).
* Chaque requête comporte trois en-têtes : `x-api-key`, `anthropic-version: 2023-06-01` et `anthropic-beta: ce-plugins-2026-09-01`.
Les SDK Python, TypeScript, C#, Go, Java, PHP et Ruby exposent ces points de terminaison sous `client.beta.organization` (csharp, go: `client.Beta.Organization`; java: `client.beta().organization()`; php: `$client->beta->organization`), et la [CLI `ant`](https://platform.claude.com/docs/fr/cli-sdks-libraries/cli/quickstart) sous `ant beta:organization` ; ils envoient les en-têtes `anthropic-version` et `anthropic-beta` pour vous. Les exemples de cette page utilisent le client par défaut de chaque SDK qui, comme la CLI, lit la clé API Admin depuis la variable d'environnement `ANTHROPIC_API_KEY` ; les exemples curl lisent la clé depuis la même variable et la transmettent dans l'en-tête `x-api-key`. Lorsqu'un SDK ou la CLI récupère des pages supplémentaires pour vous, `limit` définit la taille de page, et non le total (consultez [Pagination](https://platform.claude.com/docs/fr/manage-claude/plugins-api#pagination)).
Les clés API appartiennent à l'organisation et continuent de fonctionner après le départ de la personne qui les a créées. Ne les partagez pas et ne les enregistrez pas dans un système de gestion de versions.
## Démarrage rapide
Listez les plugins des marketplaces propres à votre organisation, du plus récent au plus ancien :
```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)
# Récupère automatiquement des pages supplémentaires si nécessaire.
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,
);
// Cette page uniquement ; pour la suivante, rappelez list() avec page: $plugins->nextPage.
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"
}
```
Dans cet exemple, le plugin est épinglé à une version antérieure : une version plus récente (`latest_version_id`) est stockée mais pas encore servie.
## Portées
| Portée | Accorde |
| -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `read:plugins` | Tous les points de terminaison `GET` de cette page, y compris les téléchargements d'archives, ainsi que la validation de marketplace. |
| `write:plugins` | Tous les points de terminaison `POST` et `DELETE` de cette page : créer un plugin, créer une version, changer la version servie, supprimer un plugin, définir et supprimer des paramètres d'installation, et définir la valeur par défaut d'une marketplace, ainsi que la validation de marketplace. Elle n'accorde pas les lectures. |
| `read:org_audit` | Une portée en lecture seule destinée aux intégrations d'audit de sécurité : tous les points de terminaison `GET` de cette page, y compris les téléchargements d'archives, ainsi que les points de terminaison de lecture de la [gestion des utilisateurs](https://platform.claude.com/docs/fr/manage-claude/user-management) et de la [Compliance API](https://platform.claude.com/docs/fr/manage-claude/compliance-api). Elle n'accorde ni la validation de marketplace ni aucune écriture. |
| `read:compliance_org_data` | La portée de la Compliance API pour les métadonnées de l'organisation (noms, types, rôles et groupes) et les paramètres effectifs. Accorde tous les points de terminaison `GET` de cette page, exactement comme `read:org_audit`, de sorte qu'une Compliance Access Key peut lire les plugins sans seconde clé. Elle n'accorde ni la validation de marketplace ni aucune écriture. |
Une clé peut porter plusieurs portées. Une intégration qui téléverse un plugin puis le relit a besoin à la fois de `read:plugins` et de `write:plugins`. Partout où cette page indique qu'un point de terminaison nécessite la portée `read:plugins`, une clé dotée de `read:org_audit` ou de `read:compliance_org_data` fonctionne également.
### Accès aux fichiers des plugins des membres
Chacune de ces portées de lecture (`read:plugins`, `read:org_audit` et `read:compliance_org_data`) permet de télécharger les fichiers des plugins situés dans les marketplaces personnelles des membres, y compris des fichiers que les paramètres d'administration de claude.ai n'affichent pas, et une clé `read:org_audit` ou `read:compliance_org_data` liée à votre organisation parente peut le faire dans toute organisation placée sous celle-ci qui a accès à cette API, en transmettant `organization_id` (consultez [Lire une autre organisation sous le même parent](https://platform.claude.com/docs/fr/manage-claude/plugins-api#reading-another-organization-under-the-same-parent)). Chacun de ces téléchargements enregistre un événement `claude_plugin_archive_accessed` dans le [flux d'activité (Activity Feed) de la Compliance API](https://platform.claude.com/docs/fr/manage-claude/compliance-activity-feed), identifiant la clé, le plugin, la version et le membre (consultez [Événements du flux d'activité](https://platform.claude.com/docs/fr/manage-claude/plugins-api#activity-feed-events)). Les téléchargements de plugins appartenant à l'organisation ne sont pas enregistrés.
### Lire une autre organisation sous le même parent
Les clés `read:plugins` et `write:plugins` ne lisent et n'écrivent que dans l'organisation où elles ont été créées. Si votre entreprise possède plusieurs organisations Claude liées sous une même organisation parente, une clé `read:org_audit` ou `read:compliance_org_data` que le propriétaire principal du parent a créée pour toutes les organisations liées (consultez [Créer une clé API Admin](https://platform.claude.com/docs/fr/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization)) peut également lire n'importe laquelle d'entre elles ayant accès à cette API : transmettez l'ID de cette organisation dans le paramètre de requête `organization_id` sur n'importe quel point de terminaison `GET` de cette page. L'ID est l'UUID de l'organisation affiché dans les paramètres de claude.ai (sa forme préfixée par `org_` est également acceptée). Sans ce paramètre, la clé lit l'organisation dans laquelle elle a été créée. Un `404` signifie que l'organisation désignée ne se trouve pas sous le parent de la clé ou que l'API ne lui est pas disponible ; une valeur qui n'est ni un UUID ni un ID `org_` renvoie `400`. Toute autre clé qui désigne une organisation autre que la sienne obtient `404`. Les écritures n'acceptent pas `organization_id`.
## Concepts clés
### Plugins et composants
Un **plugin** est un paquet qui étend Claude pour les membres de votre organisation. Il contient n'importe quelle combinaison des composants suivants :
| Composant | Description |
| ----------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| Skill | Des instructions et des fichiers que Claude charge lorsqu'une tâche le requiert. |
| Commande | Un prompt enregistré qu'un membre exécute en tapant `/` suivi du nom de la commande. |
| Agent | Un assistant auxiliaire doté de ses propres instructions, auquel Claude peut confier une partie d'une tâche. |
| Hook | Une commande qui s'exécute automatiquement lorsqu'un événement se produit dans une session, par exemple avant que Claude n'utilise un outil. |
| Serveur MCP | Une connexion de Claude vers les outils et les données d'un autre système (« Model Context Protocol », ou MCP). |
| CLI | Un programme en ligne de commande que le plugin permet à Claude d'exécuter. |
Chaque plugin possède un manifeste à l'emplacement `.claude-plugin/plugin.json`. Le `name` du manifeste devient le `name` du plugin : un identifiant en minuscules, unique au sein de sa marketplace.
### Marketplaces
Une **marketplace** est un conteneur de plugins. Chaque marketplace a un propriétaire et une source.
* **Propriétaire.** L'organisation possède ses marketplaces. Chaque membre peut également avoir des marketplaces personnelles.
* **Source.** `manual` signifie que les plugins sont téléversés, dans claude.ai ou, pour une marketplace d'organisation, via cette API. `github`, `gitlab` et `public_git` signifient que les plugins sont synchronisés depuis un dépôt Git que le propriétaire a connecté. Rien ne peut être téléversé dans une marketplace synchronisée, et cette API ne peut pas en supprimer les plugins, car la synchronisation suivante annulerait l'une ou l'autre modification. Modifiez plutôt le dépôt.
La **marketplace de bibliothèque** de votre organisation est la marketplace `manual` appartenant à l'organisation vers laquelle vont les téléversements lorsque vous ne désignez pas de marketplace. Elle est créée la première fois que quelque chose y est téléversé.
### Plugins appartenant à l'organisation et plugins appartenant aux membres
Le champ `owner.type` d'un plugin indique dans quelle marketplace il se trouve :
* `organization` : vous pouvez le gérer via cette API, sauf qu'un plugin situé dans une marketplace synchronisée depuis Git ne peut pas recevoir de téléversements ni être supprimé ici.
* `user` : il se trouve dans la marketplace personnelle d'un membre. Vous pouvez lire ses détails et télécharger ses fichiers, et le supprimer si sa marketplace est `manual`. Le téléversement de versions et le choix de la version servie renvoient `403`. Le partage est géré uniquement par le membre, dans claude.ai.
Retirer un membre de l'organisation ne supprime pas ses plugins. Ils restent dans l'inventaire sous le `user_id` du membre, et le filtre `owner_user_id` les trouve toujours, ce qui vous permet d'examiner et de supprimer le contenu d'un membre parti. Ils sont retirés de l'inventaire lorsque le compte du membre est supprimé.
### Versions et version servie
Chaque téléversement crée une nouvelle **version** immuable, qu'il provienne de cette API, de claude.ai ou d'une synchronisation Git. Un plugin possède deux pointeurs vers ses versions :
* `latest_version_id` : la version la plus récente.
* `served_version_id` : la version servie aux membres.
Par défaut, `served_version_pinned` vaut `false` : la version servie suit normalement la plus récente. Lorsque l'analyse de contenu est activée, une version enregistrée dans claude.ai peut **attendre** son analyse de contenu : elle est stockée mais pas servie immédiatement. Cette page utilise « attendre » uniquement pour une version enregistrée dans claude.ai, et non pour une version qu'un membre ou un administrateur publie dans un plugin. Tant que l'analyse est activée, une version en attente n'est servie qu'une fois son analyse terminée avec `pass` ou `warn`. Pendant qu'une version attend, `served_version_id` désigne une version antérieure à `latest_version_id`. N'interrogez pas l'API en boucle jusqu'à ce que les deux ID correspondent : ils peuvent rester différents, par exemple lorsque l'analyse échoue.
Choisir une version avec `POST /v1/organizations/plugins/{plugin_id}` **épingle** le plugin (`served_version_pinned: true`). Il en va de même lorsqu'un administrateur choisit une version dans claude.ai, ou accepte la demande d'un membre de publier dans le plugin. À partir de ce moment, les nouveaux téléversements sont stockés et font avancer `latest_version_id`, mais les membres conservent la version épinglée jusqu'à ce que vous fassiez pointer `served_version_id` vers une autre version. Un plugin dont les deux pointeurs diffèrent possède une version stockée qui n'est pas servie.
Cela permet à un pipeline de publication de téléverser chaque build, de le tester, puis de le promouvoir. Pour que votre pipeline décide du moment où chaque build est servi, épinglez le plugin une fois en définissant `served_version_id` sur sa version actuelle ; à partir de là, promouvez chaque build que vous souhaitez servir. Lorsque l'analyse de contenu est activée, ce premier épinglage renvoie `409 scan_pending` jusqu'à ce que l'analyse de la version actuelle soit terminée, et `400 scan_failed` si l'analyse s'est terminée avec `fail` ou `unknown`, ou a échoué avec une erreur (`warn` est accepté). Un plugin épinglé ne peut actuellement pas être désépinglé, ni ici ni dans claude.ai.
Pour revenir en arrière, définissez `served_version_id` sur une version antérieure. Procédez de la même manière pour avancer.
Ces règles décrivent les plugins appartenant à l'organisation. La version servie d'un plugin appartenant à un membre est contrôlée par son propriétaire dans claude.ai.
### Paramètres d'installation
Les **paramètres d'installation** déterminent qui peut utiliser un plugin appartenant à l'organisation. Chaque paramètre a l'une des quatre valeurs suivantes, portées par les champs nommés `installation_preference` (et, sur les objets plugin et marketplace, `organization_installation_preference` et `default_installation_preference`) :
| Valeur | Ce que voient les membres |
| --------------- | ---------------------------------------------------- |
| `required` | Le plugin est installé et ne peut pas être supprimé. |
| `auto_install` | Le plugin est installé et peut être supprimé. |
| `available` | Le plugin peut être installé sur demande. |
| `not_available` | Le plugin est masqué. |
Un plugin peut avoir un paramètre à l'échelle de l'organisation et un paramètre par groupe (les groupes de contrôle d'accès basé sur les rôles gérés dans la [gestion des utilisateurs](https://platform.claude.com/docs/fr/manage-claude/user-management#groups)). Un membre obtient une valeur selon les règles suivantes :
1. La valeur à l'échelle de l'organisation est le paramètre propre du plugin à l'échelle de l'organisation s'il en a un, sinon la valeur par défaut de sa marketplace, sinon `not_available`. Le plugin indique cette valeur dans `organization_installation_preference`, avec `organization_installation_preference_inherited: true` tant qu'elle provient de la valeur par défaut de la marketplace.
2. Un membre qui n'appartient à aucun groupe ayant un paramètre pour le plugin obtient la valeur à l'échelle de l'organisation.
3. Un membre qui appartient à un ou plusieurs groupes ayant un paramètre obtient à la place le plus permissif des paramètres de ces groupes, selon l'ordre `required`, `auto_install`, `available`, `not_available`.
Le paramètre d'un groupe remplace la valeur à l'échelle de l'organisation pour ses membres ; il ne s'y ajoute pas. Par exemple, si la valeur à l'échelle de l'organisation est `required` et que le groupe Pilot a `available`, les membres de Pilot obtiennent `available`. Lorsque vous faites passer un plugin d'un groupe pilote à toute l'organisation, définissez la valeur à l'échelle de l'organisation, puis supprimez le paramètre du groupe. Définir la valeur à l'échelle de l'organisation empêche le plugin d'hériter de la valeur par défaut de sa marketplace ; [supprimer le paramètre à l'échelle de l'organisation](https://platform.claude.com/docs/fr/manage-claude/plugins-api#remove-an-installation-setting) ramène le plugin à cette valeur par défaut.
Un plugin créé via cette API démarre sans paramètre propre ; il hérite donc de la valeur par défaut de sa marketplace : `not_available`, sauf si quelqu'un a défini une valeur par défaut. La suppression d'un groupe supprime ses paramètres de tous les plugins.
### Partages
Les **partages** déterminent qui peut utiliser un plugin appartenant à un membre. Le propriétaire le partage dans claude.ai avec tous les membres, avec un groupe ou avec des membres nommés. Cette API liste les partages mais ne peut pas les modifier.
Si votre organisation a désactivé un type de partage dans ses paramètres claude.ai, les partages de ce type apparaissent toujours dans la liste mais ne donnent accès à personne tant que ce paramètre est désactivé ; la liste elle-même n'indique pas s'il l'est.
### Analyse de contenu
L'« content scanning » (analyse de contenu) est un paramètre d'organisation dans claude.ai. Lorsqu'elle est activée, les versions nouvellement stockées sont analysées (claude.ai en exempte quelques-unes) et le résultat est indiqué dans `content_scan` ; une version qui n'a pas été analysée, par exemple une version stockée avant l'activation de l'analyse, a `content_scan: null`. L'analyse n'est pas proposée aux organisations qui utilisent des clés de chiffrement gérées par le client ou la conservation zéro des données.
Tant que l'analyse est activée, un plugin n'est servi aux membres que lorsque l'analyse de sa version servie est `completed` avec `pass` ou `warn`. Pendant l'analyse, ou après qu'elle a échoué, rencontré une erreur ou n'a abouti à aucun verdict, le plugin est retenu et n'est pas servi aux membres, et aucune version antérieure n'est servie à sa place. Une version qui n'a jamais été analysée (`content_scan: null`) est servie normalement.
Une version que vous téléversez via cette API n'attend jamais son analyse de contenu. Lorsqu'elle devient la version servie, les membres perdent le plugin jusqu'à ce que son analyse réussisse, et en restent privés si l'analyse échoue. Si les membres doivent conserver la version actuelle pendant l'analyse d'une nouvelle version, épinglez d'abord le plugin (consultez [Versions et version servie](https://platform.claude.com/docs/fr/manage-claude/plugins-api#versions-and-the-served-version)).
Pendant qu'une version enregistrée dans claude.ai attend son analyse, la version servie ne change pas. Lorsque votre téléversement via l'API devient la version servie, toute attente prend fin : la version en attente n'est servie que si quelqu'un la choisit. Pour voir l'analyse d'une version en attente, lisez la version (consultez [Lister les versions d'un plugin](https://platform.claude.com/docs/fr/manage-claude/plugins-api#list-a-plugins-versions)).
Après un téléversement, `content_scan.status` vaut `processing` et le verdict arrive de manière asynchrone. Lisez la version pour le consulter ; l'objet plugin n'affiche que l'analyse de sa version servie. Changer la version servie pour une version dont l'analyse est encore en cours renvoie `409 scan_pending` ; pour une version dont l'analyse a échoué, `400 scan_failed`.
### Reach (rayon d'action)
`reach` résume, en une seule valeur, jusqu'où une version s'étend sur les machines des membres et au-delà :
| Valeur | Signification |
| ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `remote` | Déclare un serveur MCP ou une CLI, quoi qu'elle déclare par ailleurs. |
| `privileged` | Ne déclare ni serveur MCP ni CLI, mais déclare un hook, un moniteur (une commande en arrière-plan qui continue de s'exécuter pendant une session), un serveur « Language Server Protocol » (protocole de serveur de langage), ou LSP, ou des paramètres que le plugin applique à l'application du membre, ou contient une skill, une commande ou tout autre fichier Markdown dont le frontmatter pré-approuve des outils (`allowed-tools`). Ces éléments s'exécutent, ou prennent effet, sur l'ordinateur du membre. |
| `contained` | Ne déclare ni serveur MCP, ni CLI, ni hook, ni moniteur, ni serveur LSP, ni paramètres d'application, et aucun de ses fichiers Markdown ne pré-approuve d'outils (par exemple, un plugin qui ne contient que des skills, des commandes et des agents, aucun avec `allowed-tools`). |
`reach` prend en compte tout ce que la version déclare, y compris les moniteurs, les serveurs LSP et les paramètres d'application, que `components` ne liste pas ; une version dont la liste `components` est vide peut donc tout de même être `privileged`. Il vaut `null` pour une version stockée avant l'enregistrement des composants, et pour une version dont le rayon d'action n'a pas pu être déterminé parce que le `SKILL.md` de l'une de ses skills, ou l'un de ses fichiers de commande, n'a pas pu être lu ; traitez `null` comme non classé.
### Exigences de téléversement
Les téléversements suivent les mêmes règles que les téléversements de plugins dans claude.ai, de sorte que les mêmes archives sont acceptées aux deux endroits.
* Le téléversement est soit une archive `.zip` ou `.plugin` unique, soit un ensemble de fichiers individuels. Une archive peut tout envelopper dans un seul dossier de premier niveau.
* Il doit contenir exactement un manifeste, à l'emplacement `.claude-plugin/plugin.json`, qui doit déclarer un `name`. Un `SKILL.md` seul sans manifeste est rejeté.
* Un `SKILL.md` de premier niveau dont le frontmatter déclare des composants de plugin est fusionné dans le manifeste ; `plugin.json` l'emporte partout où les deux définissent une valeur.
* `name` peut contenir des lettres minuscules (de n'importe quel alphabet), des chiffres et des traits d'union, jusqu'à 64 caractères. Les lettres majuscules, les espaces, les traits de soulignement et les autres signes de ponctuation sont rejetés.
* `displayName` comporte au plus 64 caractères et `description` au plus 500.
* Chaque `SKILL.md` nécessite un frontmatter YAML valide avec un `name` et une `description`, aucun des deux ne contenant de balises XML telles que ``. Deux skills, ou deux commandes, ne peuvent pas partager le même nom.
* Aucun fichier ne peut se trouver sous un répertoire `bin/` de premier niveau.
* Aucun fichier `.zip` imbriqué. Les serveurs MCP empaquetés (`.mcpb`, `.dxt`) sont autorisés.
* Les chemins de fichiers doivent être relatifs, ne contenir aucun `..` et n'utiliser que des lettres, des chiffres, des espaces et `_ . - / ( ) ,`.
* Le corps de la requête et l'archive décompressée font chacun au plus 200 Mo ; un corps de requête dépassant la limite renvoie `413` (`request_too_large`) plutôt que `400`. Un téléversement comporte au plus 5 000 fichiers, une profondeur de chemin de 12, des chemins de 472 caractères et des noms de fichiers ou de dossiers de 255 caractères.
* Les archives ZIP doivent utiliser la compression DEFLATE ou STORE, et ne peuvent pas être chiffrées ni contenir de liens symboliques.
* Une marketplace contient au plus 500 éléments, en comptant ses plugins et toutes les skills autonomes que les membres y conservent. Cette limite et la limite de 5 000 fichiers sont des valeurs actuelles susceptibles d'être relevées.
## Exemples de flux de travail
### Publier chaque build depuis un pipeline de publication
Téléversez chaque build étiqueté depuis la CI, et laissez le pipeline décider du moment où un build est servi.
1. Trouvez la marketplace dans laquelle téléverser avec `GET /v1/organizations/plugin_marketplaces?owner_type=organization`, ou omettez `marketplace_id` pour utiliser la marketplace de bibliothèque.
2. Lors de la première publication, [créez le plugin](https://platform.claude.com/docs/fr/manage-claude/plugins-api#create-a-plugin) avec `POST /v1/organizations/plugins`. À chaque publication ultérieure, notez le `latest_version_id` du plugin, puis [téléversez une version](https://platform.claude.com/docs/fr/manage-claude/plugins-api#create-a-version) avec `POST /v1/organizations/plugins/{plugin_id}/versions`. Si la réponse du téléversement est perdue, lisez le plugin et ne réessayez que si `latest_version_id` n'a pas changé (consultez [Réessayer les téléversements](https://platform.claude.com/docs/fr/manage-claude/plugins-api#retrying-uploads)).
3. Pour que les membres conservent la version actuelle pendant la vérification de chaque nouveau build, épinglez le plugin une fois en définissant `served_version_id` sur sa version actuelle. À partir de là, chaque téléversement est stocké sans être servi, et l'épinglage ne peut pas être annulé : chaque build que vous souhaitez servir nécessite l'étape 5.
4. Lorsque l'analyse de contenu est activée, interrogez `GET /v1/organizations/plugins/{plugin_id}/versions/{version}` jusqu'à ce que `content_scan.status` ne soit plus `processing`, et ne promouvez que lorsqu'il vaut `completed` avec `pass` ou `warn`.
5. [Promouvez le build](https://platform.claude.com/docs/fr/manage-claude/plugins-api#change-the-served-version) avec `POST /v1/organizations/plugins/{plugin_id}` et `{"served_version_id": ""}`. Pour revenir en arrière, envoyez l'ID de la version précédente de la même manière.
### Déployer un plugin auprès d'un groupe pilote, puis de tout le monde
1. Recherchez l'ID du groupe pilote avec `GET /v1/organizations/rbac_groups`. Cet appel nécessite la portée `read:rbac_groups`, qui requiert une clé créée pour toutes les organisations liées (consultez la [gestion des utilisateurs](https://platform.claude.com/docs/fr/manage-claude/user-management#groups)). Les étapes suivantes nécessitent `write:plugins`, qui n'agit que sur l'organisation dans laquelle sa clé a été créée ; dans une entreprise comportant plusieurs organisations liées, créez donc cette clé dans l'organisation qui détient le plugin et attribuez-lui les deux portées, ou utilisez une seconde clé créée dans cette organisation pour ces étapes.
2. [Attribuez au groupe son propre paramètre](https://platform.claude.com/docs/fr/manage-claude/plugins-api#set-an-installation-setting), par exemple `auto_install`, avec `POST /v1/organizations/plugins/{plugin_id}/installation_settings/{target}`, où `{target}` est l'ID `rbac_group_` du groupe, tandis que la valeur à l'échelle de l'organisation reste `not_available`. Seuls les membres du groupe obtiennent le plugin.
3. À la fin du pilote, définissez la valeur à l'échelle de l'organisation avec l'appel suivant, puis supprimez le paramètre du groupe afin que le groupe suive à nouveau l'organisation. Définir la valeur à l'échelle de l'organisation empêche le plugin d'hériter de la valeur par défaut de sa marketplace ; [supprimer le paramètre à l'échelle de l'organisation](https://platform.claude.com/docs/fr/manage-claude/plugins-api#remove-an-installation-setting) ramène ultérieurement le plugin à cette valeur par défaut.
```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}"
```
Supprimez ensuite le paramètre du groupe avec `DELETE /v1/organizations/plugins/{plugin_id}/installation_settings/{target}`, où `{target}` est l'ID du groupe. Le paramètre d'un groupe remplace la valeur à l'échelle de l'organisation pour ses membres au lieu de s'y ajouter ; un paramètre de groupe résiduel à `available` maintiendrait donc ces membres sur `available`.
### Maintenir un inventaire de sécurité à jour
Exécutez une tâche nocturne qui signale les plugins qui s'étendent au-delà de la session du membre ou qui échouent à leur analyse de contenu.
1. Parcourez les pages de [`GET /v1/organizations/plugins?limit=100`](https://platform.claude.com/docs/fr/manage-claude/plugins-api#list-plugins) jusqu'à ce que `next_page` vaille `null` (consultez [Pagination](https://platform.claude.com/docs/fr/manage-claude/plugins-api#pagination)). Lisez le `reach` et le `content_scan` de chaque plugin depuis cette liste à chaque exécution : un verdict d'analyse qui arrive plus tard ne modifie pas `updated_at`. `updated_at` vous indique normalement quels plugins ont un nouveau contenu ou une nouvelle version servie depuis la dernière exécution (ce qui justifie un nouveau téléchargement d'archive). Une version en attente (consultez [Versions et version servie](https://platform.claude.com/docs/fr/manage-claude/plugins-api#versions-and-the-served-version)) modifie `updated_at` lorsqu'elle devient la version servie, pas nécessairement lorsqu'elle est stockée. Pour en repérer une, comparez `latest_version_id` avec la valeur de votre dernière exécution. La relecture complète de la liste est également ce qui permet de détecter les suppressions, car un plugin supprimé par une synchronisation Git ou une suppression de compte disparaît sans événement.
2. Signalez chaque plugin dont le `reach` vaut `remote` (il déclare un serveur MCP ou une CLI), ou dont le `content_scan.assessment` vaut `fail` ou `unknown`. Ces champs décrivent la version servie. Pour vérifier également une version plus récente qui n'est pas servie, listez les versions du plugin lorsque `latest_version_id` diffère de `served_version_id` (consultez [Lister les versions d'un plugin](https://platform.claude.com/docs/fr/manage-claude/plugins-api#list-a-plugins-versions)).
3. Pour chaque plugin signalé, téléchargez l'archive de la version servie pour l'examiner avec `GET /v1/organizations/plugins/{plugin_id}/versions/{served_version_id}/content` (consultez [Télécharger les fichiers d'une version](https://platform.claude.com/docs/fr/manage-claude/plugins-api#download-a-versions-files)). Téléchargez également, par son ID, toute version non servie qui répond au critère de l'étape 2.
4. Pour retirer un plugin aux membres pendant que vous l'examinez, consultez [Supprimer un plugin](https://platform.claude.com/docs/fr/manage-claude/plugins-api#delete-a-plugin) pour les options réversible (appartenant à l'organisation) et définitive.
## Plugins
L'objet plugin décrit un plugin situé dans l'une des marketplaces de votre organisation ou dans la marketplace personnelle d'un membre (la réponse du [Démarrage rapide](https://platform.claude.com/docs/fr/manage-claude/plugins-api#quick-start) en montre un exemple complet). Ses champs `display_name`, `description`, `manifest_version`, `content_scan`, `components` et `reach` décrivent sa version **servie**, de sorte qu'un seul appel de liste montre ce qui est servi aux membres.
| Champ | Description |
| ---------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `id` | Préfixé par `plugin_`. |
| `name` | Issu du manifeste. Unique au sein de sa marketplace, et non à l'échelle de l'organisation. Fixe pour un plugin appartenant à l'organisation ; change si un membre renomme son propre plugin dans claude.ai. |
| `display_name`, `description`, `manifest_version` | Les champs `displayName`, `description` et `version` du manifeste de la version servie ; chacun vaut `null` lorsque le manifeste n'en déclare pas. `manifest_version` est normalisé pour l'affichage : un `v` ou `V` initial est supprimé, de sorte qu'une `version` de manifeste `"v1.4.0"` est renvoyée sous la forme `"1.4.0"`. Il vaut également `null` pour une valeur qui ne ressemble pas à un numéro de version, comme `"latest"`, et pour une version de plugin créée avant que claude.ai ne commence à enregistrer ce champ en août 2026. Un téléversement n'est jamais refusé en raison de sa `version`, et `manifest_version` n'est pas unique. |
| `served_version_id`, `latest_version_id` | Préfixés par `pluginver_` : la version servie aux membres et la version la plus récente. Consultez [Versions et version servie](https://platform.claude.com/docs/fr/manage-claude/plugins-api#versions-and-the-served-version). |
| `served_version_pinned` | `false` jusqu'à ce que le plugin soit épinglé (consultez [Versions et version servie](https://platform.claude.com/docs/fr/manage-claude/plugins-api#versions-and-the-served-version)) ; `true` par la suite. |
| `owner` | `{"type": "organization"}`, ou `{"type": "user", "user_id": "user_..."}` pour la marketplace personnelle d'un membre. |
| `marketplace_id` | Préfixé par `marketplace_`. |
| `created_by` | Qui a créé le plugin : `{"type": "user_actor", "user_id": "user_...", "email_address": "..."}` pour une personne dans claude.ai (`email_address` peut valoir `null`), ou `{"type": "api_actor", "api_key_id": "apikey_..."}` pour une clé API. D'autres types d'acteurs peuvent apparaître. `null` lorsqu'aucun créateur n'est enregistré, par exemple pour les plugins synchronisés depuis Git. |
| `organization_installation_preference`, `organization_installation_preference_inherited` | Appartenant à l'organisation : la valeur à l'échelle de l'organisation, et si elle provient de la valeur par défaut de la marketplace (consultez [Paramètres d'installation](https://platform.claude.com/docs/fr/manage-claude/plugins-api#installation-settings)). Appartenant à un membre : les deux valent `null`. |
| `content_scan` | Le résultat de l'analyse de la version servie, un objet comportant `status`, `assessment` et `reason` (décrits après ce tableau). `null` lorsqu'elle n'a jamais été analysée. |
| `components` | Les composants de la version servie, chacun sous la forme `{"type", "name", "description"}` avec `type` parmi `skill`, `mcp_server`, `command`, `agent`, `hook` ou `cli`, listés dans cet ordre de type puis par nom. Pour un serveur MCP, `name` est sa clé dans le manifeste ; pour un hook, l'événement sur lequel il s'exécute ; pour une CLI, le nom de l'exécutable. `description` vaut toujours `null` pour les serveurs MCP, les hooks et les CLI. `null` lorsqu'ils ne sont pas enregistrés. |
| `reach` | `contained`, `privileged` ou `remote`. Consultez [Reach](https://platform.claude.com/docs/fr/manage-claude/plugins-api#reach). |
| `updated_at` | Change lorsque la version servie change, lorsque le plugin est épinglé et, normalement, lorsqu'une nouvelle version est stockée. Une version en attente (consultez [Versions et version servie](https://platform.claude.com/docs/fr/manage-claude/plugins-api#versions-and-the-served-version)) le modifie lorsqu'elle devient la version servie, pas nécessairement lorsqu'elle est stockée. Il ne change pas pour les paramètres d'installation, les partages ou les nouveaux résultats d'analyse. |
L'objet `content_scan` :
| Champ | Description |
| ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `status` | `processing` pendant l'analyse, `completed` lorsqu'elle est terminée, ou `errored` lorsqu'elle n'a pas pu aboutir (ou, occasionnellement, lorsque son résultat n'a pas pu être lu pour cette réponse, auquel cas une lecture ultérieure peut l'indiquer). Une version dont l'analyse est `processing` ou `errored` n'est pas servie aux membres ; téléverser à nouveau le contenu en tant que nouvelle version déclenche une nouvelle analyse. |
| `assessment` | Défini lorsque `status` vaut `completed` : `pass` (rien n'a été trouvé), `warn` (quelque chose a été trouvé qui ne bloque pas l'utilisation), `fail` (quelque chose a été trouvé qui bloque l'utilisation) ou `unknown` (aucun verdict). Sinon `null`. |
| `reason` | Pour `warn` et `fail`, la principale préoccupation, parmi la liste suivante. Sinon `null`, et également `null` pour une analyse plus ancienne antérieure à l'enregistrement des raisons. |
| `reason` | Signification |
| --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `covert-usage-telemetry` | Demande à Claude d'envoyer des informations sur le membre ou son utilisation à une adresse externe sans l'en informer. |
| `undisclosed-data-destination` | Envoie des fichiers, des e-mails, des documents ou d'autres contenus vers une destination externe fixe que le membre ne voit pas et ne contrôle pas. |
| `remote-code-instruction-loader` | Demande à Claude de télécharger et d'exécuter, ou de suivre les instructions d'un contenu externe susceptible de changer après l'installation du plugin. |
| `credential-exposure` | Contient des identifiants actifs, ou collecte des identifiants ou des jetons depuis l'environnement du membre. |
| `guardrail-tampering` | Affaiblit les protections du membre, par exemple en pré-approuvant chaque demande d'autorisation. |
| `system-prompt-spoofing` | Imite ou tente de remplacer les instructions système de Claude. |
| `covert-record-tampering` | Modifie, masque ou supprime discrètement des informations que le membre verrait autrement. |
| `covert-behavior-override` | Modifie le comportement de Claude au-delà de l'objectif du plugin et dissimule ce changement au membre. |
| `hidden-code-execution` | Exécute du code intégré tout en demandant à Claude de ne pas révéler ce qu'il fait. |
| `undisclosed-promotion-injection` | Insère du contenu promotionnel non divulgué dans la sortie de Claude. |
| `hidden-identity-gate` | Modifie ou interrompt son comportement selon le compte qui l'exécute, sans en indiquer la raison. |
| `destructive-persistence` | Peut supprimer ou corrompre les fichiers du membre, ou installer des programmes qui subsistent après le plugin. |
| `unanalyzable-binary` | Inclut un programme compilé ou illisible, de sorte que l'analyse n'a pas pu vérifier ce qu'il fait. |
| `other` | Toute autre préoccupation, y compris une préoccupation plus récente que cette liste. |
Un `plugin_id` dépourvu du préfixe `plugin_` renvoie `400`. Un `plugin_id` qui porte le préfixe mais ne correspond à rien, appartient à une autre organisation ou fait référence à une skill autonome renvoie `404`.
### Lister les plugins
`GET /v1/organizations/plugins` liste tous les plugins de votre organisation, dans les marketplaces de l'organisation et dans les marketplaces personnelles des membres, triés par `created_at` décroissant. Filtrez par `owner_type` (`organization` ou `user`), `owner_user_id` (préfixé par `user_` ; les plugins d'un membre, y compris après son départ de l'organisation), `marketplace_id`, et `created_at[gte]`, `created_at[gt]`, `created_at[lte]`, `created_at[lt]` (horodatages RFC 3339). Les filtres se combinent avec AND. Un `marketplace_id` ou un `owner_user_id` qui ne correspond à rien dans votre organisation renvoie une page vide, et non une erreur. La réponse a la forme présentée dans le [Démarrage rapide](https://platform.claude.com/docs/fr/manage-claude/plugins-api#quick-start). Nécessite la portée `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)
# Récupère automatiquement des pages supplémentaires si nécessaire.
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,
);
// Cette page uniquement ; pour la suivante, rappelez list() avec page: $plugins->nextPage.
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
```
### Créer un plugin
`POST /v1/organizations/plugins` crée un plugin appartenant à l'organisation et sa première version en un seul appel ; cette version devient la version servie. Le corps est au format `multipart/form-data` : `files[]` est soit une archive `.zip` ou `.plugin` unique, soit une partie par fichier, où le nom de fichier de chaque partie est le chemin du fichier au sein du plugin (par exemple `.claude-plugin/plugin.json`). Les champs facultatifs sont `marketplace_id` (une marketplace `manual` appartenant à l'organisation ; par défaut, votre marketplace de bibliothèque, qui est créée lors de la première utilisation) et `release_notes` (jusqu'à 5 000 caractères, affichées dans l'historique des versions de claude.ai et renvoyées sur la version). Les champs `name`, `display_name`, `description` et `manifest_version` du plugin proviennent du manifeste téléversé, et le téléversement doit respecter les [exigences de téléversement](https://platform.claude.com/docs/fr/manage-claude/plugins-api#upload-requirements). Lorsque l'analyse de contenu est activée, le `content_scan.status` de la réponse vaut `processing` et le verdict arrive de manière asynchrone. Renvoie le plugin. Nécessite la portée `write:plugins`.
Téléverser une archive :
```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();
// Construire la partie `files[]` manuellement afin que l'archive soit envoyée avec son nom de fichier,
// ce que le téléversement exige.
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"
}
```
Téléversez des fichiers individuels dans une marketplace nommée. Joignez chaque fichier sous son chemin au sein du plugin (le suffixe `;filename=` dans l'exemple cURL, les arguments de nom de fichier dans les exemples de SDK) ; un fichier envoyé sous son seul nom de base entraîne l'impossibilité de trouver le manifeste. Les SDK TypeScript et Java ainsi que la CLI `ant` ne peuvent pas encore joindre de fichiers sous un chemin ; ces exemples téléversent donc plutôt le plugin sous forme d'une archive unique dans la marketplace :
```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
# La CLI envoie chaque fichier sous son seul nom de base,
# téléversez donc plutôt le plugin sous forme d'une seule archive.
ant beta:organization:plugins create \
--file dist/sales-toolkit.zip \
--marketplace-id marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r
```
```python Python
client = anthropic.Anthropic()
# Un tuple (filename, file) conserve le chemin de chaque fichier dans le plugin ;
# un objet fichier seul serait envoyé sous son seul nom de base.
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();
// Le SDK TypeScript envoie chaque fichier sous son nom de base,
// téléversez donc le plugin sous forme d'une seule archive.
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 conserve le chemin de chaque fichier dans le plugin ; sans lui, un FileStream
// est envoyé sous son seul nom de base.
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 conserve le chemin de chaque fichier dans le plugin comme nom de fichier de la partie ;
// un *os.File brut serait envoyé sous son nom de base et le manifeste serait introuvable.
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();
// Les setters `files` de PluginCreateParams n'acceptent qu'un seul nom de fichier pour toute la
// liste ; téléversez donc plutôt le plugin sous forme d'une seule archive : une partie unique construite à la main
// qui porte le nom de fichier de l'archive, ce que le téléversement exige.
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
# Un FilePart avec filename: conserve le chemin de chaque fichier dans le plugin ;
# un Pathname seul serait envoyé sous son seul nom de base.
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}"
```
Outre une erreur `400` pour un téléversement qui enfreint les [exigences de téléversement](https://platform.claude.com/docs/fr/manage-claude/plugins-api#upload-requirements) (`413` pour un corps de requête de plus de 200 Mo) et les réponses communes (une erreur `403` lorsque `marketplace_id` est la marketplace personnelle d'un membre ; consultez [Réponses d'erreur](https://platform.claude.com/docs/fr/manage-claude/plugins-api#error-responses)), une création peut échouer avec :
| Statut | Cause | Que faire |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| 404 | `marketplace_id` n'est pas une marketplace de votre organisation. | Prenez l'ID depuis [Lister les marketplaces](https://platform.claude.com/docs/fr/manage-claude/plugins-api#list-marketplaces). |
| 400 | La marketplace est synchronisée depuis Git, ou contient déjà 500 plugins et skills. | Téléversez vers une marketplace `manual`, ou modifiez plutôt le dépôt. |
| 409 `plugin_name_taken` | Le nom est déjà pris dans cette marketplace. | Continuez avec `details.plugin_id` (téléversez-y une version), ou modifiez le `name` du manifeste. |
| 409 `skill_name_taken` | Le plugin est destiné à la marketplace de bibliothèque et l'une de ses skills porte le nom d'une skill de l'organisation. | Renommez la skill, ou supprimez la skill de l'organisation dans claude.ai. |
| 409 (sans `error_code`) | Un autre téléversement portant le même nom vers la même marketplace est toujours en cours. | Réessayez sous peu. |
| 503 `registration_pending` | Le plugin a été créé mais son enregistrement ne s'est pas terminé. | Ne renvoyez pas la requête ; téléversez les mêmes fichiers en tant que version de `details.plugin_id` (consultez [Nouvelles tentatives de téléversement](https://platform.claude.com/docs/fr/manage-claude/plugins-api#retrying-uploads)). |
### Obtenir un plugin
`GET /v1/organizations/plugins/{plugin_id}` renvoie un plugin. Nécessite la portée `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}"
```
### Modifier la version servie
`POST /v1/organizations/plugins/{plugin_id}` modifie la version d'un plugin appartenant à l'organisation qui est servie aux membres. Passez une version antérieure pour revenir en arrière, ou une version plus récente pour promouvoir un build qui a été stocké sans être servi. Cela épingle le plugin, et un plugin épinglé ne peut actuellement pas être désépinglé, ni ici ni dans claude.ai (voir [Versions et version servie](https://platform.claude.com/docs/fr/manage-claude/plugins-api#versions-and-the-served-version)). Le seul champ modifiable est `served_version_id`, et il est obligatoire. La modification atteint les membres avant que la réponse ne soit renvoyée et ne crée pas de version. Lorsque l'analyse de contenu est activée, la version doit être une version pouvant être servie aux membres (voir [Analyse de contenu](https://platform.claude.com/docs/fr/manage-claude/plugins-api#content-scanning)). Passer la version déjà servie sur un plugin épinglé ne change rien ; la passer sur un plugin non épinglé l'y épingle, de sorte que les téléversements ultérieurs cessent d'être servis automatiquement. L'épinglage met également fin à toute attente : une version qui attendait son analyse de contenu reste stockée, et n'est servie que si quelqu'un la choisit. Renvoie le plugin. Nécessite la portée `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"
}
```
Outre les réponses communes (une erreur `403` pour un plugin appartenant à un membre, et `409 scan_pending` ou `400 scan_failed` pour une version qui ne peut pas être servie aux membres ; consultez [Réponses d'erreur](https://platform.claude.com/docs/fr/manage-claude/plugins-api#error-responses)), la requête peut échouer avec :
| Statut | Cause | Que faire |
| ----------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| 400 | Le corps omet `served_version_id`, le définit sur `null` ou contient tout autre champ ; ou la valeur n'a pas le préfixe `pluginver_` ou vaut `latest`. | Envoyez exactement `{"served_version_id": "pluginver_…"}`. |
| 404 | `served_version_id` n'est pas une version de ce plugin. | Prenez l'ID depuis [Lister les versions d'un plugin](https://platform.claude.com/docs/fr/manage-claude/plugins-api#list-a-plugins-versions). |
| 409 (sans `error_code`) | Un téléversement vers ce plugin ou une autre modification de la version servie est toujours en cours. | Réessayez sous peu. |
| 409 `skill_name_taken` | Le plugin se trouve dans la marketplace de bibliothèque et la version contient une skill dont le nom est désormais utilisé par une skill de l'organisation. | Choisissez une autre version, ou renommez l'une des skills. |
### Supprimer un plugin
`DELETE /v1/organizations/plugins/{plugin_id}` supprime définitivement un plugin et toutes les versions qu'il contient, exactement comme le fait une suppression effectuée par un administrateur dans claude.ai. Cela fonctionne sur n'importe quel plugin d'une marketplace `manual`, y compris le plugin d'un membre, même si ce membre a depuis quitté l'organisation. Lorsque la suppression renvoie sa réponse, le plugin, ses versions et leurs fichiers ont disparu de toutes les lectures, et le plugin n'est plus servi aux membres. Les paramètres d'installation d'un plugin appartenant à l'organisation sont supprimés avec lui ; les partages d'un plugin appartenant à un membre sont retirés, et le plugin disparaît également pour son propriétaire. Un plugin d'une marketplace synchronisée depuis Git renvoie `400` : supprimez-le du dépôt, ou supprimez la marketplace dans claude.ai. Nécessite la portée `write:plugins`.
La suppression est irréversible, et il n'existe pas de suppression par version. Pour retenir plutôt un plugin appartenant à l'organisation de manière réversible, définissez son paramètre d'installation à l'échelle de l'organisation sur `not_available` (un plugin qui héritait de la valeur par défaut de sa marketplace obtient son propre paramètre, et [supprimer ce paramètre à l'échelle de l'organisation](https://platform.claude.com/docs/fr/manage-claude/plugins-api#remove-an-installation-setting) ultérieurement ramène le plugin à la valeur par défaut), et supprimez (ou définissez sur `not_available`) chaque paramètre de groupe que liste `GET /v1/organizations/plugins/{plugin_id}/installation_settings`, car le paramètre d'un groupe remplace la valeur à l'échelle de l'organisation pour ses membres. Envoyez ces écritures l'une après l'autre, et non en parallèle (voir [Définir un paramètre d'installation](https://platform.claude.com/docs/fr/manage-claude/plugins-api#set-an-installation-setting)). Un plugin appartenant à un membre ne peut pas être retenu via cette API autrement qu'en le supprimant, et uniquement si sa marketplace est `manual`.
```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" }
```
## Versions de plugin
Une version de plugin est un instantané immuable des fichiers d'un plugin issu d'un téléversement (la réponse de [Créer une version](https://platform.claude.com/docs/fr/manage-claude/plugins-api#create-a-version) montre un objet complet). Ses champs reflètent, pour cette version, les champs de version servie du plugin (`display_name`, `description`, `manifest_version`, `content_scan`, `components`, `reach`), auxquels s'ajoutent `release_notes` (tel que fourni avec le téléversement ; affiché dans l'historique des versions de claude.ai) et `created_by` (la personne qui l'a téléversée).
Un `{version}` dépourvu du préfixe `pluginver_` renvoie `400` (sauf la valeur littérale `latest` lorsque cela est indiqué). Un identifiant qui porte le préfixe mais n'identifie pas une version de ce plugin renvoie `404`.
### Lister les versions d'un plugin
`GET /v1/organizations/plugins/{plugin_id}/versions` liste les versions d'un plugin, triées par `created_at` décroissant ; le premier élément est la version qu'identifie `latest_version_id`. `limit` est compris entre 1 et 1 000. Nécessite la portée `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
)
# Récupère automatiquement les pages suivantes selon les besoins.
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,
);
// Uniquement cette page ; pour la suivante, rappelez list() avec page: $versions->nextPage.
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
```
### Créer une version
`POST /v1/organizations/plugins/{plugin_id}/versions` ajoute une version à un plugin appartenant à l'organisation dans une marketplace `manual`. Le corps est en `multipart/form-data`, avec les mêmes champs `files[]` et `release_notes`, les mêmes [exigences de téléversement](https://platform.claude.com/docs/fr/manage-claude/plugins-api#upload-requirements), et les mêmes erreurs de fichier, de manifeste, d'archive et de taille que [Créer un plugin](https://platform.claude.com/docs/fr/manage-claude/plugins-api#create-a-plugin). Le nom téléversé (le `name` du manifeste) doit être égal au `name` du plugin. Si le plugin n'est pas épinglé, la nouvelle version est normalement servie dès qu'elle est stockée ; s'il est épinglé, la version est stockée mais n'est pas servie tant que vous n'y avez pas basculé la version servie. Pour vérifier, comparez l'`id` de la réponse avec le `served_version_id` du plugin. Renvoie la version. Nécessite la portée `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();
// Construisez la partie `files[]` manuellement afin que l'archive soit envoyée avec son nom de fichier,
// ce que le téléversement exige.
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"
}
```
Outre une erreur `400` pour un téléversement qui enfreint les [exigences de téléversement](https://platform.claude.com/docs/fr/manage-claude/plugins-api#upload-requirements) (`413` pour un corps de requête de plus de 200 Mo) et les réponses communes (une erreur `403` pour un plugin appartenant à un membre ; consultez [Réponses d'erreur](https://platform.claude.com/docs/fr/manage-claude/plugins-api#error-responses)), la requête peut échouer avec :
| Statut | Cause | Que faire |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 400 | Le plugin se trouve dans une marketplace synchronisée depuis Git, ou le nom téléversé diffère de celui du plugin. | Modifiez plutôt le dépôt, ou corrigez le `name` du manifeste. |
| 409 (sans `error_code`) | Un autre téléversement vers ce plugin, ou une modification de la version servie, est toujours en cours. | Réessayez sous peu. |
| 409 `skill_name_taken` | Le plugin se trouve dans la marketplace de bibliothèque et la version ajoute une skill portant le nom d'une skill de l'organisation. | Renommez la skill, ou supprimez la skill de l'organisation dans claude.ai. |
| 503 `registration_pending` | La version a été stockée mais son enregistrement ne s'est pas terminé. | Renvoyez la même requête lorsque la réponse contient `x-should-retry: true` (consultez [Nouvelles tentatives de téléversement](https://platform.claude.com/docs/fr/manage-claude/plugins-api#retrying-uploads)). |
### Obtenir une version
`GET /v1/organizations/plugins/{plugin_id}/versions/{version}` renvoie une version. `{version}` est un ID de version, ou `latest` pour la version qu'identifie `latest_version_id` au moment de la requête. Nécessite la portée `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}"
```
### Télécharger les fichiers d'une version
`GET /v1/organizations/plugins/{plugin_id}/versions/{version}/content` télécharge les fichiers d'une version sous la forme de l'archive `.zip` stockée (`Content-Type: application/zip`). L'archive est renvoyée quel que soit le résultat de son analyse de contenu, ce qui vous permet d'inspecter les versions qui ne sont pas servies aux membres. Elle est servie exactement telle qu'elle a été stockée ; ainsi, pour un plugin appartenant à l'organisation dans une marketplace `manual`, vous pouvez la téléverser à nouveau sans modification en tant que nouvelle version, à condition qu'elle respecte les exigences de téléversement actuelles. `{version}` doit être un ID de version, et non `latest` : lisez d'abord le `served_version_id` ou le `latest_version_id` du plugin, ou résolvez `latest` avec `GET /v1/organizations/plugins/{plugin_id}/versions/latest`. Le nom de fichier `Content-Disposition` est dérivé du nom du plugin et n'est pas unique ; nommez les fichiers enregistrés d'après le plugin et l'ID de version. Nécessite la portée `read:plugins`.
Le téléchargement de l'archive d'un plugin **appartenant à un membre** enregistre un événement `claude_plugin_archive_accessed` dans l'Activity Feed de la Compliance API, qui identifie par ID la clé (en tant que `api_actor`), le plugin et sa marketplace, la version et le membre propriétaire ; il ne contient aucun nom. Le téléchargement de l'archive d'un plugin appartenant à l'organisation n'enregistre rien.
```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() renverrait l'archive entière sous forme d'une seule chaîne ; on prend donc la
// réponse brute et on copie son corps sur le disque par blocs.
$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)
# Le SDK renvoie l'archive déjà chargée en mémoire, sous forme de StringIO.
File.binwrite("#{plugin_id}_#{version_id}.zip", archive.string)
```
## Paramètres d'installation de plugin
Ces points de terminaison s'appliquent aux plugins appartenant à l'organisation. Ils renvoient `404` pour un plugin appartenant à un membre, qui dispose à la place de [partages](https://platform.claude.com/docs/fr/manage-claude/plugins-api#plugin-shares). `{target}` est la valeur littérale `organization` pour le paramètre à l'échelle de l'organisation du plugin, ou l'ID `rbac_group_` d'un groupe pour le paramètre de ce groupe ; toute autre valeur renvoie `400`. Les ID de groupe proviennent de `GET /v1/organizations/rbac_groups` (portée `read:rbac_groups` ; consultez [Gestion des utilisateurs](https://platform.claude.com/docs/fr/manage-claude/user-management#groups)). Un paramètre n'a pas d'`id` propre : il est adressé par `(plugin_id, target)`, et aucun acteur n'y est enregistré (l'acteur figure sur son événement d'activité `plugin_installation_preference_updated`).
### Lister les paramètres d'installation d'un plugin
`GET /v1/organizations/plugins/{plugin_id}/installation_settings` liste les paramètres que détient un plugin appartenant à l'organisation, triés par `created_at` décroissant : son propre paramètre à l'échelle de l'organisation (absent tant qu'il hérite de la valeur par défaut de sa marketplace) et le paramètre de chaque groupe. Filtrez par `target_type` (`organization` ou `rbac_group`). Nécessite la portée `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"
)
# Récupère automatiquement des pages supplémentaires si nécessaire.
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',
);
// Cette page uniquement ; pour la suivante, rappelez list() avec page: $settings->nextPage.
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
```
### Définir un paramètre d'installation
`POST /v1/organizations/plugins/{plugin_id}/installation_settings/{target}` définit le paramètre d'installation d'une cible pour un plugin appartenant à l'organisation, en le créant ou en modifiant la valeur qu'il détient déjà. Le seul champ du corps est `installation_preference` (`required`, `auto_install`, `available` ou `not_available`), et il est obligatoire. Définir la valeur que la cible détient déjà ne change rien. Définir la cible `organization` fait cesser l'héritage par le plugin de la valeur par défaut de sa marketplace (`organization_installation_preference_inherited` devient `false`), même lorsque la valeur est identique à la valeur par défaut, de sorte que le plugin ne suit plus les modifications ultérieures de la valeur par défaut de la marketplace. Pour ramener le plugin à la valeur par défaut de sa marketplace, [supprimez le paramètre à l'échelle de l'organisation](https://platform.claude.com/docs/fr/manage-claude/plugins-api#remove-an-installation-setting) ; les paramètres de groupe ne sont pas affectés. Une cible de groupe doit être un groupe que votre organisation peut voir dans `GET /v1/organizations/rbac_groups`, sinon la requête renvoie `404`. La modification n'altère pas le `updated_at` du plugin ; elle est enregistrée dans l'Activity Feed. Renvoie le paramètre. Nécessite la portée `write:plugins`.
Envoyez les écritures de paramètres d'installation d'un plugin une à la fois. Si plusieurs écritures pour le même plugin arrivent en même temps, le serveur les traite l'une après l'autre et peut répondre à certaines d'entre elles par `503` au lieu de les appliquer. Cette réponse `503` contient `x-should-retry: true`, et l'écriture peut être répétée sans risque : attendez une seconde ou deux, puis renvoyez-la.
```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"
}
```
### Supprimer un paramètre d'installation
`DELETE /v1/organizations/plugins/{plugin_id}/installation_settings/{target}` supprime le paramètre d'installation d'une cible pour un plugin appartenant à l'organisation. Avec un `{target}` valant `organization`, il supprime le propre paramètre à l'échelle de l'organisation du plugin. Le plugin hérite alors à nouveau de la valeur par défaut de sa marketplace (`organization_installation_preference_inherited` devient `true`) et suit les modifications ultérieures de cette valeur par défaut ; les paramètres de groupe ne sont pas affectés. Avec l'ID `rbac_group_` d'un groupe, il supprime le paramètre de ce groupe : les membres du groupe se rabattent sur la valeur à l'échelle de l'organisation, ou sur le paramètre d'un autre de leurs groupes. Une cible qui ne détient aucun paramètre propre renvoie `404` ; cela inclut la cible `organization` d'un plugin qui hérite déjà de la valeur par défaut de sa marketplace. La modification n'altère pas le `updated_at` du plugin ; elle est enregistrée dans l'Activity Feed. La réponse comporte la clé composite à la place d'un `id` ; pour la cible `organization`, son `target` est `{"type": "organization"}`. Nécessite la portée `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" }
}
```
## Partages de plugin
Les partages n'existent que sur les plugins appartenant à des membres et sont en lecture seule dans cette API (consultez [Partages](https://platform.claude.com/docs/fr/manage-claude/plugins-api#shares)).
### Lister les partages d'un plugin
`GET /v1/organizations/plugins/{plugin_id}/shares` liste les destinataires avec lesquels le propriétaire d'un plugin appartenant à un membre l'a partagé, triés par `granted_at` décroissant : tous les membres (`organization`), un groupe (`rbac_group`) ou un membre nommé (`organization_member`). Filtrez par `target_type`. Un plugin que son propriétaire n'a pas partagé renvoie une liste vide ; un plugin appartenant à l'organisation renvoie `404`. Les partages sont en lecture seule dans cette API, et un partage listé ne donne accès que tant que ce type de partage est activé pour votre organisation dans claude.ai (consultez [Partages](https://platform.claude.com/docs/fr/manage-claude/plugins-api#shares)). `granted_at` correspond au moment où le partage a été accordé ; si le propriétaire modifie ultérieurement le partage dans claude.ai, il s'agit du moment de cette modification. Nécessite la portée `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")
# Récupère automatiquement les pages suivantes selon les besoins.
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',
);
// Cette page uniquement ; pour la suivante, rappelez list() avec page: $shares->nextPage.
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
}
```
## Marketplaces de plugins
Cette API lit les [marketplaces](https://platform.claude.com/docs/fr/manage-claude/plugins-api#marketplaces) et définit le paramètre d'installation par défaut d'une marketplace de l'organisation ; les marketplaces elles-mêmes sont créées, connectées à un dépôt et supprimées dans claude.ai.
```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"
}
```
| Champ | Description |
| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `name` | Le nom de la marketplace. Fixe pendant toute sa durée de vie. |
| `owner` | Même forme que sur le plugin. |
| `source` | `manual`, `github`, `gitlab` ou `public_git`. Consultez [Marketplaces](https://platform.claude.com/docs/fr/manage-claude/plugins-api#marketplaces). |
| `sync_status` | Résultat de la synchronisation la plus récente : `success`, `in_progress`, `failed_content`, `failed_transient`, `failed_auth` ou `failed_limits`. `null` jusqu'à la première tentative de synchronisation, ce qui n'arrive jamais pour une marketplace dont la source est `manual`. |
| `last_sync_ended_at` | Moment où la tentative de synchronisation la plus récente s'est terminée, quel qu'en soit le résultat ; pour un dépôt connecté qui n'a pas encore été synchronisé, moment où la marketplace a été créée. `null` pour une marketplace qui n'est pas synchronisée. |
| `last_sync_read_sha` | Le commit que la dernière synchronisation a lu depuis le dépôt. Pas nécessairement le commit dont proviennent les versions servies. `null` pour une marketplace qui n'est pas synchronisée. |
| `default_installation_preference` | Marketplaces de l'organisation : la valeur à l'échelle de l'organisation pour chaque plugin qu'elle contient sans paramètre propre (`not_available` si elle n'a jamais été définie). Marketplaces personnelles : `null`. |
Un `marketplace_id` dépourvu du préfixe `marketplace_` renvoie `400`. Un identifiant qui porte le préfixe mais ne se résout pas, ou qui appartient à une autre organisation, renvoie `404`.
### Lister les marketplaces
`GET /v1/organizations/plugin_marketplaces` liste les marketplaces de votre organisation et les marketplaces personnelles des membres, triées par `created_at` décroissant. Utilisez-le pour trouver l'ID d'une marketplace, afin de filtrer la liste des plugins par celle-ci ou d'y téléverser, avant même qu'elle ne contienne un plugin. La marketplace de bibliothèque apparaît dès que quelque chose y a été créé pour la première fois, dans claude.ai ou via cette API. Filtrez par `owner_type` (`organization` ou `user`) et par `source`. `limit` est compris entre 1 et 1 000. Nécessite la portée `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"
)
# Récupère automatiquement les pages suivantes selon les besoins.
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,
);
// Cette page uniquement ; pour la suivante, rappelez list() avec page: $marketplaces->nextPage.
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
```
### Obtenir une marketplace
`GET /v1/organizations/plugin_marketplaces/{marketplace_id}` renvoie une marketplace. Nécessite la portée `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}"
```
### Définir le paramètre d'installation par défaut d'une marketplace
`POST /v1/organizations/plugin_marketplaces/{marketplace_id}` définit le paramètre d'installation par défaut d'une marketplace appartenant à l'organisation. Chaque plugin de la marketplace sans paramètre propre à l'échelle de l'organisation indique cette valeur par défaut comme son `organization_installation_preference`, y compris les plugins ajoutés ultérieurement. Cela fonctionne pour les marketplaces `manual` et synchronisées ; la marketplace personnelle d'un membre renvoie `403`. Le seul champ modifiable est `default_installation_preference`, et il est obligatoire. Il ne peut pas être redéfini sur `null` : une fois qu'une marketplace a une valeur par défaut, elle en conserve une, comme dans claude.ai. Une modification est enregistrée sous la forme d'un seul événement `marketplace_updated`, sans événement par plugin, et n'altère le `updated_at` d'aucun plugin. Définir la valeur déjà définie ne change rien, à une exception près : une marketplace dont la valeur par défaut n'a jamais été définie indique `not_available` mais ne détient aucun paramètre, de sorte que sa première écriture (même `not_available`) compte comme une modification. Renvoie la marketplace. Nécessite la portée `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}"
```
### Valider le contenu d'une marketplace
Deux points de terminaison indiquent ce que ferait une synchronisation du contenu de marketplace fourni, sans rien connecter ni stocker : `POST /v1/organizations/plugin_marketplaces/validate_repository` lit un dépôt GitHub public, et `POST /v1/organizations/plugin_marketplaces/validate_archive` lit un `.zip` du répertoire de la marketplace que vous téléversez. Les deux renvoient le même rapport : si `marketplace.json` est bien formé, quels plugins seraient ignorés et pourquoi, et quels plugins seraient synchronisés avec une partie de leur contenu omise. Les vérifications sont celles qu'exécute une véritable synchronisation. Les problèmes liés au contenu sont signalés dans le rapport, et non sous forme d'erreurs HTTP : la requête réussit avec `valid: false`, même lorsque le dépôt ou l'archive ne peut pas du tout être lu. Une validation compte comme une lecture, et les deux points de terminaison sont en outre limités ensemble à 10 validations par minute par organisation (consultez [Limitation de débit](https://platform.claude.com/docs/fr/manage-claude/plugins-api#rate-limiting)) ; ils n'enregistrent rien dans l'Activity Feed. Une validation peut prendre jusqu'à 120 secondes avant de renvoyer une réponse ; définissez donc le délai d'expiration de votre client au-delà de cette valeur. Les deux points de terminaison nécessitent la portée `read:plugins` ou `write:plugins` (`read:org_audit` et `read:compliance_org_data` ne les accordent pas).
Le dépôt, ainsi que toute source de plugin située en dehors de celui-ci sur GitHub, sont lus de manière anonyme ; un dépôt privé ou une source de plugin privée est donc signalé comme introuvable. Les sources de plugin hébergées ailleurs que sur GitHub ne sont pas récupérées ; un tel plugin reçoit normalement un avertissement `marketplace_validate_source_not_checked` et est vérifié lorsque la marketplace est effectivement synchronisée. Si le dépôt est, ou si l'archive désigne, une marketplace qu'Anthropic synchronise dans chaque organisation, des règles plus strictes s'appliquent : chaque source de plugin située en dehors de la marketplace doit être épinglée à un SHA de commit complet, les sources non épinglées ou hébergées sur un hôte non pris en charge sont signalées comme des erreurs de plugin, et la branche lue est par défaut celle depuis laquelle cette marketplace est synchronisée.
`validate_repository` accepte un corps JSON avec deux champs : `repository_url`, l'URL `https://` d'un dépôt public sur github.com (obligatoire), et `ref`, un nom de branche ou un SHA de commit complet de 40 caractères (facultatif ; lorsqu'il est omis ou `null`, la branche qu'une synchronisation lirait, généralement la branche par défaut du dépôt). `validate_archive` accepte un corps `multipart/form-data` avec exactement une partie, `archive`, envoyée en tant que partie fichier avec un nom de fichier : un `.zip` du répertoire de la marketplace, de 32 Mo au maximum, dont le contenu se trouve à la racine ou est enveloppé dans un seul dossier (comme le produit un téléchargement depuis un hôte Git), avec une compression DEFLATE ou STORE uniquement. Aucun autre champ de formulaire n'est accepté.
Valider un dépôt public sur une branche :
```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"
}
]
}
]
}
```
| Champ | Description |
| --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `valid` | `true` lorsque `marketplace.json` est bien formé et qu'aucun plugin ne serait ignoré. Les avertissements ne le rendent pas `false`. |
| `ref` | La branche qui a été lue, par son nom ; `null` lorsqu'aucune branche n'a été nommée et que la branche par défaut a été lue, pour un SHA de commit, ou pour une archive. |
| `commit_sha` | Le commit qui a été validé. Pour une archive téléchargée depuis un hôte Git, le commit que l'hôte a enregistré dans le champ de commentaire du fichier ZIP, le cas échéant (non vérifié). |
| `total_plugin_count` | Le nombre de plugins que déclare `marketplace.json` ; `0` lorsqu'il n'a pas pu être lu. |
| `manifest_error`, `manifest_error_code` | Définis lorsque rien n'a pu être validé : la source n'a pas pu être lue, ou `marketplace.json` est manquant, mal formé ou dépasse une limite. Une validation qui ne s'est pas terminée dans les 120 secondes indique `manifest_error_code: "marketplace_validate_deadline_exceeded"`. |
| `plugin_errors` | Un `{name, error, error_code}` par plugin qu'une synchronisation ignorerait. |
| `plugin_warnings` | Un `{name, warnings: [{message, error_code}]}` par plugin qui serait synchronisé avec une partie de son contenu omise. |
Validez plutôt une copie locale du répertoire de la marketplace, sous forme de `.zip` ; la réponse est le même rapport :
```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();
// Passez un Path afin que la partie `archive` soit envoyée avec un nom de fichier, ce que cet endpoint exige.
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}"
```
Les problèmes liés au contenu ne font jamais échouer la requête. Outre les réponses communes à tous les points de terminaison (une erreur `403` pour une clé qui ne dispose que de `read:org_audit` ou `read:compliance_org_data` ; consultez [Réponses d'erreur](https://platform.claude.com/docs/fr/manage-claude/plugins-api#error-responses) et [Limitation de débit](https://platform.claude.com/docs/fr/manage-claude/plugins-api#rate-limiting)), la requête elle-même peut échouer avec :
| Statut | Cause | Que faire |
| ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- |
| 400 | Sur `validate_repository` : le corps n'est pas un objet JSON ; `repository_url` est manquant, dépasse 2 048 caractères, contient des identifiants ou n'est pas de la forme `https://github.com/{owner}/{repo}` (un suffixe `.git` est accepté ; un autre hôte, un chemin plus long tel que le `/tree/main` d'une page de branche, ou un port autre que 443 ou 80 ne l'est pas) ; `ref` est vide, dépasse 255 caractères, contient `..` ou contient un caractère autre que des lettres ASCII, des chiffres, `.`, `_`, `-`, `+` et `/` ; ou un autre champ est présent. Un `ref` qui passe ces vérifications mais désigne une branche que le dépôt ne possède pas n'est pas refusé : la requête réussit avec `valid: false` et `manifest_error` indique que la branche est introuvable. Sur `validate_archive` : le corps n'est pas au format `multipart/form-data`, la partie `archive` est manquante, répétée ou n'est pas envoyée en tant que partie fichier avec un nom de fichier, ou un autre champ de formulaire est présent. | Corrigez la requête et renvoyez-la. |
| 413 | Sur `validate_archive` : la partie `archive`, ou la longueur de corps déclarée de la requête, dépasse 32 Mo. | Validez plutôt le dépôt par URL, ou réduisez l'archive. |
#### Codes de rapport
Chaque constat d'un rapport possède un code stable : `manifest_error_code` lorsque rien n'a pu être validé, `error_code` sur chaque entrée `plugin_errors`, et `error_code` sur chaque avertissement. Lorsqu'un plugin présente plusieurs problèmes, `error_code` est celui du premier et `error` regroupe leurs messages. De nouveaux codes peuvent être ajoutés ; un `manifest_error_code` non reconnu signifie toujours que le contenu n'a pas pu être validé, un code non reconnu sur une entrée `plugin_errors` signifie toujours que le plugin serait ignoré, et un code non reconnu sur un avertissement signifie toujours que le plugin serait synchronisé. Ces codes indiquent des conditions transitoires, de sorte que la même requête peut réussir plus tard : `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` et, généralement, `marketplace_validate_deadline_exceeded`.
## Valeurs non reconnues
Chaque valeur de chaîne de cette page (types de composants, `reach`, champs d'analyse, `source` de marketplace, codes d'erreur) peut recevoir de nouvelles valeurs à tout moment. Traitez une valeur que vous ne reconnaissez pas comme vous le feriez pour toute chaîne inconnue, plutôt que de provoquer un échec.
## Limitation de débit
Les requêtes de lecture (chaque point de terminaison `GET` de cette page) partagent une « rate limit » (limite de débit) de **300 requêtes par minute** par organisation, et les requêtes d'écriture (création d'un plugin ou d'une version, modification de la version servie, suppression, définition ou suppression d'un paramètre d'installation, et mise à jour d'une marketplace) partagent une limite de **60 requêtes par minute** par organisation. Une validation de marketplace (via l'un ou l'autre point de terminaison) compte comme une lecture, et les validations sont en outre limitées à 10 par minute par organisation sur l'ensemble des deux points de terminaison ; les deux limites sont vérifiées avant la lecture du corps de la requête. Ces limites sont comptabilisées sur l'ensemble des clés de votre organisation et sont distinctes des autres limites de l'Admin API de votre organisation. Les requêtes dépassant une limite renvoient **429 Too Many Requests** avec un en-tête `retry-after`. Les réponses incluent des en-têtes `anthropic-ratelimit-requests-*` pour la limite applicable (pour la validation de marketplace, sa limite de 10 par minute ; pour une réponse `429`, la limite qui a refusé la requête).
Un téléversement, une modification de la version servie ou une validation peut également renvoyer `429` avec `retry-after` lorsque le service n'a brièvement pas la capacité d'en traiter un autre, et un téléversement renvoie `429` lorsque votre organisation a dépassé son débit d'analyse de contenu. Gérez tous ces cas de la même manière : attendez la durée indiquée par `retry-after`, puis réessayez. Indépendamment de ces limites, envoyez les écritures de paramètres d'installation pour un même plugin une à la fois : lorsque plusieurs arrivent en même temps, certaines peuvent recevoir une réponse `503` avec `x-should-retry: true`, et celles-ci peuvent être renvoyées sans risque après une seconde ou deux (consultez [Définir un paramètre d'installation](https://platform.claude.com/docs/fr/manage-claude/plugins-api#set-an-installation-setting)).
## Pagination
Les points de terminaison de liste utilisent un **curseur opaque**. La première requête renvoie jusqu'à `limit` lignes ainsi qu'un curseur `next_page` ; transmettez le curseur tel quel comme paramètre `page` lors de la requête suivante, et répétez jusqu'à ce que `next_page` soit `null`. Traitez la chaîne du curseur comme opaque : ne l'analysez pas, ne la modifiez pas et ne la construisez pas vous-même. [Lister les plugins](https://platform.claude.com/docs/fr/manage-claude/plugins-api#list-plugins) peut renvoyer une page contenant moins de `limit` plugins, voire aucun, alors que `next_page` est toujours défini ; continuez donc à demander des pages jusqu'à ce que `next_page` soit `null`. Les itérateurs de liste des SDK Python, TypeScript, C#, Go, Java et Ruby ainsi que la CLI (sauf avec `--format raw`) le font pour vous. Ils demandent la page suivante tant que `next_page` est défini, de sorte qu'une page courte ou vide ne les arrête pas. En PHP et avec curl, demandez chaque page vous-même et transmettez son `next_page` comme `page`.
`limit` vaut 20 par défaut et a un minimum de 1. Le maximum est de 100 pour les plugins, les paramètres d'installation et les partages, et de 1 000 pour les versions et les marketplaces. Chaque liste est triée de la plus récente à la plus ancienne.
## Réponses d'erreur
Les réponses d'erreur suivent la structure standard documentée dans [Erreurs](https://platform.claude.com/docs/fr/api/errors). Indiquez le `request_id` figurant dans le corps de la réponse lorsque vous contactez le support.
| Statut | Signification |
| ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 400 | Entrée non valide, ou l'opération ne s'applique pas à ce plugin ou à cette marketplace (consultez la section de chaque endpoint). Également renvoyé pour un paramètre de requête que l'endpoint ne reconnaît pas, et pour une organisation qui n'est pas une organisation Claude Enterprise (`this endpoint is not supported for this organization type`). |
| 401 | En-tête `x-api-key` manquant, ou clé non reconnue. |
| 403 | La clé ne dispose pas de la portée requise, ou la requête téléverse vers le plugin ou la marketplace personnelle d'un membre, en modifie la version servie ou en définit la valeur par défaut. (La suppression du plugin d'un membre est autorisée.) |
| 404 | Ressource introuvable. Également renvoyé lorsque la requête omet la valeur `anthropic-beta`, ou lorsque l'API n'est pas activée pour votre organisation, de sorte que les endpoints apparaissent comme inexistants. |
| 409 | Un nom est déjà pris, une analyse de contenu est toujours en cours, ou un téléversement conflictuel est en cours. |
| 413 | Le corps de la requête dépasse la limite de taille : 200 Mo pour un téléversement, 32 Mo pour la validation d'une marketplace. |
| 429 | Dépassement de la « rate limit » (limite de débit). Consultez [Limitation du débit](https://platform.claude.com/docs/fr/manage-claude/plugins-api#rate-limiting). |
| 500 | Erreur interne. |
| 503 | Temporaire. Également renvoyé lorsque plusieurs écritures de paramètres d'installation pour un même plugin arrivent en même temps ; envoyez-les une par une. Réessayez avec un « backoff » (délai d'attente progressif), sauf pour `registration_pending` (consultez le tableau suivant). |
Lorsqu'un même statut a plusieurs causes que vous traiteriez différemment, l'erreur contient également `error.details.error_code`, ainsi que `error.details.plugin_id` ou `error.details.plugin_version_id` lorsque la cause en implique un :
```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` | Statut | Signification et marche à suivre |
| ----------------------------------------------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `plugin_name_taken` | 409 | Un plugin portant ce nom existe déjà dans la marketplace. `details.plugin_id` correspond à ce plugin. Si vous relancez une création dont vous avez perdu la réponse, poursuivez avec ce plugin. Lorsque `plugin_id` est absent, le nom est détenu par une skill autonome : téléversez sous un autre nom, ou supprimez la skill dans claude.ai. |
| `skill_name_taken` | 409 | Le plugin se trouve dans la marketplace de la bibliothèque et l'une de ses skills porte le même nom qu'une skill d'organisation (une skill qu'un administrateur a téléversée pour l'ensemble de l'organisation dans claude.ai). `details.skill_name` indique son nom. Renommez ou supprimez l'une des deux. |
| `registration_pending` | 503 | Les fichiers ont été stockés, mais les skills du plugin n'ont pas encore pu être mises à la disposition des membres. Consultez [Nouvelles tentatives de téléversement](https://platform.claude.com/docs/fr/manage-claude/plugins-api#retrying-uploads). |
| `scan_pending` | 409 | L'analyse de contenu de la version est toujours en cours. Réessayez une fois qu'elle est terminée. |
| `scan_failed` | 400 | L'analyse de contenu de la version a échoué, a rencontré une erreur ou n'a abouti à aucun verdict ; la version ne peut donc pas être servie. Choisissez une autre version. |
| `cmek_key_disabled`, `cmek_key_network_blocked` | 400 | La clé de chiffrement gérée par le client de votre organisation n'est pas disponible. Consultez [Clés de chiffrement gérées par le client](https://platform.claude.com/docs/fr/manage-claude/plugins-api#customer-managed-encryption-keys). |
De nouveaux codes peuvent être ajoutés. Traitez un code que vous ne reconnaissez pas de la même manière que son statut.
### Nouvelles tentatives de téléversement
Aucun point de terminaison n'accepte d'`Idempotency-Key`. La modification de la version servie, la définition d'un paramètre d'installation et la définition d'une valeur par défaut de marketplace peuvent être répétées sans risque. Une suppression répétée, ou un retrait répété d'un paramètre d'installation, renvoie `404`.
Un téléversement qui renvoie une erreur n'a rien stocké, à une exception près : `503` avec `error_code: "registration_pending"`. Après avoir stocké les fichiers d'un téléversement, le serveur enregistre les skills de la nouvelle version auprès de claude.ai, ce qui les rend utilisables par les membres ; `registration_pending` signifie que les fichiers ont été stockés mais que cette dernière étape n'a pas abouti. Téléverser à nouveau les mêmes fichiers la termine (et stocke une version supplémentaire, identique) :
* Sur `POST /v1/organizations/plugins`, le plugin *a bien été* créé, et la réponse contient `x-should-retry: false` : ne renvoyez pas la création (un renvoi retourne `409 plugin_name_taken`) ; téléversez plutôt les mêmes fichiers en tant que version de `details.plugin_id`.
* Sur `POST /v1/organizations/plugins/{plugin_id}/versions`, la version *a bien été* stockée (`details.plugin_version_id`) ; renvoyez la même requête lorsque la réponse contient `x-should-retry: true`, et ne le faites pas lorsqu'elle contient `false`.
Si la réponse d'une création est perdue, relancez-la : la nouvelle tentative renvoie `409 plugin_name_taken` avec l'ID du plugin dans `details.plugin_id`, et vous poursuivez avec ce plugin. Relancer une création de version dont la réponse a été perdue stocke une seconde version identique. Pour éviter cela, enregistrez le `latest_version_id` du plugin avant chaque téléversement ; si une réponse est perdue, lisez le plugin et ne relancez que si `latest_version_id` n'a pas changé.
## Événements du flux d'activité
Chaque écriture effectuée via cette API est enregistrée dans le [flux d'activité de l'API Compliance](https://platform.claude.com/docs/fr/manage-claude/compliance-activity-feed) de votre organisation, attribuée à la clé API en tant qu'`api_actor` portant son ID `apikey_`. Le même acteur apparaît dans `created_by` sur les plugins et les versions que la clé crée.
| Événement | Émis lorsque |
| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `claude_plugin_created` | Un plugin est créé par un téléversement (ici ou dans claude.ai) ou par une demande de publication acceptée. Un plugin créé par une synchronisation Git émet uniquement `claude_plugin_version_created`. |
| `claude_plugin_version_created` | Une version est stockée. Les versions stockées par une synchronisation Git sont attribuées à un `system_actor`. |
| `claude_plugin_updated` | Une nouvelle version est téléversée vers un plugin existant. |
| `claude_plugin_served_version_updated` | La version servie change. |
| `claude_plugin_deleted` | Un plugin est supprimé individuellement, ici ou dans claude.ai. |
| `plugin_installation_preference_updated` | Un paramètre d'installation est défini ou retiré. |
| `marketplace_created` | Le premier téléversement crée la marketplace de la bibliothèque. |
| `marketplace_updated` | Le paramètre d'installation par défaut d'une marketplace change, ou un administrateur ou un propriétaire lance une synchronisation dans claude.ai. |
| `marketplace_deleted` | Une marketplace est supprimée dans claude.ai avec ses plugins (aucun événement par plugin). |
| `claude_plugin_archive_accessed` | L'archive d'un plugin appartenant à un membre est téléchargée. |
| `claude_plugin_security_scan_completed` | Une analyse de contenu se termine. |
Les ID de plugin, de version et de marketplace figurant dans ces événements sont les mêmes ID que ceux renvoyés par cette API. `plugin_installation_preference_updated` identifie le plugin par son `name` et son `marketplace_id` plutôt que par son `id`.
La modification de la valeur par défaut d'une marketplace enregistre un seul événement `marketplace_updated` et aucun événement par plugin, même si elle modifie la valeur de chaque plugin qui hérite de cette valeur par défaut. Les lectures ne sont pas enregistrées, à l'exception des téléchargements de l'archive d'un plugin appartenant à un membre. Une écriture qui ne modifie rien n'enregistre rien.
Les partages accordés ou retirés dans claude.ai apparaissent dans le flux sous forme d'événements `role_assignment_granted` et `role_assignment_revoked`. Cette API ne signale pas les suppressions : un plugin supprimé est simplement absent de la liste suivante. Un plugin retiré par une synchronisation Git, par la suppression de sa marketplace (un seul événement `marketplace_deleted`), ou par la suppression du compte d'un membre ou de l'organisation n'émet aucun événement par plugin ; listez donc à nouveau l'inventaire complet périodiquement pour détecter les retraits.
## Clés de chiffrement gérées par le client
Si votre organisation utilise une [« customer-managed encryption key » (clé de chiffrement gérée par le client)](https://platform.claude.com/docs/fr/manage-claude/cmek), les champs `description`, `release_notes` et `components` ainsi que les fichiers d'une version sont chiffrés avec celle-ci. Tant que la clé n'est pas disponible :
* Les lectures et les listes réussissent toujours, avec `description`, `release_notes` et `components` renvoyés à `null`.
* Les téléchargements d'archives, les créations, les créations de versions et les modifications de la version servie renvoient `400` avec `cmek_key_disabled` ou `cmek_key_network_blocked`.
* La suppression d'un plugin dans la marketplace de la bibliothèque renvoie `400 cmek_key_disabled` et ne supprime rien, car ses skills doivent d'abord être retirées de claude.ai, ce qui nécessite la clé. Les autres suppressions, les paramètres d'installation et les valeurs par défaut des marketplaces fonctionnent normalement.
Le rétablissement de la clé lève toutes ces restrictions.
## Voir aussi
Où votre propriétaire principal crée une clé dotée de portées.
Les endpoints de groupes qui fournissent les ID `rbac_group_` utilisés dans les paramètres d'installation.
Où sont enregistrées les écritures de plugins et les téléchargements d'archives de membres.
Rapports d'utilisation des plugins et des skills pour Claude Enterprise.