---
title: API do Claude Tag
url: https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api
description: "Gerencie o Claude Tag no Slack para sua organização Claude Enterprise a partir de seus próprios sistemas: leia e altere configurações em canais e workspaces do Slack, veja quais configurações se aplicam e por quê, e anexe Access bundles."
---
O [Claude Tag](https://claude.com/docs/claude-tag/overview) é o Claude trabalhando como um colega de equipe no Slack: alguém menciona o Claude em um canal e o Claude responde na thread. A API do Claude Tag permite que você leia e altere, a partir dos seus próprios sistemas, as configurações do Claude Tag que um proprietário da organização, de outra forma, define manualmente em [claude.ai > Organization settings > Claude Tag](https://claude.ai/admin-settings/claude-tag). Use-a para ativar o Claude canal por canal a partir de um fluxo de aprovação, manter sua configuração em controle de versão ou auditar o que se aplica em cada canal.
O Claude Tag é um produto do claude.ai. Esta API o gerencia para uma organização Claude Enterprise e não tem nenhuma relação com workspaces da Claude Platform, uso da API ou o Claude Console.
**Chave de API de Admin com escopo necessária**
Esses endpoints exigem uma chave de API de Admin com o escopo `read:claude_tag` (para endpoints `GET`) ou o escopo `write:claude_tag` (para endpoints `POST` e `DELETE`); consulte [Escopos](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#scopes). Consulte [Criar uma chave de API de Admin](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization) para saber onde seu proprietário principal cria uma.
A API do Claude Tag está em **beta** e está disponível apenas para organizações Claude Enterprise. Ela não está disponível para organizações Claude Platform (Claude Console).
Toda solicitação deve incluir o [cabeçalho beta](https://platform.claude.com/docs/pt-BR/api/beta-headers) `anthropic-beta: experimental-claude-tag-2026-10-21` (o SDK e a CLI `ant` o enviam para você). Uma solicitação sem ele retorna `404`, exatamente como se o endpoint não existisse.
## Endpoints
A API expõe 14 endpoints em quatro recursos:
| Recurso | Endpoints |
| ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Canais do Slack:** configurar um canal, listar os canais de um workspace ou encontrar um pelos seus IDs do Slack, ler um, alterar suas configurações, removê-lo | `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}` |
| **Workspaces do Slack:** listar seus workspaces ou encontrar um pelo seu ID do Slack, ler um, alterar suas configurações | `GET /v1/organizations/claude_tag/slack_workspaces`
`GET /v1/organizations/claude_tag/slack_workspaces/{id}`
`POST /v1/organizations/claude_tag/slack_workspaces/{id}` |
| **Bundles:** listar os Access bundles da sua organização, ler um (somente leitura) | `GET /v1/organizations/claude_tag/bundles`
`GET /v1/organizations/claude_tag/bundles/{bundle_id}` |
| **Destinos de Bundle:** listar onde um Bundle está anexado, anexá-lo a um canal ou workspace, ler um anexo, desanexá-lo | `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}` |
Esta versão abrange o Slack. Conectar e desconectar um workspace do Slack ou Enterprise Grid, os padrões do Slack da sua organização, criar e editar Access bundles, limites de gastos e todas as configurações do Claude Tag além das cinco em [Configurações](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#settings) permanecem no claude.ai.
## Pré-requisitos
* Sua organização deve estar em um plano Claude Enterprise, com o [Claude Tag configurado](https://claude.com/docs/claude-tag/admins/setup-overview) e pelo menos um workspace do Slack ou Enterprise Grid conectado.
* Seu proprietário principal cria uma chave de API de Admin com o escopo `read:claude_tag`, o escopo `write:claude_tag` ou ambos em [claude.ai > Organization settings > API](https://claude.ai/admin-settings/api-access). Consulte [Criar uma chave para uma organização Claude Enterprise](https://platform.claude.com/docs/pt-BR/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization).
* Toda solicitação carrega três cabeçalhos: `x-api-key`, `anthropic-version: 2023-06-01` (consulte [Versões da API](https://platform.claude.com/docs/pt-BR/api/versioning)) e `anthropic-beta: experimental-claude-tag-2026-10-21`.
Em Python, TypeScript, C#, Go, Java, PHP e Ruby, o SDK expõe esses endpoints em `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`), e a [CLI `ant`](https://platform.claude.com/docs/pt-BR/cli-sdks-libraries/cli/quickstart) em `ant beta:organization:claude-tag`; eles enviam os cabeçalhos `anthropic-version` e `anthropic-beta` para você. Os exemplos nesta página leem a chave de API de Admin da variável de ambiente `ANTHROPIC_API_KEY`. Quando um SDK ou a CLI busca mais páginas para você, `limit` define o tamanho da página, não o total (consulte [Paginação](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#pagination)).
As chaves de API pertencem à organização e continuam funcionando depois que a pessoa que as criou sai. Não as compartilhe nem as inclua no controle de versão.
## Início rápido
Liste os workspaces do Slack da sua organização no 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()
# Busca automaticamente mais páginas conforme necessário.
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();
// Apenas esta página; para a próxima, chame list() novamente com 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
}
```
Uma configuração que é `null` em `settings` não está definida neste workspace, então o workspace a herda e não tem uma origem para ela. Para ler o que se aplica em vez disso, consulte [Valores armazenados e herdados](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#stored-and-inherited-values).
## Escopos
| Escopo | Concede |
| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------- |
| `read:claude_tag` | Todos os endpoints `GET` nesta página. |
| `write:claude_tag` | Todos os endpoints `POST` e `DELETE` nesta página. Ele não concede leituras, embora a resposta a uma alteração contenha o recurso alterado. |
Uma chave pode ter ambos os escopos. Uma integração que consulta um canal e depois o altera precisa de ambos. Nenhum outro escopo concede acesso a esses endpoints, e uma chave criada no Claude Console não funciona aqui.
A chave deve pertencer à organização como um todo. A organização é sempre aquela à qual a chave pertence, e nenhuma solicitação nomeia uma. O cabeçalho `anthropic-workspace-id` é ignorado, porque nada aqui pertence a um workspace do Claude Platform.
## Conceitos principais
### Nomes nesta página e no claude.ai
| Esta API | claude.ai e Slack |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Workspace do Slack | Um workspace do Slack. A própria API do Slack o chama de team, então o ID do workspace do próprio Slack nesta página é o team ID lá. Ele não tem relação com um workspace do Claude Platform, cujos IDs começam com `wrkspc_`. |
| Padrões do Slack | **Default Slack access**: as configurações que se aplicam a todos os workspaces e canais. Um proprietário da organização as altera no claude.ai; esta API mostra onde um canal ou workspace as herda. |
| Nível de configurações | Um [escopo](https://claude.com/docs/claude-tag/admins/customize): um canal, um workspace ou os padrões do Slack |
| Bundle | Um Access bundle ([glossário do Claude Tag](https://claude.com/docs/claude-tag/concepts/glossary#access-bundle)) |
| `enabled` | O botão **Enable Claude Tag in Slack** |
| `instructions` | **Custom instructions** |
| `model` | **Model** |
| `environment_id` | **Environment** |
| `guest_policy` | **How should Claude work in channels with guests**: `restrict` é **Restrict**, `channel_only` é **Channel only** e `allow` é **Full access** |
### Canais e workspaces configurados
Um canal ou workspace está **configurado** (set up) quando o Claude Tag mantém um registro de configurações para ele. Somente um canal ou workspace configurado tem um `id`, e somente esses são listados: o Slack, e não esta API, mantém a lista completa dos canais de um workspace.
* Um **workspace** é configurado quando um proprietário da organização o conecta no claude.ai. Quando um proprietário conecta um Slack Enterprise Grid, os workspaces do Grid são configurados pouco depois. O primeiro uso do Claude em um workspace, ou o primeiro canal que você [configura](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#set-up-a-channel) nele, configura qualquer um que não estava configurado. Nenhum outro endpoint configura um workspace, e nenhum remove um.
* Um **canal** é configurado no claude.ai, pelo primeiro uso do Claude nele ou com [Configurar um canal](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#set-up-a-channel).
Sua organização é proprietária de um workspace enquanto sua conexão com esse workspace estiver ativa, e é proprietária dos canais nele. Um Slack Enterprise Grid agrupa vários workspaces sob uma empresa. Enquanto a conexão da sua organização com um Grid estiver ativa, ela também é proprietária de todos os workspaces no Grid que nenhuma outra organização conectou. Tal workspace é um workspace como qualquer outro: uma vez configurado, ele tem um `id`, é listado e pode ser lido, alterado e receber Bundles, e seus canais podem ser listados. O Grid em si não é um recurso desta API e não tem `id`. Um canal ou workspace do qual você não é proprietário retorna o mesmo `404` que um que não existe.
Um workspace do qual sua organização é proprietária apenas por meio de um Grid retorna esse `404` até ser configurado, sempre que uma solicitação o nomeia pelo ID do próprio Slack: quando você encontra o workspace, lista seus canais ou consulta um canal nele que não está configurado. Você ainda pode [configurar um canal](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#set-up-a-channel) nele, o que também configura o workspace, sem configurações armazenadas.
Um canal compartilhado com um Grid inteiro pode ser armazenado sob o próprio ID do Slack do Grid, que começa com `E`, no lugar do de um workspace. Esse ID é então o `slack.workspace_id` do canal, e [listar canais](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#list-channels) com ele como `slack_workspace_id` retorna esses canais. Nenhum objeto de workspace o possui: se um proprietário armazenou configurações no próprio Grid no claude.ai, `sources` pode nomeá-las como um `slack_workspace` cujo `id` retorna `404` quando você o lê.
### IDs
Você conhece um canal pelos IDs que o Slack mostra. Consulte o `id` dele uma vez com [Encontrar um canal pelos seus IDs do Slack](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#find-a-channel-by-its-slack-ids), depois armazene e use o `id`.
| ID | Prefixo | Onde aparece |
| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------- |
| Recurso de canal do Slack | `slch_` | `id` em um canal; `slack_channel_id` em corpos de solicitação e respostas |
| Recurso de workspace do Slack | `slws_` | `id` em um workspace; `slack_workspace_id` em corpos de solicitação e respostas |
| Bundle | `capp_` | `id` em um Bundle; `{bundle_id}` em caminhos |
| Destino de Bundle | `btgt_` | `id` em um destino de Bundle; `{target_id}` em caminhos |
| ID de workspace do próprio Slack | `T`, ou `E` para o próprio ID de um Grid (consulte [Canais e workspaces configurados](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#set-up-channels-and-workspaces)) | `slack.workspace_id`; o parâmetro de consulta `slack_workspace_id` |
| ID de canal do próprio Slack | `C` ou `G` | `slack.channel_id`; o parâmetro de consulta `slack_channel_id` |
`slack_channel_id` e `slack_workspace_id` significam, cada um, duas coisas. Em um **parâmetro de consulta**, cada um é o ID do próprio Slack (`C05HJKL6MNP`, `T01ABCD2EFG`). Em um **corpo de solicitação ou resposta**, cada um é o `id` que esta API emite (`slch_...`, `slws_...`). Os IDs do próprio Slack em um corpo ou resposta estão sempre sob `slack`.
Um ID de canal do Slack em um parâmetro de consulta ou corpo de solicitação que não começa com `C` ou `G` retorna `400`, assim como qualquer ID do Slack que tenha algo além de letras maiúsculas e dígitos após sua primeira letra ou que tenha mais de 32 caracteres.
Um `id` não muda enquanto o canal ou workspace estiver configurado, seja o que for que você altere nele, com uma exceção descrita em [Modo somente leitura](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#read-only-mode). Um canal ou workspace que é removido e configurado novamente tem um novo `id`, e o antigo continua retornando `404`. Quando um `id` armazenado retorna `404` sem `error_code`, [liste seus workspaces](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#list-workspaces) com a mesma chave e os mesmos cabeçalhos. Essa solicitação não nomeia nenhum canal ou workspace, então, se ela retornar `200`, o `id` não existe mais: encontre o canal ou workspace novamente pelos seus IDs do Slack. Qualquer outro status não diz nada sobre o `id`: mantenha seus valores de `id` armazenados e consulte [Respostas de erro](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#error-responses).
### Configurações
Cada nível de configurações armazena as mesmas cinco configurações, todas opcionais:
| Configuração | Tipo | Descrição |
| ---------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `enabled` | boolean | Se o Claude está ativado. |
| `instructions` | string | Orientação permanente que o Claude lê em todas as sessões. No máximo 8.192 caracteres depois que os espaços em branco iniciais e finais são removidos. Texto em branco limpa a configuração. |
| `model` | string | O modelo com que novas sessões começam: um [ID de modelo](https://platform.claude.com/docs/pt-BR/models/overview) que sua organização pode usar com o Claude Tag. No máximo 128 caracteres. |
| `environment_id` | string | O ambiente de nuvem em que as sessões são executadas, com o prefixo `env_`. Ele deve estar ativo e pertencer à sua organização. |
| `guest_policy` | object | O que o Claude faz em um canal enquanto um convidado do Slack está nele, para todos no canal: `{"type": "allow"}` (o Claude responde), `{"type": "restrict"}` (o Claude não responde) ou `{"type": "channel_only"}` (o Claude responde apenas com os Bundles anexados ao próprio canal; se `channel_only` não estiver disponível para sua organização, uma solicitação que o define retorna `400`). Consulte [Restringir canais com convidados](https://claude.com/docs/claude-tag/admins/restrict-access#restrict-guest-channels) para saber o que isso significa em canais compartilhados por meio do Slack Connect ou em um Enterprise Grid. |
`model` e `environment_id` são verificados quando você os grava e não novamente: se o modelo ou o ambiente mudar depois, as respostas continuam retornando o valor armazenado.
Se um proprietário da organização tiver colocado um nível de configurações em um pool de runners auto-hospedado no claude.ai, seu `environment_id` retorna o ID do pool, que começa com `ccpool_`. Esta API não pode definir um pool de runners e retorna `400` para uma requisição que altera ou limpa `environment_id` em um nível de configurações que armazena um.
### Valores armazenados e herdados
As configurações existem em três níveis: o canal, o workspace em que o canal está e os padrões do Slack da sua organização, que um proprietário da organização define no claude.ai. Cada nível armazena apenas o que foi definido nele. O `settings` de um objeto de canal ou workspace pode conter uma de duas coisas:
* **O que ele armazena.** É isso que uma resposta contém, a menos que você peça o contrário. Uma configuração que não está definida no canal ou workspace é `null`. Use isso para comparar com a configuração que você mantém em outro lugar.
* **O que se aplica nele**, uma vez que todos os níveis são levados em conta. Para obter isso, adicione o parâmetro de consulta `include_inherited=true` a qualquer solicitação `GET` que retorne um canal ou um workspace, incluindo as duas listas. Use isso para auditar, ou para descobrir por que o Claude se comporta de determinada forma em um canal. O parâmetro tem como padrão `false`, e um valor que não seja booleano retorna `400`. Uma solicitação que configura um canal ou altera configurações não aceita o parâmetro e retorna `400` se você o enviar; sua resposta contém o que está armazenado.
Em ambos os casos, `sources` nomeia, para cada configuração, o nível de onde vem o valor em `settings`. Sem `include_inherited`, a origem de uma configuração que o canal ou workspace armazena nomeia o próprio canal ou workspace, e uma configuração que ele não armazena não tem origem: `null`, ou uma lista vazia para `instructions`. Com `include_inherited=true`, toda configuração exceto `instructions` tem uma origem, e uma configuração que nenhum nível define tem a origem `{"type": "default"}`; quando nenhum nível define `instructions`, ela é `null` e sua lista de origens está vazia. Portanto, para distinguir um valor que o canal ou workspace define por conta própria de um que ele herda, observe sua origem, e não se o valor é `null`.
Cada configuração é resolvida individualmente:
| Configuração | Regra | Quando nenhum nível a define |
| ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------- |
| `enabled` | O nível mais próximo que a define determina o valor, então `true` em um canal ativa o Claude lá mesmo quando seu workspace armazena `false`. | `true` |
| `instructions` | Aditiva. O texto de cada nível que a define é unido, do mais amplo para o mais específico, com uma linha em branco entre eles. | `null` |
| `model` | O nível mais próximo que a define determina o valor. | `null`: o Claude usa o modelo padrão do produto |
| `environment_id` | O nível mais próximo que a define determina o valor. | `null` |
| `guest_policy` | O nível mais próximo que a define determina o valor. | `restrict` |
Por exemplo, uma organização armazena instruções nos seus padrões do Slack, desativa o Claude em um workspace e define um modelo em um canal desse workspace. Lido com `include_inherited=true`, o canal mostra os três valores e de onde cada um vem:
```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"
}
```
Lido sem o parâmetro, o mesmo canal tem seu `model` e quatro configurações `null` em `settings`; em `sources`, `model` nomeia o canal, `instructions` é uma lista vazia e as outras três são `null`.
Uma origem é uma das seguintes:
| `type` | Significado |
| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `slack_channel` | O canal, nomeado em `slack_channel_id`. |
| `slack_workspace` | O workspace, nomeado em `slack_workspace_id`. |
| `slack_parent_channel` | O pai de um canal de código, nomeado em `slack_channel_id`. Um canal de código é aquele que foi iniciado a partir de outro canal. Enquanto o pai for um canal público no mesmo workspace, ele fica entre o canal e o workspace e contribui apenas com `instructions` e `environment_id`. |
| `slack_grid_channel` | O mesmo canal do Slack conforme configurado em outro workspace do seu Slack Enterprise Grid, nomeado pelos IDs do próprio Slack sob `slack`. Ele contribui apenas com `enabled`: quando nem o canal nem seu workspace definem `enabled`, um `true` armazenado para o canal em outro workspace do Grid se aplica. |
| `slack_default` | Os padrões do Slack da sua organização, que não têm ID. |
| `default` | Nenhum nível define um valor, então o padrão integrado se aplica. |
`sources.instructions` lista todos os níveis que contribuem com texto, do mais amplo para o mais específico, que é a ordem do texto deles em `settings.instructions`, e fica vazio quando nenhum contribui. Ele diz de quem é o texto que vem primeiro, não onde termina o texto de um nível: para obter o texto próprio de um nível, leia esse canal ou workspace sem `include_inherited` ou, para os padrões do Slack, consulte o claude.ai. Uma origem que nomeia um canal ou workspace sempre carrega seu ID, que nunca é `null`: um `id` desta API em `slack_channel_id` ou `slack_workspace_id` ou, em `slack_grid_channel`, os IDs do próprio Slack sob `slack`, como em um objeto de canal.
Com `include_inherited=true`, uma solicitação falha com `503` se um nível não puder ser lido, em vez de responder sem ele.
### Alterando configurações
Os dois endpoints de atualização e [Configurar um canal](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#set-up-a-channel) aceitam um objeto `settings` sob as mesmas regras:
* **Uma configuração que você omite permanece inalterada.** `{"settings": {"enabled": false}}` desativa o Claude e deixa as outras quatro configurações como estão.
* **Uma configuração que você envia como `null` é limpa**, então o nível volta a herdá-la.
* **Tudo ou nada.** Se qualquer valor em uma solicitação for recusado, nenhuma configuração da solicitação é armazenada.
* **Seguro para repetir.** Toda alteração deixa o recurso como a primeira solicitação idêntica o deixou, então nenhum endpoint aceita um `Idempotency-Key`. Uma solicitação que não altera nada não grava nada e não registra nenhum evento no Activity Feed.
* **A última gravação vence.** Nenhuma solicitação aceita uma pré-condição. Dois chamadores que leem um recurso e depois alteram a mesma configuração sobrescrevem um ao outro. Um `409` é retornado apenas quando outra alteração se sobrepõe à sua solicitação enquanto ela é executada; nada do que sua solicitação pediu para alterar ou excluir foi feito, exceto que uma solicitação de configuração pode já ter configurado o canal, então leia o recurso novamente e reenvie a alteração se ela ainda for necessária.
Uma alteração em `guest_policy` em um canal pode encerrar sessões que estão em execução nesse canal. Elas são encerradas em segundo plano, e a resposta não espera por isso.
### Modo somente leitura
**API / Terraform read-only mode** é uma configuração que um proprietário da organização ativa e desativa nas configurações do Claude Tag no claude.ai. O nome descreve o claude.ai e o Slack: enquanto o modo está ativado, eles recusam as alterações de uma pessoa ao que esta API gerencia, então apenas chaves fazem essas alterações. Eles também recusam algumas alterações relacionadas que nenhuma chave faz, como alterar uma configuração nos padrões do Slack, então ninguém as faz até que um proprietário desative o modo. Ele não torna esta API somente leitura. Todos os endpoints nesta página respondem da mesma forma, com o modo ativado ou desativado, e nenhum endpoint o lê ou altera.
Enquanto o modo está desativado, pessoas e chaves alteram as mesmas configurações e anexam e desanexam os mesmos Bundles, e cada alteração substitui o que está armazenado. Ative-o se o seu pipeline deve ser a única fonte de alterações.
Enquanto o modo está ativado, o claude.ai e o Slack recusam:
* Alterar qualquer uma das cinco configurações em um canal, um workspace ou nos padrões do Slack (que nenhuma chave altera também)
* Configurar um canal, remover um canal, adicionar um workspace de um Enterprise Grid conectado ou desconectar um workspace ou um Grid no claude.ai
* Anexar um Bundle a um canal ou workspace, desanexar um, ou excluir um Bundle que esteja anexado a um
Algumas coisas continuam possíveis de qualquer forma: um proprietário ainda pode conectar um novo workspace ou Grid, criar e editar Bundles e alterar configurações do Claude Tag que esta API não gerencia. O primeiro uso do Claude ainda configura um canal, ou um workspace de Grid que não estava configurado, excluir um canal no Slack ainda o remove, e desinstalar o app do Claude para Slack ainda desconecta esse workspace ou Grid.
Enquanto o modo está desativado, configurar no claude.ai um canal que já está configurado pode substituir o registro do canal, mas apenas de um canal que ainda não contém nada: um que o primeiro uso do Claude configurou, ou que esta API configurou sem `settings`, e no qual ninguém desde então armazenou uma configuração ou anexou um Bundle. O canal passa então a ter um novo `id`, e o antigo retorna `404`. Qualquer outro canal mantém seu `id` até ser removido.
### Mensagens diretas em grupo
Uma mensagem direta em grupo do Slack tem um ID no formato de um canal, então o uso do Claude em uma a configura como um canal: ela tem um `id`, é listada e pode ser lida. Configurar uma por meio desta API, alterar uma configuração em uma, anexar um Bundle a uma e remover uma retornam `400`, exceto que uma solicitação de configuração que omite `settings` para uma que já está configurada a retorna com `200`, como uma leitura faz. Desanexar um Bundle de uma é permitido.
## Fluxos de trabalho de exemplo
### Ativar o Claude apenas em canais aprovados
Qualquer membro pode convidar o Claude para um canal público. Para manter o Claude ativado apenas onde você o aprovou:
1. Peça a um proprietário da organização para desativar o Claude em todos os lugares no claude.ai, com o botão **Enable Claude Tag in Slack** em **Default Slack access**, que armazena `enabled` como `false` nos padrões do Slack da sua organização. O [modo somente leitura](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#read-only-mode) deve estar desativado enquanto ele faz isso.
2. Quando seu sistema de aprovação aprovar um canal, [configure o canal](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#set-up-a-channel) com `"settings": {"enabled": true}`. A solicitação aceita os IDs do próprio Slack e retorna o canal mesmo que ele já estivesse configurado, então é seguro repeti-la.
3. Na mesma execução, [anexe](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#attach-a-bundle) os Bundles para os quais a equipe foi aprovada, para que a primeira sessão do canal já tenha suas ferramentas.
### Manter a configuração em controle de versão
1. Identifique sua configuração pelos IDs que o Slack mostra para cada canal e [encontre cada canal](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#find-a-channel-by-its-slack-ids) por eles.
2. Leia cada canal sem `include_inherited` e compare seu `settings` com o que seu repositório declara. Com o parâmetro, valores herdados seriam misturados.
3. Envie apenas as configurações que diferem, e envie `null` para uma configuração que seu repositório não declara mais.
4. Peça a um proprietário da organização para ativar o [modo somente leitura](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#read-only-mode), para que ninguém altere as mesmas configurações manualmente.
### Auditar o que se aplica em todos os lugares
1. [Liste seus workspaces](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#list-workspaces), depois [liste os canais de cada workspace](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#list-channels), ambos com `include_inherited=true`, para que cada item contenha o que se aplica nele. Se sua organização conectou um Enterprise Grid, liste também os canais armazenados sob o próprio ID do Slack do Grid. Consulte [Canais e workspaces configurados](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#set-up-channels-and-workspaces).
2. Sinalize o que sua política proíbe, como um canal em que `enabled` é `true` sem uma aprovação registrada, ou em que `guest_policy` é `allow`.
3. [Liste seus Bundles](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#list-bundles), depois [os destinos de cada Bundle](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#list-a-bundles-targets), para ver onde o acesso a sistemas sensíveis está anexado.
## Canais do Slack
O objeto de canal descreve um canal do Slack:
| Campo | Descrição |
| ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` | `slack_channel`. |
| `id` | Com o prefixo `slch_`. Consulte [IDs](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#ids). |
| `slack` | Os IDs do próprio Slack: `workspace_id` para o workspace em que o canal está e `channel_id` para o canal. |
| `settings` | O que o próprio canal armazena ou, com `include_inherited=true`, o que se aplica nele. Sempre presente, com todas as cinco [configurações](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#settings); uma que não está definida é `null`. Consulte [Valores armazenados e herdados](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#stored-and-inherited-values). |
| `sources` | Para cada configuração, o nível de onde vem o valor em `settings`. Sempre presente. |
| `created_at` | Quando o canal foi configurado. |
| `updated_at` | Quando o registro do canal no Claude Tag mudou pela última vez. Ele muda a cada alteração de uma configuração, aqui, no claude.ai ou no Slack, e também pode mudar por uma alteração que nenhuma resposta aqui mostra. Trate um valor posterior como um motivo para ler o canal novamente, não como prova de que uma configuração mudou. Anexar ou desanexar um Bundle não o altera por si só. |
Um `id` que não é um identificador `slch_` válido retorna `400`. Um válido que não nomeia nenhum canal da sua organização retorna `404`.
### Configurar um canal
`POST /v1/organizations/claude_tag/slack_channels` configura um canal do Slack e o retorna. `slack.workspace_id` e `slack.channel_id` são obrigatórios e são os IDs do próprio Slack. `settings` é opcional e segue [Alterando configurações](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#changing-settings). Se o canal já estiver configurado, a solicitação retorna o canal existente e aplica `settings`; a resposta é `200` em ambos os casos. Requer o escopo `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"
}
```
Antes de um canal ser configurado, o app do Claude para Slack confirma com o Slack que o canal está no workspace, não está arquivado e é visível para o app. Um canal que falha nessa verificação retorna `404`, assim como um workspace que não tem o app do Claude para Slack instalado. Para um workspace do qual sua organização é proprietária por meio de um Enterprise Grid, o app deve estar instalado no Grid.
Configurar o canal e aplicar `settings` são duas etapas. Quando esta solicitação configura o canal e `settings` é então recusado com um `400`, `404` ou `409`, a resposta é a recusa e o canal permanece configurado sem nada armazenado (após um `409`, a menos que a alteração sobreposta o tenha removido ou substituído). Essa recusa carrega um `error_code` que começa com `slack_channel_set_up_` e o `id` do novo canal em `error.details.slack_channel_id` (consulte [Respostas de erro](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#error-responses)). Corrija `settings` e envie-o em uma [atualização](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#update-a-channel) para esse `id`, ou envie a solicitação de configuração novamente. Se o canal já estava configurado, um `settings` recusado retorna o mesmo erro que uma [atualização](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#update-a-channel) retornaria, e o canal mantém o que armazenava. Um `500` ou `503` em qualquer dos casos não carrega `error_code` e não diz se o canal foi configurado ou se `settings` foi armazenado: envie a solicitação de configuração novamente.
### Listar canais
`GET /v1/organizations/claude_tag/slack_channels` lista os canais configurados de um workspace, do mais recente para o mais antigo por `created_at`. `slack_workspace_id` é obrigatório e é o ID do próprio Slack para o workspace. Adicione `include_inherited=true` para que cada canal contenha o que se aplica nele (consulte [Valores armazenados e herdados](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#stored-and-inherited-values)). Uma página pode conter menos de `limit` canais, ou nenhum, enquanto `next_page` ainda estiver definido, então continue solicitando páginas até que `next_page` seja `null` (consulte [Paginação](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#pagination)). Requer o escopo `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"
)
# Busca automaticamente mais páginas conforme necessário.
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',
);
// Apenas esta página; para a próxima, chame list() novamente com 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
```
A resposta é `{"data": [...], "next_page": ...}`, em que cada item é um objeto de canal. Um `slack_workspace_id` que nomeia um workspace do qual sua organização não é proprietária retorna `404`, assim como um do qual ela é proprietária apenas por meio de um Enterprise Grid até que esse workspace seja configurado (consulte [Canais e workspaces configurados](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#set-up-channels-and-workspaces)).
### Encontrar um canal pelos seus IDs do Slack
Adicione `slack_channel_id`, o ID do próprio Slack para o canal, para consultar um canal. `data` contém esse canal, ou fica vazio quando o canal não está configurado. Em um workspace que não está configurado e do qual sua organização é proprietária apenas por meio de um Enterprise Grid, um canal que não está configurado retorna `404` em vez disso. Uma consulta não pagina: ela ignora `page` e qualquer `limit` de 1 a 100 (um `limit` fora desse intervalo ainda retorna `400`), e seu `next_page` é `null`. É assim que você encontra o `id` de um 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
```
Passar um ID `slch_` como `slack_channel_id` retorna `400`.
### Obter um canal
`GET /v1/organizations/claude_tag/slack_channels/{id}` retorna o objeto de canal, contendo o que o canal armazena. Para ler o que se aplica nele em vez disso, consulte [Ler o que se aplica em um canal](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#read-what-applies-in-a-channel). Requer o escopo `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
```
### Ler o que se aplica em um canal
A mesma solicitação com `include_inherited=true` retorna o objeto de canal com `settings` contendo o que se aplica no canal, e `sources` dizendo de onde vem cada valor. [Valores armazenados e herdados](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#stored-and-inherited-values) mostra uma resposta completa; `enabled` e `guest_policy` nunca são `null` nela. Se um nível não puder ser lido, a solicitação falha com `503` em vez de responder sem ele. Requer o escopo `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
```
### Atualizar um canal
`POST /v1/organizations/claude_tag/slack_channels/{id}` altera as configurações do canal e retorna o objeto de canal. `settings` é obrigatório e segue [Alterando configurações](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#changing-settings). Requer o escopo `write:claude_tag`.
Desative o Claude em um canal e deixe suas outras configurações como estão:
```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
```
Limpe as instruções do canal, para que apenas as herdadas se apliquem:
```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() descarta nulls dentro de arrays, então monte o objeto settings para enviar 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
```
### Remover um canal
`DELETE /v1/organizations/claude_tag/slack_channels/{id}` remove um canal do Claude Tag. É a mesma remoção que um proprietário da organização faz no claude.ai, com o mesmo efeito. Ela não exclui, arquiva nem altera o canal no Slack, nem qualquer mensagem nele. Requer o escopo `write:claude_tag`.
A remoção não pode ser desfeita. Ela exclui o que o Claude Tag mantém para o canal:
* suas configurações armazenadas e seus destinos de Bundle
* suas sessões e as respectivas transcrições, incluindo sessões em execução
* sua memória, que é o que o Claude guarda sobre o canal de uma sessão para a próxima
* suas rotinas e os artefatos publicados a partir dele
**Um canal só pode ser removido enquanto o Claude estiver desativado nele.** Enquanto `enabled` for resolvido como `true` para o canal, conforme [Ler o que se aplica em um canal](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#read-what-applies-in-a-channel) o retorna, a solicitação retorna `400` com `error_code: "slack_channel_enabled"`. Defina `enabled` como `false` no canal primeiro e depois envie a solicitação novamente. A única exceção é uma organização com uma [configuração de conformidade restrita](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#error-responses): ela não pode fazer essa alteração, então sua solicitação remove o canal esteja o Claude ativado nele ou não. Se um nível de que essa verificação precisa não puder ser lido, a solicitação retorna `503` e não remove nada.
A verificação protege contra a remoção por engano de um canal que está em uso. Ela não mantém o Claude fora do canal depois. A remoção exclui as configurações próprias do canal, incluindo um `enabled` de `false`, então a partir de então apenas o que o canal herda determina se o Claude está ativado lá. Se isso ativar o Claude, o Claude volta a responder no canal na próxima menção, e esse uso configura o canal novamente: um novo `id`, sem configurações próprias e sem nada da memória do canal removido.
* Para manter o Claude fora de um canal, mantenha-o configurado com `enabled` definido como `false` em vez de removê-lo, ou certifique-se de que o que ele herdaria, que a remoção não afeta, mantém o Claude desativado.
* Para que um canal não armazene nada e mantenha suas sessões e memória, limpe cada configuração e desanexe cada Bundle em vez disso.
Dois tipos de canal não podem ser removidos aqui de forma alguma, esteja o Claude ativado ou desativado neles, e retornam `400` sem `error_code`: uma [mensagem direta em grupo](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#group-direct-messages) e um canal que contém configuração que esta API não gerencia, como um pool de runners ou uma configuração que apenas o claude.ai tem. Eles são verificados antes de `enabled`, então desativar o Claude não ajuda; um proprietário da organização remove o segundo tipo no 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"
}
```
O `id` retorna `404` assim que a solicitação retorna, e o restante é excluído em segundo plano. Uma remoção repetida retorna `404`, então, se você reenviar uma remoção após um `503`, um `404` significa que o canal já não existe.
## Workspaces do Slack
O objeto de workspace descreve um workspace do Slack. Ele tem os mesmos campos que o [objeto de canal](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#slack-channels), exceto que `type` é `slack_workspace`, `id` tem o prefixo `slws_` e `slack` contém apenas `workspace_id`. A resposta do [Início rápido](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#quick-start) mostra um completo. Lido com `include_inherited=true`, um workspace mostra cada configuração conforme o workspace e os padrões do Slack a resolvem, que é o que um canal do workspace herda, a menos que um nível mais próximo defina essa configuração.
Um `id` que não é um identificador `slws_` válido retorna `400`. Um válido que não nomeia nenhum workspace da sua organização retorna `404`.
### Listar workspaces
`GET /v1/organizations/claude_tag/slack_workspaces` lista os workspaces configurados dos quais sua organização é proprietária, do mais recente para o mais antigo por `created_at`. O [Início rápido](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#quick-start) mostra a solicitação e a resposta. Para encontrar um workspace pelo ID do próprio Slack, adicione `slack_workspace_id`: `data` contém esse workspace, ou fica vazio quando ele não está configurado, e um workspace do qual sua organização não é proprietária retorna `404`. Um workspace do qual ela é proprietária apenas por meio de um Enterprise Grid também retorna `404` até ser configurado. Adicione `include_inherited=true` para que cada workspace contenha o que se aplica nele (consulte [Valores armazenados e herdados](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#stored-and-inherited-values)). Requer o escopo `read:claude_tag`.
### Obter um workspace
`GET /v1/organizations/claude_tag/slack_workspaces/{id}` retorna o objeto de workspace, contendo o que o workspace armazena ou, com `include_inherited=true` na consulta, como em [Ler o que se aplica em um canal](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#read-what-applies-in-a-channel), o que se aplica nele. Requer o escopo `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
```
### Atualizar um workspace
`POST /v1/organizations/claude_tag/slack_workspaces/{id}` altera as configurações do workspace e retorna o objeto de workspace. `settings` é obrigatório e segue [Alterando configurações](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#changing-settings). O que você define aqui se aplica em todos os canais do workspace que não definem seu próprio valor, exceto `instructions`, ao qual cada canal adiciona o seu próprio em vez de substituí-lo. Requer o escopo `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
Um Bundle é o que o claude.ai chama de [Access bundle](https://claude.com/docs/claude-tag/admins/add-connections): um conjunto nomeado de acessos, como conectores, repositórios e credenciais, que o Claude pode usar em um canal ou workspace. Proprietários da organização criam, editam e excluem Bundles no claude.ai. Esta API os lista e os anexa. Ela retorna o nome e a descrição de um Bundle e nunca o que o Bundle concede.
| Campo | Descrição |
| -------------------------- | --------------------------------------------------------- |
| `type` | `bundle`. |
| `id` | Com prefixo `capp_`. |
| `display_name` | O nome do Bundle. |
| `description` | Para que serve o Bundle. `null` quando não tem descrição. |
| `created_at`, `updated_at` | Quando o Bundle foi criado e alterado pela última vez. |
Um `bundle_id` que não é um identificador `capp_` válido retorna `400`. Um válido que não existe ou pertence a outra organização retorna `404`, independentemente do que mais a solicitação contenha. Bundles que o Claude Tag gerencia para si mesmo não são listados e retornam `404`.
### Listar Bundles
`GET /v1/organizations/claude_tag/bundles` lista os Bundles da sua organização, do mais recente para o mais antigo por `created_at`. Requer o escopo `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()
# Busca automaticamente mais páginas conforme necessário.
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();
// Apenas esta página; para a próxima, chame list() novamente com 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
}
```
### Obter um Bundle
`GET /v1/organizations/claude_tag/bundles/{bundle_id}` retorna o objeto Bundle. Requer o escopo `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
```
## Destinos de Bundle
Um destino de Bundle é o registro de um Bundle anexado a um canal ou a um workspace. Um Bundle anexado a um workspace pode ser usado no workspace e em todos os canais dele. Um Bundle anexado a um canal pode ser usado apenas nesse canal.
| Campo | Descrição |
| -------------------- | ------------------------------------------------------------------------------------------------------ |
| `type` | `slack_channel` ou `slack_workspace`. |
| `id` | Com prefixo `btgt_`. É o `{target_id}` nos caminhos e nunca é o próprio `id` do canal ou do workspace. |
| `slack_channel_id` | Em um destino `slack_channel`: o `id` do canal, com prefixo `slch_`. |
| `slack_workspace_id` | Em um destino `slack_workspace`: o `id` do workspace, com prefixo `slws_`. |
| `created_at` | Quando o Bundle foi anexado. |
Um Bundle é anexado a um canal ou workspace no máximo uma vez, e o mesmo par sempre tem o mesmo `id`, inclusive após uma desanexação e uma nova anexação. O `id` é opaco: obtenha-o da resposta a uma anexação ou da lista. Um destino de Bundle não contém o `id` do seu Bundle, que seus caminhos também exigem, portanto mantenha os dois juntos.
Anexar ou desanexar não altera nenhuma configuração armazenada. As sessões em execução no canal ou workspace são informadas de que seu acesso mudou.
O Bundle que o claude.ai anexa como parte de uma configuração de plantão (on-call) é listado e pode ser lido, mas não pode ser anexado nem desanexado aqui, e nada pode ser anexado a um canal ou workspace que uma configuração de plantão gerencia, nem desanexado dele. Cada uma dessas requisições retorna `400`.
### Listar os destinos de um Bundle
`GET /v1/organizations/claude_tag/bundles/{bundle_id}/targets` lista os canais e workspaces aos quais o Bundle está anexado, do mais recente para o mais antigo por `created_at`. Requer o escopo `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"
)
# Busca automaticamente mais páginas conforme necessário.
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',
);
// Apenas esta página; para a próxima, chame list() novamente com 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
}
```
Apenas anexações a canais e workspaces são listadas. Um Bundle que está anexado no claude.ai a qualquer outra coisa, como **Default Slack access**, não tem um destino de Bundle para isso, e o mesmo vale para uma regra que aplica um Bundle em muitos canais de uma vez. Portanto, os Bundles que o Claude pode usar em um canal podem ser mais do que os destinos que o identificam. Nenhum endpoint lista os Bundles anexados a um canal ou workspace.
### Anexar um Bundle
`POST /v1/organizations/claude_tag/bundles/{bundle_id}/targets` anexa o Bundle e retorna o destino de Bundle. O corpo informa o `type` e o `id` correspondente. O canal ou workspace já deve estar configurado: anexar nunca configura um canal. Anexar um par que já está anexado retorna `200` com o destino de Bundle existente. Requer o escopo `write:claude_tag`.
Anexe um Bundle a um 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"
}
```
Anexe um Bundle a um workspace:
```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
```
Uma anexação a um canal tem condições sob as quais se aplica, como apenas enquanto nenhum convidado do Slack estiver no canal. As condições são definidas no claude.ai e não são retornadas aqui. Anexar por meio desta API usa as condições padrão, e anexar um par que já está anexado mantém suas condições inalteradas.
### Obter um destino de Bundle
`GET /v1/organizations/claude_tag/bundles/{bundle_id}/targets/{target_id}` retorna o destino de Bundle. Um `target_id` que não é um identificador `btgt_` válido retorna `400`. Um válido que pertence a outro Bundle, foi desanexado ou nomeia um canal ou workspace que não está mais configurado retorna `404`. Requer o escopo `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
```
### Desanexar um Bundle
`DELETE /v1/organizations/claude_tag/bundles/{bundle_id}/targets/{target_id}` desanexa o Bundle. Uma desanexação repetida retorna `404`, então, após um `503`, uma desanexação reenviada que retorna `404` significa que o destino de Bundle já não existe. Requer o escopo `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"
}
```
## Valores não reconhecidos
`guest_policy.type`, o `type` de uma origem, o `type` de um destino de Bundle e os códigos de erro podem ganhar novos valores a qualquer momento. Trate um valor que você não reconhece como trataria qualquer string desconhecida, em vez de falhar.
## Limitação de taxa
As solicitações são limitadas para cada organização, em dois orçamentos que todas as chaves da sua organização compartilham e que são separados dos outros limites da Admin API da sua organização. Cada orçamento permite um pico e depois é reabastecido a uma taxa constante:
| Orçamento | Requisições | Pico | Reabastecimento |
| ---------- | ---------------------- | ---- | --------------- |
| Leituras | Todo `GET` | 120 | 2 por segundo |
| Alterações | Todo `POST` e `DELETE` | 60 | 1 por segundo |
Solicitações acima de um orçamento retornam **429 Too Many Requests** com um cabeçalho `retry-after`: aguarde esse número de segundos e depois envie a solicitação novamente. Uma solicitação que chegou até seu orçamento, qualquer que seja seu resultado, recebe os cabeçalhos `anthropic-ratelimit-requests-limit`, `anthropic-ratelimit-requests-remaining` e `anthropic-ratelimit-requests-reset` para esse orçamento; uma solicitação recusada antes disso, por exemplo por causa de sua chave, escopo ou cabeçalhos, ou porque a API, as alterações ou o novo armazenamento não estão habilitados para sua organização, não recebe nenhum.
## Paginação
Os endpoints de lista usam um **cursor opaco**. A primeira solicitação retorna até `limit` linhas mais um cursor `next_page`; passe o cursor sem alterações como o parâmetro `page` na próxima solicitação, com os outros parâmetros de consulta inalterados, e repita até que `next_page` seja `null`. Um cursor enviado com o outro valor de `include_inherited` em relação à solicitação que o retornou retorna `400`. Trate a string do cursor como opaca: não a analise, modifique ou construa você mesmo. [Listar canais](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#list-channels) pode retornar uma página com menos de `limit` canais, ou nenhum, enquanto `next_page` ainda estiver definido, então continue solicitando páginas até que `next_page` seja `null`. Os iteradores de lista dos SDKs de Python, TypeScript, C#, Go, Java e Ruby e a CLI (exceto com `--format raw`) fazem isso por você. Em PHP e curl, solicite cada página você mesmo e passe seu `next_page` como `page`.
`limit` tem como padrão 20, com mínimo de 1 e máximo de 100; um valor fora desse intervalo retorna `400` em todas as listas. Todas as listas são ordenadas da mais recente para a mais antiga por `created_at`, e não aceitam outra ordem.
## Respostas de erro
As respostas de erro seguem o formato padrão documentado em [Erros da Claude API](https://platform.claude.com/docs/pt-BR/api/errors). Informe o `request_id` do corpo da resposta ao entrar em contato com o suporte.
| Status | Significado |
| ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 400 | Entrada inválida, ou a operação não se aplica a este canal, workspace ou Bundle (consulte a seção de cada endpoint). |
| 401 | Cabeçalho `x-api-key` ausente, ou a chave não é reconhecida. |
| 403 | A chave não é uma chave com escopo no nível da organização, não tem o escopo necessário ou sua organização não pode fazer essa alteração. |
| 404 | Recurso não encontrado, ou não pertence à sua organização. Também retornado quando a solicitação omite o valor `anthropic-beta`, ou a API não está habilitada para sua organização, de modo que os endpoints parecem inexistentes. |
| 409 | Outra coisa alterou ou removeu o recurso enquanto a solicitação era executada. Nada do que a solicitação pediu foi feito: nenhuma configuração armazenada, nada anexado, desanexado ou removido. A única exceção é uma solicitação de configuração, que pode ter configurado o canal antes que seu `settings` encontrasse o conflito (`slack_channel_set_up_settings_conflict`). Leia o recurso novamente e reenvie a solicitação se ela ainda for necessária. |
| 429 | "Rate limit" (limite de taxa) excedido. Consulte [Limitação de taxa](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#rate-limiting). |
| 500 | Erro interno. |
| 503 | Temporário. Em uma alteração, não diz se a alteração foi armazenada. Toda alteração é segura para repetir, então envie a solicitação novamente sem alterações. Se um `DELETE` reenviado retornar `404`, o canal ou o destino de Bundle já não existe. |
Quando um status tem várias causas que você trataria de forma diferente, o erro também contém `error.details.error_code`:
```json
{
"type": "error",
"error": {
"type": "invalid_request_error",
"message": "...",
"details": {
"error_code": "slack_channel_set_up_settings_refused",
"slack_channel_id": "slch_011CZkZmRt4vNq8sHbYw2KdX"
}
},
"request_id": "req_018EeWyXxfu5pfWkrYcMdjWG"
}
```
| `error_code` | Status | Significado e o que fazer |
| -------------------------------------------- | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `organization_level_scoped_api_key_required` | 403 | A credencial não é uma chave de API de Admin com escopo que pertence à organização como um todo. Peça uma ao seu proprietário principal. |
| `api_key_scope_missing` | 403 | A chave não tem `read:claude_tag` ou `write:claude_tag`, conforme o endpoint exigir. |
| `claude_tag_writes_not_enabled` | 403 | Sua organização pode ler por meio desta API, mas não está habilitada para alterações. |
| `compliance_configuration_restricted` | 403 | Sua organização tem uma configuração de conformidade sob a qual o Claude Tag não armazena nada novo, como retenção zero de dados. Configurar um canal, atualizar configurações (mesmo para limpá-las) e anexar um Bundle são recusados. Desanexar um Bundle e remover um canal não são, e tal organização pode [remover](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#remove-a-channel) um canal mesmo enquanto o Claude estiver ativado nele. |
| `environment_not_found` | 404 | `environment_id` não nomeia nenhum ambiente que sua organização possa usar aqui. O `id` no caminho está correto. |
| `environment_archived` | 400 | `environment_id` nomeia um ambiente arquivado. |
| `slack_channel_set_up_settings_refused` | 400 | A solicitação configurou o canal, depois `settings` foi recusado. `details.slack_channel_id` é o canal. Consulte [Configurar um canal](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#set-up-a-channel). |
| `slack_channel_set_up_environment_not_found` | 404 | A solicitação configurou o canal, depois `environment_id` não foi encontrado. `details.slack_channel_id` é o canal. Consulte [Configurar um canal](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#set-up-a-channel). |
| `slack_channel_set_up_settings_conflict` | 409 | A solicitação configurou o canal, depois outra alteração se sobrepôs a `settings`. Nada de `settings` foi armazenado. `details.slack_channel_id` é o canal. Consulte [Configurar um canal](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#set-up-a-channel). |
| `slack_channel_enabled` | 400 | O Claude está ativado no canal (`enabled` é resolvido como `true`), então ele não pode ser removido. Defina `enabled` como `false` primeiro. Consulte [Remover um canal](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#remove-a-channel). |
Novos códigos podem ser adicionados. Trate um código que você não reconhece da mesma forma que trata seu status. Um `404` sem `error_code` tem uma de duas causas. Ou algo que a solicitação nomeia não foi encontrado (um `id` no caminho, ou um canal ou workspace do Slack no corpo ou na consulta), ou todos os endpoints parecem inexistentes porque a solicitação omite o valor `anthropic-beta` ou a API não está habilitada para sua organização. Para distingui-las, [liste seus workspaces](https://platform.claude.com/docs/pt-BR/manage-claude/claude-tag-api#list-workspaces) com a mesma chave e os mesmos cabeçalhos: essa solicitação não nomeia nada, então retorna `404` apenas no segundo caso.
## Eventos do Activity Feed
Toda alteração feita por meio desta API é registrada no [Compliance API Activity Feed](https://platform.claude.com/docs/pt-BR/manage-claude/compliance-activity-feed) da sua organização, atribuída à chave de API como um `api_actor` que contém seu ID `apikey_`. Os eventos são os mesmos que o feed registra quando a mesma alteração é feita no claude.ai, de modo que uma única consulta encontra uma alteração independentemente da forma como ela foi feita.
| Evento | Emitido quando |
| --------------------------------- | ------------------------------------------------------------------------------------------ |
| `ccr_agent_created` | Um canal é configurado. |
| `ccr_agent_updated` | Uma configuração muda em um canal ou workspace. |
| `ccr_agent_deleted` | Um canal é removido. Seus destinos de Bundle vão junto e não emitem nenhum evento próprio. |
| `ccr_agent_proxy_profile_bound` | Um Bundle é anexado. |
| `ccr_agent_proxy_profile_unbound` | Um Bundle é desanexado. |
Os eventos nomeiam um canal ou workspace por um identificador próprio do feed, `agent_id` (com o prefixo `cagt_`), que nenhuma resposta desta API contém, então você ainda não pode associar um evento ao `id` de um canal ou workspace. Os dois eventos de Bundle nomeiam o Bundle em `profile_id` e o canal ou workspace, pelo mesmo `agent_id`, em `scope_id`.
Um evento `ccr_agent_updated` lista o que mudou em `updated_fields`, usando os nomes do próprio feed:
| Configuração | Nome em `updated_fields` |
| ---------------- | ------------------------ |
| `enabled` | `slackbot_version` |
| `instructions` | `system_prompt_addendum` |
| `model` | `default_model` |
| `environment_id` | `default_environment_id` |
| `guest_policy` | `guest_policy` |
`updated_fields` também pode conter `is_virtual`, que não nomeia nenhuma configuração. Ele aparece ao lado dos nomes das configurações alteradas no evento de uma alteração por meio desta API que é a primeira coisa que alguém armazena no canal ou workspace: um canal que o primeiro uso do Claude configurou, ou que esta API configurou sem `settings`, ou um workspace em que o Claude nunca foi usado, e no qual ninguém ainda armazenou uma configuração ou anexou um Bundle, aqui ou no claude.ai. O `model` com que um canal de código começa não conta como armazenado. Anexar um Bundle registra apenas `ccr_agent_proxy_profile_bound`.
Leituras, requisições que não alteram nada e requisições recusadas antes que qualquer coisa seja armazenada não registram nada. Uma requisição de configuração que configura um canal e cujo `settings` é então recusado registra `ccr_agent_created`.
## Veja também
Onde o proprietário principal da sua organização cria uma chave com escopo.
O que é o Claude Tag, como configurá-lo e o que cada configuração faz no Slack.
A trilha de auditoria de todas as alterações feitas aqui e no claude.ai.
Gerencie os plugins da sua organização Claude Enterprise.