---
title: Claude Tag API
url: https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api
description: 从您自己的系统为您的 Claude Enterprise 组织管理 Slack 中的 Claude Tag：读取和更改频道、工作区以及组织 Slack 默认设置上的设置，查看哪些设置生效及其原因，并附加 Access bundle。
---
[Claude Tag](https://claude.com/docs/claude-tag/overview) 是在 Slack 中作为团队成员工作的 Claude：有人在频道中提及 Claude，Claude 就会在该线程中回答。借助 Claude Tag API，您可以从自己的系统读取和更改 Claude Tag 设置，而这些设置原本需要组织所有者在 [claude.ai > Organization settings > Claude Tag](https://claude.ai/admin-settings/claude-tag) 中手动设置。您可以用它从审批工作流中逐个频道开启 Claude，将配置保存在版本控制中，或审计每个频道中生效的设置。
Claude Tag 是一款 claude.ai 产品。此 API 为 Claude Enterprise 组织管理该产品，与 Claude Platform 工作区、API 用量或 Claude Console 无关。
**需要具有作用域的 Admin API 密钥**
这些端点需要具有 `read:claude_tag` 作用域（用于 `GET` 端点）或 `write:claude_tag` 作用域（用于 `POST` 和 `DELETE` 端点）的 Admin API 密钥；请参阅[作用域](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#scopes)。有关主要所有者在何处创建密钥，请参阅[创建 Admin API 密钥](https://platform.claude.com/docs/zh-CN/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization)。请在每个请求的 `x-api-key` 标头中传递该密钥，同时附带 [`anthropic-version`](https://platform.claude.com/docs/zh-CN/api/versioning) 标头以及下方说明中所示的 beta 标头。
Claude Tag API 目前处于 **beta** 阶段，仅适用于 Claude Enterprise 组织，不适用于 Claude Platform（Claude Console）组织。
每个请求都必须包含 [beta 标头](https://platform.claude.com/docs/zh-CN/api/beta-headers) `anthropic-beta: claude-tag-2026-09-28`（SDK 和 `ant` CLI 会为您发送该标头）。缺少该标头的请求会返回 `404`，就像该端点不存在一样。
## 端点
该 API 在五种资源上共提供 18 个端点：
| 资源 | 端点 |
| --------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Slack 频道：** 设置频道、列出工作区的频道或按 Slack ID 查找频道、读取频道、更改其设置、查看其中生效的设置、移除频道 | `POST /v1/organizations/claude_tag/slack_channels`
`GET /v1/organizations/claude_tag/slack_channels`
`GET /v1/organizations/claude_tag/slack_channels/{id}`
`POST /v1/organizations/claude_tag/slack_channels/{id}`
`GET /v1/organizations/claude_tag/slack_channels/{id}/effective`
`DELETE /v1/organizations/claude_tag/slack_channels/{id}` |
| **Slack 工作区：** 列出已连接的工作区或按 Slack ID 查找工作区、读取工作区、更改其设置、查看其中生效的设置 | `GET /v1/organizations/claude_tag/slack_workspaces`
`GET /v1/organizations/claude_tag/slack_workspaces/{id}`
`POST /v1/organizations/claude_tag/slack_workspaces/{id}`
`GET /v1/organizations/claude_tag/slack_workspaces/{id}/effective` |
| **Slack 默认设置：** 读取和更改适用于每个工作区和频道的设置 | `GET /v1/organizations/claude_tag/slack_defaults`
`POST /v1/organizations/claude_tag/slack_defaults` |
| **Bundle：** 列出组织的 Access bundle、读取单个 Bundle（只读） | `GET /v1/organizations/claude_tag/bundles`
`GET /v1/organizations/claude_tag/bundles/{bundle_id}` |
| **Bundle 目标：** 列出 Bundle 附加到的位置、将其附加到频道或工作区、读取单条附加记录、将其分离 | `GET /v1/organizations/claude_tag/bundles/{bundle_id}/targets`
`POST /v1/organizations/claude_tag/bundles/{bundle_id}/targets`
`GET /v1/organizations/claude_tag/bundles/{bundle_id}/targets/{target_id}`
`DELETE /v1/organizations/claude_tag/bundles/{bundle_id}/targets/{target_id}` |
此版本涵盖 Slack。连接和断开 Slack 工作区、创建和编辑 Access bundle、支出限额，以及除[设置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#settings)中五项之外的所有 Claude Tag 设置，仍在 claude.ai 中进行。
## 前提条件
* 您的组织必须使用 Claude Enterprise 计划，已[完成 Claude Tag 设置](https://claude.com/docs/claude-tag/admins/setup-overview)，并且至少连接了一个 Slack 工作区。
* 您的主要所有者在 [claude.ai > Organization settings > API](https://claude.ai/admin-settings/api-access) 中创建具有 `read:claude_tag` 作用域、`write:claude_tag` 作用域或两者兼有的 Admin API 密钥。请参阅[创建 Admin API 密钥](https://platform.claude.com/docs/zh-CN/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization)。
* 每个请求都携带三个标头：`x-api-key`、`anthropic-version: 2023-06-01` 和 `anthropic-beta: claude-tag-2026-09-28`。
Python、TypeScript、C#、Go、Java、PHP 和 Ruby SDK 在 `client.beta.organization.claude_tag` (typescript: `client.beta.organization.claudeTag`; csharp, go: `client.Beta.Organization.ClaudeTag`; java: `client.beta().organization().claudeTag()`; php: `$client->beta->organization->claudeTag`) 下提供这些端点，[`ant` CLI](https://platform.claude.com/docs/zh-CN/cli-sdks-libraries/cli/quickstart) 则在 `ant beta:organization:claude-tag` 下提供；它们会为您发送 `anthropic-version` 和 `anthropic-beta` 标头。本页示例使用各 SDK 的默认客户端，与 CLI 一样，它会从 `ANTHROPIC_API_KEY` 环境变量中读取 Admin API 密钥；curl 示例从同一变量读取密钥，并在 `x-api-key` 标头中传递。当 SDK 或 CLI 为您获取更多页面时，`limit` 设置的是每页大小，而不是总数（请参阅[分页](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#pagination)）。
API 密钥属于组织，在创建者离开后仍然有效。请勿共享这些密钥，也不要将其提交到源代码管理中。
## 快速入门
列出您的组织已连接到 Claude Tag 的 Slack 工作区：
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_workspaces" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-workspaces list
```
```python Python
client = anthropic.Anthropic()
workspaces = client.beta.organization.claude_tag.slack_workspaces.list()
# 根据需要自动获取更多页面。
for workspace in workspaces:
print(f"{workspace.id}: {workspace.slack.team_id}")
```
```typescript TypeScript
const client = new Anthropic();
const workspaces = await client.beta.organization.claudeTag.slackWorkspaces.list();
for await (const workspace of workspaces) {
console.log(`${workspace.id}: ${workspace.slack.team_id}`);
}
```
```csharp C#
AnthropicClient client = new();
var page = await client.Beta.Organization.ClaudeTag.SlackWorkspaces.List();
await foreach (var workspace in page.Paginate())
{
Console.WriteLine($"{workspace.ID}: {workspace.Slack.TeamID}");
}
```
```go Go
client := anthropic.NewClient()
workspaces := client.Beta.Organization.ClaudeTag.SlackWorkspaces.ListAutoPaging(
context.Background(),
anthropic.BetaOrganizationClaudeTagSlackWorkspaceListParams{},
)
for workspaces.Next() {
workspace := workspaces.Current()
fmt.Printf("%s: %s\n", workspace.ID, workspace.Slack.TeamID)
}
if err := workspaces.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var workspaces = client.beta().organization().claudeTag().slackWorkspaces().list();
for (var workspace : workspaces.autoPager()) {
IO.println(workspace.id() + ": " + workspace.slack().teamId());
}
```
```php PHP
$client = new Client();
$workspaces = $client->beta->organization->claudeTag->slackWorkspaces->list();
// 仅限当前页；如需下一页，请使用 page: $workspaces->nextPage 再次调用 list()。
foreach ($workspaces->getItems() as $workspace) {
echo "{$workspace->id}: {$workspace->slack->teamID}\n";
}
```
```ruby Ruby
client = Anthropic::Client.new
page = client.beta.organization.claude_tag.slack_workspaces.list
page.auto_paging_each do |workspace|
puts "#{workspace.id}: #{workspace.slack.team_id}"
end
```
```json Response
{
"data": [
{
"type": "slack_workspace",
"id": "slws_011CZkZnWa7xPc3uJfZe5LgT",
"slack": {
"team_id": "T01ABCD2EFG"
},
"settings": {
"enabled": null,
"instructions": "Answer in English unless asked otherwise.",
"model": null,
"environment_id": null,
"guest_policy": null
},
"agent_id": "cagt_011CZkZrFy4aSg8uMkDt9PqW",
"created_at": "2026-09-02T17:04:11Z",
"updated_at": "2026-10-06T09:41:53Z"
}
],
"next_page": null
}
```
值为 `null` 的设置表示未在此工作区上设置，因此该工作区会继承它。请参阅[存储的设置与生效的设置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#stored-and-effective-settings)。
## 作用域
| 作用域 | 授予的权限 |
| ------------------ | -------------------------------------------------------- |
| `read:claude_tag` | 本页上的每个 `GET` 端点。 |
| `write:claude_tag` | 本页上的每个 `POST` 和 `DELETE` 端点。它不授予读取权限，尽管更改请求的响应中包含已更改的资源。 |
一个密钥可以同时携带两个作用域。先查找频道再更改它的集成需要两者兼有。没有其他作用域可以授予对这些端点的访问权限。
密钥必须属于整个组织。组织始终是密钥所属的组织，任何请求都不会指定组织。发送 `anthropic-workspace-id` 标头的请求会返回 `400`，因为这里的任何内容都不属于 Claude Platform 工作区。
## 关键概念
### 本页与 claude.ai 中的名称
| 此 API | claude.ai 和 Slack |
| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| Slack 工作区 | Slack 工作区（Slack 也称之为 team）。它与 Claude Platform 工作区无关，后者的 ID 以 `wrkspc_` 开头。 |
| Slack 默认设置 | **Default Slack access** |
| 设置层级 | 一个 [scope](https://claude.com/docs/claude-tag/admins/customize)：频道、工作区或 Slack 默认设置 |
| Bundle | 一个 [Access bundle](https://claude.com/docs/claude-tag/concepts/glossary#access-bundle) |
| `enabled` | **Enable Claude Tag in Slack** 开关 |
| `instructions` | **Custom instructions** |
| `model` | **Model** |
| `environment_id` | **Environment** |
| `guest_policy` | **How should Claude work in channels with guests**：`restrict` 对应 **Restrict**，`channel_only` 对应 **Channel only**，`allow` 对应 **Full access** |
### 已设置的频道和工作区
当 Claude Tag 为某个频道或工作区保存了设置记录时，该频道或工作区即为**已设置**。只有已设置的频道或工作区才有 `id`，也只有它们会被列出：工作区的完整频道列表由 Slack 而非此 API 保存。
* 当组织所有者在 claude.ai 中连接**工作区**时，该工作区即为已设置。没有端点可以设置或移除工作区。
* **频道**可以在 claude.ai 中设置、通过 Claude 在其中的首次使用设置，或通过[设置频道](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#set-up-a-channel)设置。
* **Slack 默认设置**在首次有人设置 Claude Tag 时即为已设置：所有者连接 Slack 工作区，或成员在 Slack 中登录或首次使用 Claude。
在工作区连接处于活动状态期间，您的组织拥有该工作区及其中的频道。您不拥有的频道或工作区会返回与不存在的频道或工作区相同的 `404`。
### ID
您通过 Slack 显示的 ID 来识别频道。使用[按 Slack ID 查找频道](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#find-a-channel-by-its-slack-ids)查找一次其 `id`，然后存储并使用该 `id`。
| ID | 前缀 | 出现位置 |
| ----------------- | --------- | ------------------------------------------ |
| Slack 频道资源 | `slch_` | 频道上的 `id`；请求体和响应中的 `slack_channel_id` |
| Slack 工作区资源 | `slws_` | 工作区上的 `id`；请求体和响应中的 `slack_workspace_id` |
| Bundle | `capp_` | Bundle 上的 `id`；路径中的 `{bundle_id}` |
| Bundle 目标 | `btgt_` | Bundle 目标上的 `id`；路径中的 `{target_id}` |
| Slack 自身的 team ID | `T` | `slack.team_id`；`slack_team_id` 查询参数 |
| Slack 自身的频道 ID | `C` 或 `G` | `slack.channel_id`；`slack_channel_id` 查询参数 |
`slack_channel_id` 有两种含义。在**查询参数**中，它是 Slack 自身的 ID（`C05HJKL6MNP`）。在**请求体或响应**中，它是此 API 签发的 `id`（`slch_...`）。请求体或响应中的 Slack 自身 ID 始终位于 `slack` 下。
只要频道或工作区处于已设置状态，无论您对其做何更改，其 `id` 都不会改变，唯一的例外见[只读模式](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#read-only-mode)。被移除后重新设置的频道或工作区会获得新的 `id`，旧的 `id` 会持续返回 `404`。当存储的 `id` 返回不带 `error_code` 的 `404` 时，请使用相同的密钥和标头[获取 Slack 默认设置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#get-the-slack-defaults)。该请求不指定任何频道或工作区，因此任何非 `404` 的状态都表示该 `id` 已失效：请通过 Slack ID 重新查找该频道或工作区。如果该请求也返回 `404`，则无法说明该 `id` 的任何情况：请保留您存储的 `id` 值，并参阅[错误响应](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#error-responses)。
`agent_id`（前缀为 `cagt_`）是 [Compliance API](https://platform.claude.com/docs/zh-CN/manage-claude/compliance-api) 对同一频道或工作区的命名方式，既用作 Claude 在其中运行的会话的所有者，也用于 [Activity Feed 事件](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#activity-feed-events)中。它的有效期与 `id` 相同。
### 设置
每个设置层级都存储相同的五项设置，均为可选：
| 设置 | 类型 | 描述 |
| ---------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `enabled` | boolean | Claude 是否开启。 |
| `instructions` | string | Claude 在每个会话中读取的常设指导。去除首尾空白后最多 8,192 个字符。空白文本会清除该设置。 |
| `model` | string | 新会话启动时使用的模型：您的组织可在 Claude Tag 中使用的[模型 ID](https://platform.claude.com/docs/zh-CN/models/overview)。最多 128 个字符。 |
| `environment_id` | string | 会话运行所在的云环境，前缀为 `env_`。它必须处于活动状态并属于您的组织。 |
| `guest_policy` | object | 当频道中有 Slack 访客时，Claude 对频道中所有人的行为：`{"type": "allow"}`（Claude 回答）、`{"type": "restrict"}`（Claude 不回答）或 `{"type": "channel_only"}`（Claude 仅使用附加到该频道本身的 Bundle 回答）。有关它在通过 Slack Connect 共享或跨 Enterprise Grid 的频道中的含义，请参阅[限制访客频道](https://claude.com/docs/claude-tag/admins/restrict-access#restrict-guest-channels)。 |
`model` 和 `environment_id` 仅在写入时检查，之后不再检查：如果模型或环境后来发生变化，两种视图都会继续返回存储的值。
如果组织所有者在 claude.ai 中将某个设置层级置于自托管运行器池上，则其 `environment_id` 会返回该池的 ID，以 `ccpool_` 开头。此 API 无法设置运行器池，对于在存储了运行器池的设置层级上更改或清除 `environment_id` 的请求，会返回 `400`。
### 存储的设置与生效的设置
设置存在于三个层级：频道、频道所在的工作区，以及组织的 Slack 默认设置。每个层级只存储在其上设置的内容。API 为您提供两种视图：
* **存储**视图（[获取频道](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#get-a-channel)、[获取工作区](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#get-a-workspace)）包含频道或工作区本身存储的内容。未在其上设置的设置为 `null`。可用它与您在其他地方保存的配置进行比较。
* **生效**视图（[获取频道的生效设置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#get-a-channels-effective-settings)、[获取工作区的生效设置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#get-a-workspaces-effective-settings)）包含综合考虑所有层级后生效的内容，`sources` 指明每个值来自哪个层级。可用它进行审计，或了解 Claude 在某个频道中为何如此表现。
每项设置单独解析：
| 设置 | 规则 | 没有层级设置时 |
| ---------------- | ------------------------------------------------------------- | ------------------------------- |
| `enabled` | 由设置了它的最近层级决定，因此频道上的 `true` 会在该频道开启 Claude，即使其工作区存储的是 `false`。 | `true` |
| `instructions` | 累加。所有设置了它的层级的文本会按从最宽泛到最具体的顺序拼接，中间以空行分隔。 | `null` |
| `model` | 由设置了它的最近层级决定。 | `null`：Claude 使用产品的默认模型 |
| `environment_id` | 由设置了它的最近层级决定。 | `null` |
| `guest_policy` | 由设置了它的最近层级决定。 | 在已设置 Slack 默认设置的组织中为 `restrict` |
例如，某组织在其 Slack 默认设置上存储了指令，在某个工作区上关闭了 Claude，并在该工作区的一个频道上设置了模型。该频道的生效视图会显示这三个值及其各自来源：
```json
{
"type": "slack_channel_effective",
"id": "slch_011CZkZmRt4vNq8sHbYw2KdX",
"settings": {
"enabled": false,
"instructions": "Be brief.",
"model": "claude-opus-5-5",
"environment_id": null,
"guest_policy": { "type": "restrict" }
},
"sources": {
"enabled": {
"type": "slack_workspace",
"slack_workspace_id": "slws_011CZkZnWa7xPc3uJfZe5LgT"
},
"instructions": [{ "type": "slack_defaults" }],
"model": {
"type": "slack_channel",
"slack_channel_id": "slch_011CZkZmRt4vNq8sHbYw2KdX"
},
"environment_id": { "type": "default" },
"guest_policy": { "type": "default" }
}
}
```
来源为以下之一：
| `type` | 含义 |
| ---------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| `slack_channel` | 频道，在 `slack_channel_id` 中指明。 |
| `slack_workspace` | 工作区，在 `slack_workspace_id` 中指明。 |
| `slack_parent_channel` | 代码频道的父频道，在 `slack_channel_id` 中指明。代码频道是从另一个频道启动的频道。当父频道是同一工作区中的公共频道时，它位于该频道与工作区之间，并且仅提供 `instructions` 和 `environment_id`。 |
| `slack_defaults` | 组织的 Slack 默认设置，没有 ID。 |
| `default` | 没有层级设置值，因此应用内置默认值。 |
`sources.instructions` 是一个列表，按从最宽泛到最具体的顺序列出所有提供文本的层级，没有层级提供时为空。在通过 Slack Enterprise Grid 连接而非频道自身工作区访问该频道的组织中，来源上的 ID 可能为 `null`。
### 更改设置
三个更新端点和[设置频道](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#set-up-a-channel)都接受遵循相同规则的 `settings` 对象：
* **您省略的设置保持不变。** `{"settings": {"enabled": false}}` 会关闭 Claude，其他四项设置保持原样。
* **您以 `null` 发送的设置会被清除**，因此该层级会重新继承它。
* **全有或全无。** 如果请求中的任何值被拒绝，则请求中的任何设置都不会被存储。
* **可安全重复。** 每次更改都会使资源保持与第一次相同请求后的状态一致，因此没有端点接受 `Idempotency-Key`。未做任何更改的请求不会写入任何内容，也不会记录 Activity Feed 事件。
* **最后写入者胜出。** 没有请求接受前置条件。两个调用方各自读取资源后更改同一设置，会相互覆盖。仅当另一项更改在您的请求运行期间与之重叠时才会返回 `409`；您的请求中没有任何内容被存储，因此请重新读取资源，如果仍有需要，请重新发送更改。
更改频道上的 `guest_policy` 可能会结束该频道中正在运行的会话。这些会话在后台结束，响应不会等待其完成。
### 已配置的层级
一旦有人或密钥更改了某个设置层级上的设置或向其附加了 Bundle，该层级即为**已配置**。此后它将一直保持已配置状态，即使所有设置都被清除、所有 Bundle 都被分离。通过 Claude 的首次使用设置的频道，或通过此 API 在不带任何设置的情况下设置的频道，在首次更改或首次附加 Bundle 之前都不是已配置状态。这在两个地方很重要：只有已配置的频道才能被[移除](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#remove-a-channel)，只有未配置的频道才可能获得新的 `id`（请参阅[只读模式](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#read-only-mode)）。
### 只读模式
**API / Terraform read-only mode** 是组织所有者在 claude.ai 的 Claude Tag 设置中开启和关闭的一项设置。该名称描述的是 claude.ai 和 Slack：开启此模式时，它们会拒绝个人对此 API 所管理内容的更改，因此只有密钥才能进行这些更改。它不会使此 API 变为只读。无论此模式开启与否，本页上的每个端点的响应都相同，也没有端点读取或更改此模式。
此模式关闭时，个人和密钥会更改相同的设置、附加和分离相同的 Bundle，每次更改都会替换已存储的内容。如果您的流水线应成为唯一的更改来源，请开启此模式。
此模式开启时，claude.ai 和 Slack 会拒绝：
* 更改频道、工作区或 Slack 默认设置上五项设置中的任何一项。
* 在 claude.ai 中设置频道、移除频道或断开工作区连接。
* 将 Bundle 附加到频道或工作区、将其分离，或删除已附加到频道或工作区的 Bundle。
无论此模式开启与否，有些操作都仍然可行：所有者仍可连接新工作区、创建和编辑 Bundle，以及更改此 API 不管理的 Claude Tag 设置。Claude 的首次使用仍会设置频道，在 Slack 中删除频道仍会将其移除，卸载 Claude 的 Slack 应用仍会断开该工作区的连接。
此模式关闭时，在 claude.ai 中设置一个已设置但未[配置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#configured-levels)的频道可能会替换该频道的记录。此时该频道会获得新的 `id` 和 `agent_id`，旧的 `id` 会返回 `404`。已配置频道的 `id` 会一直有效，直到该频道被移除。
### 群组私信
Slack 群组私信的 ID 采用频道的格式，因此 Claude 在其中的使用会像频道一样设置它：它有 `id`、会被列出，并且可以读取。通过此 API 设置群组私信、更改其设置以及向其附加 Bundle 都会返回 `400`。允许从中分离 Bundle。
## 示例工作流
### 仅在已批准的频道中开启 Claude
任何成员都可以邀请 Claude 加入公共频道。要仅在您已批准的地方开启 Claude：
1. 通过在 [Slack 默认设置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#update-the-slack-defaults)上将 `enabled` 设置为 `false`，在所有地方关闭 Claude。
2. 当您的审批系统批准某个频道时，使用 `"settings": {"enabled": true}` [设置该频道](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#set-up-a-channel)。该请求接受 Slack 自身的 ID，无论频道是否已设置都会返回该频道，因此可以安全重复。
3. 在同一次运行中，[附加](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#attach-a-bundle)该团队获批的 Bundle，使频道的第一个会话就已具备其工具。
### 将配置保存在版本控制中
1. 以 Slack 为每个频道显示的 ID 作为配置的键，并通过这些 ID [查找每个频道](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#find-a-channel-by-its-slack-ids)。
2. 将**存储**视图与您的代码仓库声明的内容进行比较。生效视图会混入继承的值。
3. 仅发送不同的设置，对于代码仓库不再声明的设置发送 `null`。
4. 请组织所有者开启[只读模式](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#read-only-mode)，以免有人手动更改相同的设置。
### 审计所有地方生效的设置
1. [列出您的工作区](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#list-workspaces)，然后[列出每个工作区的频道](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#list-channels)。
2. 读取每个频道的[生效设置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#get-a-channels-effective-settings)，并标记您的策略所禁止的情况，例如 `enabled` 为 `true` 但没有存档审批的频道，或 `guest_policy` 为 `allow` 的频道。
3. [列出您的 Bundle](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#list-bundles)，然后列出[每个 Bundle 的目标](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#list-a-bundles-targets)，以查看对敏感系统的访问权限附加在何处。
## Slack 频道
频道对象是单个 Slack 频道的存储视图：
| 字段 | 描述 |
| ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` | `slack_channel`。 |
| `id` | 前缀为 `slch_`。请参阅 [ID](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#ids)。 |
| `slack` | Slack 自身的 ID：`team_id` 表示频道所在的工作区，`channel_id` 表示频道。 |
| `settings` | 频道本身存储的内容。始终存在，包含全部五项[设置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#settings)；未设置的项为 `null`。 |
| `agent_id` | 前缀为 `cagt_`。请参阅 [ID](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#ids)。 |
| `created_at` | 频道被设置的时间。 |
| `updated_at` | Claude Tag 对该频道的记录最后一次更改的时间。每次更改设置时（无论是在此处、claude.ai 还是 Slack 中）它都会变化，也可能因此处任何响应都未显示的更改而变化。请将较新的值视为重新读取频道的理由，而不是设置已更改的证据。附加或分离 Bundle 本身不会使其变化。 |
缺少 `slch_` 前缀的 `id` 会返回 `400`。带有该前缀但不对应您组织中任何频道的 `id` 会返回 `404`。
### 设置频道
`POST /v1/organizations/claude_tag/slack_channels` 设置一个 Slack 频道并返回该频道。`slack.team_id` 和 `slack.channel_id` 为必填项，是 Slack 自身的 ID。`settings` 为可选项，并遵循[更改设置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#changing-settings)中的规则。如果频道已设置，请求会返回现有频道并应用 `settings`；两种情况下响应均为 `200`。需要 `write:claude_tag` 作用域。
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28" \
-d '{
"slack": {"team_id": "T01ABCD2EFG", "channel_id": "C05HJKL6MNP"},
"settings": {"instructions": "Answer in the language of the question."}
}'
```
```bash CLI
ant beta:organization:claude-tag:slack-channels create \
--slack '{team_id: T01ABCD2EFG, channel_id: C05HJKL6MNP}' \
--settings '{instructions: "Answer in the language of the question."}'
```
```python Python
client = anthropic.Anthropic()
channel = client.beta.organization.claude_tag.slack_channels.create(
slack={"team_id": "T01ABCD2EFG", "channel_id": "C05HJKL6MNP"},
settings={"instructions": "Answer in the language of the question."},
)
print(channel.id)
```
```typescript TypeScript
const client = new Anthropic();
const channel = await client.beta.organization.claudeTag.slackChannels.create({
slack: { team_id: "T01ABCD2EFG", channel_id: "C05HJKL6MNP" },
settings: { instructions: "Answer in the language of the question." }
});
console.log(channel.id);
```
```csharp C#
AnthropicClient client = new();
var channel = await client.Beta.Organization.ClaudeTag.SlackChannels.Create(
new()
{
Slack = new() { TeamID = "T01ABCD2EFG", ChannelID = "C05HJKL6MNP" },
Settings = new() { Instructions = "Answer in the language of the question." },
}
);
Console.WriteLine(channel.ID);
```
```go Go
client := anthropic.NewClient()
channel, err := client.Beta.Organization.ClaudeTag.SlackChannels.New(
context.Background(),
anthropic.BetaOrganizationClaudeTagSlackChannelNewParams{
Slack: anthropic.BetaClaudeTagSlackChannelIdentifiersParam{
TeamID: "T01ABCD2EFG",
ChannelID: "C05HJKL6MNP",
},
Settings: anthropic.BetaClaudeTagSettingsCreateParam{
Instructions: anthropic.String("Answer in the language of the question."),
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(channel.ID)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.BetaClaudeTagSettingsCreate;
import com.anthropic.models.beta.organization.claudetag.slackchannels.BetaClaudeTagSlackChannelIdentifiers;
import com.anthropic.models.beta.organization.claudetag.slackchannels.SlackChannelCreateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SlackChannelCreateParams.builder()
.slack(BetaClaudeTagSlackChannelIdentifiers.builder()
.teamId("T01ABCD2EFG")
.channelId("C05HJKL6MNP")
.build())
.settings(BetaClaudeTagSettingsCreate.builder()
.instructions("Answer in the language of the question.")
.build())
.build();
var channel = client.beta().organization().claudeTag().slackChannels().create(params);
IO.println(channel.id());
}
```
```php PHP
$client = new Client();
$channel = $client->beta->organization->claudeTag->slackChannels->create(
slack: ['teamID' => 'T01ABCD2EFG', 'channelID' => 'C05HJKL6MNP'],
settings: ['instructions' => 'Answer in the language of the question.'],
);
echo "{$channel->id}\n";
```
```ruby Ruby
client = Anthropic::Client.new
channel = client.beta.organization.claude_tag.slack_channels.create(
slack: {team_id: "T01ABCD2EFG", channel_id: "C05HJKL6MNP"},
settings: {instructions: "Answer in the language of the question."}
)
puts channel.id
```
```json Response
{
"type": "slack_channel",
"id": "slch_011CZkZmRt4vNq8sHbYw2KdX",
"slack": {
"team_id": "T01ABCD2EFG",
"channel_id": "C05HJKL6MNP"
},
"settings": {
"enabled": null,
"instructions": "Answer in the language of the question.",
"model": null,
"environment_id": null,
"guest_policy": null
},
"agent_id": "cagt_011CZkZsHz6bTh2vNmEu4QrX",
"created_at": "2026-10-19T16:20:05Z",
"updated_at": "2026-10-19T16:20:05Z"
}
```
在设置频道之前，Claude 的 Slack 应用会向 Slack 确认该频道位于该工作区中、未被归档且对该应用可见。未通过此检查的频道会返回 `404`，未安装 Claude 的 Slack 应用的工作区也会返回 `404`。
设置频道和应用 `settings` 是两个步骤。当第一步成功而第二步被拒绝时，返回的是拒绝响应，频道保持已设置状态且未存储任何内容。该拒绝响应带有以 `slack_channel_set_up_` 开头的 `error_code`，并在 `error.details.slack_channel_id` 中包含新频道的 `id`（请参阅[错误响应](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#error-responses)）。请更正 `settings` 并通过[更新](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#update-a-channel)请求将其发送到该 `id`，或再次发送设置请求。
### 列出频道
`GET /v1/organizations/claude_tag/slack_channels` 列出一个工作区中已设置的频道，按 `created_at` 从新到旧排序。`slack_team_id` 为必填项，是 Slack 自身的工作区 ID。即使 `next_page` 仍有值，一页中的频道也可能少于 `limit` 个，甚至没有，因此请持续请求页面，直到 `next_page` 为 `null`（请参阅[分页](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#pagination)）。需要 `read:claude_tag` 作用域。
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels?slack_team_id=T01ABCD2EFG" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-channels list --slack-team-id T01ABCD2EFG
```
```python Python
client = anthropic.Anthropic()
channels = client.beta.organization.claude_tag.slack_channels.list(
slack_team_id="T01ABCD2EFG"
)
# 根据需要自动获取更多页面。
for channel in channels:
print(f"{channel.id}: {channel.slack.channel_id}")
```
```typescript TypeScript
const client = new Anthropic();
const channels = await client.beta.organization.claudeTag.slackChannels.list({
slack_team_id: "T01ABCD2EFG"
});
for await (const channel of channels) {
console.log(`${channel.id}: ${channel.slack.channel_id}`);
}
```
```csharp C#
AnthropicClient client = new();
var page = await client.Beta.Organization.ClaudeTag.SlackChannels.List(
new() { SlackTeamID = "T01ABCD2EFG" }
);
await foreach (var channel in page.Paginate())
{
Console.WriteLine($"{channel.ID}: {channel.Slack.ChannelID}");
}
```
```go Go
client := anthropic.NewClient()
channels := client.Beta.Organization.ClaudeTag.SlackChannels.ListAutoPaging(
context.Background(),
anthropic.BetaOrganizationClaudeTagSlackChannelListParams{
SlackTeamID: "T01ABCD2EFG",
},
)
for channels.Next() {
channel := channels.Current()
fmt.Printf("%s: %s\n", channel.ID, channel.Slack.ChannelID)
}
if err := channels.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
import com.anthropic.models.beta.organization.claudetag.slackchannels.SlackChannelListParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SlackChannelListParams.builder()
.slackTeamId("T01ABCD2EFG")
.build();
var channels = client.beta().organization().claudeTag().slackChannels().list(params);
for (var channel : channels.autoPager()) {
IO.println(channel.id() + ": " + channel.slack().channelId());
}
}
```
```php PHP
$client = new Client();
$channels = $client->beta->organization->claudeTag->slackChannels->list(
slackTeamID: 'T01ABCD2EFG',
);
// 仅限当前页；如需下一页，请使用 page: $channels->nextPage 再次调用 list()。
foreach ($channels->getItems() as $channel) {
echo "{$channel->id}: {$channel->slack->channelID}\n";
}
```
```ruby Ruby
client = Anthropic::Client.new
page = client.beta.organization.claude_tag.slack_channels.list(slack_team_id: "T01ABCD2EFG")
page.auto_paging_each do |channel|
puts "#{channel.id}: #{channel.slack.channel_id}"
end
```
响应为 `{"data": [...], "next_page": ...}`，其中每一项都是一个频道对象。指向您的组织不拥有的工作区的 `slack_team_id` 会返回 `404`。
### 按 Slack ID 查找频道
添加 `slack_channel_id`（Slack 自身的频道 ID）即可查找单个频道。`data` 包含该频道，如果该频道未设置则为空。查找会忽略 `limit` 和 `page`，其 `next_page` 为 `null`。这就是查找频道 `id` 的方法。
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels?slack_team_id=T01ABCD2EFG&slack_channel_id=C05HJKL6MNP" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-channels list \
--slack-team-id T01ABCD2EFG \
--slack-channel-id C05HJKL6MNP
```
```python Python
client = anthropic.Anthropic()
page = client.beta.organization.claude_tag.slack_channels.list(
slack_team_id="T01ABCD2EFG",
slack_channel_id="C05HJKL6MNP",
)
for channel in page.data:
print(channel.id)
```
```typescript TypeScript
const client = new Anthropic();
const page = await client.beta.organization.claudeTag.slackChannels.list({
slack_team_id: "T01ABCD2EFG",
slack_channel_id: "C05HJKL6MNP"
});
for (const channel of page.data) {
console.log(channel.id);
}
```
```csharp C#
AnthropicClient client = new();
var page = await client.Beta.Organization.ClaudeTag.SlackChannels.List(
new() { SlackTeamID = "T01ABCD2EFG", SlackChannelID = "C05HJKL6MNP" }
);
foreach (var channel in page.Items)
{
Console.WriteLine(channel.ID);
}
```
```go Go
client := anthropic.NewClient()
page, err := client.Beta.Organization.ClaudeTag.SlackChannels.List(
context.Background(),
anthropic.BetaOrganizationClaudeTagSlackChannelListParams{
SlackTeamID: "T01ABCD2EFG",
SlackChannelID: anthropic.String("C05HJKL6MNP"),
},
)
if err != nil {
log.Fatal(err)
}
for _, channel := range page.Data {
fmt.Println(channel.ID)
}
```
```java Java
import com.anthropic.models.beta.organization.claudetag.slackchannels.SlackChannelListParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SlackChannelListParams.builder()
.slackTeamId("T01ABCD2EFG")
.slackChannelId("C05HJKL6MNP")
.build();
var page = client.beta().organization().claudeTag().slackChannels().list(params);
for (var channel : page.items()) {
IO.println(channel.id());
}
}
```
```php PHP
$client = new Client();
$channels = $client->beta->organization->claudeTag->slackChannels->list(
slackTeamID: 'T01ABCD2EFG',
slackChannelID: 'C05HJKL6MNP',
);
foreach ($channels->getItems() as $channel) {
echo "{$channel->id}\n";
}
```
```ruby Ruby
client = Anthropic::Client.new
page = client.beta.organization.claude_tag.slack_channels.list(
slack_team_id: "T01ABCD2EFG",
slack_channel_id: "C05HJKL6MNP"
)
page.data&.each do |channel|
puts channel.id
end
```
将 `slch_` ID 作为 `slack_channel_id` 传递会返回 `400`。
### 获取频道
`GET /v1/organizations/claude_tag/slack_channels/{id}` 返回频道对象。需要 `read:claude_tag` 作用域。
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels/slch_011CZkZmRt4vNq8sHbYw2KdX" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-channels retrieve \
--id slch_011CZkZmRt4vNq8sHbYw2KdX
```
```python Python
client = anthropic.Anthropic()
channel = client.beta.organization.claude_tag.slack_channels.retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
)
print(channel.settings.enabled)
```
```typescript TypeScript
const client = new Anthropic();
const channel = await client.beta.organization.claudeTag.slackChannels.retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
);
console.log(channel.settings.enabled);
```
```csharp C#
AnthropicClient client = new();
var channel = await client.Beta.Organization.ClaudeTag.SlackChannels.Retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
);
Console.WriteLine(channel.Settings.Enabled);
```
```go Go
client := anthropic.NewClient()
channel, err := client.Beta.Organization.ClaudeTag.SlackChannels.Get(
context.Background(),
"slch_011CZkZmRt4vNq8sHbYw2KdX",
anthropic.BetaOrganizationClaudeTagSlackChannelGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(channel.Settings.Enabled)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var channel = client.beta().organization().claudeTag().slackChannels()
.retrieve("slch_011CZkZmRt4vNq8sHbYw2KdX");
IO.println(channel.settings().enabled().orElse(null));
```
```php PHP
$client = new Client();
$channel = $client->beta->organization->claudeTag->slackChannels->retrieve(
id: 'slch_011CZkZmRt4vNq8sHbYw2KdX',
);
echo json_encode($channel->settings->enabled) . "\n";
```
```ruby Ruby
client = Anthropic::Client.new
channel_id = "slch_011CZkZmRt4vNq8sHbYw2KdX"
channel = client.beta.organization.claude_tag.slack_channels.retrieve(channel_id)
puts channel.settings.enabled
```
### 更新频道
`POST /v1/organizations/claude_tag/slack_channels/{id}` 更改频道的设置并返回频道对象。`settings` 为必填项，并遵循[更改设置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#changing-settings)中的规则。需要 `write:claude_tag` 作用域。
在一个频道中关闭 Claude，并保持其他设置不变：
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels/slch_011CZkZmRt4vNq8sHbYw2KdX" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28" \
-d '{"settings": {"enabled": false}}'
```
```bash CLI
ant beta:organization:claude-tag:slack-channels update \
--id slch_011CZkZmRt4vNq8sHbYw2KdX \
--settings '{enabled: false}'
```
```python Python
client = anthropic.Anthropic()
channel = client.beta.organization.claude_tag.slack_channels.update(
"slch_011CZkZmRt4vNq8sHbYw2KdX",
settings={"enabled": False},
)
print(channel.settings.enabled)
```
```typescript TypeScript
const client = new Anthropic();
const channel = await client.beta.organization.claudeTag.slackChannels.update(
"slch_011CZkZmRt4vNq8sHbYw2KdX",
{ settings: { enabled: false } }
);
console.log(channel.settings.enabled);
```
```csharp C#
AnthropicClient client = new();
var channel = await client.Beta.Organization.ClaudeTag.SlackChannels.Update(
"slch_011CZkZmRt4vNq8sHbYw2KdX",
new() { Settings = new() { Enabled = false } }
);
Console.WriteLine(channel.Settings.Enabled);
```
```go Go
client := anthropic.NewClient()
channel, err := client.Beta.Organization.ClaudeTag.SlackChannels.Update(
context.Background(),
"slch_011CZkZmRt4vNq8sHbYw2KdX",
anthropic.BetaOrganizationClaudeTagSlackChannelUpdateParams{
Settings: anthropic.BetaClaudeTagSettingsUpdateParam{
Enabled: anthropic.Bool(false),
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(channel.Settings.Enabled)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.BetaClaudeTagSettingsUpdate;
import com.anthropic.models.beta.organization.claudetag.slackchannels.SlackChannelUpdateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SlackChannelUpdateParams.builder()
.settings(BetaClaudeTagSettingsUpdate.builder()
.enabled(false)
.build())
.build();
var channel = client.beta().organization().claudeTag().slackChannels()
.update("slch_011CZkZmRt4vNq8sHbYw2KdX", params);
IO.println(channel.settings().enabled().orElse(null));
}
```
```php PHP
$client = new Client();
$channel = $client->beta->organization->claudeTag->slackChannels->update(
id: 'slch_011CZkZmRt4vNq8sHbYw2KdX',
settings: ['enabled' => false],
);
echo json_encode($channel->settings->enabled) . "\n";
```
```ruby Ruby
client = Anthropic::Client.new
channel_id = "slch_011CZkZmRt4vNq8sHbYw2KdX"
channel = client.beta.organization.claude_tag.slack_channels.update(
channel_id,
settings: {enabled: false}
)
puts channel.settings.enabled
```
清除频道的指令，使只有继承的指令生效：
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels/slch_011CZkZmRt4vNq8sHbYw2KdX" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28" \
-d '{"settings": {"instructions": null}}'
```
```bash CLI
ant beta:organization:claude-tag:slack-channels update \
--id slch_011CZkZmRt4vNq8sHbYw2KdX \
--settings '{instructions: null}'
```
```python Python
client = anthropic.Anthropic()
channel = client.beta.organization.claude_tag.slack_channels.update(
"slch_011CZkZmRt4vNq8sHbYw2KdX",
settings={"instructions": None},
)
print(channel.settings.instructions)
```
```typescript TypeScript
const client = new Anthropic();
const channel = await client.beta.organization.claudeTag.slackChannels.update(
"slch_011CZkZmRt4vNq8sHbYw2KdX",
{ settings: { instructions: null } }
);
console.log(channel.settings.instructions);
```
```csharp C#
AnthropicClient client = new();
var channel = await client.Beta.Organization.ClaudeTag.SlackChannels.Update(
"slch_011CZkZmRt4vNq8sHbYw2KdX",
new() { Settings = new() { Instructions = null } }
);
Console.WriteLine(channel.Settings.Instructions);
```
```go Go
client := anthropic.NewClient()
channel, err := client.Beta.Organization.ClaudeTag.SlackChannels.Update(
context.Background(),
"slch_011CZkZmRt4vNq8sHbYw2KdX",
anthropic.BetaOrganizationClaudeTagSlackChannelUpdateParams{
Settings: anthropic.BetaClaudeTagSettingsUpdateParam{
Instructions: param.Null[string](),
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(channel.Settings.Instructions)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.BetaClaudeTagSettingsUpdate;
import com.anthropic.models.beta.organization.claudetag.slackchannels.SlackChannelUpdateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SlackChannelUpdateParams.builder()
.settings(BetaClaudeTagSettingsUpdate.builder()
.instructions(Optional.empty())
.build())
.build();
var channel = client.beta().organization().claudeTag().slackChannels()
.update("slch_011CZkZmRt4vNq8sHbYw2KdX", params);
IO.println(channel.settings().instructions().orElse(null));
}
```
```php PHP
use Anthropic\Beta\Organization\ClaudeTag\ClaudeTagSettingsUpdate;
// ...
$client = new Client();
// update() 会丢弃数组中的 null，因此需构建 settings 对象以发送 null。
$channel = $client->beta->organization->claudeTag->slackChannels->update(
id: 'slch_011CZkZmRt4vNq8sHbYw2KdX',
settings: (new ClaudeTagSettingsUpdate())->withInstructions(null),
);
echo "{$channel->settings->instructions}\n";
```
```ruby Ruby
client = Anthropic::Client.new
channel_id = "slch_011CZkZmRt4vNq8sHbYw2KdX"
channel = client.beta.organization.claude_tag.slack_channels.update(
channel_id,
settings: {instructions: nil}
)
puts channel.settings.instructions
```
### 获取频道的生效设置
`GET /v1/organizations/claude_tag/slack_channels/{id}/effective` 返回在该频道中生效的内容以及每个值的来源。[存储的设置与生效的设置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#stored-and-effective-settings)展示了一个完整的响应。在此视图中，`enabled` 和 `guest_policy` 永远不会是 `null`。该视图在每次读取时解析，因此没有 `created_at` 或 `updated_at`。如果某个层级无法读取，请求将以 `503` 失败，而不会在缺少该层级的情况下进行解析。需要 `read:claude_tag` 作用域。
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels/slch_011CZkZmRt4vNq8sHbYw2KdX/effective" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-channels:effective retrieve \
--id slch_011CZkZmRt4vNq8sHbYw2KdX
```
```python Python
client = anthropic.Anthropic()
effective = client.beta.organization.claude_tag.slack_channels.effective.retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
)
print(effective.settings.instructions)
```
```typescript TypeScript
const client = new Anthropic();
const effective = await client.beta.organization.claudeTag.slackChannels.effective.retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
);
console.log(effective.settings.instructions);
```
```csharp C#
AnthropicClient client = new();
var effective = await client.Beta.Organization.ClaudeTag.SlackChannels.Effective.Retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
);
Console.WriteLine(effective.Settings.Instructions);
```
```go Go
client := anthropic.NewClient()
effective, err := client.Beta.Organization.ClaudeTag.SlackChannels.Effective.Get(
context.Background(),
"slch_011CZkZmRt4vNq8sHbYw2KdX",
anthropic.BetaOrganizationClaudeTagSlackChannelEffectiveGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(effective.Settings.Instructions)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var effective = client.beta().organization().claudeTag().slackChannels().effective()
.retrieve("slch_011CZkZmRt4vNq8sHbYw2KdX");
IO.println(effective.settings().instructions().orElse(null));
```
```php PHP
$client = new Client();
$effective = $client->beta->organization->claudeTag->slackChannels->effective->retrieve(
id: 'slch_011CZkZmRt4vNq8sHbYw2KdX',
);
echo "{$effective->settings->instructions}\n";
```
```ruby Ruby
client = Anthropic::Client.new
channel_id = "slch_011CZkZmRt4vNq8sHbYw2KdX"
effective = client.beta.organization.claude_tag.slack_channels.effective.retrieve(channel_id)
puts effective.settings.instructions
```
### 移除频道
`DELETE /v1/organizations/claude_tag/slack_channels/{id}` 将频道从 Claude Tag 中移除。它与组织所有者在 claude.ai 中执行的移除操作相同，效果也相同。它不会删除、归档或更改 Slack 中的频道，也不会影响其中的任何消息。需要 `write:claude_tag` 作用域。
移除操作无法撤销。它会删除 Claude Tag 为该频道保存的内容：
* 其存储的设置及其 Bundle 目标
* 其会话及会话记录，包括正在运行的会话
* 其记忆，即 Claude 在不同会话之间保留的关于该频道的信息
* 其例程以及从中发布的 artifacts
```bash cURL
curl -X DELETE "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels/slch_011CZkZmRt4vNq8sHbYw2KdX" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-channels delete \
--id slch_011CZkZmRt4vNq8sHbYw2KdX
```
```python Python
client = anthropic.Anthropic()
deleted_channel = client.beta.organization.claude_tag.slack_channels.delete(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
)
print(deleted_channel.id)
```
```typescript TypeScript
const client = new Anthropic();
const deletedChannel = await client.beta.organization.claudeTag.slackChannels.delete(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
);
console.log(deletedChannel.id);
```
```csharp C#
AnthropicClient client = new();
var deletedChannel = await client.Beta.Organization.ClaudeTag.SlackChannels.Delete(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
);
Console.WriteLine(deletedChannel.ID);
```
```go Go
client := anthropic.NewClient()
deletedChannel, err := client.Beta.Organization.ClaudeTag.SlackChannels.Delete(
context.Background(),
"slch_011CZkZmRt4vNq8sHbYw2KdX",
anthropic.BetaOrganizationClaudeTagSlackChannelDeleteParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(deletedChannel.ID)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var deletedChannel = client.beta().organization().claudeTag().slackChannels()
.delete("slch_011CZkZmRt4vNq8sHbYw2KdX");
IO.println(deletedChannel.id());
```
```php PHP
$client = new Client();
$deletedChannel = $client->beta->organization->claudeTag->slackChannels->delete(
id: 'slch_011CZkZmRt4vNq8sHbYw2KdX',
);
echo "{$deletedChannel->id}\n";
```
```ruby Ruby
client = Anthropic::Client.new
channel_id = "slch_011CZkZmRt4vNq8sHbYw2KdX"
deleted_channel = client.beta.organization.claude_tag.slack_channels.delete(channel_id)
puts deleted_channel.id
```
```json Response
{
"type": "slack_channel_deleted",
"id": "slch_011CZkZmRt4vNq8sHbYw2KdX"
}
```
请求一返回，该 `id` 即返回 `404`，其余内容在后台删除。重复移除会返回 `404`。
**移除频道并不会让 Claude 在其中停止工作。** Claude 会继续按照该频道继承的设置进行回答，但不再拥有关于该频道的记忆，并且下一次使用时可能会以新的 `id` 重新设置该频道。
* 若要让 Claude 停止在某个频道中回答，请改为在该频道上将 `enabled` 设置为 `false`。
* 若要让某个频道不存储任何内容，同时保留其会话和记忆，请改为清除每项设置并分离每个 Bundle。
有两类频道无法在此处移除，并会返回 `400`：一类是未[配置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#configured-levels)的频道（`error_code: "slack_channel_not_configured"`），另一类是包含此 API 不管理的配置的频道，例如运行器池或仅 claude.ai 才有的设置。第二类频道由组织所有者在 claude.ai 中移除。
## Slack 工作区
工作区对象是单个 Slack 工作区的存储视图。它与[频道对象](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#slack-channels)具有相同的字段，不同之处在于 `type` 为 `slack_workspace`，`id` 的前缀为 `slws_`，且 `slack` 仅包含 `team_id`。[快速入门](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#quick-start)中的响应展示了一个完整的工作区对象。
缺少 `slws_` 前缀的 `id` 会返回 `400`。带有该前缀但不对应您组织中任何工作区的 `id` 会返回 `404`。
### 列出工作区
`GET /v1/organizations/claude_tag/slack_workspaces` 列出您组织拥有的已设置工作区，按 `created_at` 从新到旧排序。[快速入门](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#quick-start)展示了请求和响应。若要按 Slack 自身的 ID 查找某个工作区，请添加 `slack_team_id`：`data` 会包含该工作区，若该工作区尚未设置则为空；您的组织不拥有的工作区会返回 `404`。需要 `read:claude_tag` 作用域。
### 获取工作区
`GET /v1/organizations/claude_tag/slack_workspaces/{id}` 返回工作区对象。需要 `read:claude_tag` 作用域。
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_workspaces/slws_011CZkZnWa7xPc3uJfZe5LgT" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-workspaces retrieve \
--id slws_011CZkZnWa7xPc3uJfZe5LgT
```
```python Python
client = anthropic.Anthropic()
workspace = client.beta.organization.claude_tag.slack_workspaces.retrieve(
"slws_011CZkZnWa7xPc3uJfZe5LgT"
)
print(workspace.settings.instructions)
```
```typescript TypeScript
const client = new Anthropic();
const workspace = await client.beta.organization.claudeTag.slackWorkspaces.retrieve(
"slws_011CZkZnWa7xPc3uJfZe5LgT"
);
console.log(workspace.settings.instructions);
```
```csharp C#
AnthropicClient client = new();
var workspace = await client.Beta.Organization.ClaudeTag.SlackWorkspaces.Retrieve(
"slws_011CZkZnWa7xPc3uJfZe5LgT"
);
Console.WriteLine(workspace.Settings.Instructions);
```
```go Go
client := anthropic.NewClient()
workspace, err := client.Beta.Organization.ClaudeTag.SlackWorkspaces.Get(
context.Background(),
"slws_011CZkZnWa7xPc3uJfZe5LgT",
anthropic.BetaOrganizationClaudeTagSlackWorkspaceGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(workspace.Settings.Instructions)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var workspace = client.beta().organization().claudeTag().slackWorkspaces()
.retrieve("slws_011CZkZnWa7xPc3uJfZe5LgT");
IO.println(workspace.settings().instructions().orElse(null));
```
```php PHP
$client = new Client();
$workspace = $client->beta->organization->claudeTag->slackWorkspaces->retrieve(
id: 'slws_011CZkZnWa7xPc3uJfZe5LgT',
);
echo "{$workspace->settings->instructions}\n";
```
```ruby Ruby
client = Anthropic::Client.new
workspace_id = "slws_011CZkZnWa7xPc3uJfZe5LgT"
workspace = client.beta.organization.claude_tag.slack_workspaces.retrieve(workspace_id)
puts workspace.settings.instructions
```
### 更新工作区
`POST /v1/organizations/claude_tag/slack_workspaces/{id}` 更改工作区的设置并返回工作区对象。`settings` 为必填项，并遵循[更改设置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#changing-settings)中的规则。您在此处设置的内容适用于该工作区中所有未设置自身值的频道。需要 `write:claude_tag` 作用域。
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/claude_tag/slack_workspaces/slws_011CZkZnWa7xPc3uJfZe5LgT" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28" \
-d '{"settings": {"guest_policy": {"type": "restrict"}}}'
```
```bash CLI
ant beta:organization:claude-tag:slack-workspaces update \
--id slws_011CZkZnWa7xPc3uJfZe5LgT \
--settings '{guest_policy: {type: restrict}}'
```
```python Python
client = anthropic.Anthropic()
workspace = client.beta.organization.claude_tag.slack_workspaces.update(
"slws_011CZkZnWa7xPc3uJfZe5LgT",
settings={"guest_policy": {"type": "restrict"}},
)
print(workspace.settings.guest_policy)
```
```typescript TypeScript
const client = new Anthropic();
const workspace = await client.beta.organization.claudeTag.slackWorkspaces.update(
"slws_011CZkZnWa7xPc3uJfZe5LgT",
{ settings: { guest_policy: { type: "restrict" } } }
);
console.log(workspace.settings.guest_policy?.type);
```
```csharp C#
using Anthropic.Models.Beta.Organization.ClaudeTag;
AnthropicClient client = new();
var workspace = await client.Beta.Organization.ClaudeTag.SlackWorkspaces.Update(
"slws_011CZkZnWa7xPc3uJfZe5LgT",
new() { Settings = new() { GuestPolicy = new BetaClaudeTagGuestPolicyRestrict() } }
);
Console.WriteLine(workspace.Settings.GuestPolicy?.Type.GetString());
```
```go Go
client := anthropic.NewClient()
workspace, err := client.Beta.Organization.ClaudeTag.SlackWorkspaces.Update(
context.Background(),
"slws_011CZkZnWa7xPc3uJfZe5LgT",
anthropic.BetaOrganizationClaudeTagSlackWorkspaceUpdateParams{
Settings: anthropic.BetaClaudeTagSettingsUpdateParam{
GuestPolicy: anthropic.BetaClaudeTagGuestPolicyUnionParam{
OfRestrict: &anthropic.BetaClaudeTagGuestPolicyRestrictParam{},
},
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(workspace.Settings.GuestPolicy.Type)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.BetaClaudeTagGuestPolicyRestrict;
import com.anthropic.models.beta.organization.claudetag.BetaClaudeTagSettingsUpdate;
import com.anthropic.models.beta.organization.claudetag.slackworkspaces.SlackWorkspaceUpdateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SlackWorkspaceUpdateParams.builder()
.settings(BetaClaudeTagSettingsUpdate.builder()
.guestPolicy(BetaClaudeTagGuestPolicyRestrict.builder().build())
.build())
.build();
var workspace = client.beta().organization().claudeTag().slackWorkspaces()
.update("slws_011CZkZnWa7xPc3uJfZe5LgT", params);
IO.println(workspace.settings().guestPolicy().map(policy -> policy.type().asString()).orElse(null));
}
```
```php PHP
$client = new Client();
$workspace = $client->beta->organization->claudeTag->slackWorkspaces->update(
id: 'slws_011CZkZnWa7xPc3uJfZe5LgT',
settings: ['guestPolicy' => ['type' => 'restrict']],
);
echo "{$workspace->settings->guestPolicy?->type}\n";
```
```ruby Ruby
client = Anthropic::Client.new
workspace_id = "slws_011CZkZnWa7xPc3uJfZe5LgT"
workspace = client.beta.organization.claude_tag.slack_workspaces.update(
workspace_id,
settings: {guest_policy: {type: :restrict}}
)
puts workspace.settings.guest_policy&.type
```
### 获取工作区的生效设置
`GET /v1/organizations/claude_tag/slack_workspaces/{id}/effective` 返回在该工作区中生效的内容，这些内容由工作区和 Slack 默认设置解析得出，其结构如[存储的设置与生效的设置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#stored-and-effective-settings)所示，且 `type` 设置为 `slack_workspace_effective`。需要 `read:claude_tag` 作用域。
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_workspaces/slws_011CZkZnWa7xPc3uJfZe5LgT/effective" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-workspaces:effective retrieve \
--id slws_011CZkZnWa7xPc3uJfZe5LgT
```
```python Python
client = anthropic.Anthropic()
effective = client.beta.organization.claude_tag.slack_workspaces.effective.retrieve(
"slws_011CZkZnWa7xPc3uJfZe5LgT"
)
print(effective.settings.enabled)
```
```typescript TypeScript
const client = new Anthropic();
const effective = await client.beta.organization.claudeTag.slackWorkspaces.effective.retrieve(
"slws_011CZkZnWa7xPc3uJfZe5LgT"
);
console.log(effective.settings.enabled);
```
```csharp C#
AnthropicClient client = new();
var effective = await client.Beta.Organization.ClaudeTag.SlackWorkspaces.Effective.Retrieve(
"slws_011CZkZnWa7xPc3uJfZe5LgT"
);
Console.WriteLine(effective.Settings.Enabled);
```
```go Go
client := anthropic.NewClient()
effective, err := client.Beta.Organization.ClaudeTag.SlackWorkspaces.Effective.Get(
context.Background(),
"slws_011CZkZnWa7xPc3uJfZe5LgT",
anthropic.BetaOrganizationClaudeTagSlackWorkspaceEffectiveGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(effective.Settings.Enabled)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var effective = client.beta().organization().claudeTag().slackWorkspaces().effective()
.retrieve("slws_011CZkZnWa7xPc3uJfZe5LgT");
IO.println(effective.settings().enabled().orElse(null));
```
```php PHP
$client = new Client();
$effective = $client->beta->organization->claudeTag->slackWorkspaces->effective->retrieve(
id: 'slws_011CZkZnWa7xPc3uJfZe5LgT',
);
echo json_encode($effective->settings->enabled) . "\n";
```
```ruby Ruby
client = Anthropic::Client.new
workspace_id = "slws_011CZkZnWa7xPc3uJfZe5LgT"
effective = client.beta.organization.claude_tag.slack_workspaces.effective.retrieve(workspace_id)
puts effective.settings.enabled
```
## Slack 默认设置
您的组织恰好有一个 Slack 默认设置对象。它适用于每个工作区和频道，没有 `id`，也没有生效视图，因为不存在比它更宽泛的层级。
| 字段 | 描述 |
| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` | `slack_defaults`。 |
| `settings` | 默认设置所存储的内容，与[频道](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#slack-channels)上的相同。 |
| `agent_id` | 前缀为 `cagt_`。在 Slack 默认设置[完成设置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#set-up-channels-and-workspaces)之前为 `null`。 |
### 获取 Slack 默认设置
`GET /v1/organizations/claude_tag/slack_defaults` 返回该对象。尚未设置 Slack 默认设置的组织会收到 `200`，其中每项设置和 `agent_id` 均为 `null`。需要 `read:claude_tag` 作用域。
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_defaults" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-defaults retrieve
```
```python Python
client = anthropic.Anthropic()
defaults = client.beta.organization.claude_tag.slack_defaults.retrieve()
print(defaults.settings.guest_policy)
```
```typescript TypeScript
const client = new Anthropic();
const defaults = await client.beta.organization.claudeTag.slackDefaults.retrieve();
console.log(defaults.settings.guest_policy?.type);
```
```csharp C#
AnthropicClient client = new();
var defaults = await client.Beta.Organization.ClaudeTag.SlackDefaults.Retrieve();
Console.WriteLine(defaults.Settings.GuestPolicy?.Type.GetString());
```
```go Go
client := anthropic.NewClient()
defaults, err := client.Beta.Organization.ClaudeTag.SlackDefaults.Get(
context.Background(),
anthropic.BetaOrganizationClaudeTagSlackDefaultGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(defaults.Settings.GuestPolicy.Type)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var defaults = client.beta().organization().claudeTag().slackDefaults().retrieve();
IO.println(defaults.settings().guestPolicy().map(policy -> policy.type().asString()).orElse(null));
```
```php PHP
$client = new Client();
$defaults = $client->beta->organization->claudeTag->slackDefaults->retrieve();
echo "{$defaults->settings->guestPolicy?->type}\n";
```
```ruby Ruby
client = Anthropic::Client.new
defaults = client.beta.organization.claude_tag.slack_defaults.retrieve
puts defaults.settings.guest_policy&.type
```
### 更新 Slack 默认设置
`POST /v1/organizations/claude_tag/slack_defaults` 更改默认设置并返回该对象。`settings` 为必填项，并遵循[更改设置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#changing-settings)中的规则。在 Slack 默认设置尚未设置时设置某个值的请求会返回 `400`。需要 `write:claude_tag` 作用域。
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/claude_tag/slack_defaults" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28" \
-d '{
"settings": {
"instructions": "Keep replies under 200 words.",
"environment_id": "env_011CZkZqDx2zRf5tLjCs7NpV"
}
}'
```
```bash CLI
ant beta:organization:claude-tag:slack-defaults update \
--settings '{instructions: "Keep replies under 200 words.", environment_id: env_011CZkZqDx2zRf5tLjCs7NpV}'
```
```python Python
client = anthropic.Anthropic()
defaults = client.beta.organization.claude_tag.slack_defaults.update(
settings={
"instructions": "Keep replies under 200 words.",
"environment_id": "env_011CZkZqDx2zRf5tLjCs7NpV",
},
)
print(defaults.settings.environment_id)
```
```typescript TypeScript
const client = new Anthropic();
const defaults = await client.beta.organization.claudeTag.slackDefaults.update({
settings: {
instructions: "Keep replies under 200 words.",
environment_id: "env_011CZkZqDx2zRf5tLjCs7NpV"
}
});
console.log(defaults.settings.environment_id);
```
```csharp C#
AnthropicClient client = new();
var defaults = await client.Beta.Organization.ClaudeTag.SlackDefaults.Update(
new()
{
Settings = new()
{
Instructions = "Keep replies under 200 words.",
EnvironmentID = "env_011CZkZqDx2zRf5tLjCs7NpV",
},
}
);
Console.WriteLine(defaults.Settings.EnvironmentID);
```
```go Go
client := anthropic.NewClient()
defaults, err := client.Beta.Organization.ClaudeTag.SlackDefaults.Update(
context.Background(),
anthropic.BetaOrganizationClaudeTagSlackDefaultUpdateParams{
Settings: anthropic.BetaClaudeTagSettingsUpdateParam{
Instructions: anthropic.String("Keep replies under 200 words."),
EnvironmentID: anthropic.String("env_011CZkZqDx2zRf5tLjCs7NpV"),
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(defaults.Settings.EnvironmentID)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.BetaClaudeTagSettingsUpdate;
import com.anthropic.models.beta.organization.claudetag.slackdefaults.SlackDefaultUpdateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SlackDefaultUpdateParams.builder()
.settings(BetaClaudeTagSettingsUpdate.builder()
.instructions("Keep replies under 200 words.")
.environmentId("env_011CZkZqDx2zRf5tLjCs7NpV")
.build())
.build();
var defaults = client.beta().organization().claudeTag().slackDefaults().update(params);
IO.println(defaults.settings().environmentId().orElse(null));
}
```
```php PHP
$client = new Client();
$defaults = $client->beta->organization->claudeTag->slackDefaults->update(
settings: [
'instructions' => 'Keep replies under 200 words.',
'environmentID' => 'env_011CZkZqDx2zRf5tLjCs7NpV',
],
);
echo "{$defaults->settings->environmentID}\n";
```
```ruby Ruby
client = Anthropic::Client.new
defaults = client.beta.organization.claude_tag.slack_defaults.update(
settings: {
instructions: "Keep replies under 200 words.",
environment_id: "env_011CZkZqDx2zRf5tLjCs7NpV"
}
)
puts defaults.settings.environment_id
```
```json Response
{
"type": "slack_defaults",
"settings": {
"enabled": null,
"instructions": "Keep replies under 200 words.",
"model": null,
"environment_id": "env_011CZkZqDx2zRf5tLjCs7NpV",
"guest_policy": null
},
"agent_id": "cagt_011CZkZtKa8cUj4wPnFv6RsY"
}
```
## Bundle
Bundle 即 claude.ai 中所称的 [Access bundle](https://claude.com/docs/claude-tag/admins/add-connections)：一组具名的访问权限，例如连接器、代码仓库和凭据，Claude 可以在频道或工作区中使用它们。组织所有者在 claude.ai 中创建、编辑和删除 Bundle。此 API 用于列出和附加 Bundle。它会返回 Bundle 的名称和描述，但绝不会返回 Bundle 所授予的内容。
| 字段 | 描述 |
| ------------------------- | ------------------------- |
| `type` | `bundle`。 |
| `id` | 前缀为 `capp_`。 |
| `display_name` | Bundle 的名称。 |
| `description` | Bundle 的用途。没有描述时为 `null`。 |
| `created_at`、`updated_at` | Bundle 的创建时间和最后更改时间。 |
缺少 `capp_` 前缀的 `bundle_id` 会返回 `400`。带有该前缀但不存在或属于其他组织的 `bundle_id` 会返回 `404`，无论请求中还包含什么内容。Claude Tag 为自身管理的 Bundle 不会被列出，并会返回 `404`。
### 列出 Bundle
`GET /v1/organizations/claude_tag/bundles` 列出您组织的 Bundle，按 `created_at` 从新到旧排序。需要 `read:claude_tag` 作用域。
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/bundles" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:bundles list
```
```python Python
client = anthropic.Anthropic()
bundles = client.beta.organization.claude_tag.bundles.list()
# 根据需要自动获取更多页面。
for bundle in bundles:
print(f"{bundle.id}: {bundle.display_name}")
```
```typescript TypeScript
const client = new Anthropic();
const bundles = await client.beta.organization.claudeTag.bundles.list();
for await (const bundle of bundles) {
console.log(`${bundle.id}: ${bundle.display_name}`);
}
```
```csharp C#
AnthropicClient client = new();
var page = await client.Beta.Organization.ClaudeTag.Bundles.List();
await foreach (var bundle in page.Paginate())
{
Console.WriteLine($"{bundle.ID}: {bundle.DisplayName}");
}
```
```go Go
client := anthropic.NewClient()
bundles := client.Beta.Organization.ClaudeTag.Bundles.ListAutoPaging(
context.Background(),
anthropic.BetaOrganizationClaudeTagBundleListParams{},
)
for bundles.Next() {
bundle := bundles.Current()
fmt.Printf("%s: %s\n", bundle.ID, bundle.DisplayName)
}
if err := bundles.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var bundles = client.beta().organization().claudeTag().bundles().list();
for (var bundle : bundles.autoPager()) {
IO.println(bundle.id() + ": " + bundle.displayName());
}
```
```php PHP
$client = new Client();
$bundles = $client->beta->organization->claudeTag->bundles->list();
// 仅限当前页；如需下一页，请使用 page: $bundles->nextPage 再次调用 list()。
foreach ($bundles->getItems() as $bundle) {
echo "{$bundle->id}: {$bundle->displayName}\n";
}
```
```ruby Ruby
client = Anthropic::Client.new
page = client.beta.organization.claude_tag.bundles.list
page.auto_paging_each do |bundle|
puts "#{bundle.id}: #{bundle.display_name}"
end
```
```json Response
{
"data": [
{
"type": "bundle",
"id": "capp_011CZkZjLP1cWxj5EtMmdgbq",
"display_name": "Support tools",
"description": "Issue tracker and the support runbooks repository.",
"created_at": "2026-09-12T08:15:30Z",
"updated_at": "2026-09-30T13:02:47Z"
}
],
"next_page": null
}
```
### 获取 Bundle
`GET /v1/organizations/claude_tag/bundles/{bundle_id}` 返回 Bundle 对象。需要 `read:claude_tag` 作用域。
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:bundles retrieve \
--bundle-id capp_011CZkZjLP1cWxj5EtMmdgbq
```
```python Python
client = anthropic.Anthropic()
bundle = client.beta.organization.claude_tag.bundles.retrieve(
"capp_011CZkZjLP1cWxj5EtMmdgbq"
)
print(bundle.display_name)
```
```typescript TypeScript
const client = new Anthropic();
const bundle = await client.beta.organization.claudeTag.bundles.retrieve(
"capp_011CZkZjLP1cWxj5EtMmdgbq"
);
console.log(bundle.display_name);
```
```csharp C#
AnthropicClient client = new();
var bundle = await client.Beta.Organization.ClaudeTag.Bundles.Retrieve(
"capp_011CZkZjLP1cWxj5EtMmdgbq"
);
Console.WriteLine(bundle.DisplayName);
```
```go Go
client := anthropic.NewClient()
bundle, err := client.Beta.Organization.ClaudeTag.Bundles.Get(
context.Background(),
"capp_011CZkZjLP1cWxj5EtMmdgbq",
anthropic.BetaOrganizationClaudeTagBundleGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(bundle.DisplayName)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var bundle = client.beta().organization().claudeTag().bundles()
.retrieve("capp_011CZkZjLP1cWxj5EtMmdgbq");
IO.println(bundle.displayName());
```
```php PHP
$client = new Client();
$bundle = $client->beta->organization->claudeTag->bundles->retrieve(
bundleID: 'capp_011CZkZjLP1cWxj5EtMmdgbq',
);
echo "{$bundle->displayName}\n";
```
```ruby Ruby
client = Anthropic::Client.new
bundle_id = "capp_011CZkZjLP1cWxj5EtMmdgbq"
bundle = client.beta.organization.claude_tag.bundles.retrieve(bundle_id)
puts bundle.display_name
```
## Bundle 目标
Bundle 目标是一个 Bundle 附加到一个频道或一个工作区的记录。附加到工作区的 Bundle 可以在该工作区及其中的每个频道中使用。附加到频道的 Bundle 只能在该频道中使用。
| 字段 | 描述 |
| -------------------- | --------------------------------------------------- |
| `type` | `slack_channel` 或 `slack_workspace`。 |
| `id` | 前缀为 `btgt_`。它是路径中的 `{target_id}`，绝不是频道或工作区自身的 `id`。 |
| `slack_channel_id` | 在 `slack_channel` 目标上：频道的 `id`，前缀为 `slch_`。 |
| `slack_workspace_id` | 在 `slack_workspace` 目标上：工作区的 `id`，前缀为 `slws_`。 |
| `created_at` | Bundle 的附加时间。 |
一个 Bundle 最多只能附加到某个频道或工作区一次，并且同一组配对始终具有相同的 `id`，即使在分离后重新附加也是如此。该 `id` 是不透明的：请从附加操作的响应或列表中获取它。Bundle 目标不包含其 Bundle 的 `id`，而其路径同样需要该 `id`，因此请将两者一起保存。
附加到频道或工作区的第一个 Bundle 会使其成为[已配置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#configured-levels)状态。附加或分离不会更改任何存储的设置。在该频道或工作区中正在运行的会话会收到其访问权限已更改的通知。
claude.ai 在值班（on-call）设置中附加的 Bundle 会被列出且可以读取，但无法在此处附加或分离；对于由值班设置管理的频道或工作区，也无法在其上附加或分离任何内容。这些请求均会返回 `400`。
### 列出 Bundle 的目标
`GET /v1/organizations/claude_tag/bundles/{bundle_id}/targets` 列出该 Bundle 所附加到的频道和工作区，按 `created_at` 从新到旧排序。需要 `read:claude_tag` 作用域。
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq/targets" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:bundles:targets list \
--bundle-id capp_011CZkZjLP1cWxj5EtMmdgbq
```
```python Python
client = anthropic.Anthropic()
targets = client.beta.organization.claude_tag.bundles.targets.list(
"capp_011CZkZjLP1cWxj5EtMmdgbq"
)
# 根据需要自动获取更多页面。
for target in targets:
print(f"{target.id}: {target.type}")
```
```typescript TypeScript
const client = new Anthropic();
const targets = await client.beta.organization.claudeTag.bundles.targets.list(
"capp_011CZkZjLP1cWxj5EtMmdgbq"
);
for await (const target of targets) {
console.log(`${target.id}: ${target.type}`);
}
```
```csharp C#
AnthropicClient client = new();
var page = await client.Beta.Organization.ClaudeTag.Bundles.Targets.List(
"capp_011CZkZjLP1cWxj5EtMmdgbq"
);
await foreach (var target in page.Paginate())
{
Console.WriteLine($"{target.ID}: {target.Type.GetString()}");
}
```
```go Go
client := anthropic.NewClient()
targets := client.Beta.Organization.ClaudeTag.Bundles.Targets.ListAutoPaging(
context.Background(),
"capp_011CZkZjLP1cWxj5EtMmdgbq",
anthropic.BetaOrganizationClaudeTagBundleTargetListParams{},
)
for targets.Next() {
target := targets.Current()
fmt.Printf("%s: %s\n", target.ID, target.Type)
}
if err := targets.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var targets = client.beta().organization().claudeTag().bundles().targets()
.list("capp_011CZkZjLP1cWxj5EtMmdgbq");
for (var target : targets.autoPager()) {
IO.println(target.id() + ": " + target.type().asString());
}
```
```php PHP
$client = new Client();
$targets = $client->beta->organization->claudeTag->bundles->targets->list(
bundleID: 'capp_011CZkZjLP1cWxj5EtMmdgbq',
);
// 仅限当前页；如需下一页，请使用 page: $targets->nextPage 再次调用 list()。
foreach ($targets->getItems() as $target) {
echo "{$target->id}: {$target->type}\n";
}
```
```ruby Ruby
client = Anthropic::Client.new
bundle_id = "capp_011CZkZjLP1cWxj5EtMmdgbq"
page = client.beta.organization.claude_tag.bundles.targets.list(bundle_id)
page.auto_paging_each do |target|
puts "#{target.id}: #{target.type}"
end
```
```json Response
{
"data": [
{
"type": "slack_channel",
"id": "btgt_011CZkZpBv9yQd6wKhAr8MnU",
"slack_channel_id": "slch_011CZkZmRt4vNq8sHbYw2KdX",
"created_at": "2026-10-19T16:21:44Z"
},
{
"type": "slack_workspace",
"id": "btgt_011CZkZuMc3dVk7xQpGw9StZ",
"slack_workspace_id": "slws_011CZkZnWa7xPc3uJfZe5LgT",
"created_at": "2026-09-12T08:17:02Z"
}
],
"next_page": null
}
```
仅列出附加到频道和工作区的记录。在 claude.ai 中附加到其他对象（例如 **Default Slack access**）的 Bundle 没有对应的 Bundle 目标，将某个 Bundle 同时应用于多个频道的规则也没有。因此，Claude 在某个频道中可以使用的 Bundle 可能多于指向该频道的目标。没有任何端点可以列出附加到某个频道或工作区的 Bundle。
### 附加 Bundle
`POST /v1/organizations/claude_tag/bundles/{bundle_id}/targets` 附加该 Bundle 并返回 Bundle 目标。请求体指定 `type` 及相应的 `id`。频道或工作区必须已经完成设置：附加操作永远不会设置频道。附加一个已附加的配对会返回 `200` 以及现有的 Bundle 目标。需要 `write:claude_tag` 作用域。
将 Bundle 附加到频道：
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq/targets" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28" \
-d '{"type": "slack_channel", "slack_channel_id": "slch_011CZkZmRt4vNq8sHbYw2KdX"}'
```
```bash CLI
ant beta:organization:claude-tag:bundles:targets create \
--bundle-id capp_011CZkZjLP1cWxj5EtMmdgbq \
--type slack_channel \
--slack-channel-id slch_011CZkZmRt4vNq8sHbYw2KdX
```
```python Python
client = anthropic.Anthropic()
target = client.beta.organization.claude_tag.bundles.targets.create(
"capp_011CZkZjLP1cWxj5EtMmdgbq",
type="slack_channel",
slack_channel_id="slch_011CZkZmRt4vNq8sHbYw2KdX",
)
print(target.id)
```
```typescript TypeScript
const client = new Anthropic();
const target = await client.beta.organization.claudeTag.bundles.targets.create(
"capp_011CZkZjLP1cWxj5EtMmdgbq",
{ type: "slack_channel", slack_channel_id: "slch_011CZkZmRt4vNq8sHbYw2KdX" }
);
console.log(target.id);
```
```csharp C#
using Anthropic.Models.Beta.Organization.ClaudeTag.Bundles.Targets;
AnthropicClient client = new();
var target = await client.Beta.Organization.ClaudeTag.Bundles.Targets.Create(
"capp_011CZkZjLP1cWxj5EtMmdgbq",
new()
{
BetaClaudeTagBundleTargetCreate = new BetaClaudeTagSlackChannelBundleTargetCreate
{
SlackChannelID = "slch_011CZkZmRt4vNq8sHbYw2KdX",
},
}
);
Console.WriteLine(target.ID);
```
```go Go
client := anthropic.NewClient()
target, err := client.Beta.Organization.ClaudeTag.Bundles.Targets.New(
context.Background(),
"capp_011CZkZjLP1cWxj5EtMmdgbq",
anthropic.BetaOrganizationClaudeTagBundleTargetNewParams{
BetaClaudeTagBundleTargetCreate: anthropic.BetaClaudeTagBundleTargetCreateUnionParam{
OfSlackChannel: &anthropic.BetaClaudeTagSlackChannelBundleTargetCreateParam{
SlackChannelID: "slch_011CZkZmRt4vNq8sHbYw2KdX",
},
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(target.ID)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.bundles.targets.TargetCreateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = TargetCreateParams.builder()
.slackChannelBetaClaudeTagBundleTargetCreate("slch_011CZkZmRt4vNq8sHbYw2KdX")
.build();
var target = client.beta().organization().claudeTag().bundles().targets()
.create("capp_011CZkZjLP1cWxj5EtMmdgbq", params);
IO.println(target.id());
}
```
```php PHP
$client = new Client();
$target = $client->beta->organization->claudeTag->bundles->targets->create(
bundleID: 'capp_011CZkZjLP1cWxj5EtMmdgbq',
betaClaudeTagBundleTargetCreate: [
'type' => 'slack_channel',
'slackChannelID' => 'slch_011CZkZmRt4vNq8sHbYw2KdX',
],
);
echo "{$target->id}\n";
```
```ruby Ruby
client = Anthropic::Client.new
bundle_id = "capp_011CZkZjLP1cWxj5EtMmdgbq"
target = client.beta.organization.claude_tag.bundles.targets.create(
bundle_id,
beta_claude_tag_bundle_target_create: {
type: :slack_channel,
slack_channel_id: "slch_011CZkZmRt4vNq8sHbYw2KdX"
}
)
puts target.id
```
```json Response
{
"type": "slack_channel",
"id": "btgt_011CZkZpBv9yQd6wKhAr8MnU",
"slack_channel_id": "slch_011CZkZmRt4vNq8sHbYw2KdX",
"created_at": "2026-10-19T16:21:44Z"
}
```
将 Bundle 附加到工作区：
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq/targets" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28" \
-d '{"type": "slack_workspace", "slack_workspace_id": "slws_011CZkZnWa7xPc3uJfZe5LgT"}'
```
```bash CLI
ant beta:organization:claude-tag:bundles:targets create \
--bundle-id capp_011CZkZjLP1cWxj5EtMmdgbq \
--type slack_workspace \
--slack-workspace-id slws_011CZkZnWa7xPc3uJfZe5LgT
```
```python Python
client = anthropic.Anthropic()
target = client.beta.organization.claude_tag.bundles.targets.create(
"capp_011CZkZjLP1cWxj5EtMmdgbq",
type="slack_workspace",
slack_workspace_id="slws_011CZkZnWa7xPc3uJfZe5LgT",
)
print(target.id)
```
```typescript TypeScript
const client = new Anthropic();
const target = await client.beta.organization.claudeTag.bundles.targets.create(
"capp_011CZkZjLP1cWxj5EtMmdgbq",
{ type: "slack_workspace", slack_workspace_id: "slws_011CZkZnWa7xPc3uJfZe5LgT" }
);
console.log(target.id);
```
```csharp C#
using Anthropic.Models.Beta.Organization.ClaudeTag.Bundles.Targets;
AnthropicClient client = new();
var target = await client.Beta.Organization.ClaudeTag.Bundles.Targets.Create(
"capp_011CZkZjLP1cWxj5EtMmdgbq",
new()
{
BetaClaudeTagBundleTargetCreate = new BetaClaudeTagSlackWorkspaceBundleTargetCreate
{
SlackWorkspaceID = "slws_011CZkZnWa7xPc3uJfZe5LgT",
},
}
);
Console.WriteLine(target.ID);
```
```go Go
client := anthropic.NewClient()
target, err := client.Beta.Organization.ClaudeTag.Bundles.Targets.New(
context.Background(),
"capp_011CZkZjLP1cWxj5EtMmdgbq",
anthropic.BetaOrganizationClaudeTagBundleTargetNewParams{
BetaClaudeTagBundleTargetCreate: anthropic.BetaClaudeTagBundleTargetCreateUnionParam{
OfSlackWorkspace: &anthropic.BetaClaudeTagSlackWorkspaceBundleTargetCreateParam{
SlackWorkspaceID: "slws_011CZkZnWa7xPc3uJfZe5LgT",
},
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(target.ID)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.bundles.targets.TargetCreateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = TargetCreateParams.builder()
.slackWorkspaceBetaClaudeTagBundleTargetCreate("slws_011CZkZnWa7xPc3uJfZe5LgT")
.build();
var target = client.beta().organization().claudeTag().bundles().targets()
.create("capp_011CZkZjLP1cWxj5EtMmdgbq", params);
IO.println(target.id());
}
```
```php PHP
$client = new Client();
$target = $client->beta->organization->claudeTag->bundles->targets->create(
bundleID: 'capp_011CZkZjLP1cWxj5EtMmdgbq',
betaClaudeTagBundleTargetCreate: [
'type' => 'slack_workspace',
'slackWorkspaceID' => 'slws_011CZkZnWa7xPc3uJfZe5LgT',
],
);
echo "{$target->id}\n";
```
```ruby Ruby
client = Anthropic::Client.new
bundle_id = "capp_011CZkZjLP1cWxj5EtMmdgbq"
target = client.beta.organization.claude_tag.bundles.targets.create(
bundle_id,
beta_claude_tag_bundle_target_create: {
type: :slack_workspace,
slack_workspace_id: "slws_011CZkZnWa7xPc3uJfZe5LgT"
}
)
puts target.id
```
附加到频道的记录带有其生效条件，例如仅在频道中没有 Slack 访客时生效。条件在 claude.ai 中设置，不会在此处返回。通过此 API 附加时使用默认条件，而附加一个已附加的配对不会更改其条件。
### 获取 Bundle 目标
`GET /v1/organizations/claude_tag/bundles/{bundle_id}/targets/{target_id}` 返回 Bundle 目标。缺少 `btgt_` 前缀的 `target_id` 会返回 `400`。属于其他 Bundle、已被分离，或指向不再处于已设置状态的频道或工作区的 `target_id` 会返回 `404`。需要 `read:claude_tag` 作用域。
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq/targets/btgt_011CZkZpBv9yQd6wKhAr8MnU" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:bundles:targets retrieve \
--bundle-id capp_011CZkZjLP1cWxj5EtMmdgbq \
--target-id btgt_011CZkZpBv9yQd6wKhAr8MnU
```
```python Python
client = anthropic.Anthropic()
target = client.beta.organization.claude_tag.bundles.targets.retrieve(
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
bundle_id="capp_011CZkZjLP1cWxj5EtMmdgbq",
)
print(target.type)
```
```typescript TypeScript
const client = new Anthropic();
const target = await client.beta.organization.claudeTag.bundles.targets.retrieve(
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
{ bundle_id: "capp_011CZkZjLP1cWxj5EtMmdgbq" }
);
console.log(target.type);
```
```csharp C#
AnthropicClient client = new();
var target = await client.Beta.Organization.ClaudeTag.Bundles.Targets.Retrieve(
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
new() { BundleID = "capp_011CZkZjLP1cWxj5EtMmdgbq" }
);
Console.WriteLine(target.Type.GetString());
```
```go Go
client := anthropic.NewClient()
target, err := client.Beta.Organization.ClaudeTag.Bundles.Targets.Get(
context.Background(),
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
anthropic.BetaOrganizationClaudeTagBundleTargetGetParams{
BundleID: "capp_011CZkZjLP1cWxj5EtMmdgbq",
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(target.Type)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.bundles.targets.TargetRetrieveParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = TargetRetrieveParams.builder()
.bundleId("capp_011CZkZjLP1cWxj5EtMmdgbq")
.build();
var target = client.beta().organization().claudeTag().bundles().targets()
.retrieve("btgt_011CZkZpBv9yQd6wKhAr8MnU", params);
IO.println(target.type().asString());
}
```
```php PHP
$client = new Client();
$target = $client->beta->organization->claudeTag->bundles->targets->retrieve(
targetID: 'btgt_011CZkZpBv9yQd6wKhAr8MnU',
bundleID: 'capp_011CZkZjLP1cWxj5EtMmdgbq',
);
echo "{$target->type}\n";
```
```ruby Ruby
client = Anthropic::Client.new
bundle_id = "capp_011CZkZjLP1cWxj5EtMmdgbq"
target_id = "btgt_011CZkZpBv9yQd6wKhAr8MnU"
target = client.beta.organization.claude_tag.bundles.targets.retrieve(
target_id,
bundle_id: bundle_id
)
puts target.type
```
### 分离 Bundle
`DELETE /v1/organizations/claude_tag/bundles/{bundle_id}/targets/{target_id}` 分离该 Bundle。重复分离会返回 `404`。需要 `write:claude_tag` 作用域。
```bash cURL
curl -X DELETE "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq/targets/btgt_011CZkZpBv9yQd6wKhAr8MnU" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:bundles:targets delete \
--bundle-id capp_011CZkZjLP1cWxj5EtMmdgbq \
--target-id btgt_011CZkZpBv9yQd6wKhAr8MnU
```
```python Python
client = anthropic.Anthropic()
deleted_target = client.beta.organization.claude_tag.bundles.targets.delete(
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
bundle_id="capp_011CZkZjLP1cWxj5EtMmdgbq",
)
print(deleted_target.id)
```
```typescript TypeScript
const client = new Anthropic();
const deletedTarget = await client.beta.organization.claudeTag.bundles.targets.delete(
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
{ bundle_id: "capp_011CZkZjLP1cWxj5EtMmdgbq" }
);
console.log(deletedTarget.id);
```
```csharp C#
AnthropicClient client = new();
var deletedTarget = await client.Beta.Organization.ClaudeTag.Bundles.Targets.Delete(
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
new() { BundleID = "capp_011CZkZjLP1cWxj5EtMmdgbq" }
);
Console.WriteLine(deletedTarget.ID);
```
```go Go
client := anthropic.NewClient()
deletedTarget, err := client.Beta.Organization.ClaudeTag.Bundles.Targets.Delete(
context.Background(),
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
anthropic.BetaOrganizationClaudeTagBundleTargetDeleteParams{
BundleID: "capp_011CZkZjLP1cWxj5EtMmdgbq",
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(deletedTarget.ID)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.bundles.targets.TargetDeleteParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = TargetDeleteParams.builder()
.bundleId("capp_011CZkZjLP1cWxj5EtMmdgbq")
.build();
var deletedTarget = client.beta().organization().claudeTag().bundles().targets()
.delete("btgt_011CZkZpBv9yQd6wKhAr8MnU", params);
IO.println(deletedTarget.id());
}
```
```php PHP
$client = new Client();
$deletedTarget = $client->beta->organization->claudeTag->bundles->targets->delete(
targetID: 'btgt_011CZkZpBv9yQd6wKhAr8MnU',
bundleID: 'capp_011CZkZjLP1cWxj5EtMmdgbq',
);
echo "{$deletedTarget->id}\n";
```
```ruby Ruby
client = Anthropic::Client.new
bundle_id = "capp_011CZkZjLP1cWxj5EtMmdgbq"
target_id = "btgt_011CZkZpBv9yQd6wKhAr8MnU"
deleted_target = client.beta.organization.claude_tag.bundles.targets.delete(
target_id,
bundle_id: bundle_id
)
puts deleted_target.id
```
```json Response
{
"type": "bundle_target_deleted",
"id": "btgt_011CZkZpBv9yQd6wKhAr8MnU"
}
```
## 无法识别的值
`guest_policy.type`、来源的 `type`、Bundle 目标的 `type` 以及错误代码随时可能新增取值。对于您无法识别的值，请像对待任何未知字符串一样处理，而不是直接失败。
## 速率限制
请求按组织进行限制，分为两个预算，由您组织的所有密钥共享，并且独立于您组织的其他 Admin API 限制。每个预算允许一次突发（burst），然后以稳定的速率补充：
| 预算 | 请求 | 突发 | 补充 |
| -- | -------------------- | --- | ------ |
| 读取 | 每个 `GET` | 120 | 每秒 2 个 |
| 更改 | 每个 `POST` 和 `DELETE` | 60 | 每秒 1 个 |
超出预算的请求会返回 **429 Too Many Requests**，并附带 `retry-after` 标头。响应中包含该请求所消耗预算的 `anthropic-ratelimit-requests-limit`、`anthropic-ratelimit-requests-remaining` 和 `anthropic-ratelimit-requests-reset` 标头。
## 分页
列表端点使用 **opaque cursor**（不透明游标）。第一个请求最多返回 `limit` 行以及一个 `next_page` 游标；在下一个请求中将该游标原样作为 `page` 参数传入，并重复此操作，直到 `next_page` 为 `null`。请将游标字符串视为不透明的：不要自行解析、修改或构造它。[列出频道](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#list-channels)可能会返回少于 `limit` 个频道甚至没有频道的页面，而 `next_page` 仍然有值，因此请持续请求页面，直到 `next_page` 为 `null`。Python、TypeScript、C#、Go、Java 和 Ruby SDK 的列表迭代器以及 CLI（使用 `--format raw` 时除外）会为您完成这一操作。在 PHP 和 curl 中，请自行请求每一页，并将其 `next_page` 作为 `page` 传入。
`limit` 默认为 20，最小值为 1，最大值为 100。每个列表都按 `created_at` 从新到旧排序，且不支持其他排序方式。
## 错误响应
错误响应遵循[错误](https://platform.claude.com/docs/zh-CN/api/errors)中记录的标准结构。联系支持团队时，请提供响应正文中的 `request_id`。
| 状态 | 含义 |
| --- | ---------------------------------------------------------------------------------------------------- |
| 400 | 输入无效，或该操作不适用于此频道、工作区或 Bundle（请参阅各端点的章节）。 |
| 401 | 缺少 `x-api-key` 标头，或无法识别该密钥。 |
| 403 | 该密钥不是具有作用域的组织级密钥、缺少所需的作用域，或您的组织无法进行此更改。 |
| 404 | 未找到资源，或资源不属于您的组织。当请求省略 `anthropic-beta` 值，或您的组织未启用此 API 时也会返回此状态，使这些端点看起来不存在。 |
| 409 | 在请求运行期间，有其他操作更改或移除了该资源。未存储任何内容。请重新读取该资源，如果仍需要更改，请重新发送。 |
| 429 | 超出速率限制。请参阅[速率限制](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#rate-limiting)。 |
| 500 | 内部错误。 |
| 503 | 临时错误。对于更改操作，它不表明更改是否已存储。每个更改都可以安全地重复执行，因此请原样重新发送请求。 |
当同一状态有多种需要您以不同方式处理的原因时，错误中还会包含 `error.details.error_code`：
```json
{
"type": "error",
"error": {
"type": "invalid_request_error",
"message": "...",
"details": {
"error_code": "slack_channel_set_up_settings_refused",
"slack_channel_id": "slch_011CZkZmRt4vNq8sHbYw2KdX"
}
},
"request_id": "req_018EeWyXxfu5pfWkrYcMdjWG"
}
```
| `error_code` | 状态 | 含义及处理方式 |
| -------------------------------------------- | --- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `organization_level_scoped_api_key_required` | 403 | 该凭据不是属于整个组织的、具有作用域的 Admin API 密钥。请向您的主要所有者申请一个。 |
| `api_key_scope_missing` | 403 | 该密钥缺少端点所需的 `read:claude_tag` 或 `write:claude_tag`。 |
| `workspace_selection_not_accepted` | 400 | 请求发送了 `anthropic-workspace-id` 标头。请将其移除。 |
| `claude_tag_writes_not_enabled` | 403 | 您的组织可以通过此 API 读取，但未启用更改功能。 |
| `compliance_configuration_restricted` | 403 | 您的组织具有合规配置，在该配置下 Claude Tag 不会存储任何新内容，例如零数据保留。设置频道、更新设置（即使是清除设置）以及附加 Bundle 都会被拒绝。分离 Bundle 和移除频道则不受影响。 |
| `environment_not_found` | 404 | `environment_id` 未指向您的组织在此处可以使用的任何环境。路径中的 `id` 没有问题。 |
| `environment_archived` | 400 | `environment_id` 指向一个已归档的环境。 |
| `slack_channel_set_up_settings_refused` | 400 | 请求设置了频道，随后 `settings` 被拒绝。`details.slack_channel_id` 即为该频道。请参阅[设置频道](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#set-up-a-channel)。 |
| `slack_channel_set_up_environment_not_found` | 404 | 请求设置了频道，随后未找到 `environment_id`。`details.slack_channel_id` 即为该频道。 |
| `slack_channel_set_up_settings_conflict` | 409 | 请求设置了频道，随后另一项更改与 `settings` 发生重叠。`settings` 中的任何内容均未存储。`details.slack_channel_id` 即为该频道。 |
| `slack_channel_not_configured` | 400 | 该频道未[配置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#configured-levels)，因此无法移除。 |
可能会新增代码。对于您无法识别的代码，请按照其状态的处理方式进行处理。不带 `error_code` 的 `404` 有两种可能的原因：要么是请求中指定的某项内容未找到（路径中的 `id`，或请求体或查询中的 Slack 频道或工作区），要么是由于请求省略了 `anthropic-beta` 值或您的组织未启用此 API，导致每个端点看起来都不存在。要区分这两种情况，请使用相同的密钥和标头[获取 Slack 默认设置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#get-the-slack-defaults)：该请求不指定任何内容，因此只有在第二种情况下才会返回 `404`。
## Activity Feed 事件
通过此 API 进行的每项更改都会记录在您组织的 [Compliance API Activity Feed](https://platform.claude.com/docs/zh-CN/manage-claude/compliance-activity-feed) 中，并归属于该 API 密钥，以携带其 `apikey_` ID 的 `api_actor` 形式记录。这些事件与在 claude.ai 中进行相同更改时 Activity Feed 所记录的事件相同，因此无论更改是通过哪种方式进行的，一次查询即可找到它。
| 事件 | 触发时机 |
| --------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| `ccr_agent_created` | 设置频道时。 |
| `ccr_agent_updated` | 频道、工作区或 Slack 默认设置上的某项设置发生更改时，或某个层级变为[已配置](https://platform.claude.com/docs/zh-CN/manage-claude/claude-tag-api#configured-levels)时。 |
| `ccr_agent_deleted` | 移除频道时。其 Bundle 目标随之一并移除，且不会单独触发事件。 |
| `ccr_agent_proxy_profile_bound` | 附加 Bundle 时。 |
| `ccr_agent_proxy_profile_unbound` | 分离 Bundle 时。 |
这些事件通过 `agent_id`（而非 `id`）来标识频道或工作区。两个 Bundle 事件在 `profile_id` 中标识 Bundle，在 `scope_id` 中标识频道或工作区。
`ccr_agent_updated` 事件会在 `updated_fields` 中列出所更改的内容，使用的是 Activity Feed 自己的名称：
| 设置 | 在 `updated_fields` 中的名称 |
| ---------------- | ------------------------ |
| `enabled` | `slackbot_version` |
| `instructions` | `system_prompt_addendum` |
| `model` | `default_model` |
| `environment_id` | `default_environment_id` |
| `guest_policy` | `guest_policy` |
| （该层级变为已配置） | `is_virtual` |
读取操作、未更改任何内容的请求，以及在存储任何内容之前即被拒绝的请求，都不会记录任何事件。如果一个设置请求设置了频道，但其 `settings` 随后被拒绝，则会记录 `ccr_agent_created`。
## 另请参阅
您的主要所有者在此创建具有作用域的密钥。
了解 Claude Tag 是什么、如何设置，以及每项设置在 Slack 中的作用。
在此处和 claude.ai 中所做的每项更改的审计记录。
管理您的 Claude Enterprise 组织中的插件。