---
title: Plugins API
url: https://platform.claude.com/docs/ru/manage-claude/plugins-api
description: "Инвентаризация плагинов в организации Claude Enterprise и управление ими: загрузка плагинов и их версий, выбор версии, которую получают участники, управление доступом к каждому плагину, скачивание файлов плагинов для проверки и проверка маркетплейса перед его подключением."
---
Plugins API позволяет:
* Провести инвентаризацию плагинов в вашей организации Claude Enterprise
* Публиковать плагины и новые версии из собственных конвейеров
* Выбирать, какая версия предоставляется участникам
* Управлять тем, кто может использовать каждый плагин
* Скачивать файлы плагинов для проверки
* Проверять Git-маркетплейс перед его подключением
Отчёты об *использовании* плагинов (какие плагины и навыки используют участники и как часто) описаны в разделе [API аналитики](https://platform.claude.com/docs/ru/manage-claude/analytics-api).
**Требуется ключ Admin API с областями действия**
Эти «endpoints» (конечные точки) требуют ключ Admin API с «scope» (областью действия) `read:plugins` (для конечных точек `GET`, включая скачивание архивов) или `write:plugins` (для конечных точек `POST` и `DELETE`, кроме проверки маркетплейса, для которой подходит любая из этих областей); подробности, включая две другие области чтения, которые также подходят, приведены в разделе [Области действия](https://platform.claude.com/docs/ru/manage-claude/plugins-api#scopes). О том, где основной владелец вашей организации создаёт такой ключ, см. [Создание ключа Admin API](https://platform.claude.com/docs/ru/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization). Передавайте ключ в заголовке `x-api-key` в каждом запросе вместе с заголовком [`anthropic-version`](https://platform.claude.com/docs/ru/api/versioning) и бета-заголовком, указанным в следующем примечании.
Plugins API находится в **бета-версии** и доступен только организациям Claude Enterprise. Он недоступен организациям Claude Platform (Claude Console), а также организациям с включённой готовностью к HIPAA.
Каждый запрос должен включать [бета-заголовок](https://platform.claude.com/docs/ru/api/beta-headers) `anthropic-beta: ce-plugins-2026-09-01` (SDK и CLI `ant` отправляют его за вас). Запрос без него возвращает `404`, в точности как если бы эндпоинта не существовало.
## Конечные точки
API предоставляет 18 конечных точек для пяти ресурсов:
| Ресурс | Конечные точки |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Плагины:** перечислить плагины в организации, загрузить новый, найти плагин, выбрать версию, которую получают участники (откатить или продвинуть), удалить плагин | `GET /v1/organizations/plugins`
`POST /v1/organizations/plugins`
`GET /v1/organizations/plugins/{plugin_id}`
`POST /v1/organizations/plugins/{plugin_id}`
`DELETE /v1/organizations/plugins/{plugin_id}` |
| **Версии плагинов:** перечислить историю версий плагина, загрузить новую версию, найти версию, скачать файлы версии | `GET /v1/organizations/plugins/{plugin_id}/versions`
`POST /v1/organizations/plugins/{plugin_id}/versions`
`GET /v1/organizations/plugins/{plugin_id}/versions/{version}`
`GET /v1/organizations/plugins/{plugin_id}/versions/{version}/content` |
| **Настройки установки:** узнать, кто может использовать плагин, принадлежащий организации, задать настройку для всей организации или для одной группы, удалить любую из этих настроек | `GET /v1/organizations/plugins/{plugin_id}/installation_settings`
`POST /v1/organizations/plugins/{plugin_id}/installation_settings/{target}`
`DELETE /v1/organizations/plugins/{plugin_id}/installation_settings/{target}` |
| **Общий доступ:** узнать, с кем участник поделился собственным плагином (только чтение) | `GET /v1/organizations/plugins/{plugin_id}/shares` |
| **Маркетплейсы плагинов:** найти ID маркетплейса, найти маркетплейс, задать настройку установки по умолчанию для его плагинов, проверить содержимое маркетплейса перед его подключением | `GET /v1/organizations/plugin_marketplaces`
`GET /v1/organizations/plugin_marketplaces/{marketplace_id}`
`POST /v1/organizations/plugin_marketplaces/{marketplace_id}`
`POST /v1/organizations/plugin_marketplaces/validate_repository`
`POST /v1/organizations/plugin_marketplaces/validate_archive` |
Плагины, публикуемые Anthropic, не инвентаризируются; их использование отражается в [API аналитики](https://platform.claude.com/docs/ru/manage-claude/analytics-api). Маркетплейсы создаются, подключаются к репозиториям и удаляются в claude.ai, а не через этот API.
## Предварительные требования
* Ваша организация должна использовать план Claude Enterprise.
* Основной владелец вашей организации создаёт ключ Admin API с областью доступа `read:plugins`, `write:plugins` или обеими в [claude.ai > Настройки организации > API](https://claude.ai/admin-settings/api-access). См. [Создание ключа для организации Claude Enterprise](https://platform.claude.com/docs/ru/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization).
* Каждый запрос содержит три заголовка: `x-api-key`, `anthropic-version: 2026-10-21` и `anthropic-beta: ce-plugins-2026-09-01`.
В Python, TypeScript, C#, Go, Java, PHP и Ruby SDK предоставляет эти эндпоинты через `client.beta.organization` (csharp, go: `client.Beta.Organization`; java: `client.beta().organization()`; php: `$client->beta->organization`), а [CLI `ant`](https://platform.claude.com/docs/ru/cli-sdks-libraries/cli/quickstart) — через `ant beta:organization`; они отправляют заголовки `anthropic-version` и `anthropic-beta` за вас. Примеры на этой странице считывают ключ Admin API из переменной окружения `ANTHROPIC_API_KEY`. Когда SDK или CLI запрашивают дополнительные страницы за вас, `limit` задаёт размер страницы, а не общее количество (см. [Пагинация](https://platform.claude.com/docs/ru/manage-claude/plugins-api#pagination)).
Ключи API принадлежат организации и продолжают работать после ухода создавшего их человека. Не передавайте их другим и не добавляйте в систему контроля версий.
## Быстрый старт
Перечислите плагины в собственных маркетплейсах вашей организации, начиная с самых новых:
```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)
# Автоматически загружает дополнительные страницы по мере необходимости.
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,
);
// Только эта страница; для следующей снова вызовите list() с page: $plugins->nextPage.
foreach ($plugins->getItems() as $plugin) {
echo "{$plugin->id}: {$plugin->name}\n";
}
```
```ruby Ruby
client = Anthropic::Client.new
page = client.beta.organization.plugins.list(owner_type: :organization, limit: 20)
page.auto_paging_each do |plugin|
puts "#{plugin.id}: #{plugin.name}"
end
```
```json
{
"data": [
{
"type": "plugin",
"id": "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
"name": "sales-toolkit",
"display_name": "Sales Toolkit",
"description": "Account research and call prep for the sales team.",
"served_version_id": "pluginver_01Km7tL4pR9xF5sU2zV3jP6q",
"served_version_pinned": true,
"latest_version_id": "pluginver_01Jd5sK2nQ8wE4rT6yU1iO3p",
"manifest_version": "1.4.0",
"owner": { "type": "organization" },
"marketplace_id": "marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r",
"created_by": { "type": "api_actor", "api_key_id": "apikey_01Nq9vN6rT2zH7uW4bX5mR8s" },
"organization_installation_preference": "available",
"organization_installation_preference_inherited": true,
"content_scan": { "status": "completed", "assessment": "pass", "reason": null },
"components": [
{
"type": "skill",
"name": "account-research",
"description": "Researches a customer account before a call."
},
{ "type": "mcp_server", "name": "crm", "description": null }
],
"reach": "remote",
"created_at": "2026-09-01T17:04:11Z",
"updated_at": "2026-09-15T14:12:30Z"
}
],
"next_page": "page_xK9f2LqT7vNw3pRzBd8sHy"
}
```
В этом примере плагин закреплён на более ранней версии: более новая версия (`latest_version_id`) сохранена, но участникам ещё не предоставляется.
## Области действия
| Область действия | Предоставляет |
| -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `read:plugins` | Все конечные точки `GET` на этой странице, включая скачивание архивов, а также проверку маркетплейсов. |
| `write:plugins` | Все конечные точки `POST` и `DELETE` на этой странице: создание плагина, создание версии, изменение обслуживаемой версии, удаление плагина, задание и удаление настроек установки и задание значения по умолчанию для маркетплейса, а также проверку маркетплейсов. Не предоставляет доступ на чтение. |
| `read:org_audit` | Область только для чтения для интеграций аудита безопасности: все конечные точки `GET` на этой странице, включая скачивание архивов, а также конечные точки чтения [управления пользователями](https://platform.claude.com/docs/ru/manage-claude/user-management) и [Compliance API](https://platform.claude.com/docs/ru/manage-claude/compliance-api). Не предоставляет проверку маркетплейсов и какую-либо запись. |
| `read:compliance_org_data` | Область Compliance API для метаданных организации (имён, типов, ролей и групп) и действующих настроек. Предоставляет все конечные точки `GET` на этой странице точно так же, как `read:org_audit`, поэтому ключ Compliance Access Key может читать плагины без второго ключа. Не предоставляет проверку маркетплейсов и какую-либо запись. |
Ключ может иметь несколько областей действия. Интеграции, которая загружает плагин, а затем считывает его, нужны обе области: `read:plugins` и `write:plugins`. Везде, где на этой странице сказано, что конечной точке требуется область `read:plugins`, подходит также ключ с `read:org_audit` или `read:compliance_org_data`.
### Доступ к файлам плагинов участников
Каждая из этих областей чтения (`read:plugins`, `read:org_audit` и `read:compliance_org_data`) позволяет скачивать файлы плагинов из личных маркетплейсов участников, включая файлы, которые не отображаются в настройках администратора claude.ai, а ключ `read:org_audit` или `read:compliance_org_data`, привязанный к вашей родительской организации, может делать это в любой подчинённой ей организации, имеющей доступ к этому API, передавая `organization_id` (см. [Чтение другой организации с тем же родителем](https://platform.claude.com/docs/ru/manage-claude/plugins-api#reading-another-organization-under-the-same-parent)). Каждое такое скачивание записывает событие `claude_plugin_archive_accessed` в [ленту активности Compliance API](https://platform.claude.com/docs/ru/manage-claude/compliance-activity-feed), указывающее ключ, плагин, версию и участника (см. [События ленты активности](https://platform.claude.com/docs/ru/manage-claude/plugins-api#activity-feed-events)). Скачивания плагинов, принадлежащих организации, не записываются.
### Чтение другой организации с тем же родителем
Ключи `read:plugins` и `write:plugins` читают и записывают данные только той организации, в которой они были созданы. В некоторых компаниях несколько организаций Claude связаны под одной родительской организацией. Ключ `read:org_audit` или `read:compliance_org_data`, [созданный для всех связанных организаций](https://platform.claude.com/docs/ru/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization), может также читать любую связанную организацию, у которой есть доступ к этому API. Чтобы прочитать её, передайте её ID в параметре запроса `organization_id` в любом эндпоинте `GET` на этой странице. ID — это UUID организации, отображаемый в настройках claude.ai (также принимается его форма с префиксом `org_`). Без этого параметра ключ читает организацию, в которой он был создан. Ключ, не имеющий собственной организации, всегда должен передавать `organization_id`. `404` означает, что указанная организация не подчинена родителю ключа или API ей недоступен; значение, не являющееся UUID или ID `org_`, возвращает `400`. Любой другой ключ, указывающий организацию, отличную от своей, получает `404`. Операции записи не принимают `organization_id`.
## Ключевые понятия
### Плагины и компоненты
**Плагин** — это пакет, расширяющий возможности Claude для участников вашей организации. Он содержит любое сочетание следующих компонентов:
| Компонент | Что это |
| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| Skill (навык) | Инструкции и файлы, которые Claude загружает, когда этого требует задача. |
| Command (команда) | Сохранённая подсказка, которую участник запускает, вводя `/` и имя команды. |
| Agent (агент) | Вспомогательный ассистент с собственными инструкциями, которому Claude может передать часть задачи. |
| Hook (хук) | Команда, которая автоматически запускается при наступлении события в сеансе, например перед тем, как Claude использует инструмент. |
| MCP server (сервер MCP) | Подключение Claude к инструментам и данным в другой системе («Model Context Protocol», или MCP). |
| CLI | Программа командной строки, которую плагин позволяет запускать Claude. |
У каждого плагина есть «manifest» (манифест) в `.claude-plugin/plugin.json`. Поле `name` манифеста становится полем `name` плагина: идентификатором в нижнем регистре, уникальным в пределах его маркетплейса.
### Маркетплейсы
**Маркетплейс** — это контейнер для плагинов. У каждого маркетплейса есть владелец и источник.
* **Владелец.** Организации принадлежат её маркетплейсы. У каждого участника также могут быть личные маркетплейсы.
* **Источник.** `manual` означает, что плагины загружаются в claude.ai или, для маркетплейса организации, через этот API. `github`, `gitlab` и `public_git` означают, что плагины синхронизируются из репозитория Git, подключённого владельцем. В синхронизируемый маркетплейс ничего нельзя загрузить, и этот API не может удалять его плагины, поскольку следующая синхронизация отменила бы любое из этих изменений. Вместо этого измените репозиторий.
**Маркетплейс библиотеки** вашей организации — это принадлежащий организации маркетплейс `manual`, в который выполняются загрузки, если вы не указываете маркетплейс. Он создаётся при первой загрузке в него.
### Плагины, принадлежащие организации и участникам
Поле `owner.type` плагина указывает, в чьём маркетплейсе он находится:
* `organization`: вы можете управлять им через этот API, за исключением того, что в плагин из маркетплейса, синхронизируемого из Git, нельзя выполнять загрузки и его нельзя удалить здесь.
* `user`: он находится в личном маркетплейсе одного участника. Вы можете читать его сведения и скачивать его файлы, а также удалить его, если его маркетплейс имеет тип `manual`. Загрузка версий и выбор обслуживаемой версии возвращают `403`. Общим доступом управляет только участник в claude.ai.
Удаление участника из организации не удаляет его плагины. Они остаются в инвентаре под `user_id` участника, и фильтр `owner_user_id` по-прежнему их находит, поэтому вы можете проверить и удалить содержимое ушедшего участника. Они удаляются из инвентаря при удалении учётной записи участника.
### Версии и обслуживаемая версия
Каждая загрузка создаёт новую неизменяемую **версию**, независимо от того, поступает ли она из этого API, из claude.ai или из синхронизации Git. У плагина есть два указателя на его версии:
* `latest_version_id`: самая новая версия
* `served_version_id`: версия, предоставляемая участникам
По умолчанию `served_version_pinned` равно `false`: предоставляемая версия обычно следует за самой новой. Когда включено сканирование содержимого, версия, сохранённая в claude.ai, может **ожидать** сканирования своего содержимого: она сохраняется, но не предоставляется сразу. На этой странице слово «ожидать» используется только для версии, сохранённой в claude.ai, а не для версии, которую участник или администратор публикует в плагин. Пока сканирование включено, ожидающая версия предоставляется только тогда, когда её `content_scan` имеет значение `completed` с `pass` или `warn`. Пока версия ожидает, `served_version_id` указывает на более раннюю версию, чем `latest_version_id`. Не опрашивайте API до совпадения этих двух ID: они могут так и остаться разными, например если сканирование завершится неудачей.
Выбор версии с помощью `POST /v1/organizations/plugins/{plugin_id}` «pins» (закрепляет) плагин (`served_version_pinned: true`). То же происходит, когда администратор выбирает версию в claude.ai или принимает запрос участника на публикацию в плагин. С этого момента новые загрузки сохраняются и продвигают `latest_version_id`, но участники остаются на закреплённой версии, пока вы не укажете в `served_version_id` другую. У плагина, два указателя которого различаются, есть сохранённая версия, которая не предоставляется участникам.
Это позволяет конвейеру выпуска загружать каждую сборку, тестировать её, а затем продвигать. Чтобы ваш конвейер определял, когда предоставляется каждая сборка, один раз закрепите плагин, задав в `served_version_id` его текущую версию; после этого продвигайте каждую сборку, которую хотите предоставлять. При включённом сканировании содержимого это первое закрепление возвращает `409 scan_pending`, пока `content_scan` текущей версии имеет значение `processing`, и `400 scan_failed`, если сканирование имеет значение `fail`, `unknown` или `errored` (`warn` принимается). Закреплённый плагин нельзя открепить ни здесь, ни в claude.ai.
Чтобы выполнить откат, задайте в `served_version_id` более раннюю версию. Переход на более новую версию выполняется так же.
Эти правила описывают плагины, принадлежащие организации. Обслуживаемой версией плагина, принадлежащего участнику, управляет его владелец в claude.ai.
### Настройки установки
**Настройки установки** (installation settings) определяют, кто может использовать плагин, принадлежащий организации. Каждая настройка имеет одно из четырёх значений, передаваемых в полях с именем `installation_preference` (а в объектах плагина и маркетплейса — `organization_installation_preference` и `default_installation_preference`):
| Значение | Что видят участники |
| --------------- | ---------------------------------------- |
| `required` | Плагин установлен, и его нельзя удалить. |
| `auto_install` | Плагин установлен, и его можно удалить. |
| `available` | Плагин можно установить по запросу. |
| `not_available` | Плагин скрыт. |
Плагин может иметь одну настройку для всей организации и по одной настройке для каждой группы ([групп управления доступом на основе ролей, управляемых в разделе «Управление пользователями»](https://platform.claude.com/docs/ru/manage-claude/user-management#groups)). Участник получает значение по следующим правилам:
1. Значение для всей организации — это собственная настройка плагина для всей организации, если она есть, иначе значение по умолчанию его маркетплейса, иначе `not_available`. Плагин сообщает это значение в `organization_installation_preference`, с `organization_installation_preference_inherited: true`, пока оно берётся из значения по умолчанию маркетплейса.
2. Участник, не входящий ни в одну группу с настройкой для плагина, получает значение для всей организации.
3. Участник, входящий в одну или несколько групп с настройкой, вместо этого получает наиболее разрешающую из настроек этих групп в порядке `required`, `auto_install`, `available`, `not_available`.
Настройка группы заменяет значение для всей организации для её участников, а не дополняет его. Например, если значение для всей организации — `required`, а группа «Пилот» имеет `available`, участники группы «Пилот» получают `available`. Когда вы переводите плагин с пилотной группы на всю организацию, задайте значение для всей организации, а затем удалите настройку группы. Задание значения для всей организации прекращает наследование плагином значения по умолчанию маркетплейса; [удаление настройки для всей организации](https://platform.claude.com/docs/ru/manage-claude/plugins-api#remove-an-installation-setting) возвращает плагин к этому значению по умолчанию.
Плагин, созданный через этот API, изначально не имеет собственных настроек, поэтому наследует значение по умолчанию своего маркетплейса: `not_available`, если никто не задал значение по умолчанию. Удаление группы удаляет её настройки из всех плагинов.
### Общий доступ
**Общий доступ** (shares) определяет, кто может использовать плагин, принадлежащий участнику. Владелец открывает к нему доступ в claude.ai для всех участников, для группы или для указанных участников. Этот API выводит список общего доступа, но не может его изменять.
Если ваша организация отключила какой-либо вид общего доступа в настройках claude.ai, записи этого вида по-прежнему отображаются в списке, но никому не дают доступа, пока эта настройка отключена; сам список не показывает, отключена ли она.
### Сканирование содержимого
«Content scanning» (сканирование содержимого) — это настройка организации в claude.ai. Когда она включена, вновь сохраняемые версии сканируются (claude.ai делает несколько исключений), а результат сообщается в `content_scan`; у версии, которая не сканировалась, например сохранённой до включения сканирования, `content_scan: null`. Сканирование не предлагается организациям, использующим ключи шифрования, управляемые клиентом, или нулевое хранение данных.
Пока сканирование включено, плагин предоставляется участникам только тогда, когда сканирование его предоставляемой версии имеет статус `completed` с `pass` или `warn`. Пока сканирование находится в состоянии `processing` или `errored` либо имеет значение `fail` или `unknown`, плагин скрыт от участников, и более ранняя версия вместо него не предоставляется. Версия, которая никогда не сканировалась (`content_scan: null`), предоставляется обычным образом.
Версия, загруженная через этот API, никогда не ожидает сканирования своего содержимого. Когда она становится предоставляемой версией, участники теряют доступ к плагину, пока её `content_scan` не примет значение `completed` с `pass` или `warn`. Если участники должны сохранить текущую версию, пока сканируется новая, сначала закрепите плагин (см. [Версии и обслуживаемая версия](https://platform.claude.com/docs/ru/manage-claude/plugins-api#versions-and-the-served-version)).
Пока версия, сохранённая в claude.ai, ожидает сканирования, обслуживаемая версия не меняется. Когда ваша загрузка через API становится обслуживаемой версией, любое ожидание заканчивается: ожидающая версия предоставляется, только если кто-то её выберет. Чтобы увидеть сканирование ожидающей версии, прочитайте версию (см. [Список версий плагина](https://platform.claude.com/docs/ru/manage-claude/plugins-api#list-a-plugins-versions)).
После загрузки `content_scan.status` равен `processing`, а вердикт поступает асинхронно. Прочитайте версию, чтобы увидеть его; объект плагина показывает только сканирование его предоставляемой версии. Пока сканирование включено, изменение предоставляемой версии на версию, чей `content_scan` показывает `processing`, возвращает `409 scan_pending`, а изменение на версию, чьё сканирование показывает `fail`, `unknown` или `errored`, возвращает `400 scan_failed`.
#### Неудачные сканирования, разрешённые в claude.ai
В claude.ai владельцы организации могут разрешить версию, сканирование которой завершилось неудачей. Это также могут делать участники, чья [пользовательская роль](https://platform.claude.com/docs/ru/manage-claude/user-management#custom-roles) позволяет управлять разделом **Библиотеки**. После этого данный API может сообщать об этом сканировании как о `completed` с `warn` и `reason` неудачного сканирования. Пока это так, действуют правила для `warn`: версия может предоставляться участникам, и вы можете сделать её предоставляемой версией. Ничто в ответе не показывает, что она была разрешена, поэтому `warn` — это либо предупреждение, либо разрешённое неудачное сканирование. Разрешение версии, сканирование которой показывает `warn`, не изменяет её `content_scan`. Когда версия перестаёт быть разрешённой, этот API сообщает вердикт её самого нового завершённого сканирования. Предоставляемая версия, сканирование которой после этого показывает `fail` или `unknown`, скрывается от участников.
### Охват
`reach` («reach» (охват)) одним значением обобщает, насколько далеко версия распространяет своё действие на компьютерах участников и за их пределами:
| Значение | Значение |
| ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `remote` | Объявляет сервер MCP или CLI, независимо от того, что ещё она объявляет. |
| `privileged` | Не объявляет MCP-сервер или CLI, но объявляет хук, монитор (фоновую команду, которая продолжает работать во время сеанса), LSP-сервер (Language Server Protocol), workflow (скрипт, который Claude Code может запускать; любой файл в папке `workflows/` в корне плагина считается workflow) или настройки, которые плагин применяет к приложению участника, либо содержит навык, команду или любой другой Markdown-файл, frontmatter которого заранее одобряет инструменты (`allowed-tools`). Они выполняются или действуют на собственном компьютере участника. |
| `contained` | Не объявляет MCP-сервер, CLI, хук, монитор, LSP-сервер, workflow или настройки приложения, и ни один из её Markdown-файлов не одобряет инструменты заранее (например, плагин, содержащий только навыки, команды и агентов, ни у одного из которых нет `allowed-tools`). |
`reach` учитывает всё, что объявляет версия, включая мониторы, LSP-серверы, workflow и настройки приложения, которые не перечисляются в `components`, поэтому версия с пустым списком `components` всё равно может быть `privileged`. Значение равно `null` для версии, сохранённой до начала записи компонентов, и для версии, охват которой не удалось определить, потому что не удалось прочитать `SKILL.md` одного из её навыков или один из её файлов команд; рассматривайте `null` как неклассифицированное значение. Обычно значение вычисляется при сохранении версии по правилам, действовавшим в то время. Поэтому более старая версия может иметь значение `contained` там, где те же файлы, сохранённые сегодня, получили бы значение `privileged`.
### Требования к загрузке
Загрузки подчиняются тем же правилам, что и загрузки плагинов в claude.ai, поэтому в обоих местах принимаются одни и те же архивы.
* Загрузка — это либо один архив `.zip` или `.plugin`, либо набор отдельных файлов. Архив может заключать всё содержимое в одну папку верхнего уровня.
* Она должна содержать ровно один манифест в `.claude-plugin/plugin.json`, который должен объявлять `name`. Отдельный `SKILL.md` без манифеста отклоняется.
* `SKILL.md` верхнего уровня, frontmatter которого объявляет компоненты плагина, объединяется с манифестом; там, где значение задано в обоих, приоритет имеет `plugin.json`. Значение `description`, которое манифест берёт из этого `SKILL.md`, обрезается до первых 500 символов.
* `name` может содержать строчные буквы (любого алфавита), цифры и дефисы, до 64 символов. Прописные буквы, пробелы, подчёркивания и другие знаки препинания отклоняются.
* `displayName` — не более 64 символов, `description` — не более 500.
* Каждому `SKILL.md` нужен корректный YAML-frontmatter с `name` и `description`, ни одно из которых не содержит XML-тегов, таких как ``. Два навыка или две команды не могут иметь одинаковое имя.
* Ни один файл не может находиться в каталоге `bin/` верхнего уровня.
* Вложенные файлы `.zip` не допускаются. Упакованные серверы MCP (`.mcpb`, `.dxt`) разрешены.
* Пути к файлам должны быть относительными, не содержать `..` и использовать только буквы, цифры, пробелы и `_ . - / ( ) ,`.
* Тело запроса и распакованный архив не должны превышать 200 МБ каждый; тело запроса, превышающее лимит, возвращает `413` (`request_too_large`), а не `400`. Загрузка содержит не более 5 000 файлов, глубина пути — не более 12, длина путей — не более 472 символов, а имена файлов или папок — не более 255 символов.
* ZIP-архивы должны использовать сжатие DEFLATE или STORE и не могут быть зашифрованы или содержать символические ссылки.
* Загрузка, создающая плагин, возвращает `400`, если маркетплейс уже содержит 1 000 плагинов. Плагины, которые этот API не перечисляет, также учитываются, поэтому лимит может быть достигнут, даже если [Получение списка плагинов](https://platform.claude.com/docs/ru/manage-claude/plugins-api#list-plugins) показывает менее 1 000 плагинов в этом маркетплейсе. Anthropic может увеличить лимит в 5 000 файлов.
## Примеры рабочих процессов
### Публикация каждой сборки из конвейера выпуска
Загружайте каждую помеченную тегом сборку из CI и позвольте конвейеру определять, когда сборка предоставляется.
1. Найдите маркетплейс для загрузки с помощью `GET /v1/organizations/plugin_marketplaces?owner_type=organization` или опустите `marketplace_id`, чтобы использовать маркетплейс библиотеки.
2. При первом выпуске [создайте плагин](https://platform.claude.com/docs/ru/manage-claude/plugins-api#create-a-plugin) с помощью `POST /v1/organizations/plugins`. При каждом последующем выпуске запишите `latest_version_id` плагина, затем [загрузите версию](https://platform.claude.com/docs/ru/manage-claude/plugins-api#create-a-version) с помощью `POST /v1/organizations/plugins/{plugin_id}/versions`. Если ответ на загрузку потерян, прочитайте плагин и повторите попытку, только если `latest_version_id` не изменился (см. [Повторные попытки загрузки](https://platform.claude.com/docs/ru/manage-claude/plugins-api#retrying-uploads)).
3. Чтобы участники оставались на текущей версии, пока проверяется каждая новая сборка, один раз закрепите плагин, задав в `served_version_id` его текущую версию. После этого каждая загрузка сохраняется, не предоставляясь участникам, а закрепление нельзя отменить: для каждой сборки, которую вы хотите предоставить, нужен шаг 5.
4. Когда сканирование содержимого включено, опрашивайте `GET /v1/organizations/plugins/{plugin_id}/versions/{version}`, пока `content_scan.status` не перестанет быть `processing`, и продвигайте сборку, только если статус — `completed` с результатом `pass` или `warn`.
5. [Продвиньте сборку](https://platform.claude.com/docs/ru/manage-claude/plugins-api#change-the-served-version) с помощью `POST /v1/organizations/plugins/{plugin_id}` и `{"served_version_id": ""}`. Чтобы выполнить откат, отправьте таким же образом ID предыдущей версии.
### Развёртывание плагина для пилотной группы, а затем для всех
1. Найдите ID пилотной группы с помощью `GET /v1/organizations/rbac_groups`. Для этого вызова нужна область доступа `read:rbac_groups` (см. [Группы и роли в разделе «Управление пользователями»](https://platform.claude.com/docs/ru/manage-claude/user-management#groups-and-roles)). Для следующих шагов нужна `write:plugins`, которая действует только в организации, где был создан её ключ, поэтому на предприятии с несколькими связанными организациями создайте один ключ в организации, которой принадлежит плагин, и дайте ему обе области доступа, либо используйте для этих шагов второй ключ, созданный там.
2. [Задайте группе собственную настройку](https://platform.claude.com/docs/ru/manage-claude/plugins-api#set-an-installation-setting), например `auto_install`, с помощью `POST /v1/organizations/plugins/{plugin_id}/installation_settings/{target}`, где `{target}` — ID группы с префиксом `rbac_group_`, при этом значение для всей организации остаётся `not_available`. Плагин получают только участники группы.
3. Когда пилот завершится, задайте значение для всей организации следующим вызовом, затем удалите настройку группы, чтобы группа снова следовала настройке организации. Задание значения для всей организации прекращает наследование плагином значения по умолчанию маркетплейса; [удаление настройки для всей организации](https://platform.claude.com/docs/ru/manage-claude/plugins-api#remove-an-installation-setting) впоследствии возвращает плагин к этому значению по умолчанию.
```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}"
```
Затем удалите настройку группы с помощью `DELETE /v1/organizations/plugins/{plugin_id}/installation_settings/{target}`, где `{target}` — ID группы. Настройка группы заменяет значение для всей организации для её участников, а не дополняет его, поэтому оставшаяся настройка группы `available` сохранила бы для этих участников значение `available`.
### Синхронизация инвентаря безопасности
Запускайте ночное задание, которое помечает плагины, выходящие за пределы сеанса участника или сканирование содержимого которых имеет значение `warn`, `fail` или `unknown`.
1. Перебирайте страницы [`GET /v1/organizations/plugins?limit=100`](https://platform.claude.com/docs/ru/manage-claude/plugins-api#list-plugins), пока `next_page` не станет `null` (см. [Пагинация](https://platform.claude.com/docs/ru/manage-claude/plugins-api#pagination)). При каждом запуске считывайте `reach` и `content_scan` каждого плагина из этого списка: изменение только `content_scan`, например вердикт, поступивший позже, не изменяет `updated_at`. `updated_at` обычно сообщает, у каких плагинов появилось новое содержимое или новая обслуживаемая версия с момента последнего запуска (что стоит повторного скачивания архива). Ожидающая версия (см. [Версии и обслуживаемая версия](https://platform.claude.com/docs/ru/manage-claude/plugins-api#versions-and-the-served-version)) изменяет `updated_at`, когда становится обслуживаемой версией, а не обязательно при сохранении. Чтобы заметить её, сравнивайте `latest_version_id` со значением из последнего запуска. Полное повторное перечисление также позволяет обнаруживать удаления, поскольку плагин, удалённый синхронизацией Git или удалением учётной записи, исчезает без события.
2. Помечайте каждый плагин, у которого `reach` равен `remote` (он объявляет MCP-сервер или CLI) или `content_scan.assessment` равен `warn`, `fail` или `unknown`. `warn` также может быть [неудачным сканированием, разрешённым в claude.ai](https://platform.claude.com/docs/ru/manage-claude/plugins-api#failed-scans-allowed-in-claude-ai). Исключайте `warn`, только если вы принимаете каждое неудачное сканирование, разрешённое там. Эти поля описывают предоставляемую версию. Чтобы также проверить более новую версию, которая не предоставляется, перечислите версии плагина, когда `latest_version_id` отличается от `served_version_id` (см. [Список версий плагина](https://platform.claude.com/docs/ru/manage-claude/plugins-api#list-a-plugins-versions)).
3. Для каждого помеченного плагина скачайте архив обслуживаемой версии для проверки с помощью `GET /v1/organizations/plugins/{plugin_id}/versions/{served_version_id}/content` (см. [Скачивание файлов версии](https://platform.claude.com/docs/ru/manage-claude/plugins-api#download-a-versions-files)). Также скачайте по ID любую необслуживаемую версию, которая соответствует критерию шага 2.
4. Чтобы отозвать плагин у участников на время проверки, см. раздел [Удаление плагина](https://platform.claude.com/docs/ru/manage-claude/plugins-api#delete-a-plugin), где описаны обратимый (для плагинов, принадлежащих организации) и необратимый варианты.
## Плагины
Объект плагина описывает плагин в одном из маркетплейсов вашей организации или в личном маркетплейсе участника (полный пример показан в ответе из раздела [Быстрый старт](https://platform.claude.com/docs/ru/manage-claude/plugins-api#quick-start)). Его поля `display_name`, `description`, `manifest_version`, `content_scan`, `components` и `reach` описывают его **обслуживаемую** версию, поэтому один вызов списка показывает, что получают участники.
| Поле | Описание |
| ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `id` | С префиксом `plugin_`. |
| `name` | Из манифеста. Уникально в пределах своего маркетплейса, но не в пределах организации. Неизменно для плагина, принадлежащего организации; меняется, если участник переименовывает собственный плагин в claude.ai. |
| `display_name`, `description`, `manifest_version` | Значения `displayName`, `description` и `version` из манифеста обслуживаемой версии; каждое равно `null`, если манифест его не объявляет. `description` может быть значением `description` навыка, а не манифеста (описано после этой таблицы). `manifest_version` нормализуется для отображения: один начальный символ `v` или `V` отбрасывается, поэтому значение `version` в манифесте `"v1.4.0"` возвращается как `"1.4.0"`. Оно также равно `null` для значения, не похожего на номер версии, например `"latest"`, и для версии плагина, созданной до того, как claude.ai начал записывать это поле в августе 2026 года. Загрузка никогда не отклоняется из-за её `version`, и `manifest_version` не является уникальным. |
| `served_version_id`, `latest_version_id` | С префиксом `pluginver_`: версия, которую получают участники, и самая новая версия. См. [Версии и обслуживаемая версия](https://platform.claude.com/docs/ru/manage-claude/plugins-api#versions-and-the-served-version). |
| `served_version_pinned` | `false`, пока плагин не закреплён (см. [Версии и обслуживаемая версия](https://platform.claude.com/docs/ru/manage-claude/plugins-api#versions-and-the-served-version)); `true` с этого момента. |
| `owner` | `{"type": "organization"}` или `{"type": "user", "user_id": "user_..."}` для личного маркетплейса участника. |
| `marketplace_id` | С префиксом `marketplace_`. |
| `created_by` | Кто создал плагин: `{"type": "user_actor", "user_id": "user_...", "email_address": "..."}` для человека в claude.ai (`email_address` может быть `null`) или `{"type": "api_actor", "api_key_id": "apikey_..."}` для ключа API. Могут встречаться и другие типы акторов. `null`, если создатель не записан, например для плагинов, синхронизированных из Git. |
| `organization_installation_preference`, `organization_installation_preference_inherited` | Для плагинов, принадлежащих организации: значение для всей организации и признак того, берётся ли оно из значения по умолчанию маркетплейса (см. [Настройки установки](https://platform.claude.com/docs/ru/manage-claude/plugins-api#installation-settings)). Для плагинов, принадлежащих участникам: оба `null`. |
| `content_scan` | Результат сканирования обслуживаемой версии — объект с полями `status`, `assessment` и `reason` (описаны после этой таблицы). `null`, если версия никогда не сканировалась. |
| `components` | Компоненты обслуживаемой версии, каждый в виде `{"type", "name", "description"}`, где `type` — одно из значений `skill`, `mcp_server`, `command`, `agent`, `hook` или `cli`; перечисляются в этом порядке типов, а затем по имени. Для сервера MCP `name` — его ключ в манифесте; для хука — событие, при котором он выполняется; для CLI — имя исполняемого файла. `description` всегда равно `null` для серверов MCP, хуков и CLI. `null`, если не записано. |
| `reach` | `contained`, `privileged` или `remote`. См. [Охват](https://platform.claude.com/docs/ru/manage-claude/plugins-api#reach). |
| `updated_at` | Меняется при смене обслуживаемой версии, при закреплении плагина и, как правило, при сохранении новой версии. Ожидающая версия (см. [Версии и обслуживаемая версия](https://platform.claude.com/docs/ru/manage-claude/plugins-api#versions-and-the-served-version)) меняет его, когда становится обслуживаемой, а не обязательно в момент сохранения. Не меняется при изменении настроек установки, предоставлений доступа или только `content_scan`. |
`description` не всегда берётся из манифеста. `description`, который манифест берёт из `SKILL.md` верхнего уровня, обрезается до первых 500 символов (см. [Требования к загрузке](https://platform.claude.com/docs/ru/manage-claude/plugins-api#upload-requirements)). Если `description` манифеста представляет собой первые 500 символов ровно одного уникального `description` навыка в `components`, API вместо этого возвращает `description` этого навыка. В результате:
* Прочитанный вами `description` может быть длиннее 500 символов — лимита для загружаемого манифеста. Загрузка, в которой `plugin.json` задаёт такой `description`, возвращает `400`.
* В [скачиваемых вами файлах](https://platform.claude.com/docs/ru/manage-claude/plugins-api#download-a-versions-files) `.claude-plugin/plugin.json` может иметь другой `description` или не иметь его вовсе.
Объект `content_scan`:
| Поле | Описание |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `status` | `processing`, пока выполняется сканирование, `completed`, когда оно завершено, или `errored`, когда его не удалось завершить (или, изредка, когда его результат не удалось прочитать для этого ответа; в таком случае последующее чтение может его сообщить). Сообщается самое новое завершённое сканирование, если оно есть. Участники не получают версию, у которой `status` равен `processing` или `errored`; повторная загрузка содержимого в виде новой версии запускает новое сканирование. |
| `assessment` | Задаётся, когда `status` равен `completed`: `pass` (ничего не найдено), `warn` (найдено что-то, что не блокирует использование, или [неудачное сканирование, разрешённое в claude.ai](https://platform.claude.com/docs/ru/manage-claude/plugins-api#failed-scans-allowed-in-claude-ai)), `fail` (найдено что-то, что блокирует использование) или `unknown` (вердикта нет). В остальных случаях `null`. |
| `reason` | Для `warn` и `fail` — основная проблема из следующего списка. В остальных случаях `null`; также `null` для более старого сканирования, выполненного до начала записи причин. |
| `reason` | Значение |
| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `covert-usage-telemetry` | Указывает Claude отправлять сведения об участнике или его использовании на внешний адрес, не сообщая ему об этом. |
| `undisclosed-data-destination` | Отправляет файлы, электронные письма, документы или другое содержимое в фиксированное внешнее место назначения, которое не показывается участнику и не контролируется им. |
| `remote-code-instruction-loader` | Указывает Claude скачивать и запускать внешнее содержимое или следовать инструкциям из него, причём это содержимое может измениться после установки плагина. |
| `credential-exposure` | Содержит действующие учётные данные или собирает учётные данные или токены из среды участника. |
| `guardrail-tampering` | Ослабляет защитные механизмы участника, например заранее одобряя каждый запрос разрешения. |
| `system-prompt-spoofing` | Имитирует системные инструкции Claude или пытается их подменить. |
| `covert-record-tampering` | Незаметно изменяет, скрывает или удаляет информацию, которую участник иначе увидел бы. |
| `covert-behavior-override` | Изменяет поведение Claude за пределами назначения плагина и скрывает это изменение от участника. |
| `hidden-code-execution` | Запускает встроенный код, указывая Claude не раскрывать, что он делает. |
| `undisclosed-promotion-injection` | Вставляет нераскрытое рекламное содержимое в вывод Claude. |
| `hidden-identity-gate` | Изменяет или прекращает своё поведение в зависимости от того, какая учётная запись его запускает, не объясняя причин. |
| `destructive-persistence` | Может удалять или повреждать файлы участника либо устанавливать программы, которые остаются после удаления плагина. |
| `unanalyzable-binary` | Включает скомпилированную или нечитаемую программу, поэтому сканирование не смогло проверить, что она делает. |
| `other` | Любая другая проблема, включая более новую, чем этот список. |
`plugin_id` без префикса `plugin_` возвращает `400`. `plugin_id`, который имеет префикс, но отсутствует в инвентаре вашей организации, возвращает `404`.
### Получение списка плагинов
`GET /v1/organizations/plugins` возвращает список плагинов вашей организации — в маркетплейсах организации и в личных маркетплейсах участников — в порядке убывания `created_at`. Фильтруйте по `owner_type` (`organization` или `user`), `owner_user_id` (идентификатор с префиксом `user_`, позволяющий найти плагины участника, в том числе после его ухода из организации), `marketplace_id`, а также `created_at[gte]`, `created_at[gt]`, `created_at[lte]`, `created_at[lt]` (временные метки RFC 3339). Фильтры объединяются через AND. `marketplace_id` или `owner_user_id`, которым ничего не соответствует в вашей организации, возвращает пустую страницу, а не ошибку. Ответ имеет структуру, показанную в разделе [Быстрый старт](https://platform.claude.com/docs/ru/manage-claude/plugins-api#quick-start). Требуется область `read:plugins`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/plugins?owner_type=organization&limit=20" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 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)
# Автоматически загружает дополнительные страницы по мере необходимости.
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,
);
// Только эта страница; для следующей снова вызовите list() с 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
```
### Создание плагина
`POST /v1/organizations/plugins` создаёт плагин, принадлежащий организации, и его первую версию за один вызов; эта версия становится обслуживаемой. Тело запроса имеет формат `multipart/form-data`: `files[]` — это либо один архив `.zip` или `.plugin`, либо по одной части на каждый файл, где имя файла каждой части — это путь к файлу внутри плагина (например, `.claude-plugin/plugin.json`). Необязательные поля: `marketplace_id` (маркетплейс `manual`, принадлежащий организации, или по умолчанию ваш библиотечный маркетплейс, который создаётся при первом использовании) и `release_notes` (до 5 000 символов; отображается в истории версий claude.ai и возвращается вместе с версией). Поля `name`, `display_name`, `description` и `manifest_version` плагина берутся из загруженных файлов, а загрузка должна соответствовать [требованиям к загрузке](https://platform.claude.com/docs/ru/manage-claude/plugins-api#upload-requirements). Когда сканирование содержимого включено, `content_scan.status` в ответе равен `processing`, а вердикт поступает асинхронно. Возвращает плагин. Требуется область `write:plugins`.
Загрузка архива:
```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();
// Формируем часть `files[]` вручную, чтобы архив отправлялся с именем файла,
// которое требуется для загрузки.
var archive = MultipartField.>builder()
.value(List.of(Files.newInputStream(Path.of("dist/sales-toolkit.zip"))))
.filename("sales-toolkit.zip")
.contentType("application/octet-stream")
.build();
var params = PluginCreateParams.builder()
.files(archive)
.releaseNotes("First release")
.build();
var plugin = client.beta().organization().plugins().create(params);
IO.println("id: " + plugin.id());
IO.println("served_version_id: " + plugin.servedVersionId());
}
```
```php PHP
use Anthropic\Core\FileParam;
$client = new Client();
$plugin = $client->beta->organization->plugins->create(
files: [
FileParam::fromResource(fopen('dist/sales-toolkit.zip', 'r')),
],
releaseNotes: 'First release',
);
echo "id: {$plugin->id}\n";
echo "served_version_id: {$plugin->servedVersionID}\n";
```
```ruby Ruby
client = Anthropic::Client.new
plugin = client.beta.organization.plugins.create(
files: [Pathname("dist/sales-toolkit.zip")],
release_notes: "First release"
)
puts "id: #{plugin.id}"
puts "served_version_id: #{plugin.served_version_id}"
```
```json
{
"type": "plugin",
"id": "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
"name": "sales-toolkit",
"display_name": "Sales Toolkit",
"description": "Account research and call prep for the sales team.",
"served_version_id": "pluginver_01Km7tL4pR9xF5sU2zV3jP6q",
"served_version_pinned": false,
"latest_version_id": "pluginver_01Km7tL4pR9xF5sU2zV3jP6q",
"manifest_version": "1.4.0",
"owner": { "type": "organization" },
"marketplace_id": "marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r",
"created_by": { "type": "api_actor", "api_key_id": "apikey_01Nq9vN6rT2zH7uW4bX5mR8s" },
"organization_installation_preference": "available",
"organization_installation_preference_inherited": true,
"content_scan": { "status": "processing", "assessment": null, "reason": null },
"components": [
{
"type": "skill",
"name": "account-research",
"description": "Researches a customer account before a call."
},
{ "type": "mcp_server", "name": "crm", "description": null }
],
"reach": "remote",
"created_at": "2026-09-01T17:04:11Z",
"updated_at": "2026-09-01T17:04:11Z"
}
```
Загрузка отдельных файлов в указанный маркетплейс. Прикрепляйте каждый файл под его путём внутри плагина (суффикс `;filename=` в примере cURL, аргументы имени файла в примерах SDK); файл, отправленный только под своим базовым именем, приводит к тому, что манифест не находится. SDK для TypeScript и Java, а также CLI `ant` пока не умеют прикреплять файлы под путём, поэтому в этих примерах плагин загружается в маркетплейс одним архивом:
```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
# CLI отправляет каждый файл только под его базовым именем,
# поэтому загрузите плагин одним архивом.
ant beta:organization:plugins create \
--file dist/sales-toolkit.zip \
--marketplace-id marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r
```
```python Python
client = anthropic.Anthropic()
# Кортеж (filename, file) сохраняет путь каждого файла внутри плагина;
# голый файловый объект был бы отправлен только под своим базовым именем.
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();
// TypeScript SDK отправляет каждый файл под его базовым именем,
// поэтому загружайте плагин одним архивом.
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 сохраняет путь каждого файла внутри плагина; без него FileStream
// отправляется только под своим базовым именем.
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 сохраняет путь каждого файла внутри плагина как имя файла в части;
// голый *os.File был бы отправлен под своим базовым именем, и манифест не был бы найден.
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();
// Сеттеры `files` в PluginCreateParams принимают одно имя файла на весь
// список, поэтому загружайте плагин одним архивом: одна собранная вручную
// часть с именем файла архива, которое требуется для загрузки.
var archive = MultipartField.>builder()
.value(List.of(Files.newInputStream(Path.of("dist/sales-toolkit.zip"))))
.filename("sales-toolkit.zip")
.contentType("application/octet-stream")
.build();
var params = PluginCreateParams.builder()
.files(archive)
.marketplaceId("marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r")
.build();
var plugin = client.beta().organization().plugins().create(params);
IO.println("id: " + plugin.id());
IO.println("served_version_id: " + plugin.servedVersionId());
}
```
```php PHP
use Anthropic\Core\FileParam;
$client = new Client();
$plugin = $client->beta->organization->plugins->create(
files: [
FileParam::fromResource(
fopen('.claude-plugin/plugin.json', 'r'),
filename: '.claude-plugin/plugin.json',
),
FileParam::fromResource(
fopen('skills/account-research/SKILL.md', 'r'),
filename: 'skills/account-research/SKILL.md',
),
],
marketplaceID: 'marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r',
);
echo "id: {$plugin->id}\n";
echo "served_version_id: {$plugin->servedVersionID}\n";
```
```ruby Ruby
client = Anthropic::Client.new
# FilePart с filename: сохраняет путь каждого файла внутри плагина;
# голый Pathname был бы отправлен только под своим базовым именем.
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}"
```
Помимо `400` для загрузки, нарушающей [требования к загрузке](https://platform.claude.com/docs/ru/manage-claude/plugins-api#upload-requirements) (`413` для тела запроса более 200 МБ), и общих ответов (`403`, когда `marketplace_id` — личный маркетплейс участника; см. [Ответы с ошибками](https://platform.claude.com/docs/ru/manage-claude/plugins-api#error-responses)), создание может завершиться ошибкой:
| Статус | Причина | Что делать |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 404 | `marketplace_id` не является маркетплейсом вашей организации. | Возьмите ID из [Списка маркетплейсов](https://platform.claude.com/docs/ru/manage-claude/plugins-api#list-marketplaces). |
| 400 | Маркетплейс синхронизируется из Git или уже содержит 1 000 плагинов (см. [Требования к загрузке](https://platform.claude.com/docs/ru/manage-claude/plugins-api#upload-requirements)). | Загрузите в другой маркетплейс типа `manual` или вместо этого измените репозиторий. |
| 409 `plugin_name_taken` | Имя уже занято в этом маркетплейсе. | Загружайте версию в `details.plugin_id`, только если это именно тот плагин, который вы хотели обновить, поскольку его мог создать кто-то другой. В противном случае или если `details.plugin_id` отсутствует, выполните загрузку под другим именем (измените `name` в манифесте). |
| 409 `skill_name_taken` | Плагин добавляется в маркетплейс библиотеки, и один из его навыков имеет имя навыка организации. | Переименуйте навык или удалите навык организации в claude.ai. |
| 409 (без `error_code`) | Другая загрузка с тем же именем в тот же маркетплейс выполняется, или имя занято плагином, который этот API не перечисляет. | Повторите попытку с экспоненциальной задержкой. Если `409` сохраняется дольше нескольких минут, выполните загрузку под другим именем (измените `name` в манифесте). |
| 503 `registration_pending` | Плагин был создан, но его регистрация не завершилась. | Не отправляйте запрос повторно; загрузите те же файлы как версию `details.plugin_id` (см. [Повторные попытки загрузки](https://platform.claude.com/docs/ru/manage-claude/plugins-api#retrying-uploads)). |
### Получение плагина
`GET /v1/organizations/plugins/{plugin_id}` возвращает один плагин. Требуется область доступа `read:plugins`.
```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}"
```
### Изменение обслуживаемой версии
`POST /v1/organizations/plugins/{plugin_id}` изменяет, какую версию плагина организации получают участники. Передайте более раннюю версию для отката или более новую, чтобы продвинуть сборку, которая была сохранена, но не обслуживалась. Это закрепляет плагин, а закреплённый плагин нельзя открепить ни здесь, ни в claude.ai (см. [Версии и обслуживаемая версия](https://platform.claude.com/docs/ru/manage-claude/plugins-api#versions-and-the-served-version)). Единственное изменяемое поле — `served_version_id`, и оно обязательно. Изменение доходит до участников до возврата ответа и не создаёт новую версию. Если сканирование содержимого включено, версия должна быть такой, которую можно предоставлять участникам (см. [Сканирование содержимого](https://platform.claude.com/docs/ru/manage-claude/plugins-api#content-scanning)). Передача уже обслуживаемой версии для закреплённого плагина ничего не меняет; для незакреплённого плагина она закрепляет его на этой версии, поэтому последующие загрузки перестают обслуживаться автоматически. Закрепление также прекращает любое ожидание: версия, ожидавшая сканирования содержимого, остаётся сохранённой и обслуживается только в том случае, если кто-то её выберет. Возвращает плагин. Требуется область `write:plugins`.
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 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}"
```
```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"
}
```
Помимо общих ответов (`403` для плагина, принадлежащего участнику, а также `409 scan_pending` или `400 scan_failed` для версии, которую нельзя предоставлять участникам; см. [Ответы с ошибками](https://platform.claude.com/docs/ru/manage-claude/plugins-api#error-responses)), запрос может завершиться следующими ошибками:
| Статус | Причина | Что делать |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------ |
| 400 | В теле отсутствует `served_version_id`, ему присвоено `null` или тело содержит любое другое поле; либо значение не имеет префикса `pluginver_` или равно `latest`. | Отправьте ровно `{"served_version_id": "pluginver_..."}`. |
| 404 | `served_version_id` не является версией этого плагина. | Возьмите ID из [Списка версий плагина](https://platform.claude.com/docs/ru/manage-claude/plugins-api#list-a-plugins-versions). |
| 409 (без `error_code`) | Загрузка в этот плагин или другое изменение обслуживаемой версии ещё выполняется. | Повторите попытку чуть позже. |
| 409 `skill_name_taken` | Плагин находится в маркетплейсе библиотеки, и в версии есть навык, имя которого теперь использует навык организации. | Выберите другую версию или переименуйте один из навыков. |
### Удаление плагина
`DELETE /v1/organizations/plugins/{plugin_id}` безвозвратно удаляет плагин и все его версии — так же, как это делает удаление администратором в claude.ai. Это работает для любого плагина в маркетплейсе типа `manual`, включая плагин участника, даже если этот участник уже покинул организацию. Когда удаление возвращает ответ, плагин, его версии и их файлы исчезают из всех операций чтения, и участникам он больше не предоставляется. Настройки установки плагина, принадлежащего организации, удаляются вместе с ним; предоставления доступа к плагину, принадлежащему участнику, отзываются, и он исчезает также и для своего владельца. Для плагина в маркетплейсе, синхронизируемом из Git, возвращается `400`: удалите его из репозитория или удалите маркетплейс в claude.ai. Требуется область доступа `write:plugins`.
Удаление нельзя отменить, и удаления отдельных версий не существует. Чтобы вместо этого обратимо скрыть плагин, принадлежащий организации, установите его общеорганизационную настройку установки в `not_available` (плагин, который наследовал значение по умолчанию своего маркетплейса, получает собственную настройку, а [удаление этой общеорганизационной настройки](https://platform.claude.com/docs/ru/manage-claude/plugins-api#remove-an-installation-setting) впоследствии вернёт плагин к значению по умолчанию), а также удалите (или установите в `not_available`) каждую групповую настройку, которую перечисляет `GET /v1/organizations/plugins/{plugin_id}/installation_settings`, поскольку настройка группы переопределяет общеорганизационное значение для её участников. Отправляйте эти записи одну за другой, а не параллельно (см. [Установка настройки установки](https://platform.claude.com/docs/ru/manage-claude/plugins-api#set-an-installation-setting)). Плагин, принадлежащий участнику, нельзя скрыть через этот API иначе как удалив его, и только если его маркетплейс имеет тип `manual`.
```bash cURL
curl -X DELETE "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 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}"
```
```json
{ "type": "plugin_deleted", "id": "plugin_01Hq3vX8kZcN2mB7pR4tY9wL" }
```
## Версии плагинов
Версия плагина — это неизменяемый снимок файлов плагина из одной загрузки (полный объект показан в ответе из раздела [Создание версии](https://platform.claude.com/docs/ru/manage-claude/plugins-api#create-a-version)). Её поля повторяют поля обслуживаемой версии плагина (`display_name`, `description`, `manifest_version`, `content_scan`, `components`, `reach`) для этой версии, а также включают `release_notes` (в том виде, в каком они были переданы при загрузке и отображаются в истории версий claude.ai) и `created_by` (кто её загрузил).
Для `{version}` без префикса `pluginver_` возвращается `400` (за исключением литерала `latest` там, где это указано). Для значения с префиксом, которое не идентифицирует версию этого плагина, возвращается `404`.
### Список версий плагина
`GET /v1/organizations/plugins/{plugin_id}/versions` возвращает список версий плагина, упорядоченный по `created_at` по убыванию; первый элемент — это версия, которую идентифицирует `latest_version_id`. `limit` — от 1 до 1 000. Требуется область доступа `read:plugins`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL/versions?limit=50" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 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
)
# Автоматически загружает дополнительные страницы по мере необходимости.
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,
);
// Только эта страница; для следующей снова вызовите list() с 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
```
### Создание версии
`POST /v1/organizations/plugins/{plugin_id}/versions` добавляет версию к плагину, принадлежащему организации, в маркетплейсе типа `manual`. Тело запроса имеет формат `multipart/form-data` с теми же полями `files[]` и `release_notes`, [требованиями к загрузке](https://platform.claude.com/docs/ru/manage-claude/plugins-api#upload-requirements) и ошибками, связанными с файлами, манифестом, архивом и размером, что и в [Создании плагина](https://platform.claude.com/docs/ru/manage-claude/plugins-api#create-a-plugin). Загруженное имя (`name` из манифеста) должно совпадать с `name` плагина. Если плагин не закреплён, новая версия обычно начинает обслуживаться сразу после сохранения; если закреплён, версия сохраняется, но не обслуживается, пока вы не сделаете её обслуживаемой версией. Чтобы проверить, сравните `id` из ответа с `served_version_id` плагина. Возвращает версию. Требуется область доступа `write:plugins`.
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL/versions" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 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();
// Формируем часть `files[]` вручную, чтобы архив отправлялся вместе с именем файла,
// которое требуется для загрузки.
var archive = MultipartField.>builder()
.value(List.of(Files.newInputStream(Path.of("dist/sales-toolkit.zip"))))
.filename("sales-toolkit.zip")
.contentType("application/octet-stream")
.build();
var params = VersionCreateParams.builder()
.files(archive)
.releaseNotes("Adds the call-prep command.")
.build();
var version = client.beta().organization().plugins().versions()
.create("plugin_01Hq3vX8kZcN2mB7pR4tY9wL", params);
IO.println("id: " + version.id());
IO.println("manifest_version: " + version.manifestVersion().orElse(null));
}
```
```php PHP
use Anthropic\Core\FileParam;
$client = new Client();
$version = $client->beta->organization->plugins->versions->create(
pluginID: 'plugin_01Hq3vX8kZcN2mB7pR4tY9wL',
files: [
FileParam::fromResource(fopen('dist/sales-toolkit.zip', 'r')),
],
releaseNotes: 'Adds the call-prep command.',
);
echo "id: {$version->id}\n";
echo "manifest_version: {$version->manifestVersion}\n";
```
```ruby Ruby
client = Anthropic::Client.new
plugin_id = "plugin_01Hq3vX8kZcN2mB7pR4tY9wL"
version = client.beta.organization.plugins.versions.create(
plugin_id,
files: [Pathname("dist/sales-toolkit.zip")],
release_notes: "Adds the call-prep command."
)
puts "id: #{version.id}"
puts "manifest_version: #{version.manifest_version}"
```
```json
{
"type": "plugin_version",
"id": "pluginver_01Jd5sK2nQ8wE4rT6yU1iO3p",
"plugin_id": "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
"display_name": "Sales Toolkit",
"description": "Account research and call prep for the sales team.",
"manifest_version": "1.5.0",
"release_notes": "Adds the call-prep command.",
"created_by": { "type": "api_actor", "api_key_id": "apikey_01Nq9vN6rT2zH7uW4bX5mR8s" },
"content_scan": { "status": "processing", "assessment": null, "reason": null },
"components": [
{
"type": "skill",
"name": "account-research",
"description": "Researches a customer account before a call."
},
{ "type": "mcp_server", "name": "crm", "description": null },
{
"type": "command",
"name": "call-prep",
"description": "Builds a one-page brief for an upcoming call."
}
],
"reach": "remote",
"created_at": "2026-09-15T14:12:30Z"
}
```
Помимо `400` для загрузки, нарушающей [требования к загрузке](https://platform.claude.com/docs/ru/manage-claude/plugins-api#upload-requirements) (`413` для тела запроса более 200 МБ), и общих ответов (`403` для плагина, принадлежащего участнику; см. [Ответы с ошибками](https://platform.claude.com/docs/ru/manage-claude/plugins-api#error-responses)), запрос может завершиться ошибкой:
| Статус | Причина | Что делать |
| -------------------------- | ---------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| 400 | Плагин находится в маркетплейсе, синхронизируемом из Git, или загруженное имя отличается от имени плагина. | Вместо этого измените репозиторий или исправьте `name` в манифесте. |
| 409 (без `error_code`) | Другая загрузка в этот плагин или изменение обслуживаемой версии ещё выполняется. | Повторите попытку чуть позже. |
| 409 `skill_name_taken` | Плагин находится в маркетплейсе библиотеки, и версия добавляет навык с именем навыка организации. | Переименуйте навык или удалите навык организации в claude.ai. |
| 503 `registration_pending` | Версия была сохранена, но её регистрация не завершилась. | Отправьте тот же запрос повторно, если ответ содержит `x-should-retry: true` (см. [Повторные попытки загрузки](https://platform.claude.com/docs/ru/manage-claude/plugins-api#retrying-uploads)). |
### Получение версии
`GET /v1/organizations/plugins/{plugin_id}/versions/{version}` возвращает одну версию. `{version}` — это ID версии или `latest` для версии, которую идентифицирует `latest_version_id` на момент запроса. Требуется область доступа `read:plugins`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL/versions/latest" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 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}"
```
### Скачивание файлов версии
`GET /v1/organizations/plugins/{plugin_id}/versions/{version}/content` скачивает файлы версии в виде сохранённого архива `.zip` (`Content-Type: application/zip`). Архив возвращается независимо от результата сканирования содержимого, поэтому вы можете проверять версии, скрытые от участников. Он отдаётся ровно в том виде, в каком сохранён, поэтому для плагина, принадлежащего организации, в маркетплейсе `manual` его можно повторно загрузить без изменений как новую версию, при условии что он соответствует текущим требованиям к загрузке. `{version}` должен быть идентификатором версии, а не `latest`: сначала прочитайте `served_version_id` или `latest_version_id` плагина либо разрешите `latest` с помощью `GET /v1/organizations/plugins/{plugin_id}/versions/latest`. Имя файла в `Content-Disposition` формируется из имени плагина и не является уникальным; называйте сохраняемые файлы по идентификаторам плагина и версии. Требуется область `read:plugins`.
Скачивание архива плагина, **принадлежащего участнику**, записывает событие `claude_plugin_archive_accessed` в ленту активности Compliance API, которое идентифицирует ключ (как `api_actor`), плагин и его маркетплейс, версию и участника-владельца по ID; имён оно не содержит. Скачивание архива плагина, принадлежащего организации, ничего не записывает.
```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() вернул бы весь архив одной строкой, поэтому берём исходный
// ответ и копируем его тело на диск по частям.
$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)
# SDK возвращает архив, уже считанный в память, в виде StringIO.
File.binwrite("#{plugin_id}_#{version_id}.zip", archive.string)
```
## Настройки установки плагинов
Эти эндпоинты применяются к плагинам, принадлежащим организации. Для плагина, принадлежащего участнику, они возвращают `404` — у него вместо этого есть предоставления доступа (см. [Предоставления доступа к плагинам](https://platform.claude.com/docs/ru/manage-claude/plugins-api#plugin-shares)). `{target}` — это литерал `organization` для настройки плагина на уровне организации или идентификатор группы `rbac_group_` для настройки этой группы; любое другое значение возвращает `400`. Идентификаторы групп можно получить через `GET /v1/organizations/rbac_groups` (область `read:rbac_groups`; см. [Группы в разделе «Управление пользователями»](https://platform.claude.com/docs/ru/manage-claude/user-management#groups)). У настройки нет собственного `id`: она адресуется парой `(plugin_id, target)`, и субъект действия на ней не записывается (он указывается в событии активности `plugin_installation_preference_updated`).
### Список настроек установки плагина
`GET /v1/organizations/plugins/{plugin_id}/installation_settings` возвращает список настроек, которые имеет принадлежащий организации плагин, упорядоченный по `created_at` по убыванию: его собственную общеорганизационную настройку (отсутствует, пока он наследует значение по умолчанию своего маркетплейса) и настройку каждой группы. Фильтруйте по `target_type` (`organization` или `rbac_group`). Требуется область доступа `read:plugins`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL/installation_settings" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 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"
)
# Автоматически загружает дополнительные страницы по мере необходимости.
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',
);
// Только эта страница; для следующей снова вызовите list() с 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
```
### Установка настройки установки
`POST /v1/organizations/plugins/{plugin_id}/installation_settings/{target}` задаёт настройку установки одной цели для плагина, принадлежащего организации, создавая её или изменяя уже имеющееся значение. Единственное поле тела — `installation_preference` (`required`, `auto_install`, `available` или `not_available`), и оно обязательно. Установка значения, которое у цели уже есть, ничего не меняет. Установка цели `organization` прекращает наследование плагином значения по умолчанию его маркетплейса (`organization_installation_preference_inherited` становится `false`), даже если значение совпадает со значением по умолчанию, поэтому плагин больше не следует последующим изменениям значения по умолчанию маркетплейса. Чтобы вернуть плагин к значению по умолчанию его маркетплейса, [удалите общеорганизационную настройку](https://platform.claude.com/docs/ru/manage-claude/plugins-api#remove-an-installation-setting); групповые настройки при этом не затрагиваются. Целевая группа должна быть группой, которую ваша организация видит в `GET /v1/organizations/rbac_groups`, иначе запрос возвращает `404`. Изменение не меняет `updated_at` плагина; оно записывается в ленту активности. Возвращает настройку. Требуется область доступа `write:plugins`.
Отправляйте записи настроек установки для одного плагина по одной. Если несколько записей для одного и того же плагина поступают одновременно, сервер обрабатывает их одну за другой и может ответить на некоторые из них кодом `503` вместо их применения. Такой `503` содержит `x-should-retry: true`, и запись можно безопасно повторить: подождите секунду-другую, затем отправьте её снова.
```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}"
```
```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"
}
```
### Удаление настройки установки
`DELETE /v1/organizations/plugins/{plugin_id}/installation_settings/{target}` удаляет настройку установки одной цели для плагина, принадлежащего организации. Со значением `{target}`, равным `organization`, удаляется собственная общеорганизационная настройка плагина. После этого плагин снова наследует значение по умолчанию своего маркетплейса (`organization_installation_preference_inherited` становится `true`) и следует последующим изменениям этого значения; групповые настройки не затрагиваются. С ID группы `rbac_group_` удаляется настройка этой группы: участники группы возвращаются к общеорганизационному значению или к настройкам других своих групп. Цель, у которой нет собственной настройки, возвращает `404`; это относится и к цели `organization` плагина, который уже наследует значение по умолчанию своего маркетплейса. Изменение не меняет `updated_at` плагина; оно записывается в ленту активности. Ответ содержит составной ключ вместо `id`; для цели `organization` её `target` равен `{"type": "organization"}`. Требуется область доступа `write:plugins`.
```bash cURL
curl -X DELETE "https://api.anthropic.com/v1/organizations/plugins/plugin_01Hq3vX8kZcN2mB7pR4tY9wL/installation_settings/rbac_group_01F3xQqQzXyWvUtSrQpOnMlK" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 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}"
```
```json
{
"type": "plugin_installation_setting_deleted",
"plugin_id": "plugin_01Hq3vX8kZcN2mB7pR4tY9wL",
"target": { "type": "rbac_group", "rbac_group_id": "rbac_group_01F3xQqQzXyWvUtSrQpOnMlK" }
}
```
## Общий доступ к плагинам
Предоставления доступа существуют только у плагинов, принадлежащих участникам, и в этом API доступны только для чтения (см. [Общий доступ](https://platform.claude.com/docs/ru/manage-claude/plugins-api#shares)).
### Список предоставлений доступа к плагину
`GET /v1/organizations/plugins/{plugin_id}/shares` возвращает список тех, кому владелец принадлежащего участнику плагина предоставил к нему доступ, упорядоченный по `granted_at` по убыванию: всем участникам (`organization`), группе (`rbac_group`) или конкретному участнику (`organization_member`). Фильтруйте по `target_type`. Для плагина, к которому владелец не предоставлял доступ, возвращается пустой список; для плагина, принадлежащего организации, возвращается `404`. Предоставления доступа в этом API доступны только для чтения, и указанное в списке предоставление даёт доступ только пока соответствующий вид общего доступа включён для вашей организации в claude.ai (см. [Общий доступ](https://platform.claude.com/docs/ru/manage-claude/plugins-api#shares)). `granted_at` — время предоставления доступа; если владелец позже изменит предоставление в claude.ai, это будет время этого изменения. Требуется область доступа `read:plugins`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/plugins/plugin_01Mr2wP7sU3aJ8vX5cY6nS9t/shares" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 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")
# Автоматически загружает дополнительные страницы по мере необходимости.
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',
);
// Только эта страница; для следующей снова вызовите list() с page: $shares->nextPage.
foreach ($shares->getItems() as $share) {
echo "plugin_id: {$share->pluginID}\n";
}
```
```ruby Ruby
client = Anthropic::Client.new
plugin_id = "plugin_01Mr2wP7sU3aJ8vX5cY6nS9t"
page = client.beta.organization.plugins.shares.list(plugin_id)
page.auto_paging_each do |share|
puts "plugin_id: #{share.plugin_id}"
end
```
```json
{
"data": [
{
"type": "plugin_share",
"plugin_id": "plugin_01Mr2wP7sU3aJ8vX5cY6nS9t",
"target": { "type": "organization_member", "user_id": "user_01WCz9BvGLdMYRUMmcAxMWvW" },
"granted_at": "2026-08-20T15:12:00Z"
}
],
"next_page": null
}
```
## Маркетплейсы плагинов
Этот API читает [маркетплейсы](https://platform.claude.com/docs/ru/manage-claude/plugins-api#marketplaces) и задаёт настройку установки по умолчанию для маркетплейса организации; сами маркетплейсы создаются, подключаются к репозиторию и удаляются в 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"
}
```
| Поле | Описание |
| --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `name` | Имя маркетплейса. Не меняется в течение всего срока его существования. |
| `owner` | Та же структура, что и у плагина. |
| `source` | `manual`, `github`, `gitlab` или `public_git`. См. [Маркетплейсы](https://platform.claude.com/docs/ru/manage-claude/plugins-api#marketplaces). |
| `sync_status` | Результат последней синхронизации: `success`, `in_progress`, `failed_content`, `failed_transient`, `failed_auth` или `failed_limits`. `null` до первой попытки синхронизации, которая никогда не происходит для маркетплейса с источником `manual`. |
| `last_sync_ended_at` | Время завершения последней попытки синхронизации, независимо от её результата; для подключённого репозитория, который ещё не синхронизировался, — время создания маркетплейса. `null` для маркетплейса, который не синхронизируется. |
| `last_sync_read_sha` | Коммит, который последняя синхронизация прочитала из репозитория. Не обязательно тот коммит, из которого получены обслуживаемые версии. `null` для маркетплейса, который не синхронизируется. |
| `default_installation_preference` | Маркетплейсы организации: общеорганизационное значение для каждого плагина в нём, у которого нет собственной настройки (`not_available`, если никогда не задавалось). Личные маркетплейсы: `null`. |
Для `marketplace_id` без префикса `marketplace_` возвращается `400`. Для значения с префиксом, которое не разрешается или принадлежит другой организации, возвращается `404`.
### Список маркетплейсов
`GET /v1/organizations/plugin_marketplaces` возвращает список маркетплейсов вашей организации и личных маркетплейсов участников, упорядоченный по `created_at` по убыванию. Используйте его, чтобы найти ID маркетплейса — для фильтрации списка плагинов по нему или для загрузки в него — ещё до того, как в нём появится хотя бы один плагин. Маркетплейс библиотеки появляется после того, как в нём впервые что-то создано — в claude.ai или через этот API. Фильтруйте по `owner_type` (`organization` или `user`) и `source`. `limit` — от 1 до 1 000. Требуется область доступа `read:plugins`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/plugin_marketplaces?owner_type=organization" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 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"
)
# Автоматически загружает дополнительные страницы по мере необходимости.
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,
);
// Только эта страница; для следующей снова вызовите list() с 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
```
### Получение маркетплейса
`GET /v1/organizations/plugin_marketplaces/{marketplace_id}` возвращает один маркетплейс. Требуется область доступа `read:plugins`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/plugin_marketplaces/marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 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}"
```
### Установка настройки установки по умолчанию для маркетплейса
`POST /v1/organizations/plugin_marketplaces/{marketplace_id}` задаёт настройку установки по умолчанию для маркетплейса, принадлежащего организации. Каждый плагин в маркетплейсе без собственной общеорганизационной настройки сообщает это значение по умолчанию в качестве своего `organization_installation_preference`, включая плагины, добавленные позже. Это работает для маркетплейсов типа `manual` и синхронизируемых маркетплейсов; для личного маркетплейса участника возвращается `403`. Единственное обновляемое поле — `default_installation_preference`, и оно обязательно. Его нельзя вернуть в `null`: как только у маркетплейса появилось значение по умолчанию, оно сохраняется, как и в claude.ai. Изменение записывается как одно событие `marketplace_updated` без событий для отдельных плагинов и не меняет `updated_at` ни одного плагина. Установка уже заданного значения ничего не меняет, за одним исключением: маркетплейс, значение по умолчанию которого никогда не задавалось, сообщает `not_available`, но не хранит настройку, поэтому его первая запись (даже `not_available`) считается изменением. Возвращает маркетплейс. Требуется область доступа `write:plugins`.
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/plugin_marketplaces/marketplace_01Lp8uM5qS1yG6tV3aW4kQ7r" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 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}"
```
### Проверка содержимого маркетплейса
Два эндпоинта сообщают, что произойдёт при синхронизации указанного содержимого маркетплейса, ничего не подключая и не сохраняя: `POST /v1/organizations/plugin_marketplaces/validate_repository` читает публичный репозиторий GitHub, а `POST /v1/organizations/plugin_marketplaces/validate_archive` читает загружаемый вами `.zip` каталога маркетплейса. Оба возвращают одинаковый отчёт: корректен ли `marketplace.json`, какие плагины будут пропущены и почему, и какие плагины будут синхронизированы с частично опущенным содержимым. Выполняются те же проверки, что и при реальной синхронизации. Проблемы с содержимым возвращаются в отчёте, а не в виде ошибок HTTP: запрос завершается успешно с `valid: false`, даже если репозиторий или архив вообще не удаётся прочитать. Проверка считается чтением, и для двух эндпоинтов вместе действует дополнительное ограничение в 10 проверок в минуту для каждой организации (см. [Ограничение скорости](https://platform.claude.com/docs/ru/manage-claude/plugins-api#rate-limiting)); они ничего не записывают в ленту активности. Проверка может занять до 120 секунд, прежде чем вернуть результат, поэтому установите тайм-аут клиента больше этого значения. Оба эндпоинта требуют области `read:plugins` или `write:plugins` (`read:org_audit` и `read:compliance_org_data` их не предоставляют).
Проверка читает репозиторий анонимно. То же самое она делает для любого источника плагина, который находится на GitHub, но вне репозитория. В результате проверка сообщает о приватном репозитории или приватном источнике плагина как о ненайденном или требующем входа в GitHub. Когда проверка сообщает, что требуется вход в GitHub, код в отчёте — `marketplace_repo_sign_in_required`.
Проверка не загружает источники плагинов с хостов, отличных от GitHub. Плагин с таким источником обычно получает предупреждение `marketplace_validate_source_not_checked` и проверяется, когда маркетплейс действительно синхронизируется.
Проверка применяет более строгие правила к маркетплейсу, который Anthropic синхронизирует в каждую организацию. `validate_repository` применяет их, когда репозиторий является таким маркетплейсом. `validate_archive` применяет их, когда архив указывает такой маркетплейс. Более строгие правила следующие:
* Каждый источник плагина вне маркетплейса должен быть закреплён за полным SHA коммита.
* Проверка сообщает о незакреплённых источниках и источниках на неподдерживаемых хостах как об ошибках плагинов.
* Для `validate_repository` ветка, которую читает проверка, по умолчанию — это ветка, из которой синхронизируется маркетплейс.
`validate_repository` принимает тело JSON с двумя полями: `repository_url` — URL `https://` публичного репозитория на github.com (обязательно), и `ref` — имя ветки или полный 40-символьный SHA коммита (необязательно). Если `ref` опущен или равен `null`, по умолчанию используется ветка, которую читала бы синхронизация, обычно ветка репозитория по умолчанию. `validate_archive` принимает `multipart/form-data` ровно с одной частью `archive`, отправленной как файловая часть с именем файла. Файл — это `.zip` каталога маркетплейса размером не более 32 МБ, использующий только сжатие DEFLATE или STORE. Содержимое архива находится в корне или обёрнуто в одну папку (как при скачивании с Git-хоста). Другие поля формы не принимаются.
Проверка публичного репозитория в определённой ветке:
```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}"
```
```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"
}
]
}
]
}
```
| Поле | Описание |
| --------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `valid` | `true`, когда `marketplace.json` корректно сформирован и ни один плагин не был бы пропущен. Предупреждения не делают его `false`. |
| `ref` | Прочитанная ветка, по имени; `null`, если ветка не была указана и была прочитана ветка по умолчанию, для SHA коммита или для архива. |
| `commit_sha` | Проверенный коммит. Для архива, скачанного с Git-хоста, — коммит, который хост записал в поле комментария ZIP-файла, если он есть (не проверяется). |
| `total_plugin_count` | Сколько плагинов объявляет `marketplace.json`; `0`, если его не удалось прочитать. |
| `manifest_error`, `manifest_error_code` | Устанавливаются, когда ничего не удалось проверить: источник не удалось прочитать, либо `marketplace.json` отсутствует, повреждён или превышает лимит. Проверка, не завершившаяся за 120 секунд, сообщает `manifest_error_code: "marketplace_validate_deadline_exceeded"`. |
| `plugin_errors` | По одному `{name, error, error_code}` на каждый плагин, который синхронизация пропустила бы. |
| `plugin_warnings` | По одному `{name, warnings: [{message, error_code}]}` на каждый плагин, который синхронизировался бы с частично исключённым содержимым. |
Вместо этого можно проверить локальную копию каталога маркетплейса в виде `.zip`; ответ — такой же отчёт:
```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();
// Передавайте Path, чтобы часть `archive` отправлялась с именем файла — этого требует данная конечная точка.
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}"
```
Проблемы с содержимым никогда не приводят к ошибке запроса. Помимо ответов, общих для всех эндпоинтов (`403` для ключа, у которого есть только `read:org_audit` или `read:compliance_org_data`; см. [Ответы с ошибками](https://platform.claude.com/docs/ru/manage-claude/plugins-api#error-responses) и [Ограничение скорости](https://platform.claude.com/docs/ru/manage-claude/plugins-api#rate-limiting)), сам запрос может завершиться следующими ошибками:
| Статус | Причина | Что делать |
| ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------- |
| 400 | Для `validate_repository`: тело не является объектом JSON; `repository_url` отсутствует, длиннее 2 048 символов, содержит учётные данные или не имеет вида `https://github.com/{owner}/{repo}` (суффикс `.git` допускается; другой хост, более длинный путь, например `/tree/main` страницы ветки, или порт, отличный от 443 или 80, — нет); `ref` пуст, длиннее 255 символов, содержит `..` или содержит символ, отличный от букв ASCII, цифр, `.`, `_`, `-`, `+` и `/`; либо присутствует другое поле. `ref`, прошедший эти проверки, но указывающий ветку, которой нет в репозитории, не отклоняется: запрос завершается успешно с `valid: false`, а `manifest_error` сообщает, что ветка не найдена. Для `validate_archive`: тело не является `multipart/form-data`, часть `archive` отсутствует, повторяется или отправлена не как файловая часть с именем файла, либо присутствует другое поле формы. | Исправьте запрос и отправьте его повторно. |
| 413 | Для `validate_archive`: часть `archive` или объявленная длина тела запроса превышает 32 МБ. | Вместо этого проверьте репозиторий по URL или уменьшите архив. |
#### Коды отчёта
Каждая находка в отчёте имеет стабильный код: `manifest_error_code`, когда ничего не удалось проверить, `error_code` в каждой записи `plugin_errors` и `error_code` в каждом предупреждении. Если у плагина несколько проблем, `error_code` соответствует первой, а `error` объединяет их сообщения. Могут добавляться новые коды; нераспознанный `manifest_error_code` по-прежнему означает, что содержимое не удалось проверить, такой код в записи `plugin_errors` по-прежнему означает, что плагин будет пропущен, а в предупреждении — что плагин будет синхронизирован. Эти коды указывают на временные условия, поэтому тот же запрос может позже завершиться успешно: `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` и обычно `marketplace_validate_deadline_exceeded`.
## Нераспознанные значения
Любое строковое значение на этой странице (типы компонентов, `reach`, поля сканирования, `source` маркетплейса, коды ошибок) может в любой момент получить новые значения. Обрабатывайте нераспознанное значение так же, как любую неизвестную строку, а не завершайте работу с ошибкой.
## Ограничение скорости
Запросы на чтение (все эндпоинты `GET` на этой странице) имеют общее ограничение в **300 запросов в минуту** для каждой организации. Запросы на запись (создание плагина или версии, изменение обслуживаемой версии, удаление, установка или удаление настройки установки и обновление маркетплейса) имеют общее ограничение в **60 запросов в минуту** для каждой организации. Проверка маркетплейса (любой из двух эндпоинтов) считается чтением, и дополнительно проверки ограничены 10 в минуту для каждой организации суммарно по обоим эндпоинтам; оба ограничения проверяются до чтения тела запроса. Эти ограничения считаются по всем ключам вашей организации и не зависят от прочих ограничений Admin API вашей организации. Запрос на чтение, передающий `organization_id`, учитывается в ограничении организации, в которой был создан ключ, или родительской организации, если у ключа нет собственной организации. Запросы сверх ограничения возвращают **429 Too Many Requests** с заголовком `retry-after`. Ответы включают заголовки `anthropic-ratelimit-requests-*` для применимого ограничения (при проверке маркетплейса — её ограничение в 10 в минуту; при `429` — то ограничение, которое отклонило запрос).
Загрузка, изменение обслуживаемой версии или проверка также могут вернуть `429` с `retry-after`, когда у сервиса временно нет ресурсов для ещё одной такой операции, а загрузка возвращает `429`, когда ваша организация превысила свою скорость сканирования содержимого. Обрабатывайте все эти случаи одинаково: подождите время, указанное в `retry-after`, затем повторите попытку. Независимо от этих ограничений, отправляйте записи настроек установки для одного и того же плагина по одной: когда несколько из них поступают одновременно, на некоторые может быть дан ответ `503` с `x-should-retry: true`, и их можно безопасно отправить снова через секунду-другую (см. [Установка настройки установки](https://platform.claude.com/docs/ru/manage-claude/plugins-api#set-an-installation-setting)).
## Пагинация
Эндпоинты списков используют **opaque cursor** (непрозрачный курсор). Первый запрос возвращает до `limit` строк и курсор `next_page`; передайте этот курсор без изменений в параметре `page` следующего запроса и повторяйте, пока `next_page` не станет `null`. Считайте строку курсора непрозрачной: не разбирайте, не изменяйте и не формируйте её самостоятельно. [Получение списка плагинов](https://platform.claude.com/docs/ru/manage-claude/plugins-api#list-plugins) может вернуть страницу, содержащую меньше `limit` плагинов или не содержащую их вовсе, при этом `next_page` всё ещё будет задан, поэтому продолжайте запрашивать страницы, пока `next_page` не станет `null`. Итераторы списков в SDK для Python, TypeScript, C#, Go, Java и Ruby, а также CLI (кроме режима `--format raw`) делают это за вас. Они запрашивают следующую страницу, пока задан `next_page`, поэтому короткая или пустая страница не прерывает их работу. В PHP и curl запрашивайте каждую страницу самостоятельно и передавайте её `next_page` в качестве `page`.
`limit` по умолчанию равен 20, минимальное значение — 1. Максимальное значение — 100 для плагинов, настроек установки и предоставлений доступа и 1 000 для версий и маркетплейсов. Каждый список упорядочен от новых к старым.
## Ответы с ошибками
Ответы с ошибками имеют стандартную структуру, описанную в разделе [Ошибки Claude API](https://platform.claude.com/docs/ru/api/errors). При обращении в поддержку указывайте `request_id` из тела ответа.
| Статус | Значение |
| ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 400 | Недопустимые входные данные, или операция неприменима к этому плагину или маркетплейсу (см. раздел каждой конечной точки). Также возвращается для параметра запроса, который конечная точка не распознаёт, и для организации, не являющейся организацией Claude Enterprise (`this endpoint is not supported for this organization type`). |
| 401 | Отсутствует заголовок `x-api-key`, или ключ не распознан. |
| 403 | У ключа нет требуемой области действия, или запрос выполняет загрузку в плагин или личный маркетплейс участника, изменяет обслуживаемую версию такого плагина или задаёт для него значение по умолчанию. (Удаление плагина участника разрешено.) |
| 404 | Ресурс не найден. Также возвращается, когда в запросе отсутствует значение `anthropic-beta` или API не включён для вашей организации, поэтому конечные точки выглядят несуществующими. |
| 409 | Имя занято, `content_scan` версии имеет значение `processing`, или выполняется конфликтующая загрузка. |
| 413 | Тело запроса превышает ограничение размера: 200 МБ для загрузки, 32 МБ для проверки маркетплейса. |
| 429 | Превышен «rate limit» (ограничение скорости). См. [Ограничение скорости](https://platform.claude.com/docs/ru/manage-claude/plugins-api#rate-limiting). |
| 500 | Внутренняя ошибка. |
| 503 | Временная ошибка. Также возвращается, когда несколько операций записи параметров установки для одного плагина поступают одновременно; отправляйте их по одной. Повторите попытку с «backoff» (экспоненциальной задержкой), за исключением `registration_pending` (см. следующую таблицу). |
Когда у одного статуса есть несколько причин, которые вы обрабатывали бы по-разному, ошибка также содержит `error.details.error_code`, а также `error.details.plugin_id` или `error.details.plugin_version_id`, если причина связана с одним из них:
```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` | Статус | Значение и что делать |
| ----------------------------------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `plugin_name_taken` | 409 | Это имя в маркетплейсе уже занято. `details.plugin_id` — это плагин, который его занимает, и его мог создать кто-то другой. Чтобы узнать, кто именно, [получите плагин](https://platform.claude.com/docs/ru/manage-claude/plugins-api#get-a-plugin) и прочитайте его поле `created_by`, которое равно `null`, если создатель не записан. Загружайте в него версии, только если это тот плагин, который вы собирались обновить. В противном случае или если `plugin_id` отсутствует, выполните загрузку под другим именем. |
| `skill_name_taken` | 409 | Плагин находится в маркетплейсе библиотеки, и один из его навыков имеет то же имя, что и навык организации (навык, который администратор загрузил для всей организации в claude.ai). `details.skill_name` указывает его имя. Переименуйте или удалите один из них. |
| `registration_pending` | 503 | Файлы были сохранены, но навыки плагина пока не удалось сделать доступными для участников. См. [Повторные попытки загрузки](https://platform.claude.com/docs/ru/manage-claude/plugins-api#retrying-uploads). |
| `scan_pending` | 409 | `content_scan` версии имеет значение `processing`. Повторите попытку после завершения сканирования. |
| `scan_failed` | 400 | `content_scan` версии имеет значение `fail`, `unknown` или `errored`, поэтому её нельзя обслуживать. Выберите другую версию. |
| `cmek_key_disabled`, `cmek_key_network_blocked` | 400 | Ключ шифрования, управляемый клиентом, вашей организации недоступен. См. [Ключи шифрования, управляемые клиентом](https://platform.claude.com/docs/ru/manage-claude/plugins-api#customer-managed-encryption-keys). |
| `unsupported_charset` | 400 | При загрузке или `validate_archive` заголовок `Content-Type` запроса указывает кодировку, отличную от UTF-8, ISO-8859-1 или US-ASCII. Отправьте запрос без кодировки или с одной из этих. |
Могут быть добавлены новые коды. Обрабатывайте нераспознанный код так же, как его статус.
### Повторные попытки загрузки
Ни один эндпоинт не принимает `Idempotency-Key`. Изменение обслуживаемой версии, задание настройки установки и задание значения по умолчанию для маркетплейса можно безопасно повторять. Повторный запрос на удаление, как и повторное удаление настройки установки, возвращает `404`.
Загрузка, вернувшая ошибку, ничего не сохранила, за одним исключением: `503` с `error_code: "registration_pending"`. После сохранения файлов загрузки сервер регистрирует навыки новой версии в claude.ai, что и делает их доступными для участников; `registration_pending` означает, что файлы были сохранены, но этот последний шаг не завершился. Повторная загрузка тех же файлов завершает его (и сохраняет ещё одну, идентичную версию):
* При `POST /v1/organizations/plugins` плагин *был* создан, и ответ содержит `x-should-retry: false`: не отправляйте запрос на создание повторно (повторная отправка возвращает `409 plugin_name_taken`); вместо этого загрузите те же файлы как версию `details.plugin_id`.
* При `POST /v1/organizations/plugins/{plugin_id}/versions` версия *была* сохранена (`details.plugin_version_id`); отправьте тот же запрос повторно, если ответ содержит `x-should-retry: true`, и не отправляйте, если он содержит `false`.
Если ответ на создание потерян, отправьте запрос на создание снова. `409 plugin_name_taken` означает либо то, что первая попытка сохранила плагин, либо то, что имя уже было занято. Плагин из `details.plugin_id` создан вашим потерянным запросом, только если его `created_by` — это `api_actor` с `api_key_id` вашего ключа. Проверьте это, прежде чем загружать в него версии (см. `plugin_name_taken` в предыдущей таблице). Повторная попытка создания версии, ответ на которое был потерян, сохраняет вторую, идентичную версию. Чтобы избежать этого, записывайте `latest_version_id` плагина перед каждой загрузкой; если ответ потерян, прочитайте плагин и повторите попытку, только если `latest_version_id` не изменился.
## События ленты активности
Каждая операция записи через этот API регистрируется в [ленте активности Compliance API](https://platform.claude.com/docs/ru/manage-claude/compliance-activity-feed) вашей организации и приписывается «API key» (ключу API) как `api_actor` с его идентификатором `apikey_`. Тот же субъект указывается в `created_by` у плагинов и версий, которые создаёт ключ.
| Событие | Когда генерируется |
| ---------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `claude_plugin_created` | Плагин создан загрузкой (здесь или в claude.ai) или принятым запросом на публикацию. Плагин, созданный синхронизацией Git, генерирует только `claude_plugin_version_created`. |
| `claude_plugin_version_created` | Версия сохранена. Версии, сохранённые синхронизацией Git, приписываются `system_actor`. |
| `claude_plugin_updated` | В существующий плагин загружена новая версия. |
| `claude_plugin_served_version_updated` | Изменилась обслуживаемая версия. |
| `claude_plugin_deleted` | Плагин удалён отдельно, здесь или в claude.ai. |
| `plugin_installation_preference_updated` | Параметр установки задан или удалён. |
| `marketplace_created` | Первая загрузка создаёт маркетплейс библиотеки. |
| `marketplace_updated` | Изменился параметр установки маркетплейса по умолчанию, или администратор либо владелец запускает синхронизацию в claude.ai. |
| `marketplace_deleted` | Маркетплейс удалён в claude.ai вместе с его плагинами (без событий для отдельных плагинов). |
| `claude_plugin_archive_accessed` | Скачан архив плагина, принадлежащего участнику. |
| `claude_plugin_security_scan_completed` | Завершено сканирование содержимого. |
Идентификаторы плагинов, версий и маркетплейсов в этих событиях — те же идентификаторы, которые возвращает этот API. Событие также может указывать маркетплейс, который этот API не перечисляет, например маркетплейс плагинов, публикуемых Anthropic. `plugin_installation_preference_updated` идентифицирует плагин по его `name` и `marketplace_id`, а не по `id`. В `claude_plugin_security_scan_completed` `plugin_version` не является идентификатором версии, и ни одно поле [версии плагина](https://platform.claude.com/docs/ru/manage-claude/plugins-api#plugin-versions) ему не соответствует.
Изменение значения по умолчанию для маркетплейса регистрирует одно событие `marketplace_updated` и не регистрирует событий для отдельных плагинов, хотя оно изменяет значение каждого плагина, наследующего значение по умолчанию. Операции чтения не регистрируются, за исключением скачивания архива плагина, принадлежащего участнику. Операция записи, которая ничего не изменяет, ничего не регистрирует.
Предоставление или отзыв общего доступа в claude.ai отображаются в ленте как события `role_assignment_granted` и `role_assignment_revoked`. Этот API не сообщает об удалениях: удалённый плагин отсутствует в следующем списке. Плагин, удалённый синхронизацией Git, удалением его маркетплейса (одно событие `marketplace_deleted`) или удалением учётной записи участника либо организации, не генерирует события для отдельного плагина, поэтому периодически заново получайте полный список, чтобы отслеживать удаления.
## Ключи шифрования, управляемые клиентом
Если ваша организация использует «[customer-managed encryption key](https://platform.claude.com/docs/ru/manage-claude/cmek)» (ключ шифрования, управляемый клиентом), то `description`, `release_notes`, `components` и файлы версии шифруются с его помощью. Пока ключ недоступен:
* Операции чтения и получения списков по-прежнему выполняются успешно, при этом `description`, `release_notes` и `components` возвращаются как `null`.
* Скачивание архивов, создание плагинов, создание версий и изменение обслуживаемой версии возвращают `400` с `cmek_key_disabled` или `cmek_key_network_blocked`.
* Удаление плагина в маркетплейсе библиотеки возвращает `400 cmek_key_disabled` и ничего не удаляет, поскольку его навыки сначала должны быть отозваны из claude.ai, а для этого нужен ключ. Другие операции удаления, параметры установки и значения по умолчанию для маркетплейсов работают в обычном режиме.
Восстановление ключа устраняет все эти ограничения.
## См. также
Где ваш основной владелец создаёт ключ с ограниченной областью действия.
Конечные точки групп, предоставляющие идентификаторы `rbac_group_`, используемые в параметрах установки.
Где регистрируются операции записи плагинов и скачивания архивов участников.
Отчёты об использовании плагинов и навыков для Claude Enterprise.