---
title: API Claude Tag
url: https://platform.claude.com/docs/fr/manage-claude/claude-tag-api
description: "Gérez Claude Tag dans Slack pour votre organisation Claude Enterprise depuis vos propres systèmes : lisez et modifiez les paramètres des canaux et espaces de travail Slack, voyez quels paramètres s'appliquent et pourquoi, et attachez des Access bundles."
---
[Claude Tag](https://claude.com/docs/claude-tag/overview), c'est Claude qui travaille comme un coéquipier dans Slack : quelqu'un mentionne Claude dans un canal et Claude répond dans le fil. L'API Claude Tag vous permet de lire et de modifier, depuis vos propres systèmes, les paramètres Claude Tag qu'un propriétaire d'organisation définit sinon manuellement dans [claude.ai > Organization settings > Claude Tag](https://claude.ai/admin-settings/claude-tag). Utilisez-la pour activer Claude canal par canal depuis un flux de travail d'approbation, conserver votre configuration dans un système de gestion de versions, ou auditer ce qui s'applique dans chaque canal.
Claude Tag est un produit claude.ai. Cette API le gère pour une organisation Claude Enterprise et n'a rien à voir avec les espaces de travail Claude Platform, l'utilisation de l'API ou la Claude Console.
**Clé Admin API à portée limitée requise**
Ces endpoints nécessitent une clé Admin API avec la portée `read:claude_tag` (pour les endpoints `GET`) ou la portée `write:claude_tag` (pour les endpoints `POST` et `DELETE`) ; consultez [Portées](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#scopes). Consultez [Créer une clé Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization) pour savoir où votre propriétaire principal en crée une.
L'API Claude Tag est en **bêta** et n'est disponible que pour les organisations Claude Enterprise. Elle n'est pas disponible pour les organisations Claude Platform (Claude Console).
Chaque requête doit inclure l'[en-tête bêta](https://platform.claude.com/docs/fr/api/beta-headers) `anthropic-beta: experimental-claude-tag-2026-10-21` (le SDK et la CLI `ant` l'envoient pour vous). Une requête sans cet en-tête renvoie `404`, exactement comme si l'endpoint n'existait pas.
## Points de terminaison
L'API expose 14 endpoints répartis sur quatre ressources :
| Ressource | Endpoints |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Canaux Slack :** configurer un canal, lister les canaux d'un espace de travail ou en trouver un par ses identifiants Slack, en lire un, modifier ses paramètres, le supprimer | `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}`
`DELETE /v1/organizations/claude_tag/slack_channels/{id}` |
| **Espaces de travail Slack :** lister vos espaces de travail ou en trouver un par son identifiant Slack, en lire un, modifier ses paramètres | `GET /v1/organizations/claude_tag/slack_workspaces`
`GET /v1/organizations/claude_tag/slack_workspaces/{id}`
`POST /v1/organizations/claude_tag/slack_workspaces/{id}` |
| **Bundles :** lister les Access bundles de votre organisation, en lire un (lecture seule) | `GET /v1/organizations/claude_tag/bundles`
`GET /v1/organizations/claude_tag/bundles/{bundle_id}` |
| **Cibles de Bundle :** lister les endroits où un Bundle est attaché, l'attacher à un canal ou un espace de travail, lire un attachement, le détacher | `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}` |
Cette version couvre Slack. La connexion et la déconnexion d'un espace de travail Slack ou d'une Enterprise Grid, les paramètres par défaut Slack de votre organisation, la création et la modification des Access bundles, les limites de dépenses et tous les paramètres Claude Tag autres que les cinq décrits dans [Paramètres](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#settings) restent dans claude.ai.
## Prérequis
* Votre organisation doit disposer d'un forfait Claude Enterprise, avec [Claude Tag configuré](https://claude.com/docs/claude-tag/admins/setup-overview) et au moins un espace de travail Slack ou une Enterprise Grid connecté.
* Votre propriétaire principal crée une clé Admin API avec la portée `read:claude_tag`, la portée `write:claude_tag`, ou les deux, dans [claude.ai > Organization settings > API](https://claude.ai/admin-settings/api-access). Consultez [Créer une clé pour une organisation Claude Enterprise](https://platform.claude.com/docs/fr/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization).
* Chaque requête comporte trois en-têtes : `x-api-key`, `anthropic-version: 2023-06-01` (consultez [Versions de l'API](https://platform.claude.com/docs/fr/api/versioning)) et `anthropic-beta: experimental-claude-tag-2026-10-21`.
En Python, TypeScript, C#, Go, Java, PHP et Ruby, le SDK expose ces endpoints sous `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`), et la [CLI `ant`](https://platform.claude.com/docs/fr/cli-sdks-libraries/cli/quickstart) sous `ant beta:organization:claude-tag` ; ils envoient les en-têtes `anthropic-version` et `anthropic-beta` pour vous. Les exemples de cette page lisent la clé Admin API depuis la variable d'environnement `ANTHROPIC_API_KEY`. Lorsqu'un SDK ou la CLI récupère des pages supplémentaires pour vous, `limit` définit la taille de page, et non le total (consultez [Pagination](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#pagination)).
Les clés API appartiennent à l'organisation et continuent de fonctionner après le départ de la personne qui les a créées. Ne les partagez pas et ne les enregistrez pas dans un système de gestion de versions.
## Démarrage rapide
Listez les espaces de travail Slack de votre organisation dans Claude Tag :
```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: experimental-claude-tag-2026-10-21"
```
```bash CLI
ant beta:organization:claude-tag:slack-workspaces list
```
```python Python
client = anthropic.Anthropic()
workspaces = client.beta.organization.claude_tag.slack_workspaces.list()
# Récupère automatiquement les pages suivantes selon les besoins.
for workspace in workspaces:
print(f"{workspace.id}: {workspace.slack.workspace_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.workspace_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.WorkspaceID}");
}
```
```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.WorkspaceID)
}
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().workspaceId());
}
```
```php PHP
$client = new Client();
$workspaces = $client->beta->organization->claudeTag->slackWorkspaces->list();
// Cette page uniquement ; pour la suivante, rappelez list() avec page: $workspaces->nextPage.
foreach ($workspaces->getItems() as $workspace) {
echo "{$workspace->id}: {$workspace->slack->workspaceID}\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.workspace_id}"
end
```
```json Response
{
"data": [
{
"type": "slack_workspace",
"id": "slws_011CZkZnWa7xPc3uJfZe5LgT",
"slack": {
"workspace_id": "T01ABCD2EFG"
},
"settings": {
"enabled": null,
"instructions": "Answer in English unless asked otherwise.",
"model": null,
"environment_id": null,
"guest_policy": null
},
"sources": {
"enabled": null,
"instructions": [
{
"type": "slack_workspace",
"slack_workspace_id": "slws_011CZkZnWa7xPc3uJfZe5LgT"
}
],
"model": null,
"environment_id": null,
"guest_policy": null
},
"created_at": "2026-09-02T17:04:11Z",
"updated_at": "2026-10-06T09:41:53Z"
}
],
"next_page": null
}
```
Un paramètre qui vaut `null` dans `settings` n'est pas défini sur cet espace de travail : l'espace de travail en hérite donc et n'a pas de source pour ce paramètre. Pour lire plutôt ce qui s'applique, consultez [Valeurs stockées et héritées](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#stored-and-inherited-values).
## Portées
| Portée | Accorde |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `read:claude_tag` | Tous les points de terminaison `GET` de cette page. |
| `write:claude_tag` | Tous les points de terminaison `POST` et `DELETE` de cette page. Elle n'accorde pas les lectures, bien que la réponse à une modification contienne la ressource modifiée. |
Une clé peut porter les deux portées. Une intégration qui recherche un canal puis le modifie a besoin des deux. Aucune autre portée n'accorde l'accès à ces endpoints, et une clé créée dans la Claude Console ne fonctionne pas ici.
La clé doit appartenir à l'organisation dans son ensemble. L'organisation est toujours celle à laquelle appartient la clé, et aucune requête n'en nomme une. L'en-tête `anthropic-workspace-id` est ignoré, car rien ici n'appartient à un espace de travail Claude Platform.
## Concepts clés
### Noms sur cette page et dans claude.ai
| Cette API | claude.ai et Slack |
| --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Espace de travail Slack | Un espace de travail Slack. L'API de Slack l'appelle une team, donc l'identifiant d'espace de travail propre à Slack sur cette page correspond au team ID de Slack. Il n'a aucun rapport avec un espace de travail Claude Platform, dont les identifiants commencent par `wrkspc_`. |
| Paramètres par défaut Slack | **Default Slack access** : les paramètres qui s'appliquent à chaque espace de travail et à chaque canal. Un propriétaire de l'organisation les modifie dans claude.ai ; cette API indique où un canal ou un espace de travail en hérite. |
| Niveau de paramètres | Une [portée](https://claude.com/docs/claude-tag/admins/customize) : un canal, un espace de travail ou les paramètres par défaut Slack |
| Bundle | Un Access bundle ([glossaire Claude Tag](https://claude.com/docs/claude-tag/concepts/glossary#access-bundle)) |
| `enabled` | Le bouton **Enable Claude Tag in Slack** |
| `instructions` | **Custom instructions** |
| `model` | **Model** |
| `environment_id` | **Environment** |
| `guest_policy` | **How should Claude work in channels with guests** : `restrict` correspond à **Restrict**, `channel_only` à **Channel only** et `allow` à **Full access** |
### Canaux et espaces de travail configurés
Un canal ou un espace de travail est **configuré** lorsque Claude Tag détient un enregistrement de paramètres pour celui-ci. Seul un canal ou un espace de travail configuré possède un `id`, et seuls ceux-ci sont listés : c'est Slack, et non cette API, qui détient la liste complète des canaux d'un espace de travail.
* Un **espace de travail** est configuré lorsqu'un propriétaire de l'organisation le connecte dans claude.ai. Lorsqu'un propriétaire connecte une Slack Enterprise Grid, les espaces de travail de la Grid sont configurés peu après. La première utilisation de Claude dans un espace de travail, ou le premier canal que vous y [configurez](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#set-up-a-channel), configure tout espace de travail qui ne l'était pas. Aucun autre endpoint ne configure d'espace de travail, et aucun n'en supprime.
* Un **canal** est configuré dans claude.ai, par la première utilisation de Claude dans celui-ci, ou avec [Configurer un canal](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#set-up-a-channel).
Votre organisation possède un espace de travail tant que sa connexion à cet espace de travail est active, et possède les canaux qu'il contient. Une Slack Enterprise Grid regroupe plusieurs espaces de travail sous une même entreprise. Tant que la connexion de votre organisation à une Grid est active, elle possède également chaque espace de travail de la Grid qu'aucune autre organisation n'a connecté. Un tel espace de travail est un espace de travail comme un autre : une fois configuré, il possède un `id`, est listé, et peut être lu, modifié et recevoir des Bundles, et ses canaux peuvent être listés. La Grid elle-même n'est pas une ressource de cette API et n'a pas d'`id`. Un canal ou un espace de travail que vous ne possédez pas renvoie le même `404` qu'un canal ou un espace de travail qui n'existe pas.
Un espace de travail que votre organisation possède uniquement via une Grid renvoie ce `404` tant qu'il n'est pas configuré, partout où une requête le nomme par l'identifiant propre à Slack : lorsque vous recherchez l'espace de travail, listez ses canaux ou recherchez un canal non configuré qu'il contient. Vous pouvez néanmoins y [configurer un canal](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#set-up-a-channel), ce qui configure également l'espace de travail, sans aucun paramètre stocké.
Un canal partagé avec toute une Grid peut être stocké sous l'identifiant Slack propre à la Grid, qui commence par `E`, à la place de celui d'un espace de travail. Cet identifiant est alors le `slack.workspace_id` du canal, et [lister les canaux](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#list-channels) avec cet identifiant comme `slack_workspace_id` renvoie ces canaux. Aucun objet espace de travail ne le porte : si un propriétaire a stocké des paramètres sur la Grid elle-même dans claude.ai, `sources` peut les nommer comme un `slack_workspace` dont l'`id` renvoie `404` lorsque vous le lisez.
### ID
Vous connaissez un canal par les ID que Slack vous affiche. Recherchez son `id` une fois avec [Trouver un canal par ses ID Slack](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#find-a-channel-by-its-slack-ids), puis stockez et utilisez cet `id`.
| Identifiant | Préfixe | Où il apparaît |
| ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| Ressource canal Slack | `slch_` | `id` sur un canal ; `slack_channel_id` dans les corps de requête et les réponses |
| Ressource espace de travail Slack | `slws_` | `id` sur un espace de travail ; `slack_workspace_id` dans les corps de requête et les réponses |
| Bundle | `capp_` | `id` sur un Bundle ; `{bundle_id}` dans les chemins |
| Cible de Bundle | `btgt_` | `id` sur une cible de Bundle ; `{target_id}` dans les chemins |
| Identifiant d'espace de travail propre à Slack | `T`, ou `E` pour l'identifiant propre à une Grid (consultez [Canaux et espaces de travail configurés](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#set-up-channels-and-workspaces)) | `slack.workspace_id` ; le paramètre de requête `slack_workspace_id` |
| Identifiant de canal propre à Slack | `C` ou `G` | `slack.channel_id` ; le paramètre de requête `slack_channel_id` |
`slack_channel_id` et `slack_workspace_id` ont chacun deux significations. Dans un **paramètre de requête**, chacun est l'identifiant propre à Slack (`C05HJKL6MNP`, `T01ABCD2EFG`). Dans un **corps de requête ou une réponse**, chacun est l'`id` émis par cette API (`slch_...`, `slws_...`). Les identifiants propres à Slack dans un corps ou une réponse se trouvent toujours sous `slack`.
Un identifiant de canal Slack dans un paramètre de requête ou un corps de requête qui ne commence pas par `C` ou `G` renvoie `400`, de même que tout identifiant Slack contenant autre chose que des lettres majuscules et des chiffres après sa première lettre, ou dépassant 32 caractères.
Un `id` ne change pas tant que le canal ou l'espace de travail est configuré, quoi que vous y modifiiez, à une exception près décrite dans [Mode lecture seule](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#read-only-mode). Un canal ou un espace de travail supprimé puis configuré à nouveau reçoit un nouvel `id`, et l'ancien continue de renvoyer `404`. Lorsqu'un `id` stocké renvoie `404` sans `error_code`, [listez vos espaces de travail](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#list-workspaces) avec la même clé et les mêmes en-têtes. Cette requête ne nomme aucun canal ni aucun espace de travail : si elle renvoie `200`, l'`id` n'existe plus ; retrouvez le canal ou l'espace de travail par ses identifiants Slack. Tout autre statut n'indique rien sur l'`id` : conservez vos valeurs `id` stockées et consultez [Réponses d'erreur](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#error-responses).
### Paramètres
Chaque niveau de paramètres stocke les cinq mêmes paramètres, tous facultatifs :
| Paramètre | Type | Description |
| ---------------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `enabled` | boolean | Indique si Claude est activé. |
| `instructions` | string | Consignes permanentes que Claude lit à chaque session. Au maximum 8 192 caractères après suppression des espaces de début et de fin. Un texte vide efface le paramètre. |
| `model` | string | Le modèle sur lequel démarrent les nouvelles sessions : un [identifiant de modèle](https://platform.claude.com/docs/fr/models/overview) que votre organisation peut utiliser avec Claude Tag. Au maximum 128 caractères. |
| `environment_id` | string | L'environnement cloud dans lequel s'exécutent les sessions, préfixé `env_`. Il doit être actif et appartenir à votre organisation. |
| `guest_policy` | object | Ce que fait Claude dans un canal lorsqu'un invité Slack s'y trouve, pour tous les membres du canal : `{"type": "allow"}` (Claude répond), `{"type": "restrict"}` (Claude ne répond pas) ou `{"type": "channel_only"}` (Claude répond uniquement avec les Bundles attachés au canal lui-même ; si `channel_only` n'est pas disponible pour votre organisation, une requête qui le définit renvoie `400`). Consultez [Restreindre les canaux avec invités](https://claude.com/docs/claude-tag/admins/restrict-access#restrict-guest-channels) pour savoir ce que cela signifie dans les canaux partagés via Slack Connect ou au sein d'une Enterprise Grid. |
`model` et `environment_id` sont vérifiés lorsque vous les écrivez, puis plus jamais : si le modèle ou l'environnement change ultérieurement, les réponses continuent de renvoyer la valeur stockée.
Si un propriétaire d'organisation a placé un niveau de paramètres sur un pool de runners auto-hébergés dans claude.ai, son `environment_id` renvoie l'ID du pool, qui commence par `ccpool_`. Cette API ne peut pas définir de pool de runners, et renvoie `400` pour une requête qui modifie ou efface `environment_id` sur un niveau de paramètres qui en stocke un.
### Valeurs stockées et héritées
Les paramètres existent à trois niveaux : le canal, l'espace de travail dans lequel se trouve le canal, et les paramètres par défaut Slack de votre organisation, qu'un propriétaire de l'organisation définit dans claude.ai. Chaque niveau ne stocke que ce qui a été défini à ce niveau. Les `settings` d'un objet canal ou espace de travail peuvent contenir l'une de ces deux choses :
* **Ce qu'il stocke.** C'est ce que contient une réponse, sauf demande contraire. Un paramètre qui n'est pas défini sur le canal ou l'espace de travail vaut `null`. Utilisez-le pour comparer avec une configuration que vous conservez ailleurs.
* **Ce qui s'y applique**, une fois tous les niveaux pris en compte. Pour l'obtenir, ajoutez le paramètre de requête `include_inherited=true` à toute requête `GET` qui renvoie un canal ou un espace de travail, y compris les deux listes. Utilisez-le pour auditer, ou pour comprendre pourquoi Claude se comporte comme il le fait dans un canal. Le paramètre vaut `false` par défaut, et une valeur qui n'est pas un booléen renvoie `400`. Une requête qui configure un canal ou modifie des paramètres n'accepte pas ce paramètre et renvoie `400` si vous l'envoyez ; sa réponse contient ce qui est stocké.
Dans les deux cas, `sources` nomme, pour chaque paramètre, le niveau dont provient la valeur figurant dans `settings`. Sans `include_inherited`, la source d'un paramètre stocké par le canal ou l'espace de travail nomme le canal ou l'espace de travail lui-même, et un paramètre qu'il ne stocke pas n'a pas de source : `null`, ou une liste vide pour `instructions`. Avec `include_inherited=true`, chaque paramètre sauf `instructions` a une source, et un paramètre qu'aucun niveau ne définit a pour source `{"type": "default"}` ; lorsqu'aucun niveau ne définit `instructions`, il vaut `null` et sa liste de sources est vide. Ainsi, pour distinguer une valeur que le canal ou l'espace de travail définit lui-même d'une valeur héritée, examinez sa source, et non le fait que la valeur soit `null` ou non.
Chaque paramètre est résolu indépendamment :
| Paramètre | Règle | Lorsqu'aucun niveau ne le définit |
| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- |
| `enabled` | Le niveau le plus proche qui le définit détermine la valeur ; ainsi, `true` sur un canal y active Claude même lorsque son espace de travail stocke `false`. | `true` |
| `instructions` | Cumulatif. Le texte de chaque niveau qui le définit est concaténé, du plus large au plus spécifique, séparé par une ligne vide. | `null` |
| `model` | Le niveau le plus proche qui le définit détermine la valeur. | `null` : Claude utilise le modèle par défaut du produit |
| `environment_id` | Le niveau le plus proche qui le définit détermine la valeur. | `null` |
| `guest_policy` | Le niveau le plus proche qui le définit détermine la valeur. | `restrict` |
Par exemple, une organisation stocke des instructions dans ses paramètres par défaut Slack, désactive Claude sur un espace de travail et définit un modèle sur un canal de cet espace de travail. Lu avec `include_inherited=true`, le canal affiche les trois valeurs et la provenance de chacune :
```json
{
"type": "slack_channel",
"id": "slch_011CZkZmRt4vNq8sHbYw2KdX",
"slack": {
"workspace_id": "T01ABCD2EFG",
"channel_id": "C05HJKL6MNP"
},
"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_default" }],
"model": {
"type": "slack_channel",
"slack_channel_id": "slch_011CZkZmRt4vNq8sHbYw2KdX"
},
"environment_id": { "type": "default" },
"guest_policy": { "type": "default" }
},
"created_at": "2026-10-19T16:20:05Z",
"updated_at": "2026-10-19T16:24:38Z"
}
```
Lu sans le paramètre, le même canal a son `model` et quatre paramètres `null` dans `settings` ; dans `sources`, `model` nomme le canal, `instructions` est une liste vide et les trois autres valent `null`.
Une source est l'une des suivantes :
| `type` | Signification |
| ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `slack_channel` | Le canal, nommé dans `slack_channel_id`. |
| `slack_workspace` | L'espace de travail, nommé dans `slack_workspace_id`. |
| `slack_parent_channel` | Le parent d'un canal de code, nommé dans `slack_channel_id`. Un canal de code est un canal démarré à partir d'un autre canal. Tant que le parent est un canal public du même espace de travail, il se situe entre le canal et l'espace de travail et ne fournit que `instructions` et `environment_id`. |
| `slack_grid_channel` | Le même canal Slack tel que configuré sous un autre espace de travail de sa Slack Enterprise Grid, nommé par les identifiants propres à Slack sous `slack`. Il ne fournit que `enabled` : lorsque ni le canal ni son espace de travail ne définissent `enabled`, une valeur `true` stockée pour le canal sous un autre espace de travail de la Grid s'applique. |
| `slack_default` | Les paramètres par défaut Slack de votre organisation, qui n'ont pas d'identifiant. |
| `default` | Aucun niveau ne définit de valeur, donc la valeur par défaut intégrée s'applique. |
`sources.instructions` liste chaque niveau qui fournit du texte, du plus large au plus spécifique, ce qui correspond à l'ordre de leur texte dans `settings.instructions`, et est vide lorsqu'aucun n'en fournit. Elle indique quel texte vient en premier, et non où se termine le texte d'un niveau : pour obtenir le texte propre à un niveau, lisez ce canal ou cet espace de travail sans `include_inherited` ou, pour les paramètres par défaut Slack, consultez claude.ai. Une source qui nomme un canal ou un espace de travail porte toujours son identifiant, qui n'est jamais `null` : un `id` de cette API dans `slack_channel_id` ou `slack_workspace_id` ou, pour `slack_grid_channel`, les identifiants propres à Slack sous `slack`, comme sur un objet canal.
Avec `include_inherited=true`, une requête échoue avec `503` si un niveau ne peut pas être lu, plutôt que de répondre sans lui.
### Modifier les paramètres
Les deux endpoints de mise à jour et [Configurer un canal](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#set-up-a-channel) acceptent un objet `settings` selon les mêmes règles :
* **Un paramètre que vous omettez reste inchangé.** `{"settings": {"enabled": false}}` désactive Claude et laisse les quatre autres paramètres tels quels.
* **Un paramètre que vous envoyez avec la valeur `null` est effacé**, de sorte que le niveau en hérite à nouveau.
* **Tout ou rien.** Si une valeur de la requête est refusée, aucun paramètre de la requête n'est stocké.
* **Répétition sans risque.** Chaque modification laisse la ressource dans l'état où l'a laissée la première requête identique ; aucun endpoint n'accepte donc d'`Idempotency-Key`. Une requête qui ne modifie rien n'écrit rien et n'enregistre aucun événement dans l'Activity Feed.
* **La dernière écriture l'emporte.** Aucune requête n'accepte de précondition. Deux appelants qui lisent chacun une ressource puis modifient le même paramètre s'écrasent mutuellement. Un `409` n'est renvoyé que lorsqu'une autre modification chevauche votre requête pendant son exécution ; rien de ce que votre requête demandait de modifier ou de supprimer n'a été effectué, sauf qu'une requête de configuration a pu déjà configurer le canal : relisez donc la ressource et renvoyez la modification si elle est toujours nécessaire.
Une modification de `guest_policy` sur un canal peut mettre fin aux sessions en cours dans ce canal. Elles se terminent en arrière-plan, et la réponse n'attend pas qu'elles soient terminées.
### Mode lecture seule
Le **API / Terraform read-only mode** (mode lecture seule API / Terraform) est un paramètre qu'un propriétaire de l'organisation active et désactive dans les paramètres Claude Tag de claude.ai. Le nom décrit claude.ai et Slack : tant que le mode est activé, ils refusent les modifications qu'une personne apporte à ce que gère cette API, de sorte que seules les clés effectuent ces modifications. Ils refusent également quelques modifications connexes qu'aucune clé n'effectue, comme la modification d'un paramètre des paramètres par défaut Slack : personne ne les effectue donc tant qu'un propriétaire n'a pas désactivé le mode. Il ne rend pas cette API en lecture seule. Chaque endpoint de cette page répond de la même façon que le mode soit activé ou non, et aucun endpoint ne le lit ni ne le modifie.
Tant que le mode est désactivé, les personnes et les clés modifient les mêmes paramètres et attachent et détachent les mêmes Bundles, et chaque modification remplace ce qui est stocké. Activez-le si votre pipeline doit être la seule source de modifications.
Tant que le mode est activé, claude.ai et Slack refusent :
* Modifier l'un des cinq paramètres sur un canal, un espace de travail ou les paramètres par défaut Slack (qu'aucune clé ne modifie non plus)
* Configurer un canal, supprimer un canal, ajouter un espace de travail d'une Enterprise Grid connectée, ou déconnecter un espace de travail ou une Grid dans claude.ai
* Attacher un Bundle à un canal ou à un espace de travail, en détacher un, ou supprimer un Bundle qui est attaché à l'un d'eux
Certaines actions restent possibles dans les deux cas : un propriétaire peut toujours connecter un nouvel espace de travail ou une nouvelle Grid, créer et modifier des Bundles, et modifier les paramètres Claude Tag que cette API ne gère pas. La première utilisation de Claude configure toujours un canal, ou un espace de travail de Grid qui n'était pas configuré, la suppression d'un canal dans Slack le supprime toujours, et la désinstallation de l'application Slack de Claude déconnecte toujours cet espace de travail ou cette Grid.
Tant que le mode est désactivé, configurer dans claude.ai un canal déjà configuré peut remplacer l'enregistrement du canal, mais uniquement pour un canal qui ne contient encore rien : un canal que la première utilisation de Claude a configuré, ou que cette API a configuré sans `settings`, et sur lequel personne n'a depuis stocké de paramètre ni attaché de Bundle. Le canal reçoit alors un nouvel `id`, et l'ancien renvoie `404`. Tout autre canal conserve son `id` jusqu'à sa suppression.
### Messages directs de groupe
Un message direct de groupe Slack possède un identifiant au format d'un canal ; l'utilisation de Claude dans l'un d'eux le configure donc comme un canal : il possède un `id`, est listé et peut être lu. Le configurer via cette API, y modifier un paramètre, y attacher un Bundle et le supprimer renvoient chacun `400`, sauf qu'une requête de configuration qui omet `settings` pour un message direct de groupe déjà configuré le renvoie avec `200`, comme le ferait une lecture. Détacher un Bundle d'un message direct de groupe est autorisé.
## Exemples de flux de travail
### Activer Claude uniquement dans les canaux approuvés
N'importe quel membre peut inviter Claude dans un canal public. Pour que Claude ne soit activé que là où vous l'avez approuvé :
1. Demandez à un propriétaire de l'organisation de désactiver Claude partout dans claude.ai, avec le bouton **Enable Claude Tag in Slack** sous **Default Slack access**, ce qui stocke `enabled` à `false` dans les paramètres par défaut Slack de votre organisation. Le [mode lecture seule](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#read-only-mode) doit être désactivé pendant cette opération.
2. Lorsque votre système d'approbation approuve un canal, [configurez le canal](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#set-up-a-channel) avec `"settings": {"enabled": true}`. La requête accepte les identifiants propres à Slack et renvoie le canal même s'il était déjà configuré ; elle peut donc être répétée sans risque.
3. Dans la même exécution, [attachez](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#attach-a-bundle) les Bundles pour lesquels l'équipe a été approuvée, afin que la première session du canal dispose déjà de ses outils.
### Conserver la configuration dans un système de gestion de versions
1. Indexez votre configuration par les identifiants que Slack affiche pour chaque canal, et [trouvez chaque canal](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#find-a-channel-by-its-slack-ids) grâce à eux.
2. Lisez chaque canal sans `include_inherited` et comparez ses `settings` avec ce que déclare votre dépôt. Avec le paramètre, des valeurs héritées seraient mélangées.
3. N'envoyez que les paramètres qui diffèrent, et envoyez `null` pour un paramètre que votre dépôt ne déclare plus.
4. Demandez à un propriétaire de l'organisation d'activer le [mode lecture seule](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#read-only-mode), afin que personne ne modifie les mêmes paramètres à la main.
### Auditer ce qui s'applique partout
1. [Listez vos espaces de travail](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#list-workspaces), puis [listez les canaux de chaque espace de travail](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#list-channels), dans les deux cas avec `include_inherited=true` afin que chaque élément contienne ce qui s'y applique. Si votre organisation a connecté une Enterprise Grid, listez également les canaux stockés sous l'identifiant Slack propre à la Grid. Consultez [Canaux et espaces de travail configurés](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#set-up-channels-and-workspaces).
2. Signalez ce que votre politique interdit, par exemple un canal où `enabled` vaut `true` sans approbation enregistrée, ou où `guest_policy` vaut `allow`.
3. [Listez vos Bundles](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#list-bundles), puis [les cibles de chaque Bundle](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#list-a-bundles-targets), pour voir où est attaché l'accès aux systèmes sensibles.
## Canaux Slack
L'objet canal décrit un canal Slack :
| Champ | Description |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` | `slack_channel`. |
| `id` | Préfixé `slch_`. Consultez [Identifiants](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#ids). |
| `slack` | Les identifiants propres à Slack : `workspace_id` pour l'espace de travail dans lequel se trouve le canal, et `channel_id` pour le canal. |
| `settings` | Ce que le canal stocke lui-même ou, avec `include_inherited=true`, ce qui s'y applique. Toujours présent, avec les cinq [paramètres](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#settings) ; un paramètre non défini vaut `null`. Consultez [Valeurs stockées et héritées](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#stored-and-inherited-values). |
| `sources` | Pour chaque paramètre, le niveau dont provient la valeur figurant dans `settings`. Toujours présent. |
| `created_at` | Date à laquelle le canal a été configuré. |
| `updated_at` | Date de la dernière modification de l'enregistrement du canal par Claude Tag. Il change à chaque modification d'un paramètre, ici, dans claude.ai ou dans Slack, et peut aussi changer pour une modification qu'aucune réponse ici n'affiche. Considérez une valeur plus récente comme une raison de relire le canal, et non comme la preuve qu'un paramètre a changé. Attacher ou détacher un Bundle ne le modifie pas en soi. |
Un `id` qui n'est pas un identifiant `slch_` valide renvoie `400`. Un identifiant valide qui ne nomme aucun canal de votre organisation renvoie `404`.
### Configurer un canal
`POST /v1/organizations/claude_tag/slack_channels` configure un canal Slack et le renvoie. `slack.workspace_id` et `slack.channel_id` sont obligatoires et sont les identifiants propres à Slack. `settings` est facultatif et suit [Modifier les paramètres](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#changing-settings). Si le canal est déjà configuré, la requête renvoie le canal existant et applique `settings` ; la réponse est `200` dans les deux cas. Nécessite la portée `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: experimental-claude-tag-2026-10-21" \
-d '{
"slack": {"workspace_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 '{workspace_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={"workspace_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: { workspace_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() { WorkspaceID = "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{
WorkspaceID: "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()
.workspaceId("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: ['workspaceID' => '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: {workspace_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": {
"workspace_id": "T01ABCD2EFG",
"channel_id": "C05HJKL6MNP"
},
"settings": {
"enabled": null,
"instructions": "Answer in the language of the question.",
"model": null,
"environment_id": null,
"guest_policy": null
},
"sources": {
"enabled": null,
"instructions": [
{
"type": "slack_channel",
"slack_channel_id": "slch_011CZkZmRt4vNq8sHbYw2KdX"
}
],
"model": null,
"environment_id": null,
"guest_policy": null
},
"created_at": "2026-10-19T16:20:05Z",
"updated_at": "2026-10-19T16:20:05Z"
}
```
Avant qu'un canal ne soit configuré, l'application Slack de Claude vérifie auprès de Slack que le canal se trouve dans l'espace de travail, n'est pas archivé et est visible par l'application. Un canal qui échoue à cette vérification renvoie `404`, de même qu'un espace de travail sur lequel l'application Slack de Claude n'est pas installée. Pour un espace de travail que votre organisation possède via une Enterprise Grid, l'application doit être installée sur la Grid.
La configuration du canal et l'application de `settings` sont deux étapes distinctes. Lorsque cette requête configure le canal et que `settings` est ensuite refusé avec un `400`, `404` ou `409`, la réponse est le refus et le canal reste configuré sans rien de stocké (après un `409`, sauf si la modification concurrente l'a supprimé ou remplacé). Ce refus porte un `error_code` qui commence par `slack_channel_set_up_` et l'`id` du nouveau canal dans `error.details.slack_channel_id` (consultez [Réponses d'erreur](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#error-responses)). Corrigez `settings` et envoyez-le dans une [mise à jour](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#update-a-channel) vers cet `id`, ou renvoyez la requête de configuration. Si le canal était déjà configuré, un `settings` refusé renvoie la même erreur qu'une [mise à jour](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#update-a-channel), et le canal conserve ce qu'il stockait. Un `500` ou un `503` ne porte dans aucun des deux cas d'`error_code` et n'indique pas si le canal a été configuré ni si `settings` a été stocké : renvoyez la requête de configuration.
### Lister les canaux
`GET /v1/organizations/claude_tag/slack_channels` liste les canaux configurés d'un espace de travail, du plus récent au plus ancien selon `created_at`. `slack_workspace_id` est obligatoire et correspond à l'identifiant propre à Slack de l'espace de travail. Ajoutez `include_inherited=true` pour que chaque canal contienne ce qui s'y applique (consultez [Valeurs stockées et héritées](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#stored-and-inherited-values)). Une page peut contenir moins de `limit` canaux, voire aucun, alors que `next_page` est toujours défini : continuez donc à demander des pages jusqu'à ce que `next_page` vaille `null` (consultez [Pagination](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#pagination)). Nécessite la portée `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels?slack_workspace_id=T01ABCD2EFG" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: experimental-claude-tag-2026-10-21"
```
```bash CLI
ant beta:organization:claude-tag:slack-channels list --slack-workspace-id T01ABCD2EFG
```
```python Python
client = anthropic.Anthropic()
channels = client.beta.organization.claude_tag.slack_channels.list(
slack_workspace_id="T01ABCD2EFG"
)
# Récupère automatiquement des pages supplémentaires selon les besoins.
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_workspace_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() { SlackWorkspaceID = "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{
SlackWorkspaceID: "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()
.slackWorkspaceId("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(
slackWorkspaceID: 'T01ABCD2EFG',
);
// Uniquement cette page ; pour la suivante, rappelez list() avec page: $channels->nextPage.
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_workspace_id: "T01ABCD2EFG")
page.auto_paging_each do |channel|
puts "#{channel.id}: #{channel.slack.channel_id}"
end
```
La réponse est `{"data": [...], "next_page": ...}`, où chaque élément est un objet canal. Un `slack_workspace_id` qui nomme un espace de travail que votre organisation ne possède pas renvoie `404`, de même qu'un espace de travail qu'elle possède uniquement via une Enterprise Grid tant que cet espace de travail n'est pas configuré (consultez [Canaux et espaces de travail configurés](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#set-up-channels-and-workspaces)).
### Trouver un canal par ses ID Slack
Ajoutez `slack_channel_id`, l'identifiant propre à Slack du canal, pour rechercher un canal. `data` contient ce canal, ou est vide lorsque le canal n'est pas configuré. Dans un espace de travail non configuré que votre organisation possède uniquement via une Enterprise Grid, un canal non configuré renvoie plutôt `404`. Une recherche n'est pas paginée : elle ignore `page` et toute valeur de `limit` comprise entre 1 et 100 (une valeur de `limit` hors de cette plage renvoie toujours `400`), et son `next_page` vaut `null`. C'est ainsi que vous trouvez l'`id` d'un canal.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels?slack_workspace_id=T01ABCD2EFG&slack_channel_id=C05HJKL6MNP" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: experimental-claude-tag-2026-10-21"
```
```bash CLI
ant beta:organization:claude-tag:slack-channels list \
--slack-workspace-id T01ABCD2EFG \
--slack-channel-id C05HJKL6MNP
```
```python Python
client = anthropic.Anthropic()
page = client.beta.organization.claude_tag.slack_channels.list(
slack_workspace_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_workspace_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() { SlackWorkspaceID = "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{
SlackWorkspaceID: "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()
.slackWorkspaceId("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(
slackWorkspaceID: '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_workspace_id: "T01ABCD2EFG",
slack_channel_id: "C05HJKL6MNP"
)
page.data&.each do |channel|
puts channel.id
end
```
Transmettre un ID `slch_` comme `slack_channel_id` renvoie `400`.
### Obtenir un canal
`GET /v1/organizations/claude_tag/slack_channels/{id}` renvoie l'objet canal, contenant ce que le canal stocke. Pour lire plutôt ce qui s'y applique, consultez [Lire ce qui s'applique dans un canal](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#read-what-applies-in-a-channel). Nécessite la portée `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: experimental-claude-tag-2026-10-21"
```
```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
```
### Lire ce qui s'applique dans un canal
La même requête avec `include_inherited=true` renvoie l'objet canal dont `settings` contient ce qui s'applique dans le canal, et dont `sources` indique la provenance de chaque valeur. [Valeurs stockées et héritées](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#stored-and-inherited-values) présente une réponse complète ; `enabled` et `guest_policy` n'y valent jamais `null`. Si un niveau ne peut pas être lu, la requête échoue avec `503` plutôt que de répondre sans lui. Nécessite la portée `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels/slch_011CZkZmRt4vNq8sHbYw2KdX?include_inherited=true" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: experimental-claude-tag-2026-10-21"
```
```bash CLI
ant beta:organization:claude-tag:slack-channels retrieve \
--id slch_011CZkZmRt4vNq8sHbYw2KdX \
--include-inherited
```
```python Python
client = anthropic.Anthropic()
channel = client.beta.organization.claude_tag.slack_channels.retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX",
include_inherited=True,
)
print(channel.settings.instructions)
```
```typescript TypeScript
const client = new Anthropic();
const channel = await client.beta.organization.claudeTag.slackChannels.retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX",
{ include_inherited: true }
);
console.log(channel.settings.instructions);
```
```csharp C#
AnthropicClient client = new();
var channel = await client.Beta.Organization.ClaudeTag.SlackChannels.Retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX",
new() { IncludeInherited = true }
);
Console.WriteLine(channel.Settings.Instructions);
```
```go Go
client := anthropic.NewClient()
channel, err := client.Beta.Organization.ClaudeTag.SlackChannels.Get(
context.Background(),
"slch_011CZkZmRt4vNq8sHbYw2KdX",
anthropic.BetaOrganizationClaudeTagSlackChannelGetParams{
IncludeInherited: anthropic.Bool(true),
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(channel.Settings.Instructions)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.slackchannels.SlackChannelRetrieveParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SlackChannelRetrieveParams.builder()
.includeInherited(true)
.build();
var channel = client.beta().organization().claudeTag().slackChannels()
.retrieve("slch_011CZkZmRt4vNq8sHbYw2KdX", params);
IO.println(channel.settings().instructions().orElse(null));
}
```
```php PHP
$client = new Client();
$channel = $client->beta->organization->claudeTag->slackChannels->retrieve(
id: 'slch_011CZkZmRt4vNq8sHbYw2KdX',
includeInherited: true,
);
echo "{$channel->settings->instructions}\n";
```
```ruby Ruby
client = Anthropic::Client.new
channel_id = "slch_011CZkZmRt4vNq8sHbYw2KdX"
channel = client.beta.organization.claude_tag.slack_channels.retrieve(channel_id, include_inherited: true)
puts channel.settings.instructions
```
### Mettre à jour un canal
`POST /v1/organizations/claude_tag/slack_channels/{id}` modifie les paramètres du canal et renvoie l'objet canal. `settings` est obligatoire et suit [Modifier les paramètres](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#changing-settings). Nécessite la portée `write:claude_tag`.
Désactivez Claude dans un canal et laissez ses autres paramètres tels quels :
```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: experimental-claude-tag-2026-10-21" \
-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
```
Effacez les instructions du canal, afin que seules les instructions héritées s'appliquent :
```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: experimental-claude-tag-2026-10-21" \
-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() supprime les valeurs null dans les tableaux : construisez donc l'objet settings pour envoyer null.
$channel = $client->beta->organization->claudeTag->slackChannels->update(
id: 'slch_011CZkZmRt4vNq8sHbYw2KdX',
settings: (new ClaudeTagSettingsUpdate())->withInstructions(null),
);
echo "{$channel->settings->instructions}\n";
```
```ruby Ruby
client = Anthropic::Client.new
channel_id = "slch_011CZkZmRt4vNq8sHbYw2KdX"
channel = client.beta.organization.claude_tag.slack_channels.update(
channel_id,
settings: {instructions: nil}
)
puts channel.settings.instructions
```
### Supprimer un canal
`DELETE /v1/organizations/claude_tag/slack_channels/{id}` retire un canal de Claude Tag. Il s'agit de la même suppression que celle qu'un propriétaire d'organisation effectue dans claude.ai, avec le même effet. Elle ne supprime, n'archive ni ne modifie le canal dans Slack, ni aucun message qu'il contient. Nécessite la portée `write:claude_tag`.
La suppression est irréversible. Elle supprime ce que Claude Tag conserve pour le canal :
* ses paramètres stockés et ses cibles de Bundle
* ses sessions et leurs transcriptions, y compris les sessions en cours d'exécution
* sa mémoire, c'est-à-dire ce que Claude conserve à propos du canal d'une session à l'autre
* ses routines et les artefacts publiés depuis celui-ci
**Un canal ne peut être supprimé que lorsque Claude y est désactivé.** Tant que `enabled` se résout à `true` pour le canal, tel que [Lire ce qui s'applique dans un canal](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#read-what-applies-in-a-channel) le renvoie, la requête renvoie `400` avec `error_code: "slack_channel_enabled"`. Définissez d'abord `enabled` à `false` sur le canal, puis renvoyez la requête. La seule exception concerne une organisation ayant une [configuration de conformité restreinte](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#error-responses) : elle ne peut pas effectuer cette modification, donc sa requête supprime le canal, que Claude y soit activé ou non. Si un niveau nécessaire à cette vérification ne peut pas être lu, la requête renvoie `503` et ne supprime rien.
Cette vérification protège contre la suppression par erreur d'un canal en cours d'utilisation. Elle n'empêche pas Claude d'accéder au canal par la suite. La suppression efface les paramètres propres au canal, y compris un `enabled` à `false` ; dès lors, seul ce dont hérite le canal détermine si Claude y est activé. Si cela active Claude, Claude répond à nouveau dans le canal à sa prochaine mention, et cette utilisation configure le canal à nouveau : un nouvel `id`, aucun paramètre propre, et rien de la mémoire du canal supprimé.
* Pour tenir Claude à l'écart d'un canal, gardez-le configuré avec `enabled` à `false` plutôt que de le supprimer, ou assurez-vous que ce dont il hériterait, que la suppression ne modifie pas, maintient Claude désactivé.
* Pour qu'un canal ne stocke rien tout en conservant ses sessions et sa mémoire, effacez plutôt chaque paramètre et détachez chaque Bundle.
Deux types de canaux ne peuvent pas du tout être supprimés ici, que Claude y soit activé ou non, et renvoient `400` sans `error_code` : un [message direct de groupe](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#group-direct-messages), et un canal qui contient une configuration que cette API ne gère pas, comme un pool de runners ou un paramètre que seul claude.ai possède. Ces cas sont vérifiés avant `enabled`, donc désactiver Claude n'y change rien ; un propriétaire de l'organisation supprime le second type dans claude.ai.
```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: experimental-claude-tag-2026-10-21"
```
```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"
}
```
L'`id` renvoie `404` dès que la requête se termine, et le reste est supprimé en arrière-plan. Une suppression répétée renvoie `404` : si vous renvoyez une suppression après un `503`, un `404` signifie alors que le canal n'existe déjà plus.
## Espaces de travail Slack
L'objet espace de travail décrit un espace de travail Slack. Il possède les mêmes champs que l'[objet canal](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#slack-channels), sauf que `type` vaut `slack_workspace`, que `id` est préfixé `slws_` et que `slack` ne contient que `workspace_id`. La réponse du [Démarrage rapide](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#quick-start) en présente un complet. Lu avec `include_inherited=true`, un espace de travail affiche chaque paramètre tel que l'espace de travail et les paramètres par défaut Slack le résolvent, ce dont hérite un canal de l'espace de travail sauf si un niveau plus proche définit ce paramètre.
Un `id` qui n'est pas un identifiant `slws_` valide renvoie `400`. Un identifiant valide qui ne nomme aucun espace de travail de votre organisation renvoie `404`.
### Lister les espaces de travail
`GET /v1/organizations/claude_tag/slack_workspaces` liste les espaces de travail configurés que possède votre organisation, du plus récent au plus ancien selon `created_at`. Le [Démarrage rapide](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#quick-start) présente la requête et la réponse. Pour trouver un espace de travail par l'identifiant propre à Slack, ajoutez `slack_workspace_id` : `data` contient cet espace de travail, ou est vide lorsqu'il n'est pas configuré, et un espace de travail que votre organisation ne possède pas renvoie `404`. Un espace de travail qu'elle possède uniquement via une Enterprise Grid renvoie également `404` tant qu'il n'est pas configuré. Ajoutez `include_inherited=true` pour que chaque espace de travail contienne ce qui s'y applique (consultez [Valeurs stockées et héritées](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#stored-and-inherited-values)). Nécessite la portée `read:claude_tag`.
### Obtenir un espace de travail
`GET /v1/organizations/claude_tag/slack_workspaces/{id}` renvoie l'objet espace de travail, contenant ce que l'espace de travail stocke ou, avec `include_inherited=true` dans la requête comme dans [Lire ce qui s'applique dans un canal](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#read-what-applies-in-a-channel), ce qui s'y applique. Nécessite la portée `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: experimental-claude-tag-2026-10-21"
```
```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
```
### Mettre à jour un espace de travail
`POST /v1/organizations/claude_tag/slack_workspaces/{id}` modifie les paramètres de l'espace de travail et renvoie l'objet espace de travail. `settings` est obligatoire et suit [Modifier les paramètres](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#changing-settings). Ce que vous définissez ici s'applique dans chaque canal de l'espace de travail qui ne définit pas sa propre valeur, à l'exception de `instructions`, auquel chaque canal ajoute ses propres instructions plutôt que de les remplacer. Nécessite la portée `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: experimental-claude-tag-2026-10-21" \
-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
```
## Bundles
Un Bundle est ce que claude.ai appelle un [Access bundle](https://claude.com/docs/claude-tag/admins/add-connections) : un ensemble nommé d'accès, tels que des connecteurs, des dépôts et des identifiants, que Claude peut utiliser dans un canal ou un espace de travail. Les propriétaires d'organisation créent, modifient et suppriment les Bundles dans claude.ai. Cette API les liste et les attache. Elle renvoie le nom et la description d'un Bundle, mais jamais ce que le Bundle accorde.
| Champ | Description |
| -------------------------- | ------------------------------------------------------------------------------------- |
| `type` | `bundle`. |
| `id` | Préfixé par `capp_`. |
| `display_name` | Le nom du Bundle. |
| `description` | Ce à quoi sert le Bundle. `null` lorsqu'il n'a pas de description. |
| `created_at`, `updated_at` | Le moment où le Bundle a été créé et celui où il a été modifié pour la dernière fois. |
Un `bundle_id` qui n'est pas un identifiant `capp_` valide renvoie `400`. Un identifiant valide qui n'existe pas ou appartient à une autre organisation renvoie `404`, quel que soit le reste de la requête. Les Bundles que Claude Tag gère pour son propre compte ne sont pas listés et renvoient `404`.
### Lister les Bundles
`GET /v1/organizations/claude_tag/bundles` liste les Bundles de votre organisation, du plus récent au plus ancien selon `created_at`. Nécessite la portée `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: experimental-claude-tag-2026-10-21"
```
```bash CLI
ant beta:organization:claude-tag:bundles list
```
```python Python
client = anthropic.Anthropic()
bundles = client.beta.organization.claude_tag.bundles.list()
# Récupère automatiquement des pages supplémentaires si nécessaire.
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();
// Cette page uniquement ; pour la suivante, rappelez list() avec page: $bundles->nextPage.
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
}
```
### Obtenir un Bundle
`GET /v1/organizations/claude_tag/bundles/{bundle_id}` renvoie l'objet Bundle. Nécessite la portée `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: experimental-claude-tag-2026-10-21"
```
```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
```
## Cibles de Bundle
Une cible de Bundle est l'enregistrement d'un Bundle attaché à un canal ou à un espace de travail. Un Bundle attaché à un espace de travail peut être utilisé dans l'espace de travail et dans chacun de ses canaux. Un Bundle attaché à un canal ne peut être utilisé que dans ce canal.
| Champ | Description |
| -------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
| `type` | `slack_channel` ou `slack_workspace`. |
| `id` | Préfixé par `btgt_`. Il s'agit du `{target_id}` dans les chemins, et ce n'est jamais l'`id` propre du canal ou de l'espace de travail. |
| `slack_channel_id` | Sur une cible `slack_channel` : l'`id` du canal, préfixé par `slch_`. |
| `slack_workspace_id` | Sur une cible `slack_workspace` : l'`id` de l'espace de travail, préfixé par `slws_`. |
| `created_at` | Le moment où le Bundle a été attaché. |
Un Bundle est attaché au plus une fois à un canal ou à un espace de travail, et la même paire a toujours le même `id`, y compris après un détachement suivi d'un nouvel attachement. L'`id` est opaque : obtenez-le à partir de la réponse à un attachement ou à partir de la liste. Une cible de Bundle ne contient pas l'`id` de son Bundle, dont ses chemins ont également besoin ; conservez donc les deux ensemble.
Attacher ou détacher ne modifie aucun paramètre stocké. Les sessions en cours d'exécution dans le canal ou l'espace de travail sont informées que son accès a changé.
Le Bundle que claude.ai attache dans le cadre d'une configuration d'astreinte est listé et peut être lu, mais ne peut pas être attaché ou détaché ici, et rien ne peut être attaché à un canal ou à un espace de travail géré par une configuration d'astreinte, ni en être détaché. Chacune de ces requêtes renvoie `400`.
### Lister les cibles d'un Bundle
`GET /v1/organizations/claude_tag/bundles/{bundle_id}/targets` liste les canaux et les espaces de travail auxquels le Bundle est attaché, du plus récent au plus ancien selon `created_at`. Nécessite la portée `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: experimental-claude-tag-2026-10-21"
```
```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"
)
# Récupère automatiquement les pages suivantes selon les besoins.
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',
);
// Cette page uniquement ; pour la suivante, rappelez list() avec page: $targets->nextPage.
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_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH",
"slack_channel_id": "slch_011CZkZmRt4vNq8sHbYw2KdX",
"created_at": "2026-10-19T16:21:44Z"
},
{
"type": "slack_workspace",
"id": "btgt_011CZkZuMc3dVk7xQpGw9StZ1CZkZxRe6gTk9uNyVs4adJ",
"slack_workspace_id": "slws_011CZkZnWa7xPc3uJfZe5LgT",
"created_at": "2026-09-12T08:17:02Z"
}
],
"next_page": null
}
```
Seuls les attachements à des canaux et à des espaces de travail sont listés. Un Bundle attaché dans claude.ai à autre chose, comme **Default Slack access**, n'a pas de cible de Bundle correspondante, pas plus qu'une règle qui applique un Bundle dans de nombreux canaux à la fois. Ainsi, les Bundles que Claude peut utiliser dans un canal peuvent être plus nombreux que les cibles qui le désignent. Aucun point de terminaison ne liste les Bundles attachés à un canal ou à un espace de travail donné.
### Attacher un Bundle
`POST /v1/organizations/claude_tag/bundles/{bundle_id}/targets` attache le Bundle et renvoie la cible de Bundle. Le corps indique le `type` et l'`id` correspondant. Le canal ou l'espace de travail doit déjà être configuré : l'attachement ne configure jamais un canal. Attacher une paire déjà attachée renvoie `200` avec la cible de Bundle existante. Nécessite la portée `write:claude_tag`.
Attachez un Bundle à un canal :
```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: experimental-claude-tag-2026-10-21" \
-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_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH",
"slack_channel_id": "slch_011CZkZmRt4vNq8sHbYw2KdX",
"created_at": "2026-10-19T16:21:44Z"
}
```
Attachez un Bundle à un espace de travail :
```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: experimental-claude-tag-2026-10-21" \
-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
```
Un attachement à un canal comporte des conditions dans lesquelles il s'applique, par exemple uniquement tant qu'aucun invité Slack n'est présent dans le canal. Les conditions sont définies dans claude.ai et ne sont pas renvoyées ici. Un attachement effectué via cette API utilise les conditions par défaut, et attacher une paire déjà attachée laisse ses conditions inchangées.
### Obtenir une cible de Bundle
`GET /v1/organizations/claude_tag/bundles/{bundle_id}/targets/{target_id}` renvoie la cible de Bundle. Un `target_id` qui n'est pas un identifiant `btgt_` valide renvoie `400`. Un identifiant valide qui appartient à un autre Bundle, a été détaché ou nomme un canal ou un espace de travail qui n'est plus configuré renvoie `404`. Nécessite la portée `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq/targets/btgt_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: experimental-claude-tag-2026-10-21"
```
```bash CLI
ant beta:organization:claude-tag:bundles:targets retrieve \
--bundle-id capp_011CZkZjLP1cWxj5EtMmdgbq \
--target-id btgt_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH
```
```python Python
client = anthropic.Anthropic()
target = client.beta.organization.claude_tag.bundles.targets.retrieve(
"btgt_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH",
bundle_id="capp_011CZkZjLP1cWxj5EtMmdgbq",
)
print(target.type)
```
```typescript TypeScript
const client = new Anthropic();
const target = await client.beta.organization.claudeTag.bundles.targets.retrieve(
"btgt_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH",
{ bundle_id: "capp_011CZkZjLP1cWxj5EtMmdgbq" }
);
console.log(target.type);
```
```csharp C#
AnthropicClient client = new();
var target = await client.Beta.Organization.ClaudeTag.Bundles.Targets.Retrieve(
"btgt_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH",
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_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH",
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_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH", params);
IO.println(target.type().asString());
}
```
```php PHP
$client = new Client();
$target = $client->beta->organization->claudeTag->bundles->targets->retrieve(
targetID: 'btgt_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH',
bundleID: 'capp_011CZkZjLP1cWxj5EtMmdgbq',
);
echo "{$target->type}\n";
```
```ruby Ruby
client = Anthropic::Client.new
bundle_id = "capp_011CZkZjLP1cWxj5EtMmdgbq"
target_id = "btgt_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH"
target = client.beta.organization.claude_tag.bundles.targets.retrieve(
target_id,
bundle_id: bundle_id
)
puts target.type
```
### Détacher un Bundle
`DELETE /v1/organizations/claude_tag/bundles/{bundle_id}/targets/{target_id}` détache le Bundle. Un détachement répété renvoie `404` : après un `503`, un détachement renvoyé qui renvoie `404` signifie que la cible de Bundle n'existe déjà plus. Nécessite la portée `write:claude_tag`.
```bash cURL
curl -X DELETE "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq/targets/btgt_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: experimental-claude-tag-2026-10-21"
```
```bash CLI
ant beta:organization:claude-tag:bundles:targets delete \
--bundle-id capp_011CZkZjLP1cWxj5EtMmdgbq \
--target-id btgt_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH
```
```python Python
client = anthropic.Anthropic()
deleted_target = client.beta.organization.claude_tag.bundles.targets.delete(
"btgt_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH",
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_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH",
{ bundle_id: "capp_011CZkZjLP1cWxj5EtMmdgbq" }
);
console.log(deletedTarget.id);
```
```csharp C#
AnthropicClient client = new();
var deletedTarget = await client.Beta.Organization.ClaudeTag.Bundles.Targets.Delete(
"btgt_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH",
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_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH",
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_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH", params);
IO.println(deletedTarget.id());
}
```
```php PHP
$client = new Client();
$deletedTarget = $client->beta->organization->claudeTag->bundles->targets->delete(
targetID: 'btgt_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH',
bundleID: 'capp_011CZkZjLP1cWxj5EtMmdgbq',
);
echo "{$deletedTarget->id}\n";
```
```ruby Ruby
client = Anthropic::Client.new
bundle_id = "capp_011CZkZjLP1cWxj5EtMmdgbq"
target_id = "btgt_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH"
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_011CZkZpBv9yQd6wKhAr8MnU1CZkZwPd5fSj8tMxUr3ZcH"
}
```
## Valeurs non reconnues
`guest_policy.type`, le `type` d'une source, le `type` d'une cible de Bundle et les codes d'erreur peuvent recevoir de nouvelles valeurs à tout moment. Traitez une valeur que vous ne reconnaissez pas comme vous le feriez pour toute chaîne inconnue, plutôt que de provoquer un échec.
## Limitation de débit
Les requêtes sont limitées pour chaque organisation, selon deux budgets que partagent toutes les clés de votre organisation et qui sont distincts des autres limites Admin API de votre organisation. Chaque budget autorise une rafale, puis se recharge à un rythme constant :
| Budget | Requêtes | Rafale | Recharge |
| ------------- | ------------------------- | ------ | ------------- |
| Lectures | Chaque `GET` | 120 | 2 par seconde |
| Modifications | Chaque `POST` et `DELETE` | 60 | 1 par seconde |
Les requêtes qui dépassent un budget renvoient **429 Too Many Requests** avec un en-tête `retry-after` : attendez ce nombre de secondes, puis renvoyez la requête. Une requête qui est parvenue jusqu'à son budget, quel que soit son résultat, reçoit les en-têtes `anthropic-ratelimit-requests-limit`, `anthropic-ratelimit-requests-remaining` et `anthropic-ratelimit-requests-reset` pour ce budget ; une requête refusée avant cette étape, par exemple en raison de sa clé, de sa portée ou de ses en-têtes, ou parce que l'API, les modifications ou le nouveau stockage ne sont pas activés pour votre organisation, n'en reçoit aucun.
## Pagination
Les endpoints de liste utilisent un **curseur opaque**. La première requête renvoie jusqu'à `limit` lignes ainsi qu'un curseur `next_page` ; transmettez le curseur tel quel comme paramètre `page` dans la requête suivante, avec les autres paramètres de requête inchangés, et répétez jusqu'à ce que `next_page` vaille `null`. Un curseur envoyé avec une valeur de `include_inherited` différente de celle de la requête qui l'a renvoyé renvoie `400`. Traitez la chaîne du curseur comme opaque : ne l'analysez pas, ne la modifiez pas et ne la construisez pas vous-même. [Lister les canaux](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#list-channels) peut renvoyer une page contenant moins de `limit` canaux, voire aucun, alors que `next_page` est toujours défini : continuez donc à demander des pages jusqu'à ce que `next_page` vaille `null`. Les itérateurs de liste des SDK Python, TypeScript, C#, Go, Java et Ruby ainsi que la CLI (sauf avec `--format raw`) le font pour vous. En PHP et avec curl, demandez chaque page vous-même et transmettez son `next_page` comme `page`.
`limit` vaut 20 par défaut, avec un minimum de 1 et un maximum de 100 ; une valeur hors de cette plage renvoie `400` sur toutes les listes. Chaque liste est triée du plus récent au plus ancien selon `created_at`, et n'accepte aucun autre ordre.
## Réponses d'erreur
Les réponses d'erreur suivent la structure standard documentée dans [Erreurs de l'API Claude](https://platform.claude.com/docs/fr/api/errors). Indiquez le `request_id` figurant dans le corps de la réponse lorsque vous contactez le support.
| Statut | Signification |
| ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| 400 | Entrée invalide, ou l'opération ne s'applique pas à ce canal, cet espace de travail ou ce Bundle (consultez la section de chaque endpoint). |
| 401 | En-tête `x-api-key` manquant, ou clé non reconnue. |
| 403 | La clé n'est pas une clé à portée limitée de niveau organisation, il lui manque la portée requise, ou votre organisation ne peut pas effectuer cette modification. |
| 404 | Ressource introuvable, ou n'appartenant pas à votre organisation. Également renvoyé lorsque la requête omet la valeur `anthropic-beta`, ou lorsque l'API n'est pas activée pour votre organisation, de sorte que les endpoints apparaissent comme inexistants. |
| 409 | Autre chose a modifié ou supprimé la ressource pendant l'exécution de la requête. Rien de ce que demandait la requête n'a été effectué : aucun paramètre stocké, rien d'attaché, de détaché ou de supprimé. La seule exception est une requête de configuration, qui peut avoir configuré le canal avant que ses `settings` ne rencontrent le conflit (`slack_channel_set_up_settings_conflict`). Relisez la ressource et renvoyez la requête si elle est toujours nécessaire. |
| 429 | « Rate limit » (limite de débit) dépassée. Consultez [Limitation du débit](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#rate-limiting). |
| 500 | Erreur interne. |
| 503 | Temporaire. Lors d'une modification, il n'indique pas si la modification a été stockée. Chaque modification peut être répétée sans risque : renvoyez donc la requête inchangée. Si un `DELETE` renvoyé renvoie alors `404`, le canal ou la cible de Bundle n'existe déjà plus. |
Lorsqu'un même statut a plusieurs causes que vous traiteriez différemment, l'erreur contient également `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` | Statut | Signification et action à mener |
| -------------------------------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `organization_level_scoped_api_key_required` | 403 | L'identifiant n'est pas une clé Admin API à portée limitée appartenant à l'organisation dans son ensemble. Demandez-en une à votre propriétaire principal. |
| `api_key_scope_missing` | 403 | Il manque à la clé `read:claude_tag` ou `write:claude_tag`, selon ce que requiert l'endpoint. |
| `claude_tag_writes_not_enabled` | 403 | Votre organisation peut lire via cette API, mais n'est pas activée pour les modifications. |
| `compliance_configuration_restricted` | 403 | Votre organisation a une configuration de conformité sous laquelle Claude Tag ne stocke rien de nouveau, comme la conservation zéro des données. La configuration d'un canal, la mise à jour des paramètres (même pour les effacer) et l'attachement d'un Bundle sont refusés. Le détachement d'un Bundle et la suppression d'un canal ne le sont pas, et une telle organisation peut [supprimer](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#remove-a-channel) un canal même lorsque Claude y est activé. |
| `environment_not_found` | 404 | `environment_id` ne nomme aucun environnement que votre organisation peut utiliser ici. L'`id` du chemin est correct. |
| `environment_archived` | 400 | `environment_id` nomme un environnement archivé. |
| `slack_channel_set_up_settings_refused` | 400 | La requête a configuré le canal, puis `settings` a été refusé. `details.slack_channel_id` est le canal. Consultez [Configurer un canal](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#set-up-a-channel). |
| `slack_channel_set_up_environment_not_found` | 404 | La requête a configuré le canal, puis `environment_id` est introuvable. `details.slack_channel_id` est le canal. Consultez [Configurer un canal](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#set-up-a-channel). |
| `slack_channel_set_up_settings_conflict` | 409 | La requête a configuré le canal, puis une autre modification a chevauché `settings`. Rien de `settings` n'a été stocké. `details.slack_channel_id` est le canal. Consultez [Configurer un canal](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#set-up-a-channel). |
| `slack_channel_enabled` | 400 | Claude est activé dans le canal (`enabled` se résout à `true`), il ne peut donc pas être supprimé. Définissez d'abord `enabled` à `false`. Consultez [Supprimer un canal](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#remove-a-channel). |
De nouveaux codes peuvent être ajoutés. Traitez un code que vous ne reconnaissez pas comme vous traitez son statut. Un `404` sans `error_code` a l'une de deux causes. Soit un élément nommé par la requête est introuvable (un `id` dans le chemin, ou un canal ou un espace de travail Slack dans le corps ou la requête), soit tous les endpoints apparaissent comme inexistants parce que la requête omet la valeur `anthropic-beta` ou que l'API n'est pas activée pour votre organisation. Pour les distinguer, [listez vos espaces de travail](https://platform.claude.com/docs/fr/manage-claude/claude-tag-api#list-workspaces) avec la même clé et les mêmes en-têtes : cette requête ne nomme rien, elle ne renvoie donc `404` que dans le second cas.
## Événements de l'Activity Feed
Chaque modification effectuée via cette API est enregistrée dans l'[Activity Feed de la Compliance API](https://platform.claude.com/docs/fr/manage-claude/compliance-activity-feed) de votre organisation, attribuée à la clé API en tant qu'`api_actor` portant son ID `apikey_`. Les événements sont ceux que le flux enregistre lorsque la même modification est effectuée dans claude.ai, de sorte qu'une seule requête permet de retrouver une modification, quelle que soit la manière dont elle a été effectuée.
| Événement | Émis lorsque |
| --------------------------------- | -------------------------------------------------------------------------------------------------------- |
| `ccr_agent_created` | Un canal est configuré. |
| `ccr_agent_updated` | Un paramètre change sur un canal ou un espace de travail. |
| `ccr_agent_deleted` | Un canal est supprimé. Ses cibles de Bundle disparaissent avec lui et n'émettent aucun événement propre. |
| `ccr_agent_proxy_profile_bound` | Un Bundle est attaché. |
| `ccr_agent_proxy_profile_unbound` | Un Bundle est détaché. |
Les événements nomment un canal ou un espace de travail par un identifiant propre au flux, `agent_id` (préfixé `cagt_`), qu'aucune réponse de cette API ne contient : vous ne pouvez donc pas encore faire correspondre un événement à l'`id` d'un canal ou d'un espace de travail. Les deux événements de Bundle nomment le Bundle dans `profile_id` et le canal ou l'espace de travail, par le même `agent_id`, dans `scope_id`.
Un événement `ccr_agent_updated` liste ce qui a changé dans `updated_fields`, sous les noms propres au flux :
| Paramètre | Nom dans `updated_fields` |
| ---------------- | ------------------------- |
| `enabled` | `slackbot_version` |
| `instructions` | `system_prompt_addendum` |
| `model` | `default_model` |
| `environment_id` | `default_environment_id` |
| `guest_policy` | `guest_policy` |
`updated_fields` peut également contenir `is_virtual`, qui ne nomme aucun paramètre. Il apparaît à côté des noms des paramètres modifiés dans l'événement correspondant à une modification effectuée via cette API qui est la première chose que quiconque stocke sur le canal ou l'espace de travail : un canal que la première utilisation de Claude a configuré, ou que cette API a configuré sans `settings`, ou un espace de travail dans lequel Claude n'a jamais été utilisé, et sur lequel personne n'a encore stocké de paramètre ni attaché de Bundle, ici ou dans claude.ai. Le `model` avec lequel démarre un canal de code ne compte pas comme stocké. L'attachement d'un Bundle n'enregistre que `ccr_agent_proxy_profile_bound`.
Les lectures, les requêtes qui ne modifient rien et les requêtes refusées avant que quoi que ce soit ne soit stocké n'enregistrent rien. Une requête de configuration qui configure un canal et dont `settings` est ensuite refusé enregistre `ccr_agent_created`.
## Voir aussi
Où votre propriétaire principal crée une clé à portée limitée.
Ce qu'est Claude Tag, comment le configurer et ce que fait chaque paramètre dans Slack.
La piste d'audit de chaque modification effectuée ici et dans claude.ai.
Gérez les plugins de votre organisation Claude Enterprise.