---
title: Claude Tag API
url: https://platform.claude.com/docs/zh-TW/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 Tag，與 Claude Platform 工作區、API 使用量或 Claude Console 無關。
**需要具有「scope」（範圍）的 Admin API 金鑰**
這些端點需要具有 `read:claude_tag` 範圍（用於 `GET` 端點）或 `write:claude_tag` 範圍（用於 `POST` 和 `DELETE` 端點）的 Admin API 金鑰；請參閱[範圍](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#scopes)。請參閱[建立 Admin API 金鑰](https://platform.claude.com/docs/zh-TW/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization)，了解您的主要擁有者在何處建立金鑰。請在每個請求的 `x-api-key` 標頭中傳遞金鑰，並搭配 [`anthropic-version`](https://platform.claude.com/docs/zh-TW/api/versioning) 標頭以及下方附註中所示的 beta 標頭。
Claude Tag API 目前為 **beta** 版，僅供 Claude Enterprise 組織使用。Claude Platform（Claude Console）組織無法使用。
每個請求都必須包含 [beta 標頭](https://platform.claude.com/docs/zh-TW/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、讀取其中一個（唯讀） | `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-TW/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-TW/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-TW/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-TW/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-TW/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）。它與 ID 以 `wrkspc_` 開頭的 Claude Platform 工作區無關。 |
| Slack 預設值 | **Default Slack access** |
| 設定層級 | [範圍](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 為某個頻道或工作區保存設定記錄時，該頻道或工作區即為**已設定**（set up）。只有已設定的頻道或工作區才有 `id`，也只有它們會被列出：工作區的完整頻道清單由 Slack 保存，而非此 API。
* **工作區**在組織擁有者於 claude.ai 中連接它時即完成設定。沒有任何端點可以設定或移除工作區。
* **頻道**可在 claude.ai 中設定、在其中首次使用 Claude 時設定，或透過[設定頻道](https://platform.claude.com/docs/zh-TW/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-TW/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-TW/manage-claude/claude-tag-api#read-only-mode)。被移除後再次設定的頻道或工作區會有新的 `id`，舊的 `id` 會持續傳回 `404`。當儲存的 `id` 傳回不含 `error_code` 的 `404` 時，請使用相同的金鑰和標頭[取得 Slack 預設值](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#get-the-slack-defaults)。該請求不指定任何頻道或工作區，因此任何非 `404` 的狀態都表示該 `id` 已失效：請依 Slack ID 重新尋找該頻道或工作區。如果該請求也傳回 `404`，則無法據此判斷 `id` 的狀態：請保留您儲存的 `id` 值，並參閱[錯誤回應](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#error-responses)。
`agent_id`（前綴為 `cagt_`）是 [Compliance API](https://platform.claude.com/docs/zh-TW/manage-claude/compliance-api) 用來指稱同一頻道或工作區的名稱，既作為 Claude 在該處執行之工作階段的擁有者，也出現在 [Activity Feed 事件](https://platform.claude.com/docs/zh-TW/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-TW/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 中將某個設定層級設為使用自行託管的「runner pool」（執行器集區），其 `environment_id` 會傳回該集區的 ID，以 `ccpool_` 開頭。此 API 無法設定執行器集區，對於在已儲存執行器集區的設定層級上變更或清除 `environment_id` 的請求，會傳回 `400`。
### 儲存的設定與有效設定
設定存在於三個層級：頻道、頻道所在的工作區，以及組織的 Slack 預設值。每個層級只儲存在其上設定的內容。API 提供兩種檢視：
* **儲存**檢視（[取得頻道](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#get-a-channel)、[取得工作區](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#get-a-workspace)）包含頻道或工作區本身儲存的內容。未在該處設定的設定為 `null`。可用來與您在其他地方保存的設定進行比較。
* **有效**檢視（[取得頻道的有效設定](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#get-a-channels-effective-settings)、[取得工作區的有效設定](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#get-a-workspaces-effective-settings)）包含考量所有層級後實際套用的內容，`sources` 則指出每個值來自哪個層級。可用於稽核，或找出 Claude 在某個頻道中為何有特定行為。
每項設定各自獨立解析：
| 設定 | 規則 | 沒有任何層級設定時 |
| ---------------- | --------------------------------------------------------- | ------------------------------ |
| `enabled` | 由設定它的最近層級決定，因此即使工作區儲存 `false`，頻道上的 `true` 仍會在該處開啟 Claude。 | `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-TW/manage-claude/claude-tag-api#set-up-a-channel)都接受遵循相同規則的 `settings` 物件：
* **您省略的設定保持不變。** `{"settings": {"enabled": false}}` 會關閉 Claude，並讓其他四項設定維持原狀。
* **您以 `null` 傳送的設定會被清除**，因此該層級會再次繼承它。
* **全有或全無。** 如果請求中有任何值被拒絕，請求中的所有設定都不會被儲存。
* **可安全重複。** 每次變更都會讓資源維持與第一次相同請求後的狀態，因此沒有任何端點接受 `Idempotency-Key`。未改變任何內容的請求不會寫入任何內容，也不會記錄 Activity Feed 事件。
* **最後寫入者勝出。** 沒有任何請求接受前置條件。兩個呼叫者各自讀取資源後變更同一項設定，會互相覆寫。只有在您的請求執行期間有另一個變更與之重疊時才會傳回 `409`；您的請求沒有任何內容被儲存，因此請重新讀取資源，若仍需要則重新傳送變更。
變更頻道上的 `guest_policy` 可能會結束該頻道中正在執行的工作階段。它們會在背景中結束，回應不會等待其完成。
### 已配置的層級
一旦有人或金鑰變更了某個設定層級上的設定，或將 Bundle 附加到該層級，該層級即為**已配置**（configured）。此後它會一直保持已配置狀態，即使所有設定都被清除、所有 Bundle 都被卸離也一樣。因首次使用 Claude 而設定的頻道，或透過此 API 設定但未帶任何設定的頻道，在首次變更或首次附加 Bundle 之前都不算已配置。這在兩個地方很重要：只有已配置的頻道可以被[移除](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#remove-a-channel)，而只有未配置的頻道可能取得新的 `id`（請參閱[唯讀模式](https://platform.claude.com/docs/zh-TW/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-TW/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-TW/manage-claude/claude-tag-api#update-the-slack-defaults)上將 `enabled` 設為 `false`，以在所有地方關閉 Claude。
2. 當您的核准系統核准某個頻道時，以 `"settings": {"enabled": true}` [設定該頻道](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#set-up-a-channel)。此請求接受 Slack 自身的 ID，無論頻道是否已設定都會傳回該頻道，因此可安全重複。
3. 在同一次執行中，[附加](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#attach-a-bundle)該團隊獲准使用的 Bundle，讓頻道的第一個工作階段就已具備其工具。
### 將設定保存在版本控制中
1. 以 Slack 為每個頻道顯示的 ID 作為設定的鍵，並依這些 ID [尋找每個頻道](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#find-a-channel-by-its-slack-ids)。
2. 將**儲存**檢視與您的儲存庫所宣告的內容進行比較。有效檢視會混入繼承的值。
3. 只傳送不同的設定，並對儲存庫不再宣告的設定傳送 `null`。
4. 請組織擁有者開啟[唯讀模式](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#read-only-mode)，讓任何人都無法手動變更相同的設定。
### 稽核所有地方生效的設定
1. [列出您的工作區](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#list-workspaces)，然後[列出每個工作區的頻道](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#list-channels)。
2. 讀取每個頻道的[有效設定](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#get-a-channels-effective-settings)，並標記您的政策所禁止的情況，例如 `enabled` 為 `true` 但沒有核准記錄的頻道，或 `guest_policy` 為 `allow` 的頻道。
3. [列出您的 Bundle](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#list-bundles)，然後列出[每個 Bundle 的目標](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#list-a-bundles-targets)，以查看敏感系統的存取權附加在何處。
## Slack 頻道
頻道物件是單一 Slack 頻道的儲存檢視：
| 欄位 | 說明 |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` | `slack_channel`。 |
| `id` | 前綴為 `slch_`。請參閱 [ID](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#ids)。 |
| `slack` | Slack 自身的 ID：`team_id` 為頻道所在的工作區，`channel_id` 為頻道。 |
| `settings` | 頻道本身儲存的內容。一律存在，包含全部五項[設定](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#settings)；未設定者為 `null`。 |
| `agent_id` | 前綴為 `cagt_`。請參閱 [ID](https://platform.claude.com/docs/zh-TW/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-TW/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 應用程式的工作區也是如此。
設定頻道和套用 `settings` 是兩個步驟。當第一步成功而第二步被拒絕時，回應為拒絕，頻道保持已設定狀態但未儲存任何內容。該拒絕帶有以 `slack_channel_set_up_` 開頭的 `error_code`，並在 `error.details.slack_channel_id` 中包含新頻道的 `id`（請參閱[錯誤回應](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#error-responses)）。請修正 `settings`，並以[更新](https://platform.claude.com/docs/zh-TW/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-TW/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-TW/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-TW/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-TW/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-TW/manage-claude/claude-tag-api#slack-channels)相同，差別在於 `type` 為 `slack_workspace`、`id` 的前綴為 `slws_`，且 `slack` 僅包含 `team_id`。[快速入門](https://platform.claude.com/docs/zh-TW/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-TW/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-TW/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-TW/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-TW/manage-claude/claude-tag-api#slack-channels)上的相同。 |
| `agent_id` | 前綴為 `cagt_`。在 Slack 預設值[設定](https://platform.claude.com/docs/zh-TW/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-TW/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-TW/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 限制分開計算。每個預算允許一次突發量，之後以穩定速率補充：
| 預算 | 請求 | 突發量 | 補充速率 |
| -- | -------------------- | --- | ------ |
| 讀取 | 每個 `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-TW/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-TW/api/errors)中記載的標準格式。聯絡支援團隊時，請提供回應主體中的 `request_id`。
| 狀態 | 意義 |
| --- | ---------------------------------------------------------------------------------------------------- |
| 400 | 輸入無效，或該操作不適用於此頻道、工作區或 Bundle（請參閱各端點的章節）。 |
| 401 | 缺少 `x-api-key` 標頭，或無法辨識該金鑰。 |
| 403 | 該金鑰不是組織層級且具有範圍的金鑰、缺少所需的範圍，或您的組織無法進行此變更。 |
| 404 | 找不到資源，或資源不屬於您的組織。當請求省略 `anthropic-beta` 值，或您的組織未啟用此 API 時，也會傳回此狀態，使這些端點看起來不存在。 |
| 409 | 在請求執行期間，有其他操作變更或移除了該資源。未儲存任何內容。請重新讀取，若仍需要變更，請重新傳送。 |
| 429 | 超出速率限制。請參閱[速率限制](https://platform.claude.com/docs/zh-TW/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-TW/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-TW/manage-claude/claude-tag-api#configured-levels)，因此無法移除。 |
未來可能會新增代碼。遇到無法辨識的代碼時，請依其狀態的處理方式來處理。沒有 `error_code` 的 `404` 有兩種可能原因。一是請求所指定的某項內容找不到（路徑中的 `id`，或主體或查詢參數中的 Slack 頻道或工作區）；二是因為請求省略了 `anthropic-beta` 值，或您的組織未啟用此 API，導致每個端點看起來都不存在。若要區分兩者，請使用相同的金鑰和標頭[取得 Slack 預設值](https://platform.claude.com/docs/zh-TW/manage-claude/claude-tag-api#get-the-slack-defaults)：該請求不指定任何內容，因此只有在第二種情況下才會傳回 `404`。
## Activity Feed 事件
透過此 API 進行的每項變更都會記錄在您組織的 [Compliance API Activity Feed](https://platform.claude.com/docs/zh-TW/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-TW/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 組織中的外掛程式。