---
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 de faire ce qui suit :

* Inventorier les plugins de votre organisation Claude Enterprise
* Publier des plugins et de nouvelles versions depuis vos propres pipelines
* Choisir quelle version est servie aux membres
* Contrôler qui peut utiliser chaque plugin
* Télécharger les fichiers des plugins pour les examiner
* Vérifier une marketplace 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).

<Check>
  **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.
</Check>

<Note>
  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 préparation 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` (le 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.
</Note>

## Points de terminaison

L’API expose 18 points de terminaison répartis sur cinq ressources :

| Ressource                                                                                                                                                                                                  | Points de terminaison                                                                                                                                                                                                                                                                                                     |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Plugins :** lister 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`<br />`POST /v1/organizations/plugins`<br />`GET /v1/organizations/plugins/{plugin_id}`<br />`POST /v1/organizations/plugins/{plugin_id}`<br />`DELETE /v1/organizations/plugins/{plugin_id}`                                                                                              |
| **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`<br />`POST /v1/organizations/plugins/{plugin_id}/versions`<br />`GET /v1/organizations/plugins/{plugin_id}/versions/{version}`<br />`GET /v1/organizations/plugins/{plugin_id}/versions/{version}/content`                                                           |
| **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`<br />`POST /v1/organizations/plugins/{plugin_id}/installation_settings/{target}`<br />`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`<br />`GET /v1/organizations/plugin_marketplaces/{marketplace_id}`<br />`POST /v1/organizations/plugin_marketplaces/{marketplace_id}`<br />`POST /v1/organizations/plugin_marketplaces/validate_repository`<br />`POST /v1/organizations/plugin_marketplaces/validate_archive` |

Les plugins publiés par Anthropic ne sont pas 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é Admin API avec la portée `read:plugins`, la portée `write:plugins`, ou les deux, dans [claude.ai > Paramètres de l’organisation > API](https://claude.ai/admin-settings/api-access). Consultez [Créer une clé pour une organisation Claude Enterprise](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: 2026-10-21` et `anthropic-beta: ce-plugins-2026-09-01`.

En Python, TypeScript, C#, Go, Java, PHP et Ruby, le SDK expose 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 lisent la clé Admin API depuis la variable d’environnement `ANTHROPIC_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 :

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

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

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

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

  # 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
  ```
</CodeGroup>

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

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 dans laquelle elles ont été créées. Certaines entreprises possèdent plusieurs organisations Claude liées sous une organisation parente. Une clé `read:org_audit` ou `read:compliance_org_data` [créée pour toutes les organisations liées](https://platform.claude.com/docs/fr/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization) peut également lire toute organisation liée ayant accès à cette API. Pour en lire une, transmettez son ID 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. Une clé qui n’a pas d’organisation propre doit toujours transmettre `organization_id`. Un `404` signifie que l’organisation désignée ne dépend pas du parent de la clé ou que l’API n’est pas disponible pour elle ; 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 reçoit `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 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 que lorsque son `content_scan` indique `completed` avec `pass` ou `warn`. Pendant qu’une version attend, `served_version_id` désigne une version antérieure à `latest_version_id`. N’interrogez pas 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étermine quand chaque build est servi, épinglez le plugin une fois en définissant `served_version_id` sur sa version actuelle ; ensuite, promouvez chaque build que vous souhaitez servir. Avec l’analyse de contenu activée, ce premier épinglage renvoie `409 scan_pending` tant que le `content_scan` de la version actuelle indique `processing`, et `400 scan_failed` si l’analyse indique `fail`, `unknown` ou `errored` (`warn` est accepté). Un plugin épinglé ne peut 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 pour chaque 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 ces règles :

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 Pilote a `available`, les membres de Pilote 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`. Tant que l’analyse est `processing` ou `errored`, ou indique `fail` ou `unknown`, 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 `content_scan` indique `completed` avec `pass` ou `warn`. 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 voir ; l’objet plugin n’affiche que l’analyse de sa version servie. Tant que l’analyse est activée, changer la version servie pour une version dont le `content_scan` indique `processing` renvoie `409 scan_pending`, et la changer pour une version dont l’analyse indique `fail`, `unknown` ou `errored` renvoie `400 scan_failed`.

#### Analyses échouées autorisées dans claude.ai

Dans claude.ai, les propriétaires de l’organisation peuvent autoriser une version dont l’analyse a échoué. Les membres dont le [rôle personnalisé](https://platform.claude.com/docs/fr/manage-claude/user-management#custom-roles) peut gérer les **Bibliothèques** le peuvent également. Cette API peut alors indiquer cette analyse comme `completed` avec `warn` et le `reason` de l’analyse échouée. Dans ce cas, les règles applicables à `warn` s’appliquent : la version peut être servie aux membres, et vous pouvez en faire la version servie. Rien dans la réponse n’indique qu’elle a été autorisée ; un `warn` est donc soit un avertissement, soit une analyse échouée qui a été autorisée. Autoriser une version dont l’analyse indique `warn` ne modifie pas son `content_scan`. Lorsqu’une version cesse d’être autorisée, cette API indique le verdict de sa dernière analyse terminée. Une version servie dont l’analyse indique alors `fail` ou `unknown` est retenue et n’est pas servie aux membres.

### 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, un workflow (un script que Claude Code peut exécuter ; tout fichier situé dans un dossier `workflows/` à la racine du plugin est considéré comme tel), 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 workflow, 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, les workflows 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é. La valeur est normalement déterminée lorsqu’une version est stockée, selon les règles en vigueur à ce moment-là. Une version plus ancienne peut donc être `contained` alors que les mêmes fichiers stockés aujourd’hui seraient `privileged`.

### 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. Une `description` que le manifeste reprend de ce `SKILL.md` est tronquée à ses 500 premiers caractères.
* `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 `<example>`. 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.
* Un téléversement qui crée un plugin renvoie `400` dès que la marketplace contient 1 000 plugins. Les plugins que cette API ne liste pas sont également comptés, de sorte que la limite peut être atteinte alors que [Lister les plugins](https://platform.claude.com/docs/fr/manage-claude/plugins-api#list-plugins) en affiche moins de 1 000 dans cette marketplace. Anthropic peut relever la limite de 5 000 fichiers.

## 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éterminer quand 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": "<the new version's 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` (consultez [Groupes et rôles dans la gestion des utilisateurs](https://platform.claude.com/docs/fr/manage-claude/user-management#groups-and-roles)). Les étapes suivantes nécessitent `write:plugins`, qui n’agit que sur l’organisation dans laquelle sa clé a été créée ; ainsi, dans une entreprise comptant plusieurs organisations liées, créez une seule clé dans l’organisation qui contient 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.

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

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

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

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

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

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

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

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

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

     AnthropicClient client = new();

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

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

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

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

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

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

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

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

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

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

     $client = new Client();

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

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

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

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

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

   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 dont l’analyse de contenu indique `warn`, `fail` ou `unknown`.

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 : une modification de `content_scan` seul, comme un verdict 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. C’est aussi la relecture complète de la liste 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` est `remote` (il déclare un serveur MCP ou une CLI), ou dont le `content_scan.assessment` est `warn`, `fail` ou `unknown`. Un `warn` peut aussi être une [analyse échouée qui a été autorisée dans claude.ai](https://platform.claude.com/docs/fr/manage-claude/plugins-api#failed-scans-allowed-in-claude-ai). N’excluez `warn` que si vous acceptez toutes les analyses échouées qui y sont autorisées. 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 aucun. `description` peut être la `description` d’une skill plutôt que celle du manifeste (décrit après ce tableau). `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 (rayon d’action)](https://platform.claude.com/docs/fr/manage-claude/plugins-api#reach).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `updated_at`                                                                             | Change lorsque la version servie change, lorsque le plugin devient é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 une modification de `content_scan` seul.                                                                                                                                                                                                                                                              |

`description` n’est pas toujours celle du manifeste. Une `description` que le manifeste reprend d’un `SKILL.md` de premier niveau est tronquée à ses 500 premiers caractères (voir [Exigences de téléversement](https://platform.claude.com/docs/fr/manage-claude/plugins-api#upload-requirements)). Si la `description` du manifeste correspond aux 500 premiers caractères d’exactement une `description` de skill distincte dans `components`, l’API renvoie plutôt cette `description` de skill. Par conséquent :

* Une `description` que vous lisez peut dépasser 500 caractères, la limite pour un manifeste téléversé. Un téléversement dont le `plugin.json` définit une telle `description` renvoie `400`.
* Dans les [fichiers que vous téléchargez](https://platform.claude.com/docs/fr/manage-claude/plugins-api#download-a-versions-files), `.claude-plugin/plugin.json` peut avoir une `description` différente, ou aucune.

L’objet `content_scan` :

| Champ        | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `status`     | `processing` pendant l’exécution de l’analyse, `completed` lorsqu’elle est terminée, ou `errored` lorsqu’elle n’a pas pu se terminer (ou, occasionnellement, lorsque son résultat n’a pas pu être lu pour cette réponse, auquel cas une lecture ultérieure pourrait le signaler). L’analyse terminée la plus récente, s’il y en a une, est signalée. Une version dont le `status` 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 trouvé), `warn` (quelque chose a été trouvé qui ne bloque pas l’utilisation, ou une [analyse échouée qui a été autorisée dans claude.ai](https://platform.claude.com/docs/fr/manage-claude/plugins-api#failed-scans-allowed-in-claude-ai)), `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.                                                                                                                                                                                                                                                                                                                                                    |

<Accordion title="Valeurs de raison de l’analyse de contenu">
  | `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.                                                                     |
</Accordion>

Un `plugin_id` dépourvu du préfixe `plugin_` renvoie `400`. Un `plugin_id` qui porte le préfixe mais ne figure pas dans l’inventaire de votre organisation renvoie `404`.

### Lister les plugins

`GET /v1/organizations/plugins` liste les plugins de votre organisation, dans les places de marché de l’organisation et dans les places de marché personnelles des membres, triés par `created_at` décroissant. Filtrez par `owner_type` (`organization` ou `user`), `owner_user_id` (un ID préfixé par `user_`, qui trouve les plugins d’un membre, y compris après que le membre a quitté 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, pas 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`.

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

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

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

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

  # 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
  ```
</CodeGroup>

### Créer un plugin

`POST /v1/organizations/plugins` crée un plugin appartenant à l’organisation et sa première version en un seul appel ; la version devient la version servie. Le corps est en `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 place de marché `manual` appartenant à l’organisation, ou par défaut votre place de marché de bibliothèque, qui est créée lors de la première utilisation) et `release_notes` (jusqu’à 5 000 caractères, affichés dans l’historique des versions de claude.ai et renvoyés avec la version). Les champs `name`, `display_name`, `description` et `manifest_version` du plugin proviennent des fichiers téléversés, 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 :

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

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

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

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

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

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

  const client = new Anthropic();

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

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

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

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

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

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

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

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

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

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

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

      // 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.<List<InputStream>>builder()
          .value(List.of(Files.newInputStream(Path.of("dist/sales-toolkit.zip"))))
          .filename("sales-toolkit.zip")
          .contentType("application/octet-stream")
          .build();
      var params = PluginCreateParams.builder()
          .files(archive)
          .releaseNotes("First release")
          .build();
      var plugin = client.beta().organization().plugins().create(params);

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

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

  $client = new Client();

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

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

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

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

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

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

Téléverser des fichiers individuels dans une place de marché 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é uniquement sous son nom de base signifie que le manifeste est introuvable. Les SDK TypeScript et Java ainsi que la CLI `ant` ne peuvent pas encore joindre de fichiers sous un chemin, c’est pourquoi ces exemples téléversent plutôt le plugin sous la forme d’une archive unique dans la place de marché :

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

  ```bash CLI
  # 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 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, comme l'exige le téléversement.
      var archive = MultipartField.<List<InputStream>>builder()
          .value(List.of(Files.newInputStream(Path.of("dist/sales-toolkit.zip"))))
          .filename("sales-toolkit.zip")
          .contentType("application/octet-stream")
          .build();
      var params = PluginCreateParams.builder()
          .files(archive)
          .marketplaceId("marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r")
          .build();
      var plugin = client.beta().organization().plugins().create(params);

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

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

  $client = new Client();

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

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

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

  # 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}"
  ```
</CodeGroup>

Outre un `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 (un `403` lorsque `marketplace_id` est la place de marché 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à 1 000 plugins (voir les [Exigences de téléversement](https://platform.claude.com/docs/fr/manage-claude/plugins-api#upload-requirements)). | Téléversez vers une autre marketplace `manual`, ou modifiez plutôt le dépôt.                                                                                                                                                                                            |
| 409 `plugin_name_taken`    | Le nom est déjà pris dans cette marketplace.                                                                                                                                                           | Téléversez une version vers `details.plugin_id` uniquement s’il s’agit du plugin que vous vouliez mettre à jour, car quelqu’un d’autre a pu le créer. Sinon, ou lorsque `details.plugin_id` est absent, téléversez sous un autre nom (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 en cours, ou un plugin que cette API ne liste pas détient ce nom.                                                              | Réessayez avec un délai d’attente progressif. Si le `409` persiste plus de quelques minutes, téléversez sous un autre nom (modifiez le `name` du manifeste).                                                                                                            |
| 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`.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### Modifier la version servie

`POST /v1/organizations/plugins/{plugin_id}` modifie la version d’un plugin appartenant à l’organisation qui est servie aux membres. Transmettez une version antérieure pour revenir en arrière, ou une version plus récente pour promouvoir une build qui a été stockée sans être servie. Cela épingle le plugin, et un plugin épinglé ne peut pas être désépinglé, ni ici ni dans claude.ai (consultez [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 le retour de la réponse et ne crée pas de version. Lorsque l’analyse de contenu est activée, la version doit pouvoir être servie aux membres (consultez [Analyse de contenu](https://platform.claude.com/docs/fr/manage-claude/plugins-api#content-scanning)). Transmettre la version déjà servie sur un plugin épinglé ne change rien ; la transmettre sur un plugin non épinglé l’épingle sur cette version, 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`.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

## 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 reprennent les champs de version servie du plugin (`display_name`, `description`, `manifest_version`, `content_scan`, `components`, `reach`) pour cette version, plus `release_notes` (tel que fourni avec le téléversement et affiché dans l’historique des versions de claude.ai) et `created_by` (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`.

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

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

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

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

  # 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
  ```
</CodeGroup>

### 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`.

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

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

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

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

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

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

  const client = new Anthropic();

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

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

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

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

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

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

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

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

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

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

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

      // 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.<List<InputStream>>builder()
          .value(List.of(Files.newInputStream(Path.of("dist/sales-toolkit.zip"))))
          .filename("sales-toolkit.zip")
          .contentType("application/octet-stream")
          .build();
      var params = VersionCreateParams.builder()
          .files(archive)
          .releaseNotes("Adds the call-prep command.")
          .build();
      var version = client.beta().organization().plugins().versions()
          .create("plugin_01Hq3vX8kZcN2mB7pR4tY9wL", params);

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

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

  $client = new Client();

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

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

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

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

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

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

Outre un `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 (un `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`.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### 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 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, de sorte que 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 l’ID du plugin et de la 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.

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

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

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

  plugin_id = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
  version_id = "pluginver_01Km7tL4pR9xF5sU2zV3jP6q"

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

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

  const client = new Anthropic();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  // download() 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)
  ```
</CodeGroup>

## 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 plutôt de partages (consultez [Partages de plugins](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 [Groupes dans 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`.

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

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

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

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

  # 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
  ```
</CodeGroup>

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

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

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

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

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

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

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

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

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

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

  AnthropicClient client = new();

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

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

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

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

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

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

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

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

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

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

  $client = new Client();

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

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

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

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

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

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

### 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`.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

## 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`.

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

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

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

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

  # 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
  ```
</CodeGroup>

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

## 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 place de marché 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`.

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

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

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

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

  # 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
  ```
</CodeGroup>

### Obtenir une marketplace

`GET /v1/organizations/plugin_marketplaces/{marketplace_id}` renvoie une marketplace. Nécessite la portée `read:plugins`.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### 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`.

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

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

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

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

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

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

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

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

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

  AnthropicClient client = new();

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

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

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

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

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

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

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

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

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

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

  $client = new Client();

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

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

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

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

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

### Valider le contenu d’une marketplace

Deux points de terminaison indiquent ce que ferait une synchronisation du contenu de marketplace donné, 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 fichier `.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 renvoyé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 être lu du tout. Une validation compte comme une lecture, et les deux points de terminaison sont en outre limités ensemble à 10 validations par minute pour chaque organisation (voir [Limitation du 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, réglez 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).

La validation lit le dépôt de manière anonyme. Elle fait de même pour toute source de plugin qui se trouve sur GitHub mais en dehors du dépôt. Par conséquent, la validation signale un dépôt privé ou une source de plugin privée comme introuvable ou comme nécessitant une connexion à GitHub. Lorsque la validation signale qu’une connexion à GitHub est nécessaire, le code du rapport est `marketplace_repo_sign_in_required`.

La validation ne récupère pas les sources de plugins hébergées ailleurs que sur GitHub. Un plugin disposant d’une telle source reçoit normalement un avertissement `marketplace_validate_source_not_checked` et est vérifié lorsque la marketplace est réellement synchronisée.

La validation applique des règles plus strictes à une marketplace qu’Anthropic synchronise dans chaque organisation. `validate_repository` les applique lorsque le dépôt est une telle marketplace. `validate_archive` les applique lorsque l’archive désigne une telle marketplace. Les règles plus strictes sont les suivantes :

* Chaque source de plugin extérieure à la marketplace doit être épinglée à un SHA de commit complet.
* La validation signale les sources non épinglées et les sources sur des hôtes non pris en charge comme des erreurs de plugin.
* Pour `validate_repository`, la branche lue par la validation est par défaut la branche à partir de laquelle la marketplace se synchronise.

`validate_repository` accepte un corps JSON comportant 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). Lorsque `ref` est omis ou vaut `null`, il prend par défaut la branche qu’une synchronisation lirait, généralement la branche par défaut du dépôt. `validate_archive` accepte du `multipart/form-data` comportant exactement une partie, `archive`, envoyée comme partie fichier avec un nom de fichier. Le fichier est un `.zip` du répertoire de la marketplace, d’au plus 32 Mo, qui utilise uniquement la compression DEFLATE ou STORE. Le contenu de l’archive se trouve à la racine ou est enveloppé dans un seul dossier (comme le produit un téléchargement depuis un hôte Git). Aucun autre champ de formulaire n’est accepté.

Valider un dépôt public sur une branche :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

| 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 en 120 secondes renvoie `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 :

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

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

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

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

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

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

  const client = new Anthropic();

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

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

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

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

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

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

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

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

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

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

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

      // Passez un Path afin que la partie `archive` soit envoyée avec un nom de fichier, ce que ce point de terminaison 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}"
  ```
</CodeGroup>

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 du `multipart/form-data`, la partie `archive` est manquante, répétée, ou n’est pas envoyée comme 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 de `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 de `plugin_errors` signifie toujours que le plugin serait ignoré, et un code non reconnu sur un avertissement signifie toujours que le plugin serait synchronisé. Les codes suivants indiquent des conditions transitoires, de sorte que la même requête pourrait 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 limite de **300 requêtes par minute** pour chaque organisation. Les requêtes d’écriture (création d’un plugin ou d’une version, modification de la version servie, suppression, définition ou retrait d’un paramètre d’installation, et mise à jour d’une marketplace) partagent une limite de **60 requêtes par minute** pour chaque 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 pour chaque 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. Une lecture qui transmet `organization_id` est décomptée de la limite de l’organisation dans laquelle la clé a été créée, ou de celle de l’organisation parente si la clé n’a pas d’organisation propre. Les requêtes qui dépassent 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 qui s’applique (pour la validation de marketplace, sa limite de 10 par minute ; pour un `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 le format standard documenté dans [Erreurs de l’API Claude](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 point de terminaison). Également renvoyé pour un paramètre de requête que le point de terminaison 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 points de terminaison apparaissent comme inexistants.                                                                                                                                                     |
| 409    | Un nom est déjà pris, le `content_scan` d’une version indique `processing`, 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    | La marketplace détient déjà ce nom. `details.plugin_id` correspond au plugin qui le détient, et il a pu être créé par quelqu’un d’autre. Pour savoir qui, [obtenez le plugin](https://platform.claude.com/docs/fr/manage-claude/plugins-api#get-a-plugin) et lisez son `created_by`, qui vaut `null` lorsqu’aucun créateur n’est enregistré. N’y téléversez des versions que s’il s’agit bien du plugin que vous vouliez mettre à jour. Sinon, ou lorsque `plugin_id` est absent, téléversez sous un autre nom. |
| `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    | Le `content_scan` de la version indique `processing`. Réessayez une fois l’analyse terminée.                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `scan_failed`                                   | 400    | Le `content_scan` de la version indique `fail`, `unknown` ou `errored`, elle 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).                                                                                                                                                                                                                                                                     |
| `unsupported_charset`                           | 400    | Sur un téléversement ou `validate_archive`, l’en-tête `Content-Type` de la requête indique un jeu de caractères autre que UTF-8, ISO-8859-1 ou US-ASCII. Envoyez la requête sans jeu de caractères, ou avec l’un de ceux-ci.                                                                                                                                                                                                                                                                                    |

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, renvoyez la création. Un `409 plugin_name_taken` signifie soit que la première tentative a stocké le plugin, soit que le nom était déjà pris. Votre création perdue n’a créé le plugin de `details.plugin_id` que si son `created_by` est un `api_actor` avec l’`api_key_id` de votre clé. Vérifiez-le avant d’y téléverser (voir `plugin_name_taken` dans le tableau précédent). 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 identifiants de plugin, de version et de marketplace dans ces événements sont les mêmes que ceux renvoyés par cette API. Un événement peut également nommer une marketplace que cette API ne liste pas, telle qu’une marketplace de plugins publiés par Anthropic. `plugin_installation_preference_updated` identifie le plugin par son `name` et son `marketplace_id` plutôt que par son `id`. Dans `claude_plugin_security_scan_completed`, `plugin_version` n’est pas un identifiant de version, et aucun champ d’une [version de plugin](https://platform.claude.com/docs/fr/manage-claude/plugins-api#plugin-versions) ne lui correspond.

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

<CardGroup cols={2}>
  <Card title="Créer une clé API Admin" href="https://platform.claude.com/docs/fr/manage-claude/admin-api-keys">
    Où votre propriétaire principal crée une clé dotée de portées.
  </Card>

  <Card title="Gestion des utilisateurs" href="https://platform.claude.com/docs/fr/manage-claude/user-management">
    Les points de terminaison de groupes qui fournissent les ID `rbac_group_` utilisés dans les paramètres d’installation.
  </Card>

  <Card title="Flux d’activité de l’API Compliance" href="https://platform.claude.com/docs/fr/manage-claude/compliance-activity-feed">
    Où sont enregistrées les écritures de plugins et les téléchargements d’archives de membres.
  </Card>

  <Card title="API d’analyse" href="https://platform.claude.com/docs/fr/manage-claude/analytics-api">
    Rapports d’utilisation des plugins et des skills pour Claude Enterprise.
  </Card>
</CardGroup>
