---
title: Claude Tag API
url: https://platform.claude.com/docs/de/manage-claude/claude-tag-api
description: "Verwalte Claude Tag in Slack für deine Claude Enterprise-Organisation aus deinen eigenen Systemen: Lies und ändere Einstellungen für Kanäle, Workspaces und die Slack-Standardeinstellungen deiner Organisation, sieh nach, welche Einstellungen gelten und warum, und hänge Access Bundles an."
---
[Claude Tag](https://claude.com/docs/claude-tag/overview) ist Claude, das als Teammitglied in Slack arbeitet: Jemand erwähnt Claude in einem Kanal, und Claude antwortet im Thread. Mit der Claude Tag API kannst du aus deinen eigenen Systemen die Claude Tag-Einstellungen lesen und ändern, die ein Organisationseigentümer sonst manuell unter [claude.ai > Organization settings > Claude Tag](https://claude.ai/admin-settings/claude-tag) festlegt. Verwende sie, um Claude Kanal für Kanal über einen Genehmigungs-Workflow einzuschalten, deine Konfiguration in der Versionskontrolle zu halten oder zu prüfen, was in jedem Kanal gilt.
Claude Tag ist ein claude.ai-Produkt. Diese API verwaltet es für eine Claude Enterprise-Organisation und hat nichts mit Claude Platform-Workspaces, API-Nutzung oder der Claude Console zu tun.
**Admin-API-Key mit Scope erforderlich**
Diese Endpunkte erfordern einen Admin-API-Key mit dem Scope `read:claude_tag` (für `GET`-Endpunkte) oder dem Scope `write:claude_tag` (für `POST`- und `DELETE`-Endpunkte); siehe [Scopes](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#scopes). Unter [Einen Admin-API-Key erstellen](https://platform.claude.com/docs/de/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization) erfährst du, wo dein primärer Eigentümer einen solchen Key erstellt. Übergib den Key bei jeder Anfrage im Header `x-api-key`, zusammen mit dem Header [`anthropic-version`](https://platform.claude.com/docs/de/api/versioning) und dem Beta-Header aus dem folgenden Hinweis.
Die Claude Tag API befindet sich in der **Beta** und ist nur für Claude Enterprise-Organisationen verfügbar. Sie ist nicht für Claude Platform-Organisationen (Claude Console) verfügbar.
Jede Anfrage muss den [Beta-Header](https://platform.claude.com/docs/de/api/beta-headers) `anthropic-beta: claude-tag-2026-09-28` enthalten (das SDK und die `ant` CLI senden ihn für dich). Eine Anfrage ohne diesen Header gibt `404` zurück, genau so, als ob der Endpunkt nicht existieren würde.
## Endpunkte
Die API stellt 18 Endpunkte für fünf Ressourcen bereit:
| Ressource | Endpunkte |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Slack-Kanäle:** einen Kanal einrichten, die Kanäle eines Workspace auflisten oder einen anhand seiner Slack-IDs finden, einen lesen, seine Einstellungen ändern, sehen, was in ihm gilt, ihn entfernen | `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-Workspaces:** deine verbundenen Workspaces auflisten oder einen anhand seiner Slack-ID finden, einen lesen, seine Einstellungen ändern, sehen, was in ihm gilt | `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-Standardeinstellungen:** die Einstellungen lesen und ändern, die für jeden Workspace und Kanal gelten | `GET /v1/organizations/claude_tag/slack_defaults`
`POST /v1/organizations/claude_tag/slack_defaults` |
| **Bundles:** die Access Bundles deiner Organisation auflisten, eines lesen (schreibgeschützt) | `GET /v1/organizations/claude_tag/bundles`
`GET /v1/organizations/claude_tag/bundles/{bundle_id}` |
| **Bundle-Ziele:** auflisten, wo ein Bundle angehängt ist, es an einen Kanal oder Workspace anhängen, eine Zuordnung lesen, es trennen | `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}` |
Dieses Release umfasst Slack. Das Verbinden und Trennen eines Slack-Workspace, das Erstellen und Bearbeiten von Access Bundles, Ausgabenlimits und jede Claude Tag-Einstellung außer den fünf unter [Einstellungen](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#settings) bleiben in claude.ai.
## Voraussetzungen
* Deine Organisation muss einen Claude Enterprise-Plan haben, mit [eingerichtetem Claude Tag](https://claude.com/docs/claude-tag/admins/setup-overview) und mindestens einem verbundenen Slack-Workspace.
* Dein primärer Eigentümer erstellt unter [claude.ai > Organization settings > API](https://claude.ai/admin-settings/api-access) einen Admin-API-Key mit dem Scope `read:claude_tag`, dem Scope `write:claude_tag` oder beiden. Siehe [Einen Admin-API-Key erstellen](https://platform.claude.com/docs/de/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization).
* Jede Anfrage enthält drei Header: `x-api-key`, `anthropic-version: 2023-06-01` und `anthropic-beta: claude-tag-2026-09-28`.
Die SDKs für Python, TypeScript, C#, Go, Java, PHP und Ruby stellen diese Endpunkte unter `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`) bereit und die [`ant` CLI](https://platform.claude.com/docs/de/cli-sdks-libraries/cli/quickstart) unter `ant beta:organization:claude-tag`; sie senden die Header `anthropic-version` und `anthropic-beta` für dich. Die Beispiele auf dieser Seite verwenden den Standard-Client jedes SDK, der, wie die CLI, den Admin-API-Key aus der Umgebungsvariable `ANTHROPIC_API_KEY` liest; die curl-Beispiele lesen den Key aus derselben Variable und übergeben ihn im Header `x-api-key`. Wenn ein SDK oder die CLI weitere Seiten für dich abruft, legt `limit` die Seitengröße fest, nicht die Gesamtzahl (siehe [Paginierung](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#pagination)).
API-Keys gehören der Organisation und funktionieren weiter, nachdem die Person, die sie erstellt hat, die Organisation verlässt. Teile sie nicht und checke sie nicht in die Versionskontrolle ein.
## Schnellstart
Liste die Slack-Workspaces auf, die deine Organisation mit Claude Tag verbunden hat:
```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()
# Ruft bei Bedarf automatisch weitere Seiten ab.
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();
// Nur diese Seite; für die nächste rufe list() erneut mit page: $workspaces->nextPage auf.
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
}
```
Eine Einstellung, die `null` ist, ist für diesen Workspace nicht gesetzt, sodass der Workspace sie erbt. Siehe [Gespeicherte und effektive Einstellungen](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#stored-and-effective-settings).
## Scopes
| Scope | Gewährt |
| ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `read:claude_tag` | Jeden `GET`-Endpunkt auf dieser Seite. |
| `write:claude_tag` | Jeden `POST`- und `DELETE`-Endpunkt auf dieser Seite. Er gewährt keine Lesezugriffe, obwohl die Antwort auf eine Änderung die geänderte Ressource enthält. |
Ein Key kann beide Scopes haben. Eine Integration, die einen Kanal nachschlägt und ihn dann ändert, benötigt beide. Kein anderer Scope gewährt Zugriff auf diese Endpunkte.
Der Key muss der Organisation als Ganzes gehören. Die Organisation ist immer diejenige, der der Key gehört, und keine Anfrage benennt eine. Eine Anfrage, die den Header `anthropic-workspace-id` sendet, gibt `400` zurück, da nichts hier zu einem Claude Platform-Workspace gehört.
## Wichtige Konzepte
### Bezeichnungen auf dieser Seite und in claude.ai
| Diese API | claude.ai und Slack |
| --------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| Slack-Workspace | Ein Slack-Workspace (den Slack auch Team nennt). Er hat nichts mit einem Claude Platform-Workspace zu tun, dessen IDs mit `wrkspc_` beginnen. |
| Slack-Standardeinstellungen | **Default Slack access** |
| Einstellungsebene | Ein [Scope](https://claude.com/docs/claude-tag/admins/customize): ein Kanal, ein Workspace oder die Slack-Standardeinstellungen |
| Bundle | Ein [Access Bundle](https://claude.com/docs/claude-tag/concepts/glossary#access-bundle) |
| `enabled` | Der Schalter **Enable Claude Tag in Slack** |
| `instructions` | **Custom instructions** |
| `model` | **Model** |
| `environment_id` | **Environment** |
| `guest_policy` | **How should Claude work in channels with guests**: `restrict` ist **Restrict**, `channel_only` ist **Channel only** und `allow` ist **Full access** |
### Eingerichtete Kanäle und Workspaces
Ein Kanal oder Workspace ist **eingerichtet** („set up“), wenn Claude Tag einen Einstellungsdatensatz für ihn führt. Nur ein eingerichteter Kanal oder Workspace hat eine `id`, und nur diese werden aufgelistet: Slack, nicht diese API, führt die vollständige Liste der Kanäle eines Workspace.
* Ein **Workspace** wird eingerichtet, wenn ein Organisationseigentümer ihn in claude.ai verbindet. Kein Endpunkt richtet einen Workspace ein oder entfernt ihn.
* Ein **Kanal** wird in claude.ai, durch Claudes erste Nutzung darin oder mit [Einen Kanal einrichten](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#set-up-a-channel) eingerichtet.
* Die **Slack-Standardeinstellungen** werden eingerichtet, wenn jemand Claude Tag zum ersten Mal einrichtet: Ein Eigentümer verbindet einen Slack-Workspace, oder ein Mitglied meldet sich bei Claude in Slack an oder nutzt es zum ersten Mal.
Deine Organisation besitzt einen Workspace, solange seine Verbindung aktiv ist, und besitzt die Kanäle darin. Ein Kanal oder Workspace, den du nicht besitzt, gibt dasselbe `404` zurück wie einer, der nicht existiert.
### IDs
Du kennst einen Kanal anhand der IDs, die Slack dir anzeigt. Schlage seine `id` einmal mit [Einen Kanal anhand seiner Slack-IDs finden](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#find-a-channel-by-its-slack-ids) nach, speichere dann die `id` und verwende sie.
| ID | Präfix | Wo sie erscheint |
| ------------------------- | ------------ | ----------------------------------------------------------------------------- |
| Slack-Kanal-Ressource | `slch_` | `id` bei einem Kanal; `slack_channel_id` in Request-Bodys und Antworten |
| Slack-Workspace-Ressource | `slws_` | `id` bei einem Workspace; `slack_workspace_id` in Request-Bodys und Antworten |
| Bundle | `capp_` | `id` bei einem Bundle; `{bundle_id}` in Pfaden |
| Bundle-Ziel | `btgt_` | `id` bei einem Bundle-Ziel; `{target_id}` in Pfaden |
| Slacks eigene Team-ID | `T` | `slack.team_id`; der Query-Parameter `slack_team_id` |
| Slacks eigene Kanal-ID | `C` oder `G` | `slack.channel_id`; der Query-Parameter `slack_channel_id` |
`slack_channel_id` hat zwei Bedeutungen. In einem **Query-Parameter** ist es Slacks eigene ID (`C05HJKL6MNP`). In einem **Request-Body oder einer Antwort** ist es die `id`, die diese API vergibt (`slch_...`). Slacks eigene IDs stehen in einem Body oder einer Antwort immer unter `slack`.
Eine `id` ändert sich nicht, solange der Kanal oder Workspace eingerichtet ist, egal was du daran änderst, mit einer Ausnahme, die unter [Schreibgeschützter Modus](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#read-only-mode) beschrieben ist. Ein Kanal oder Workspace, der entfernt und erneut eingerichtet wird, hat eine neue `id`, und die alte gibt weiterhin `404` zurück. Wenn eine gespeicherte `id` `404` ohne `error_code` zurückgibt, [rufe die Slack-Standardeinstellungen ab](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#get-the-slack-defaults) mit demselben Key und denselben Headern. Diese Anfrage benennt keinen Kanal und keinen Workspace, daher bedeutet jeder andere Status als `404`, dass die `id` nicht mehr existiert: Suche den Kanal oder Workspace erneut anhand seiner Slack-IDs. Ein `404` auch dort sagt nichts über die `id` aus: Behalte deine gespeicherten `id`-Werte und sieh dir [Fehlerantworten](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#error-responses) an.
`agent_id` (mit dem Präfix `cagt_`) ist die Bezeichnung, mit der die [Compliance API](https://platform.claude.com/docs/de/manage-claude/compliance-api) denselben Kanal oder Workspace benennt, sowohl als Eigentümer der Sitzungen, die Claude dort ausgeführt hat, als auch in [Activity Feed-Ereignissen](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#activity-feed-events). Sie besteht so lange wie die `id`.
### Einstellungen
Jede Einstellungsebene speichert dieselben fünf Einstellungen, alle optional:
| Einstellung | Typ | Beschreibung |
| ---------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `enabled` | boolean | Ob Claude eingeschaltet ist. |
| `instructions` | string | Dauerhafte Anweisungen, die Claude in jeder Sitzung liest. Höchstens 8.192 Zeichen, nachdem führende und nachgestellte Leerzeichen entfernt wurden. Leerer Text löscht die Einstellung. |
| `model` | string | Das Modell, mit dem neue Sitzungen starten: eine [Modell-ID](https://platform.claude.com/docs/de/models/overview), die deine Organisation mit Claude Tag verwenden kann. Höchstens 128 Zeichen. |
| `environment_id` | string | Die Cloud-Umgebung, in der Sitzungen laufen, mit dem Präfix `env_`. Sie muss aktiv sein und deiner Organisation gehören. |
| `guest_policy` | object | Was Claude in einem Kanal tut, während sich ein Slack-Gast darin befindet, für alle im Kanal: `{"type": "allow"}` (Claude antwortet), `{"type": "restrict"}` (Claude antwortet nicht) oder `{"type": "channel_only"}` (Claude antwortet nur mit den Bundles, die an den Kanal selbst angehängt sind). Unter [Restrict guest channels](https://claude.com/docs/claude-tag/admins/restrict-access#restrict-guest-channels) erfährst du, was dies in Kanälen bedeutet, die über Slack Connect oder über ein Enterprise Grid geteilt werden. |
`model` und `environment_id` werden beim Schreiben geprüft und danach nicht erneut: Wenn sich das Modell oder die Umgebung später ändert, geben beide Ansichten weiterhin den gespeicherten Wert zurück.
Wenn ein Organisationseigentümer eine Einstellungsebene in claude.ai auf einen selbst gehosteten Runner-Pool gesetzt hat, gibt ihre `environment_id` die ID des Pools zurück, die mit `ccpool_` beginnt. Diese API kann keinen Runner-Pool festlegen und gibt `400` für eine Anfrage zurück, die `environment_id` auf einer Einstellungsebene ändert oder löscht, die einen speichert.
### Gespeicherte und effektive Einstellungen
Einstellungen existieren auf drei Ebenen: dem Kanal, dem Workspace, in dem sich der Kanal befindet, und den Slack-Standardeinstellungen deiner Organisation. Jede Ebene speichert nur, was auf ihr festgelegt wurde. Die API bietet dir zwei Ansichten:
* Die **gespeicherte** Ansicht („stored“) ([Einen Kanal abrufen](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#get-a-channel), [Einen Workspace abrufen](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#get-a-workspace)) enthält, was der Kanal oder Workspace selbst speichert. Eine Einstellung, die dort nicht gesetzt ist, ist `null`. Verwende sie zum Abgleich mit einer Konfiguration, die du anderswo führst.
* Die **effektive** Ansicht („effective“) ([Die effektiven Einstellungen eines Kanals abrufen](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#get-a-channels-effective-settings), [Die effektiven Einstellungen eines Workspace abrufen](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#get-a-workspaces-effective-settings)) enthält, was gilt, sobald jede Ebene berücksichtigt ist, und `sources` benennt die Ebene, aus der jeder Wert stammt. Verwende sie zur Prüfung oder um herauszufinden, warum Claude sich in einem Kanal so verhält, wie es sich verhält.
Jede Einstellung wird für sich aufgelöst:
| Einstellung | Regel | Wenn keine Ebene sie festlegt |
| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
| `enabled` | Die nächstgelegene Ebene, die sie festlegt, entscheidet, sodass `true` für einen Kanal Claude dort einschaltet, selbst wenn sein Workspace `false` speichert. | `true` |
| `instructions` | Additiv. Der Text jeder Ebene, die sie festlegt, wird zusammengefügt, die umfassendste zuerst, mit einer Leerzeile dazwischen. | `null` |
| `model` | Die nächstgelegene Ebene, die sie festlegt, entscheidet. | `null`: Claude verwendet das Standardmodell des Produkts |
| `environment_id` | Die nächstgelegene Ebene, die sie festlegt, entscheidet. | `null` |
| `guest_policy` | Die nächstgelegene Ebene, die sie festlegt, entscheidet. | `restrict` in einer Organisation, deren Slack-Standardeinstellungen eingerichtet sind |
Beispielsweise speichert eine Organisation Anweisungen in ihren Slack-Standardeinstellungen, schaltet Claude für einen Workspace aus und legt ein Modell für einen Kanal dieses Workspace fest. Die effektive Ansicht des Kanals zeigt die drei Werte und woher jeder stammt:
```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" }
}
}
```
Eine Quelle ist eine der folgenden:
| `type` | Bedeutung |
| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `slack_channel` | Der Kanal, benannt in `slack_channel_id`. |
| `slack_workspace` | Der Workspace, benannt in `slack_workspace_id`. |
| `slack_parent_channel` | Der übergeordnete Kanal eines Code-Kanals, benannt in `slack_channel_id`. Ein Code-Kanal ist einer, der aus einem anderen Kanal heraus gestartet wurde. Solange der übergeordnete Kanal ein öffentlicher Kanal im selben Workspace ist, liegt er zwischen dem Kanal und dem Workspace und trägt nur `instructions` und `environment_id` bei. |
| `slack_defaults` | Die Slack-Standardeinstellungen deiner Organisation, die keine ID haben. |
| `default` | Keine Ebene legt einen Wert fest, daher gilt der eingebaute Standardwert. |
`sources.instructions` ist eine Liste, die umfassendste zuerst, aller Ebenen, die Text beitragen, und ist leer, wenn keine dies tut. Die ID einer Quelle kann `null` sein in einer Organisation, die den Kanal über eine Slack Enterprise Grid-Verbindung statt über den eigenen Workspace des Kanals erreicht.
### Einstellungen ändern
Die drei Update-Endpunkte und [Einen Kanal einrichten](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#set-up-a-channel) nehmen ein `settings`-Objekt nach denselben Regeln entgegen:
* **Eine Einstellung, die du weglässt, bleibt unverändert.** `{"settings": {"enabled": false}}` schaltet Claude aus und lässt die anderen vier Einstellungen, wie sie sind.
* **Eine Einstellung, die du als `null` sendest, wird gelöscht**, sodass die Ebene sie wieder erbt.
* **Alles oder nichts.** Wenn ein Wert in einer Anfrage abgelehnt wird, wird keine Einstellung der Anfrage gespeichert.
* **Gefahrlos wiederholbar.** Jede Änderung hinterlässt die Ressource so, wie die erste identische Anfrage sie hinterlassen hat, daher nimmt kein Endpunkt einen `Idempotency-Key` entgegen. Eine Anfrage, die nichts ändert, schreibt nichts und zeichnet kein Activity Feed-Ereignis auf.
* **Der letzte Schreibvorgang gewinnt.** Keine Anfrage nimmt eine Vorbedingung entgegen. Zwei Aufrufer, die jeweils eine Ressource lesen und dann dieselbe Einstellung ändern, überschreiben sich gegenseitig. Ein `409` wird nur zurückgegeben, wenn sich eine andere Änderung mit deiner Anfrage überschneidet, während diese läuft; nichts von deiner Anfrage wurde gespeichert, also lies die Ressource erneut und sende die Änderung noch einmal, falls sie noch benötigt wird.
Eine Änderung von `guest_policy` für einen Kanal kann Sitzungen beenden, die in diesem Kanal laufen. Sie enden im Hintergrund, und die Antwort wartet nicht darauf.
### Konfigurierte Ebenen
Eine Einstellungsebene ist **konfiguriert** („configured“), sobald eine Person oder ein Key eine Einstellung auf ihr geändert oder ein Bundle an sie angehängt hat. Sie bleibt von da an konfiguriert, selbst nachdem jede Einstellung gelöscht und jedes Bundle getrennt wurde. Ein Kanal, der durch Claudes erste Nutzung oder über diese API ohne Einstellung eingerichtet wurde, ist erst nach seiner ersten Änderung oder seinem ersten Bundle konfiguriert. Dies ist an zwei Stellen wichtig: Nur ein konfigurierter Kanal kann [entfernt](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#remove-a-channel) werden, und nur ein Kanal, der nicht konfiguriert ist, kann eine neue `id` erhalten (siehe [Schreibgeschützter Modus](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#read-only-mode)).
### Schreibgeschützter Modus
**API / Terraform read-only mode** (schreibgeschützter Modus) ist eine Einstellung, die ein Organisationseigentümer in den Claude Tag-Einstellungen von claude.ai ein- und ausschaltet. Der Name beschreibt claude.ai und Slack: Solange der Modus eingeschaltet ist, lehnen sie Änderungen einer Person an dem ab, was diese API verwaltet, sodass nur Keys diese Änderungen vornehmen. Er macht diese API nicht schreibgeschützt. Jeder Endpunkt auf dieser Seite antwortet gleich, ob der Modus ein- oder ausgeschaltet ist, und kein Endpunkt liest oder ändert ihn.
Solange der Modus ausgeschaltet ist, ändern Personen und Keys dieselben Einstellungen und hängen dieselben Bundles an und trennen sie, und jede Änderung ersetzt, was gespeichert ist. Schalte ihn ein, wenn deine Pipeline die einzige Quelle von Änderungen sein soll.
Solange der Modus eingeschaltet ist, lehnen claude.ai und Slack Folgendes ab:
* Das Ändern einer der fünf Einstellungen für einen Kanal, einen Workspace oder die Slack-Standardeinstellungen.
* Das Einrichten eines Kanals, das Entfernen eines Kanals oder das Trennen eines Workspace in claude.ai.
* Das Anhängen eines Bundles an einen Kanal oder Workspace, das Trennen eines Bundles oder das Löschen eines Bundles, das an einen angehängt ist.
Einige Dinge bleiben in beiden Fällen möglich: Ein Eigentümer kann weiterhin einen neuen Workspace verbinden, Bundles erstellen und bearbeiten und Claude Tag-Einstellungen ändern, die diese API nicht verwaltet. Claudes erste Nutzung richtet weiterhin einen Kanal ein, das Löschen eines Kanals in Slack entfernt ihn weiterhin, und das Deinstallieren von Claudes Slack-App trennt diesen Workspace weiterhin.
Solange der Modus ausgeschaltet ist, kann das Einrichten eines Kanals in claude.ai, der bereits eingerichtet und nicht [konfiguriert](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#configured-levels) ist, den Datensatz des Kanals ersetzen. Der Kanal hat dann eine neue `id` und `agent_id`, und die alte `id` gibt `404` zurück. Die `id` eines konfigurierten Kanals besteht, bis der Kanal entfernt wird.
### Gruppen-Direktnachrichten
Eine Slack-Gruppen-Direktnachricht hat eine ID in der Form einer Kanal-ID, daher richtet Claudes Nutzung darin sie wie einen Kanal ein: Sie hat eine `id`, wird aufgelistet und kann gelesen werden. Das Einrichten einer solchen über diese API, das Ändern einer Einstellung für sie und das Anhängen eines Bundles an sie geben jeweils `400` zurück. Das Trennen eines Bundles von ihr ist erlaubt.
## Beispiel-Workflows
### Claude nur in genehmigten Kanälen einschalten
Jedes Mitglied kann Claude in einen öffentlichen Kanal einladen. Um Claude nur dort eingeschaltet zu lassen, wo du es genehmigt hast:
1. Schalte Claude überall aus, indem du `enabled` in den [Slack-Standardeinstellungen](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#update-the-slack-defaults) auf `false` setzt.
2. Wenn dein Genehmigungssystem einen Kanal genehmigt, [richte den Kanal ein](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#set-up-a-channel) mit `"settings": {"enabled": true}`. Die Anfrage nimmt Slacks eigene IDs entgegen und gibt den Kanal zurück, unabhängig davon, ob er bereits eingerichtet war, daher kann sie gefahrlos wiederholt werden.
3. [Hänge](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#attach-a-bundle) im selben Durchlauf die Bundles an, die für das Team genehmigt wurden, damit die erste Sitzung des Kanals bereits ihre Tools hat.
### Konfiguration in der Versionskontrolle halten
1. Verwende die IDs, die Slack für jeden Kanal anzeigt, als Schlüssel deiner Konfiguration und [finde jeden Kanal](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#find-a-channel-by-its-slack-ids) anhand dieser IDs.
2. Vergleiche die **gespeicherte** Ansicht mit dem, was dein Repository deklariert. Die effektive Ansicht würde auch geerbte Werte enthalten.
3. Sende nur die Einstellungen, die sich unterscheiden, und sende `null` für eine Einstellung, die dein Repository nicht mehr deklariert.
4. Bitte einen Organisationseigentümer, den [schreibgeschützten Modus](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#read-only-mode) einzuschalten, damit niemand dieselben Einstellungen manuell ändert.
### Prüfen, was überall gilt
1. [Liste deine Workspaces auf](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#list-workspaces) und dann [die Kanäle jedes Workspace](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#list-channels).
2. Lies die [effektiven Einstellungen](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#get-a-channels-effective-settings) jedes Kanals und markiere, was deine Richtlinie verbietet, etwa einen Kanal, in dem `enabled` ohne hinterlegte Genehmigung `true` ist, oder in dem `guest_policy` `allow` ist.
3. [Liste deine Bundles auf](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#list-bundles) und dann [die Ziele jedes Bundles](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#list-a-bundles-targets), um zu sehen, wo Zugriff auf sensible Systeme angehängt ist.
## Slack-Kanäle
Das Kanal-Objekt ist die gespeicherte Ansicht eines Slack-Kanals:
| Feld | Beschreibung |
| ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` | `slack_channel`. |
| `id` | Mit dem Präfix `slch_`. Siehe [IDs](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#ids). |
| `slack` | Slacks eigene IDs: `team_id` für den Workspace, in dem sich der Kanal befindet, und `channel_id` für den Kanal. |
| `settings` | Was der Kanal selbst speichert. Immer vorhanden, mit allen fünf [Einstellungen](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#settings); eine, die nicht gesetzt ist, ist `null`. |
| `agent_id` | Mit dem Präfix `cagt_`. Siehe [IDs](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#ids). |
| `created_at` | Wann der Kanal eingerichtet wurde. |
| `updated_at` | Wann sich Claude Tags Datensatz des Kanals zuletzt geändert hat. Der Wert ändert sich bei jeder Änderung einer Einstellung, hier, in claude.ai oder in Slack, und kann sich auch bei einer Änderung ändern, die keine Antwort hier zeigt. Betrachte einen späteren Wert als Grund, den Kanal erneut zu lesen, nicht als Beweis, dass sich eine Einstellung geändert hat. Das Anhängen oder Trennen eines Bundles allein ändert ihn nicht. |
Eine `id` ohne das Präfix `slch_` gibt `400` zurück. Eine `id`, die das Präfix trägt, aber keinen Kanal deiner Organisation benennt, gibt `404` zurück.
### Einen Kanal einrichten
`POST /v1/organizations/claude_tag/slack_channels` richtet einen Slack-Kanal ein und gibt ihn zurück. `slack.team_id` und `slack.channel_id` sind erforderlich und sind Slacks eigene IDs. `settings` ist optional und folgt den Regeln unter [Einstellungen ändern](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#changing-settings). Wenn der Kanal bereits eingerichtet ist, gibt die Anfrage den vorhandenen Kanal zurück und wendet `settings` an; die Antwort ist in beiden Fällen `200`. Erfordert den Scope `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"
}
```
Bevor ein Kanal eingerichtet wird, vergewissert sich Claudes Slack-App bei Slack, dass sich der Kanal im Workspace befindet, nicht archiviert ist und für die App sichtbar ist. Ein Kanal, der diese Prüfung nicht besteht, gibt `404` zurück, ebenso wie ein Workspace, in dem Claudes Slack-App nicht installiert ist.
Das Einrichten des Kanals und das Anwenden von `settings` sind zwei Schritte. Wenn der erste erfolgreich ist und der zweite abgelehnt wird, ist die Antwort die Ablehnung, und der Kanal bleibt eingerichtet, ohne dass etwas gespeichert ist. Diese Ablehnung enthält einen `error_code`, der mit `slack_channel_set_up_` beginnt, und die `id` des neuen Kanals in `error.details.slack_channel_id` (siehe [Fehlerantworten](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#error-responses)). Korrigiere `settings` und sende es in einem [Update](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#update-a-channel) an diese `id`, oder sende die Einrichtungsanfrage erneut.
### Kanäle auflisten
`GET /v1/organizations/claude_tag/slack_channels` listet die eingerichteten Kanäle eines Workspace auf, die neuesten zuerst nach `created_at`. `slack_team_id` ist erforderlich und ist Slacks eigene ID für den Workspace. Eine Seite kann weniger als `limit` Kanäle oder gar keine enthalten, während `next_page` noch gesetzt ist, also fordere weiter Seiten an, bis `next_page` `null` ist (siehe [Paginierung](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#pagination)). Erfordert den Scope `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"
)
# Ruft bei Bedarf automatisch weitere Seiten ab.
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',
);
// Nur diese Seite; für die nächste rufe list() erneut mit page: $channels->nextPage auf.
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
```
Die Antwort ist `{"data": [...], "next_page": ...}`, wobei jedes Element ein Kanal-Objekt ist. Eine `slack_team_id`, die einen Workspace benennt, den deine Organisation nicht besitzt, gibt `404` zurück.
### Einen Kanal anhand seiner Slack-IDs finden
Füge `slack_channel_id`, Slacks eigene ID für den Kanal, hinzu, um einen Kanal nachzuschlagen. `data` enthält diesen Kanal oder ist leer, wenn der Kanal nicht eingerichtet ist. Eine Suche ignoriert `limit` und `page`, und ihr `next_page` ist `null`. So findest du die `id` eines Kanals.
```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
```
Die Übergabe einer `slch_`-ID als `slack_channel_id` gibt `400` zurück.
### Einen Kanal abrufen
`GET /v1/organizations/claude_tag/slack_channels/{id}` gibt das Kanal-Objekt zurück. Erfordert den Scope `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
```
### Einen Kanal aktualisieren
`POST /v1/organizations/claude_tag/slack_channels/{id}` ändert die Einstellungen des Kanals und gibt das Kanal-Objekt zurück. `settings` ist erforderlich und folgt den Regeln unter [Einstellungen ändern](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#changing-settings). Erfordert den Scope `write:claude_tag`.
Schalte Claude in einem Kanal aus und lass seine anderen Einstellungen, wie sie sind:
```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
```
Lösche die Anweisungen des Kanals, sodass nur die geerbten gelten:
```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() entfernt nulls in Arrays, also erstelle das Settings-Objekt, um null zu senden.
$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
```
### Die effektiven Einstellungen eines Kanals abrufen
`GET /v1/organizations/claude_tag/slack_channels/{id}/effective` gibt zurück, was im Kanal gilt und woher jeder Wert stammt. [Gespeicherte und effektive Einstellungen](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#stored-and-effective-settings) zeigt eine vollständige Antwort. In dieser Ansicht sind `enabled` und `guest_policy` nie `null`. Die Ansicht wird bei jedem Lesevorgang aufgelöst, daher hat sie kein `created_at` oder `updated_at`. Wenn eine Ebene nicht gelesen werden kann, schlägt die Anfrage mit `503` fehl, statt ohne sie aufgelöst zu werden. Erfordert den Scope `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
```
### Einen Kanal entfernen
`DELETE /v1/organizations/claude_tag/slack_channels/{id}` entfernt einen Kanal aus Claude Tag. Es ist dieselbe Entfernung, die ein Organisationseigentümer in claude.ai vornimmt, mit derselben Wirkung. Der Kanal in Slack oder eine Nachricht darin wird dabei weder gelöscht, archiviert noch verändert. Erfordert den Scope `write:claude_tag`.
Das Entfernen kann nicht rückgängig gemacht werden. Es löscht, was Claude Tag für den Kanal speichert:
* seine gespeicherten Einstellungen und seine Bundle-Ziele
* seine Sitzungen und deren Transkripte, einschließlich laufender Sitzungen
* sein Gedächtnis, also das, was Claude von einer Sitzung zur nächsten über den Kanal behält
* seine Routinen und die daraus veröffentlichten 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"
}
```
Die `id` gibt `404` zurück, sobald die Anfrage zurückkehrt, und der Rest wird im Hintergrund gelöscht. Ein wiederholtes Entfernen gibt `404` zurück.
**Das Entfernen eines Kanals stoppt Claude darin nicht.** Claude antwortet weiterhin gemäß dem, was der Kanal erbt, ohne Erinnerung an den Kanal, und bei der nächsten Nutzung kann der Kanal mit einer neuen `id` erneut eingerichtet werden.
* Um zu verhindern, dass Claude in einem Kanal antwortet, setze stattdessen `enabled` für ihn auf `false`.
* Damit ein Kanal nichts speichert und seine Sitzungen und sein Gedächtnis behält, lösche stattdessen jede Einstellung und trenne jedes Bundle.
Zwei Arten von Kanälen können hier nicht entfernt werden und geben `400` zurück: einer, der nicht [konfiguriert](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#configured-levels) ist (`error_code: "slack_channel_not_configured"`), und einer, der Konfiguration enthält, die diese API nicht verwaltet, etwa einen Runner-Pool oder eine Einstellung, die nur claude.ai hat. Ein Organisationseigentümer entfernt die zweite Art in claude.ai.
## Slack-Workspaces
Das Workspace-Objekt ist die gespeicherte Ansicht eines Slack-Workspace. Es hat dieselben Felder wie das [Kanal-Objekt](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#slack-channels), außer dass `type` den Wert `slack_workspace` hat, `id` das Präfix `slws_` trägt und `slack` nur `team_id` enthält. Die Antwort im [Schnellstart](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#quick-start) zeigt ein vollständiges Objekt.
Eine `id` ohne das Präfix `slws_` gibt `400` zurück. Eine `id`, die das Präfix trägt, aber keinen Workspace deiner Organisation benennt, gibt `404` zurück.
### Workspaces auflisten
`GET /v1/organizations/claude_tag/slack_workspaces` listet die eingerichteten Workspaces auf, die deiner Organisation gehören, die neuesten zuerst nach `created_at`. Der [Schnellstart](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#quick-start) zeigt die Anfrage und die Antwort. Um einen Workspace anhand von Slacks eigener ID zu finden, füge `slack_team_id` hinzu: `data` enthält diesen Workspace oder ist leer, wenn er nicht eingerichtet ist, und ein Workspace, der nicht deiner Organisation gehört, gibt `404` zurück. Erfordert den Scope `read:claude_tag`.
### Einen Workspace abrufen
`GET /v1/organizations/claude_tag/slack_workspaces/{id}` gibt das Workspace-Objekt zurück. Erfordert den Scope `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
```
### Einen Workspace aktualisieren
`POST /v1/organizations/claude_tag/slack_workspaces/{id}` ändert die Einstellungen des Workspace und gibt das Workspace-Objekt zurück. `settings` ist erforderlich und folgt den Regeln unter [Einstellungen ändern](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#changing-settings). Was du hier festlegst, gilt in jedem Kanal des Workspace, der keinen eigenen Wert festlegt. Erfordert den Scope `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
```
### Die effektiven Einstellungen eines Workspace abrufen
`GET /v1/organizations/claude_tag/slack_workspaces/{id}/effective` gibt zurück, was im Workspace gilt, aufgelöst aus dem Workspace und den Slack-Standardeinstellungen, in der Form, die [Gespeicherte und effektive Einstellungen](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#stored-and-effective-settings) zeigt, wobei `type` auf `slack_workspace_effective` gesetzt ist. Erfordert den Scope `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-Standardeinstellungen
Deine Organisation hat genau ein Objekt für die Slack-Standardeinstellungen. Es gilt für jeden Workspace und jeden Kanal, hat keine `id` und keine effektive Ansicht, da keine Ebene umfassender ist.
| Feld | Beschreibung |
| ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` | `slack_defaults`. |
| `settings` | Was die Standardeinstellungen speichern, wie bei einem [Kanal](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#slack-channels). |
| `agent_id` | Mit dem Präfix `cagt_`. `null`, bis die Slack-Standardeinstellungen [eingerichtet](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#set-up-channels-and-workspaces) sind. |
### Die Slack-Standardeinstellungen abrufen
`GET /v1/organizations/claude_tag/slack_defaults` gibt das Objekt zurück. Eine Organisation, deren Slack-Standardeinstellungen nicht eingerichtet sind, erhält `200`, wobei jede Einstellung und `agent_id` `null` sind. Erfordert den Scope `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
```
### Die Slack-Standardeinstellungen aktualisieren
`POST /v1/organizations/claude_tag/slack_defaults` ändert die Standardeinstellungen und gibt das Objekt zurück. `settings` ist erforderlich und folgt den Regeln unter [Einstellungen ändern](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#changing-settings). Eine Anfrage, die einen Wert festlegt, während die Slack-Standardeinstellungen nicht eingerichtet sind, gibt `400` zurück. Erfordert den Scope `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"
}
```
## Bundles
Ein Bundle ist das, was claude.ai ein [Access Bundle](https://claude.com/docs/claude-tag/admins/add-connections) nennt: eine benannte Menge an Zugriffen, etwa Connectors, Repositories und Anmeldedaten, die Claude in einem Kanal oder Workspace verwenden kann. Organisationseigentümer erstellen, bearbeiten und löschen Bundles in claude.ai. Diese API listet sie auf und hängt sie an. Sie gibt den Namen und die Beschreibung eines Bundles zurück, aber nie, was das Bundle gewährt.
| Feld | Beschreibung |
| -------------------------- | -------------------------------------------------------- |
| `type` | `bundle`. |
| `id` | Mit dem Präfix `capp_`. |
| `display_name` | Der Name des Bundles. |
| `description` | Wofür das Bundle gedacht ist. `null`, wenn es keine hat. |
| `created_at`, `updated_at` | Wann das Bundle erstellt und zuletzt geändert wurde. |
Eine `bundle_id` ohne das Präfix `capp_` gibt `400` zurück. Eine, die das Präfix trägt, aber nicht existiert oder zu einer anderen Organisation gehört, gibt `404` zurück, unabhängig davon, was die Anfrage sonst enthält. Bundles, die Claude Tag für sich selbst verwaltet, werden nicht aufgelistet und geben `404` zurück.
### Bundles auflisten
`GET /v1/organizations/claude_tag/bundles` listet die Bundles deiner Organisation auf, die neuesten zuerst nach `created_at`. Erfordert den Scope `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()
# Ruft bei Bedarf automatisch weitere Seiten ab.
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();
// Nur diese Seite; für die nächste rufe list() erneut mit page: $bundles->nextPage auf.
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
}
```
### Ein Bundle abrufen
`GET /v1/organizations/claude_tag/bundles/{bundle_id}` gibt das Bundle-Objekt zurück. Erfordert den Scope `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-Ziele
Ein Bundle-Ziel ist der Datensatz eines Bundles, das an einen Kanal oder einen Workspace angehängt ist. Ein an einen Workspace angehängtes Bundle kann im Workspace und in jedem Kanal darin verwendet werden. Ein an einen Kanal angehängtes Bundle kann nur in diesem Kanal verwendet werden.
| Feld | Beschreibung |
| -------------------- | -------------------------------------------------------------------------------------------------------------- |
| `type` | `slack_channel` oder `slack_workspace`. |
| `id` | Mit dem Präfix `btgt_`. Sie ist die `{target_id}` in Pfaden und nie die eigene `id` des Kanals oder Workspace. |
| `slack_channel_id` | Bei einem `slack_channel`-Ziel: die `id` des Kanals, mit dem Präfix `slch_`. |
| `slack_workspace_id` | Bei einem `slack_workspace`-Ziel: die `id` des Workspace, mit dem Präfix `slws_`. |
| `created_at` | Wann das Bundle angehängt wurde. |
Ein Bundle wird höchstens einmal an einen Kanal oder Workspace angehängt, und dasselbe Paar hat immer dieselbe `id`, auch nach einem Trennen und erneuten Anhängen. Die `id` ist opak: Hole sie aus der Antwort auf ein Anhängen oder aus der Liste. Ein Bundle-Ziel enthält nicht die `id` seines Bundles, die seine Pfade ebenfalls benötigen, also bewahre beide zusammen auf.
Durch das erste an einen Kanal oder Workspace angehängte Bundle gilt dieser als [konfiguriert](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#configured-levels). Anhängen oder Trennen ändert keine gespeicherte Einstellung. Sitzungen, die im Kanal oder Workspace laufen, werden darüber informiert, dass sich sein Zugriff geändert hat.
Das Bundle, das claude.ai im Rahmen einer On-Call-Einrichtung anhängt, wird aufgelistet und kann gelesen, aber hier nicht angehängt oder getrennt werden, und an einen Kanal oder Workspace, den eine On-Call-Einrichtung verwaltet, kann nichts angehängt oder davon getrennt werden. Jede dieser Anfragen gibt `400` zurück.
### Die Ziele eines Bundles auflisten
`GET /v1/organizations/claude_tag/bundles/{bundle_id}/targets` listet die Kanäle und Workspaces auf, an die das Bundle angehängt ist, die neuesten zuerst nach `created_at`. Erfordert den Scope `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"
)
# Ruft bei Bedarf automatisch weitere Seiten ab.
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',
);
// Nur diese Seite; für die nächste rufe list() erneut mit page: $targets->nextPage auf.
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
}
```
Nur Zuordnungen zu Kanälen und Workspaces werden aufgelistet. Ein Bundle, das in claude.ai an etwas anderes angehängt ist, etwa an **Default Slack access**, hat dafür kein Bundle-Ziel, und ebenso wenig eine Regel, die ein Bundle in vielen Kanälen gleichzeitig anwendet. Die Bundles, die Claude in einem Kanal verwenden kann, können also mehr sein als die Ziele, die ihn benennen. Kein Endpunkt listet die an einen einzelnen Kanal oder Workspace angehängten Bundles auf.
### Ein Bundle anhängen
`POST /v1/organizations/claude_tag/bundles/{bundle_id}/targets` hängt das Bundle an und gibt das Bundle-Ziel zurück. Der Body benennt den `type` und die passende `id`. Der Kanal oder Workspace muss bereits eingerichtet sein: Anhängen richtet nie einen Kanal ein. Das Anhängen eines bereits angehängten Paares gibt `200` mit dem vorhandenen Bundle-Ziel zurück. Erfordert den Scope `write:claude_tag`.
Hänge ein Bundle an einen Kanal an:
```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"
}
```
Hänge ein Bundle an einen Workspace an:
```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
```
Eine Zuordnung zu einem Kanal hat Bedingungen, unter denen sie gilt, etwa nur solange sich kein Slack-Gast im Kanal befindet. Bedingungen werden in claude.ai festgelegt und hier nicht zurückgegeben. Das Anhängen über diese API verwendet die Standardbedingungen, und das Anhängen eines bereits angehängten Paares lässt dessen Bedingungen unverändert.
### Ein Bundle-Ziel abrufen
`GET /v1/organizations/claude_tag/bundles/{bundle_id}/targets/{target_id}` gibt das Bundle-Ziel zurück. Eine `target_id` ohne das Präfix `btgt_` gibt `400` zurück. Eine, die zu einem anderen Bundle gehört, getrennt wurde oder einen Kanal oder Workspace bezeichnet, der nicht mehr eingerichtet ist, gibt `404` zurück. Erfordert den Scope `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
```
### Ein Bundle trennen
`DELETE /v1/organizations/claude_tag/bundles/{bundle_id}/targets/{target_id}` trennt das Bundle. Ein wiederholtes Trennen gibt `404` zurück. Erfordert den Scope `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"
}
```
## Unbekannte Werte
`guest_policy.type`, der `type` einer Quelle, der `type` eines Bundle-Ziels und Fehlercodes können jederzeit neue Werte erhalten. Behandle einen Wert, den du nicht kennst, wie jeden anderen unbekannten String, statt einen Fehler auszulösen.
## Ratenlimits
Anfragen werden pro Organisation begrenzt, in zwei Budgets, die sich alle Keys deiner Organisation teilen und die von den übrigen Admin-API-Limits deiner Organisation getrennt sind. Jedes Budget erlaubt einen „burst“ (Lastspitze) und füllt sich dann mit einer gleichmäßigen Rate wieder auf:
| Budget | Anfragen | Burst | Auffüllung |
| ------------ | ------------------------- | ----- | ------------- |
| Lesevorgänge | Jedes `GET` | 120 | 2 pro Sekunde |
| Änderungen | Jedes `POST` und `DELETE` | 60 | 1 pro Sekunde |
Anfragen über einem Budget geben **429 Too Many Requests** mit einem `retry-after`-Header zurück. Antworten enthalten die Header `anthropic-ratelimit-requests-limit`, `anthropic-ratelimit-requests-remaining` und `anthropic-ratelimit-requests-reset` für das Budget, aus dem die Anfrage verbraucht hat.
## Paginierung
Listen-Endpunkte verwenden einen **opaken Cursor**. Die erste Anfrage gibt bis zu `limit` Zeilen plus einen `next_page`-Cursor zurück; übergib den Cursor unverändert als Parameter `page` bei der nächsten Anfrage und wiederhole dies, bis `next_page` `null` ist. Behandle den Cursor-String als opak: Parse, verändere oder konstruiere ihn nicht selbst. [Kanäle auflisten](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#list-channels) kann eine Seite mit weniger als `limit` Kanälen oder gar keinen zurückgeben, während `next_page` noch gesetzt ist, also fordere weiter Seiten an, bis `next_page` `null` ist. Die Listen-Iteratoren der Python-, TypeScript-, C#-, Go-, Java- und Ruby-SDKs sowie die CLI (außer mit `--format raw`) erledigen das für dich. In PHP und curl forderst du jede Seite selbst an und übergibst ihr `next_page` als `page`.
`limit` ist standardmäßig 20, mit einem Minimum von 1 und einem Maximum von 100. Jede Liste ist nach `created_at` mit den neuesten zuerst sortiert und akzeptiert keine andere Reihenfolge.
## Fehlerantworten
Fehlerantworten folgen der Standardform, die unter [Fehler](https://platform.claude.com/docs/de/api/errors) dokumentiert ist. Gib die `request_id` aus dem Antwort-Body an, wenn du den Support kontaktierst.
| Status | Bedeutung |
| ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 400 | Ungültige Eingabe, oder der Vorgang gilt nicht für diesen Kanal, Workspace oder dieses Bundle (siehe den Abschnitt des jeweiligen Endpunkts). |
| 401 | Der Header `x-api-key` fehlt, oder der Key wird nicht erkannt. |
| 403 | Der Key ist kein Key auf Organisationsebene mit Scope, ihm fehlt der erforderliche Scope, oder deine Organisation kann diese Änderung nicht vornehmen. |
| 404 | Ressource nicht gefunden oder gehört nicht deiner Organisation. Wird auch zurückgegeben, wenn die Anfrage den `anthropic-beta`-Wert weglässt oder die API für deine Organisation nicht aktiviert ist, sodass die Endpunkte als nicht existent erscheinen. |
| 409 | Etwas anderes hat die Ressource geändert oder entfernt, während die Anfrage lief. Es wurde nichts gespeichert. Lies sie erneut und sende die Änderung noch einmal, falls sie noch benötigt wird. |
| 429 | Ratenlimit überschritten. Siehe [Ratenlimits](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#rate-limiting). |
| 500 | Interner Fehler. |
| 503 | Vorübergehend. Bei einer Änderung sagt er nicht aus, ob die Änderung gespeichert wurde. Jede Änderung kann gefahrlos wiederholt werden, also sende die Anfrage unverändert erneut. |
Wenn ein Status mehrere Ursachen hat, die du unterschiedlich behandeln würdest, enthält der Fehler zusätzlich `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` | Status | Bedeutung und Vorgehen |
| -------------------------------------------- | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `organization_level_scoped_api_key_required` | 403 | Die Anmeldedaten sind kein Admin-API-Key mit Scope, der der Organisation als Ganzes gehört. Bitte deinen primären Eigentümer um einen. |
| `api_key_scope_missing` | 403 | Dem Key fehlt `read:claude_tag` oder `write:claude_tag`, je nachdem, was der Endpunkt erfordert. |
| `workspace_selection_not_accepted` | 400 | Die Anfrage hat den Header `anthropic-workspace-id` gesendet. Entferne ihn. |
| `claude_tag_writes_not_enabled` | 403 | Deine Organisation kann über diese API lesen, ist aber nicht für Änderungen freigeschaltet. |
| `compliance_configuration_restricted` | 403 | Deine Organisation hat eine Compliance-Konfiguration, unter der Claude Tag nichts Neues speichert, etwa Zero Data Retention. Das Einrichten eines Kanals, das Aktualisieren von Einstellungen (auch um sie zu löschen) und das Anhängen eines Bundles werden abgelehnt. Das Trennen eines Bundles und das Entfernen eines Kanals nicht. |
| `environment_not_found` | 404 | `environment_id` bezeichnet keine Umgebung, die deine Organisation hier verwenden kann. Die `id` im Pfad ist in Ordnung. |
| `environment_archived` | 400 | `environment_id` bezeichnet eine archivierte Umgebung. |
| `slack_channel_set_up_settings_refused` | 400 | Die Anfrage hat den Kanal eingerichtet, dann wurde `settings` abgelehnt. `details.slack_channel_id` ist der Kanal. Siehe [Einen Kanal einrichten](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#set-up-a-channel). |
| `slack_channel_set_up_environment_not_found` | 404 | Die Anfrage hat den Kanal eingerichtet, dann wurde `environment_id` nicht gefunden. `details.slack_channel_id` ist der Kanal. |
| `slack_channel_set_up_settings_conflict` | 409 | Die Anfrage hat den Kanal eingerichtet, dann hat sich eine andere Änderung mit `settings` überschnitten. Nichts von `settings` wurde gespeichert. `details.slack_channel_id` ist der Kanal. |
| `slack_channel_not_configured` | 400 | Der Kanal ist nicht [konfiguriert](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#configured-levels), daher kann er nicht entfernt werden. |
Neue Codes können hinzukommen. Behandle einen Code, den du nicht kennst, so wie seinen Status. Ein `404` ohne `error_code` hat eine von zwei Ursachen. Entweder wurde etwas, das die Anfrage benennt, nicht gefunden (eine `id` im Pfad oder ein Slack-Kanal oder -Workspace im Body oder in der Query), oder jeder Endpunkt erscheint als nicht existent, weil die Anfrage den `anthropic-beta`-Wert weglässt oder die API für deine Organisation nicht aktiviert ist. Um sie zu unterscheiden, [rufe die Slack-Standardeinstellungen ab](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#get-the-slack-defaults) mit demselben Key und denselben Headern: Diese Anfrage benennt nichts, daher gibt sie `404` nur im zweiten Fall zurück.
## Activity Feed-Ereignisse
Jede Änderung über diese API wird im [Compliance API Activity Feed](https://platform.claude.com/docs/de/manage-claude/compliance-activity-feed) deiner Organisation aufgezeichnet und dem API-Key als `api_actor` mit dessen `apikey_`-ID zugeordnet. Die Ereignisse sind dieselben, die der Feed aufzeichnet, wenn dieselbe Änderung in claude.ai vorgenommen wird, sodass eine einzige Abfrage eine Änderung findet, egal auf welchem Weg sie vorgenommen wurde.
| Ereignis | Ausgelöst, wenn |
| --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ccr_agent_created` | Ein Kanal eingerichtet wird. |
| `ccr_agent_updated` | Sich eine Einstellung für einen Kanal, einen Workspace oder die Slack-Standardeinstellungen ändert oder eine Ebene [konfiguriert](https://platform.claude.com/docs/de/manage-claude/claude-tag-api#configured-levels) wird. |
| `ccr_agent_deleted` | Ein Kanal entfernt wird. Seine Bundle-Ziele werden mit ihm entfernt und lösen kein eigenes Ereignis aus. |
| `ccr_agent_proxy_profile_bound` | Ein Bundle angehängt wird. |
| `ccr_agent_proxy_profile_unbound` | Ein Bundle getrennt wird. |
Die Ereignisse benennen einen Kanal oder Workspace über seine `agent_id`, nicht über seine `id`. Die beiden Bundle-Ereignisse benennen das Bundle in `profile_id` und den Kanal oder Workspace in `scope_id`.
Ein `ccr_agent_updated`-Ereignis listet in `updated_fields` auf, was sich geändert hat, und zwar unter den eigenen Namen des Feeds:
| Einstellung | Name in `updated_fields` |
| ------------------------------ | ------------------------ |
| `enabled` | `slackbot_version` |
| `instructions` | `system_prompt_addendum` |
| `model` | `default_model` |
| `environment_id` | `default_environment_id` |
| `guest_policy` | `guest_policy` |
| (die Ebene wurde konfiguriert) | `is_virtual` |
Lesezugriffe, Anfragen, die nichts ändern, und Anfragen, die abgelehnt werden, bevor etwas gespeichert wird, zeichnen nichts auf. Eine Einrichtungsanfrage, die einen Kanal einrichtet und deren `settings` anschließend abgelehnt wird, zeichnet `ccr_agent_created` auf.
## Siehe auch
Wo dein primärer Eigentümer einen Key mit Scope erstellt.
Was Claude Tag ist, wie du es einrichtest und was jede Einstellung in Slack bewirkt.
Der Audit-Trail jeder Änderung, die hier und in claude.ai vorgenommen wird.
Verwalte die Plugins in deiner Claude Enterprise-Organisation.