---
title: API de Claude Tag
url: https://platform.claude.com/docs/es/manage-claude/claude-tag-api
description: "Administra Claude Tag en Slack para tu organización de Claude Enterprise desde tus propios sistemas: lee y cambia la configuración de canales, espacios de trabajo y los valores predeterminados de Slack de tu organización, consulta qué configuración se aplica y por qué, y vincula Access bundles."
---
[Claude Tag](https://claude.com/docs/claude-tag/overview) es Claude trabajando como un compañero de equipo en Slack: alguien menciona a Claude en un canal y Claude responde en el hilo. La API de Claude Tag te permite leer y cambiar, desde tus propios sistemas, la configuración de Claude Tag que, de otro modo, un propietario de la organización establece manualmente en [claude.ai > Organization settings > Claude Tag](https://claude.ai/admin-settings/claude-tag). Úsala para activar Claude canal por canal desde un flujo de aprobación, mantener tu configuración en control de versiones o auditar lo que se aplica en cada canal.
Claude Tag es un producto de claude.ai. Esta API lo administra para una organización de Claude Enterprise y no tiene nada que ver con los espacios de trabajo de Claude Platform, el uso de la API ni la Claude Console.
**Se requiere una clave de API de administrador con alcance**
Estos endpoints requieren una clave de API de administrador con el alcance `read:claude_tag` (para los endpoints `GET`) o el alcance `write:claude_tag` (para los endpoints `POST` y `DELETE`); consulta [Alcances](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#scopes). Consulta [Crear una clave de API de administrador](https://platform.claude.com/docs/es/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization) para saber dónde la crea tu propietario principal. Pasa la clave en el encabezado `x-api-key` en cada solicitud, junto con el encabezado [`anthropic-version`](https://platform.claude.com/docs/es/api/versioning) y el encabezado beta que se muestra en la siguiente nota.
La API de Claude Tag está en **beta** y solo está disponible para organizaciones de Claude Enterprise. No está disponible para organizaciones de Claude Platform (Claude Console).
Cada solicitud debe incluir el [encabezado beta](https://platform.claude.com/docs/es/api/beta-headers) `anthropic-beta: claude-tag-2026-09-28` (el SDK y la CLI `ant` lo envían por ti). Una solicitud sin él devuelve `404`, exactamente como si el endpoint no existiera.
## Endpoints
La API expone 18 endpoints en cinco recursos:
| Recurso | Endpoints |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Canales de Slack:** dar de alta un canal, listar los canales de un espacio de trabajo o encontrar uno por sus ID de Slack, leer uno, cambiar su configuración, ver qué se aplica en él, eliminarlo | `POST /v1/organizations/claude_tag/slack_channels`
`GET /v1/organizations/claude_tag/slack_channels`
`GET /v1/organizations/claude_tag/slack_channels/{id}`
`POST /v1/organizations/claude_tag/slack_channels/{id}`
`GET /v1/organizations/claude_tag/slack_channels/{id}/effective`
`DELETE /v1/organizations/claude_tag/slack_channels/{id}` |
| **Espacios de trabajo de Slack:** listar tus espacios de trabajo conectados o encontrar uno por su ID de Slack, leer uno, cambiar su configuración, ver qué se aplica en él | `GET /v1/organizations/claude_tag/slack_workspaces`
`GET /v1/organizations/claude_tag/slack_workspaces/{id}`
`POST /v1/organizations/claude_tag/slack_workspaces/{id}`
`GET /v1/organizations/claude_tag/slack_workspaces/{id}/effective` |
| **Valores predeterminados de Slack:** leer y cambiar la configuración que se aplica a cada espacio de trabajo y canal | `GET /v1/organizations/claude_tag/slack_defaults`
`POST /v1/organizations/claude_tag/slack_defaults` |
| **Bundles:** listar los Access bundles de tu organización, leer uno (solo lectura) | `GET /v1/organizations/claude_tag/bundles`
`GET /v1/organizations/claude_tag/bundles/{bundle_id}` |
| **Destinos de Bundle:** listar dónde está vinculado un Bundle, vincularlo a un canal o espacio de trabajo, leer una vinculación, desvincularlo | `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 versión cubre Slack. Conectar y desconectar un espacio de trabajo de Slack, crear y editar Access bundles, los límites de gasto y toda configuración de Claude Tag distinta de las cinco de [Configuración](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#settings) permanecen en claude.ai.
## Requisitos previos
* Tu organización debe tener un plan Claude Enterprise, con [Claude Tag configurado](https://claude.com/docs/claude-tag/admins/setup-overview) y al menos un espacio de trabajo de Slack conectado.
* Tu propietario principal crea una clave de API de administrador con el alcance `read:claude_tag`, el alcance `write:claude_tag` o ambos en [claude.ai > Organization settings > API](https://claude.ai/admin-settings/api-access). Consulta [Crear una clave de API de administrador](https://platform.claude.com/docs/es/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization).
* Cada solicitud lleva tres encabezados: `x-api-key`, `anthropic-version: 2023-06-01` y `anthropic-beta: claude-tag-2026-09-28`.
Los SDK de Python, TypeScript, C#, Go, Java, PHP y Ruby exponen estos endpoints en `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`), y la [CLI `ant`](https://platform.claude.com/docs/es/cli-sdks-libraries/cli/quickstart) en `ant beta:organization:claude-tag`; envían los encabezados `anthropic-version` y `anthropic-beta` por ti. Los ejemplos de esta página usan el cliente predeterminado de cada SDK, que, al igual que la CLI, lee la clave de API de administrador de la variable de entorno `ANTHROPIC_API_KEY`; los ejemplos de curl leen la clave de la misma variable y la pasan en el encabezado `x-api-key`. Cuando un SDK o la CLI obtienen más páginas por ti, `limit` establece el tamaño de página, no el total (consulta [Paginación](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#pagination)).
Las claves de API pertenecen a la organización y siguen funcionando después de que la persona que las creó se va. No las compartas ni las incluyas en el control de código fuente.
## Inicio rápido
Lista los espacios de trabajo de Slack que tu organización ha conectado a 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: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-workspaces list
```
```python Python
client = anthropic.Anthropic()
workspaces = client.beta.organization.claude_tag.slack_workspaces.list()
# Obtiene automáticamente más páginas según sea necesario.
for workspace in workspaces:
print(f"{workspace.id}: {workspace.slack.team_id}")
```
```typescript TypeScript
const client = new Anthropic();
const workspaces = await client.beta.organization.claudeTag.slackWorkspaces.list();
for await (const workspace of workspaces) {
console.log(`${workspace.id}: ${workspace.slack.team_id}`);
}
```
```csharp C#
AnthropicClient client = new();
var page = await client.Beta.Organization.ClaudeTag.SlackWorkspaces.List();
await foreach (var workspace in page.Paginate())
{
Console.WriteLine($"{workspace.ID}: {workspace.Slack.TeamID}");
}
```
```go Go
client := anthropic.NewClient()
workspaces := client.Beta.Organization.ClaudeTag.SlackWorkspaces.ListAutoPaging(
context.Background(),
anthropic.BetaOrganizationClaudeTagSlackWorkspaceListParams{},
)
for workspaces.Next() {
workspace := workspaces.Current()
fmt.Printf("%s: %s\n", workspace.ID, workspace.Slack.TeamID)
}
if err := workspaces.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var workspaces = client.beta().organization().claudeTag().slackWorkspaces().list();
for (var workspace : workspaces.autoPager()) {
IO.println(workspace.id() + ": " + workspace.slack().teamId());
}
```
```php PHP
$client = new Client();
$workspaces = $client->beta->organization->claudeTag->slackWorkspaces->list();
// Solo esta página; para la siguiente, vuelve a llamar a list() con page: $workspaces->nextPage.
foreach ($workspaces->getItems() as $workspace) {
echo "{$workspace->id}: {$workspace->slack->teamID}\n";
}
```
```ruby Ruby
client = Anthropic::Client.new
page = client.beta.organization.claude_tag.slack_workspaces.list
page.auto_paging_each do |workspace|
puts "#{workspace.id}: #{workspace.slack.team_id}"
end
```
```json Response
{
"data": [
{
"type": "slack_workspace",
"id": "slws_011CZkZnWa7xPc3uJfZe5LgT",
"slack": {
"team_id": "T01ABCD2EFG"
},
"settings": {
"enabled": null,
"instructions": "Answer in English unless asked otherwise.",
"model": null,
"environment_id": null,
"guest_policy": null
},
"agent_id": "cagt_011CZkZrFy4aSg8uMkDt9PqW",
"created_at": "2026-09-02T17:04:11Z",
"updated_at": "2026-10-06T09:41:53Z"
}
],
"next_page": null
}
```
Una configuración que es `null` no está establecida en este espacio de trabajo, por lo que el espacio de trabajo la hereda. Consulta [Configuración almacenada y efectiva](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#stored-and-effective-settings).
## Alcances
| Alcance | Otorga |
| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------- |
| `read:claude_tag` | Todos los endpoints `GET` de esta página. |
| `write:claude_tag` | Todos los endpoints `POST` y `DELETE` de esta página. No otorga lecturas, aunque la respuesta a un cambio contiene el recurso modificado. |
Una clave puede tener ambos alcances. Una integración que busca un canal y luego lo cambia necesita ambos. Ningún otro alcance otorga acceso a estos endpoints.
La clave debe pertenecer a la organización en su conjunto. La organización es siempre aquella a la que pertenece la clave, y ninguna solicitud nombra una. Una solicitud que envía el encabezado `anthropic-workspace-id` devuelve `400`, porque nada aquí pertenece a un espacio de trabajo de Claude Platform.
## Conceptos clave
### Nombres en esta página y en claude.ai
| Esta API | claude.ai y Slack |
| -------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Espacio de trabajo de Slack | Un espacio de trabajo de Slack (que Slack también llama team). No tiene relación con un espacio de trabajo de Claude Platform, cuyos ID comienzan con `wrkspc_`. |
| Valores predeterminados de Slack | **Default Slack access** |
| Nivel de configuración | Un [alcance](https://claude.com/docs/claude-tag/admins/customize): un canal, un espacio de trabajo o los valores predeterminados de Slack |
| Bundle | Un [Access bundle](https://claude.com/docs/claude-tag/concepts/glossary#access-bundle) |
| `enabled` | El interruptor **Enable Claude Tag in Slack** |
| `instructions` | **Custom instructions** |
| `model` | **Model** |
| `environment_id` | **Environment** |
| `guest_policy` | **How should Claude work in channels with guests**: `restrict` es **Restrict**, `channel_only` es **Channel only** y `allow` es **Full access** |
### Canales y espacios de trabajo dados de alta
Un canal o espacio de trabajo está **dado de alta** (set up) cuando Claude Tag tiene un registro de configuración para él. Solo un canal o espacio de trabajo dado de alta tiene un `id`, y solo esos se listan: Slack, no esta API, tiene la lista completa de los canales de un espacio de trabajo.
* Un **espacio de trabajo** se da de alta cuando un propietario de la organización lo conecta en claude.ai. Ningún endpoint da de alta ni elimina un espacio de trabajo.
* Un **canal** se da de alta en claude.ai, con el primer uso de Claude en él, o con [Dar de alta un canal](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#set-up-a-channel).
* Los **valores predeterminados de Slack** se dan de alta la primera vez que alguien configura Claude Tag: un propietario conecta un espacio de trabajo de Slack, o un miembro inicia sesión o usa Claude por primera vez en Slack.
Tu organización es propietaria de un espacio de trabajo mientras su conexión está activa, y es propietaria de los canales que contiene. Un canal o espacio de trabajo del que no eres propietario devuelve el mismo `404` que uno que no existe.
### ID
Conoces un canal por los ID que Slack te muestra. Busca su `id` una vez con [Encontrar un canal por sus ID de Slack](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#find-a-channel-by-its-slack-ids), y luego almacena y usa el `id`.
| ID | Prefijo | Dónde aparece |
| -------------------------------------- | --------- | ---------------------------------------------------------------------------------------- |
| Recurso de canal de Slack | `slch_` | `id` en un canal; `slack_channel_id` en cuerpos de solicitud y respuestas |
| Recurso de espacio de trabajo de Slack | `slws_` | `id` en un espacio de trabajo; `slack_workspace_id` en cuerpos de solicitud y respuestas |
| Bundle | `capp_` | `id` en un Bundle; `{bundle_id}` en rutas |
| Destino de Bundle | `btgt_` | `id` en un destino de Bundle; `{target_id}` en rutas |
| ID de team propio de Slack | `T` | `slack.team_id`; el parámetro de consulta `slack_team_id` |
| ID de canal propio de Slack | `C` o `G` | `slack.channel_id`; el parámetro de consulta `slack_channel_id` |
`slack_channel_id` significa dos cosas. En un **parámetro de consulta** es el ID propio de Slack (`C05HJKL6MNP`). En un **cuerpo de solicitud o una respuesta** es el `id` que emite esta API (`slch_...`). Los ID propios de Slack en un cuerpo o una respuesta siempre están bajo `slack`.
Un `id` no cambia mientras el canal o espacio de trabajo esté dado de alta, sin importar lo que cambies en él, con una excepción descrita en [Modo de solo lectura](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#read-only-mode). Un canal o espacio de trabajo que se elimina y se vuelve a dar de alta tiene un `id` nuevo, y el anterior sigue devolviendo `404`. Cuando un `id` almacenado devuelve `404` sin `error_code`, [obtén los valores predeterminados de Slack](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#get-the-slack-defaults) con la misma clave y los mismos encabezados. Esa solicitud no nombra ningún canal ni espacio de trabajo, así que cualquier estado distinto de `404` significa que el `id` ya no existe: vuelve a encontrar el canal o espacio de trabajo por sus ID de Slack. Si esa solicitud también devuelve `404`, eso no dice nada sobre el `id`: conserva tus valores de `id` almacenados y consulta [Respuestas de error](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#error-responses).
`agent_id` (con el prefijo `cagt_`) es la forma en que la [Compliance API](https://platform.claude.com/docs/es/manage-claude/compliance-api) nombra el mismo canal o espacio de trabajo, tanto como propietario de las sesiones que Claude ejecutó allí como en los [eventos del Activity Feed](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#activity-feed-events). Dura tanto como el `id`.
### Configuración
Cada nivel de configuración almacena las mismas cinco configuraciones, todas opcionales:
| Configuración | Tipo | Descripción |
| ---------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `enabled` | boolean | Si Claude está activado. |
| `instructions` | string | Orientación permanente que Claude lee en cada sesión. Como máximo 8,192 caracteres después de recortar los espacios en blanco iniciales y finales. Un texto en blanco borra la configuración. |
| `model` | string | El modelo con el que comienzan las nuevas sesiones: un [ID de modelo](https://platform.claude.com/docs/es/models/overview) que tu organización puede usar con Claude Tag. Como máximo 128 caracteres. |
| `environment_id` | string | El entorno en la nube en el que se ejecutan las sesiones, con el prefijo `env_`. Debe estar activo y pertenecer a tu organización. |
| `guest_policy` | object | Lo que hace Claude en un canal mientras hay un invitado de Slack en él, para todos en el canal: `{"type": "allow"}` (Claude responde), `{"type": "restrict"}` (Claude no responde) o `{"type": "channel_only"}` (Claude responde solo con los Bundles vinculados al propio canal). Consulta [Restringir canales con invitados](https://claude.com/docs/claude-tag/admins/restrict-access#restrict-guest-channels) para saber qué significa en canales compartidos mediante Slack Connect o en un Enterprise Grid. |
`model` y `environment_id` se verifican cuando los escribes y no se vuelven a verificar: si el modelo o el entorno cambian más adelante, ambas vistas siguen devolviendo el valor almacenado.
Si un propietario de la organización ha asignado un nivel de configuración a un grupo de runners autoalojados en claude.ai, su `environment_id` devuelve el ID del grupo, que comienza con `ccpool_`. Esta API no puede establecer un grupo de runners y devuelve `400` para una solicitud que cambia o borra `environment_id` en un nivel de configuración que almacena uno.
### Configuración almacenada y efectiva
La configuración existe en tres niveles: el canal, el espacio de trabajo en el que está el canal y los valores predeterminados de Slack de tu organización. Cada nivel almacena solo lo que se estableció en él. La API te ofrece dos vistas:
* La vista **almacenada** ([Obtener un canal](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#get-a-channel), [Obtener un espacio de trabajo](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#get-a-workspace)) contiene lo que almacena el propio canal o espacio de trabajo. Una configuración que no está establecida allí es `null`. Úsala para comparar con la configuración que mantienes en otro lugar.
* La vista **efectiva** ([Obtener la configuración efectiva de un canal](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#get-a-channels-effective-settings), [Obtener la configuración efectiva de un espacio de trabajo](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#get-a-workspaces-effective-settings)) contiene lo que se aplica una vez que se tienen en cuenta todos los niveles, y `sources` nombra el nivel del que proviene cada valor. Úsala para auditar o para averiguar por qué Claude se comporta como lo hace en un canal.
Cada configuración se resuelve por separado:
| Configuración | Regla | Cuando ningún nivel la establece |
| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
| `enabled` | Decide el nivel más cercano que la establece, por lo que `true` en un canal activa Claude allí incluso cuando su espacio de trabajo almacena `false`. | `true` |
| `instructions` | Aditiva. El texto de cada nivel que la establece se une, del más amplio al más específico, con una línea en blanco entre ellos. | `null` |
| `model` | Decide el nivel más cercano que la establece. | `null`: Claude usa el modelo predeterminado del producto |
| `environment_id` | Decide el nivel más cercano que la establece. | `null` |
| `guest_policy` | Decide el nivel más cercano que la establece. | `restrict` en una organización cuyos valores predeterminados de Slack están dados de alta |
Por ejemplo, una organización almacena instrucciones en sus valores predeterminados de Slack, desactiva Claude en un espacio de trabajo y establece un modelo en un canal de ese espacio de trabajo. La vista efectiva del canal muestra los tres valores y de dónde proviene cada uno:
```json
{
"type": "slack_channel_effective",
"id": "slch_011CZkZmRt4vNq8sHbYw2KdX",
"settings": {
"enabled": false,
"instructions": "Be brief.",
"model": "claude-opus-5-5",
"environment_id": null,
"guest_policy": { "type": "restrict" }
},
"sources": {
"enabled": {
"type": "slack_workspace",
"slack_workspace_id": "slws_011CZkZnWa7xPc3uJfZe5LgT"
},
"instructions": [{ "type": "slack_defaults" }],
"model": {
"type": "slack_channel",
"slack_channel_id": "slch_011CZkZmRt4vNq8sHbYw2KdX"
},
"environment_id": { "type": "default" },
"guest_policy": { "type": "default" }
}
}
```
Una fuente es una de las siguientes:
| `type` | Significado |
| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `slack_channel` | El canal, nombrado en `slack_channel_id`. |
| `slack_workspace` | El espacio de trabajo, nombrado en `slack_workspace_id`. |
| `slack_parent_channel` | El canal padre de un canal de código, nombrado en `slack_channel_id`. Un canal de código es uno que se inició desde otro canal. Mientras el padre sea un canal público en el mismo espacio de trabajo, se sitúa entre el canal y el espacio de trabajo y aporta solo `instructions` y `environment_id`. |
| `slack_defaults` | Los valores predeterminados de Slack de tu organización, que no tienen ID. |
| `default` | Ningún nivel establece un valor, por lo que se aplica el valor predeterminado integrado. |
`sources.instructions` es una lista, del más amplio al más específico, de cada nivel que aporta texto, y está vacía cuando ninguno lo hace. El ID de una fuente puede ser `null` en una organización que accede al canal mediante una conexión de Slack Enterprise Grid en lugar de mediante el propio espacio de trabajo del canal.
### Cambiar la configuración
Los tres endpoints de actualización y [Dar de alta un canal](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#set-up-a-channel) aceptan un objeto `settings` con las mismas reglas:
* **Una configuración que omites no cambia.** `{"settings": {"enabled": false}}` desactiva Claude y deja las otras cuatro configuraciones como están.
* **Una configuración que envías como `null` se borra**, por lo que el nivel vuelve a heredarla.
* **Todo o nada.** Si se rechaza cualquier valor de una solicitud, no se almacena ninguna configuración de la solicitud.
* **Seguro de repetir.** Cada cambio deja el recurso como lo dejó la primera solicitud idéntica, por lo que ningún endpoint acepta un `Idempotency-Key`. Una solicitud que no altera nada no escribe nada y no registra ningún evento del Activity Feed.
* **Gana la última escritura.** Ninguna solicitud acepta una precondición. Dos llamadores que leen un recurso y luego cambian la misma configuración se sobrescriben mutuamente. Solo se devuelve un `409` cuando otro cambio se superpone con tu solicitud mientras se ejecuta; no se almacenó nada de tu solicitud, así que vuelve a leer el recurso y reenvía el cambio si todavía es necesario.
Un cambio en `guest_policy` en un canal puede finalizar las sesiones que se están ejecutando en ese canal. Finalizan en segundo plano, y la respuesta no espera a que terminen.
### Niveles configurados
Un nivel de configuración está **configurado** (configured) una vez que una persona o una clave ha cambiado una configuración en él o le ha vinculado un Bundle. Permanece configurado a partir de entonces, incluso después de que se borren todas las configuraciones y se desvinculen todos los Bundles. Un canal que se dio de alta con el primer uso de Claude, o mediante esta API sin ninguna configuración, no está configurado hasta su primer cambio o su primer Bundle. Esto importa en dos lugares: solo un canal configurado puede [eliminarse](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#remove-a-channel), y solo un canal que no está configurado puede obtener un `id` nuevo (consulta [Modo de solo lectura](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#read-only-mode)).
### Modo de solo lectura
**API / Terraform read-only mode** es una configuración que un propietario de la organización activa y desactiva en la configuración de Claude Tag de claude.ai. El nombre describe claude.ai y Slack: mientras el modo está activado, rechazan los cambios de una persona en lo que administra esta API, por lo que solo las claves realizan esos cambios. No hace que esta API sea de solo lectura. Cada endpoint de esta página responde igual tanto si el modo está activado como desactivado, y ningún endpoint lo lee ni lo cambia.
Mientras el modo está desactivado, las personas y las claves cambian las mismas configuraciones y vinculan y desvinculan los mismos Bundles, y cada cambio reemplaza lo que está almacenado. Actívalo si tu pipeline debe ser la única fuente de cambios.
Mientras el modo está activado, claude.ai y Slack rechazan:
* Cambiar cualquiera de las cinco configuraciones en un canal, un espacio de trabajo o los valores predeterminados de Slack.
* Dar de alta un canal, eliminar un canal o desconectar un espacio de trabajo en claude.ai.
* Vincular un Bundle a un canal o espacio de trabajo, desvincular uno o eliminar un Bundle que esté vinculado a uno.
Algunas cosas siguen siendo posibles en cualquier caso: un propietario aún puede conectar un nuevo espacio de trabajo, crear y editar Bundles y cambiar configuraciones de Claude Tag que esta API no administra. El primer uso de Claude sigue dando de alta un canal, eliminar un canal en Slack sigue eliminándolo de Claude Tag y desinstalar la aplicación de Slack de Claude sigue desconectando ese espacio de trabajo.
Mientras el modo está desactivado, dar de alta en claude.ai un canal que ya está dado de alta y no está [configurado](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#configured-levels) puede reemplazar el registro del canal. El canal tiene entonces un `id` y un `agent_id` nuevos, y el `id` anterior devuelve `404`. El `id` de un canal configurado dura hasta que se elimina el canal.
### Mensajes directos grupales
Un mensaje directo grupal de Slack tiene un ID con el formato de un canal, por lo que el uso de Claude en uno lo da de alta como un canal: tiene un `id`, se lista y se puede leer. Dar de alta uno mediante esta API, cambiar una configuración en uno y vincularle un Bundle devuelven `400` cada uno. Desvincular un Bundle de uno está permitido.
## Flujos de trabajo de ejemplo
### Activar Claude solo en canales aprobados
Cualquier miembro puede invitar a Claude a un canal público. Para mantener Claude activado solo donde lo hayas aprobado:
1. Desactiva Claude en todas partes estableciendo `enabled` en `false` en los [valores predeterminados de Slack](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#update-the-slack-defaults).
2. Cuando tu sistema de aprobación apruebe un canal, [da de alta el canal](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#set-up-a-channel) con `"settings": {"enabled": true}`. La solicitud acepta los ID propios de Slack y devuelve el canal tanto si ya estaba dado de alta como si no, por lo que es seguro repetirla.
3. En la misma ejecución, [vincula](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#attach-a-bundle) los Bundles para los que se aprobó al equipo, de modo que la primera sesión del canal ya tenga sus herramientas.
### Mantener la configuración en control de versiones
1. Indexa tu configuración por los ID que Slack muestra para cada canal, y [encuentra cada canal](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#find-a-channel-by-its-slack-ids) por ellos.
2. Compara la vista **almacenada** con lo que declara tu repositorio. La vista efectiva mezclaría valores heredados.
3. Envía solo las configuraciones que difieren, y envía `null` para una configuración que tu repositorio ya no declara.
4. Pide a un propietario de la organización que active el [modo de solo lectura](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#read-only-mode), para que nadie cambie las mismas configuraciones manualmente.
### Auditar lo que se aplica en todas partes
1. [Lista tus espacios de trabajo](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#list-workspaces) y luego [lista los canales de cada espacio de trabajo](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#list-channels).
2. Lee la [configuración efectiva](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#get-a-channels-effective-settings) de cada canal y marca lo que tu política prohíbe, como un canal donde `enabled` es `true` sin una aprobación registrada, o donde `guest_policy` es `allow`.
3. [Lista tus Bundles](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#list-bundles) y luego [los destinos de cada Bundle](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#list-a-bundles-targets), para ver dónde está vinculado el acceso a sistemas sensibles.
## Canales de Slack
El objeto de canal es la vista almacenada de un canal de Slack:
| Campo | Descripción |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `type` | `slack_channel`. |
| `id` | Con el prefijo `slch_`. Consulta [ID](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#ids). |
| `slack` | Los ID propios de Slack: `team_id` para el espacio de trabajo en el que está el canal y `channel_id` para el canal. |
| `settings` | Lo que almacena el propio canal. Siempre presente, con las cinco [configuraciones](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#settings); una que no está establecida es `null`. |
| `agent_id` | Con el prefijo `cagt_`. Consulta [ID](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#ids). |
| `created_at` | Cuándo se dio de alta el canal. |
| `updated_at` | Cuándo cambió por última vez el registro del canal en Claude Tag. Se actualiza con cada cambio en una configuración, aquí, en claude.ai o en Slack, y también puede actualizarse por un cambio que ninguna respuesta de aquí muestra. Trata un valor posterior como un motivo para volver a leer el canal, no como prueba de que una configuración cambió. Vincular o desvincular un Bundle no lo actualiza por sí solo. |
Un `id` que no tiene el prefijo `slch_` devuelve `400`. Un `id` que tiene el prefijo pero no corresponde a ningún canal de tu organización devuelve `404`.
### Dar de alta un canal
`POST /v1/organizations/claude_tag/slack_channels` da de alta un canal de Slack y lo devuelve. `slack.team_id` y `slack.channel_id` son obligatorios y son los ID propios de Slack. `settings` es opcional y sigue [Cambiar la configuración](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#changing-settings). Si el canal ya está dado de alta, la solicitud devuelve el canal existente y aplica `settings`; la respuesta es `200` en ambos casos. Requiere el alcance `write:claude_tag`.
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28" \
-d '{
"slack": {"team_id": "T01ABCD2EFG", "channel_id": "C05HJKL6MNP"},
"settings": {"instructions": "Answer in the language of the question."}
}'
```
```bash CLI
ant beta:organization:claude-tag:slack-channels create \
--slack '{team_id: T01ABCD2EFG, channel_id: C05HJKL6MNP}' \
--settings '{instructions: "Answer in the language of the question."}'
```
```python Python
client = anthropic.Anthropic()
channel = client.beta.organization.claude_tag.slack_channels.create(
slack={"team_id": "T01ABCD2EFG", "channel_id": "C05HJKL6MNP"},
settings={"instructions": "Answer in the language of the question."},
)
print(channel.id)
```
```typescript TypeScript
const client = new Anthropic();
const channel = await client.beta.organization.claudeTag.slackChannels.create({
slack: { team_id: "T01ABCD2EFG", channel_id: "C05HJKL6MNP" },
settings: { instructions: "Answer in the language of the question." }
});
console.log(channel.id);
```
```csharp C#
AnthropicClient client = new();
var channel = await client.Beta.Organization.ClaudeTag.SlackChannels.Create(
new()
{
Slack = new() { TeamID = "T01ABCD2EFG", ChannelID = "C05HJKL6MNP" },
Settings = new() { Instructions = "Answer in the language of the question." },
}
);
Console.WriteLine(channel.ID);
```
```go Go
client := anthropic.NewClient()
channel, err := client.Beta.Organization.ClaudeTag.SlackChannels.New(
context.Background(),
anthropic.BetaOrganizationClaudeTagSlackChannelNewParams{
Slack: anthropic.BetaClaudeTagSlackChannelIdentifiersParam{
TeamID: "T01ABCD2EFG",
ChannelID: "C05HJKL6MNP",
},
Settings: anthropic.BetaClaudeTagSettingsCreateParam{
Instructions: anthropic.String("Answer in the language of the question."),
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(channel.ID)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.BetaClaudeTagSettingsCreate;
import com.anthropic.models.beta.organization.claudetag.slackchannels.BetaClaudeTagSlackChannelIdentifiers;
import com.anthropic.models.beta.organization.claudetag.slackchannels.SlackChannelCreateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SlackChannelCreateParams.builder()
.slack(BetaClaudeTagSlackChannelIdentifiers.builder()
.teamId("T01ABCD2EFG")
.channelId("C05HJKL6MNP")
.build())
.settings(BetaClaudeTagSettingsCreate.builder()
.instructions("Answer in the language of the question.")
.build())
.build();
var channel = client.beta().organization().claudeTag().slackChannels().create(params);
IO.println(channel.id());
}
```
```php PHP
$client = new Client();
$channel = $client->beta->organization->claudeTag->slackChannels->create(
slack: ['teamID' => 'T01ABCD2EFG', 'channelID' => 'C05HJKL6MNP'],
settings: ['instructions' => 'Answer in the language of the question.'],
);
echo "{$channel->id}\n";
```
```ruby Ruby
client = Anthropic::Client.new
channel = client.beta.organization.claude_tag.slack_channels.create(
slack: {team_id: "T01ABCD2EFG", channel_id: "C05HJKL6MNP"},
settings: {instructions: "Answer in the language of the question."}
)
puts channel.id
```
```json Response
{
"type": "slack_channel",
"id": "slch_011CZkZmRt4vNq8sHbYw2KdX",
"slack": {
"team_id": "T01ABCD2EFG",
"channel_id": "C05HJKL6MNP"
},
"settings": {
"enabled": null,
"instructions": "Answer in the language of the question.",
"model": null,
"environment_id": null,
"guest_policy": null
},
"agent_id": "cagt_011CZkZsHz6bTh2vNmEu4QrX",
"created_at": "2026-10-19T16:20:05Z",
"updated_at": "2026-10-19T16:20:05Z"
}
```
Antes de dar de alta un canal, la aplicación de Slack de Claude confirma con Slack que el canal está en el espacio de trabajo, no está archivado y es visible para la aplicación. Un canal que no supera esa verificación devuelve `404`, al igual que un espacio de trabajo que no tiene instalada la aplicación de Slack de Claude.
Dar de alta el canal y aplicar `settings` son dos pasos. Cuando el primero tiene éxito y el segundo se rechaza, la respuesta es el rechazo y el canal permanece dado de alta sin nada almacenado. Ese rechazo lleva un `error_code` que comienza con `slack_channel_set_up_` y el `id` del nuevo canal en `error.details.slack_channel_id` (consulta [Respuestas de error](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#error-responses)). Corrige `settings` y envíalo en una [actualización](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#update-a-channel) a ese `id`, o vuelve a enviar la solicitud de alta.
### Listar canales
`GET /v1/organizations/claude_tag/slack_channels` lista los canales dados de alta de un espacio de trabajo, del más reciente al más antiguo según `created_at`. `slack_team_id` es obligatorio y es el ID propio de Slack para el espacio de trabajo. Una página puede contener menos de `limit` canales, o ninguno, mientras `next_page` sigue establecido, así que sigue solicitando páginas hasta que `next_page` sea `null` (consulta [Paginación](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#pagination)). Requiere el alcance `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels?slack_team_id=T01ABCD2EFG" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-channels list --slack-team-id T01ABCD2EFG
```
```python Python
client = anthropic.Anthropic()
channels = client.beta.organization.claude_tag.slack_channels.list(
slack_team_id="T01ABCD2EFG"
)
# Obtiene automáticamente más páginas según sea necesario.
for channel in channels:
print(f"{channel.id}: {channel.slack.channel_id}")
```
```typescript TypeScript
const client = new Anthropic();
const channels = await client.beta.organization.claudeTag.slackChannels.list({
slack_team_id: "T01ABCD2EFG"
});
for await (const channel of channels) {
console.log(`${channel.id}: ${channel.slack.channel_id}`);
}
```
```csharp C#
AnthropicClient client = new();
var page = await client.Beta.Organization.ClaudeTag.SlackChannels.List(
new() { SlackTeamID = "T01ABCD2EFG" }
);
await foreach (var channel in page.Paginate())
{
Console.WriteLine($"{channel.ID}: {channel.Slack.ChannelID}");
}
```
```go Go
client := anthropic.NewClient()
channels := client.Beta.Organization.ClaudeTag.SlackChannels.ListAutoPaging(
context.Background(),
anthropic.BetaOrganizationClaudeTagSlackChannelListParams{
SlackTeamID: "T01ABCD2EFG",
},
)
for channels.Next() {
channel := channels.Current()
fmt.Printf("%s: %s\n", channel.ID, channel.Slack.ChannelID)
}
if err := channels.Err(); err != nil {
log.Fatal(err)
}
```
```java Java
import com.anthropic.models.beta.organization.claudetag.slackchannels.SlackChannelListParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SlackChannelListParams.builder()
.slackTeamId("T01ABCD2EFG")
.build();
var channels = client.beta().organization().claudeTag().slackChannels().list(params);
for (var channel : channels.autoPager()) {
IO.println(channel.id() + ": " + channel.slack().channelId());
}
}
```
```php PHP
$client = new Client();
$channels = $client->beta->organization->claudeTag->slackChannels->list(
slackTeamID: 'T01ABCD2EFG',
);
// Solo esta página; para la siguiente, vuelve a llamar a list() con 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_team_id: "T01ABCD2EFG")
page.auto_paging_each do |channel|
puts "#{channel.id}: #{channel.slack.channel_id}"
end
```
La respuesta es `{"data": [...], "next_page": ...}`, donde cada elemento es un objeto de canal. Un `slack_team_id` que nombra un espacio de trabajo del que tu organización no es propietaria devuelve `404`.
### Encontrar un canal por sus ID de Slack
Agrega `slack_channel_id`, el ID propio de Slack para el canal, para buscar un canal. `data` contiene ese canal, o está vacío cuando el canal no está dado de alta. Una búsqueda ignora `limit` y `page`, y su `next_page` es `null`. Así es como encuentras el `id` de un canal.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels?slack_team_id=T01ABCD2EFG&slack_channel_id=C05HJKL6MNP" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-channels list \
--slack-team-id T01ABCD2EFG \
--slack-channel-id C05HJKL6MNP
```
```python Python
client = anthropic.Anthropic()
page = client.beta.organization.claude_tag.slack_channels.list(
slack_team_id="T01ABCD2EFG",
slack_channel_id="C05HJKL6MNP",
)
for channel in page.data:
print(channel.id)
```
```typescript TypeScript
const client = new Anthropic();
const page = await client.beta.organization.claudeTag.slackChannels.list({
slack_team_id: "T01ABCD2EFG",
slack_channel_id: "C05HJKL6MNP"
});
for (const channel of page.data) {
console.log(channel.id);
}
```
```csharp C#
AnthropicClient client = new();
var page = await client.Beta.Organization.ClaudeTag.SlackChannels.List(
new() { SlackTeamID = "T01ABCD2EFG", SlackChannelID = "C05HJKL6MNP" }
);
foreach (var channel in page.Items)
{
Console.WriteLine(channel.ID);
}
```
```go Go
client := anthropic.NewClient()
page, err := client.Beta.Organization.ClaudeTag.SlackChannels.List(
context.Background(),
anthropic.BetaOrganizationClaudeTagSlackChannelListParams{
SlackTeamID: "T01ABCD2EFG",
SlackChannelID: anthropic.String("C05HJKL6MNP"),
},
)
if err != nil {
log.Fatal(err)
}
for _, channel := range page.Data {
fmt.Println(channel.ID)
}
```
```java Java
import com.anthropic.models.beta.organization.claudetag.slackchannels.SlackChannelListParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SlackChannelListParams.builder()
.slackTeamId("T01ABCD2EFG")
.slackChannelId("C05HJKL6MNP")
.build();
var page = client.beta().organization().claudeTag().slackChannels().list(params);
for (var channel : page.items()) {
IO.println(channel.id());
}
}
```
```php PHP
$client = new Client();
$channels = $client->beta->organization->claudeTag->slackChannels->list(
slackTeamID: 'T01ABCD2EFG',
slackChannelID: 'C05HJKL6MNP',
);
foreach ($channels->getItems() as $channel) {
echo "{$channel->id}\n";
}
```
```ruby Ruby
client = Anthropic::Client.new
page = client.beta.organization.claude_tag.slack_channels.list(
slack_team_id: "T01ABCD2EFG",
slack_channel_id: "C05HJKL6MNP"
)
page.data&.each do |channel|
puts channel.id
end
```
Pasar un ID `slch_` como `slack_channel_id` devuelve `400`.
### Obtener un canal
`GET /v1/organizations/claude_tag/slack_channels/{id}` devuelve el objeto de canal. Requiere el alcance `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels/slch_011CZkZmRt4vNq8sHbYw2KdX" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-channels retrieve \
--id slch_011CZkZmRt4vNq8sHbYw2KdX
```
```python Python
client = anthropic.Anthropic()
channel = client.beta.organization.claude_tag.slack_channels.retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
)
print(channel.settings.enabled)
```
```typescript TypeScript
const client = new Anthropic();
const channel = await client.beta.organization.claudeTag.slackChannels.retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
);
console.log(channel.settings.enabled);
```
```csharp C#
AnthropicClient client = new();
var channel = await client.Beta.Organization.ClaudeTag.SlackChannels.Retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
);
Console.WriteLine(channel.Settings.Enabled);
```
```go Go
client := anthropic.NewClient()
channel, err := client.Beta.Organization.ClaudeTag.SlackChannels.Get(
context.Background(),
"slch_011CZkZmRt4vNq8sHbYw2KdX",
anthropic.BetaOrganizationClaudeTagSlackChannelGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(channel.Settings.Enabled)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var channel = client.beta().organization().claudeTag().slackChannels()
.retrieve("slch_011CZkZmRt4vNq8sHbYw2KdX");
IO.println(channel.settings().enabled().orElse(null));
```
```php PHP
$client = new Client();
$channel = $client->beta->organization->claudeTag->slackChannels->retrieve(
id: 'slch_011CZkZmRt4vNq8sHbYw2KdX',
);
echo json_encode($channel->settings->enabled) . "\n";
```
```ruby Ruby
client = Anthropic::Client.new
channel_id = "slch_011CZkZmRt4vNq8sHbYw2KdX"
channel = client.beta.organization.claude_tag.slack_channels.retrieve(channel_id)
puts channel.settings.enabled
```
### Actualizar un canal
`POST /v1/organizations/claude_tag/slack_channels/{id}` cambia la configuración del canal y devuelve el objeto de canal. `settings` es obligatorio y sigue [Cambiar la configuración](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#changing-settings). Requiere el alcance `write:claude_tag`.
Desactiva Claude en un canal y deja sus otras configuraciones como están:
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels/slch_011CZkZmRt4vNq8sHbYw2KdX" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28" \
-d '{"settings": {"enabled": false}}'
```
```bash CLI
ant beta:organization:claude-tag:slack-channels update \
--id slch_011CZkZmRt4vNq8sHbYw2KdX \
--settings '{enabled: false}'
```
```python Python
client = anthropic.Anthropic()
channel = client.beta.organization.claude_tag.slack_channels.update(
"slch_011CZkZmRt4vNq8sHbYw2KdX",
settings={"enabled": False},
)
print(channel.settings.enabled)
```
```typescript TypeScript
const client = new Anthropic();
const channel = await client.beta.organization.claudeTag.slackChannels.update(
"slch_011CZkZmRt4vNq8sHbYw2KdX",
{ settings: { enabled: false } }
);
console.log(channel.settings.enabled);
```
```csharp C#
AnthropicClient client = new();
var channel = await client.Beta.Organization.ClaudeTag.SlackChannels.Update(
"slch_011CZkZmRt4vNq8sHbYw2KdX",
new() { Settings = new() { Enabled = false } }
);
Console.WriteLine(channel.Settings.Enabled);
```
```go Go
client := anthropic.NewClient()
channel, err := client.Beta.Organization.ClaudeTag.SlackChannels.Update(
context.Background(),
"slch_011CZkZmRt4vNq8sHbYw2KdX",
anthropic.BetaOrganizationClaudeTagSlackChannelUpdateParams{
Settings: anthropic.BetaClaudeTagSettingsUpdateParam{
Enabled: anthropic.Bool(false),
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(channel.Settings.Enabled)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.BetaClaudeTagSettingsUpdate;
import com.anthropic.models.beta.organization.claudetag.slackchannels.SlackChannelUpdateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SlackChannelUpdateParams.builder()
.settings(BetaClaudeTagSettingsUpdate.builder()
.enabled(false)
.build())
.build();
var channel = client.beta().organization().claudeTag().slackChannels()
.update("slch_011CZkZmRt4vNq8sHbYw2KdX", params);
IO.println(channel.settings().enabled().orElse(null));
}
```
```php PHP
$client = new Client();
$channel = $client->beta->organization->claudeTag->slackChannels->update(
id: 'slch_011CZkZmRt4vNq8sHbYw2KdX',
settings: ['enabled' => false],
);
echo json_encode($channel->settings->enabled) . "\n";
```
```ruby Ruby
client = Anthropic::Client.new
channel_id = "slch_011CZkZmRt4vNq8sHbYw2KdX"
channel = client.beta.organization.claude_tag.slack_channels.update(
channel_id,
settings: {enabled: false}
)
puts channel.settings.enabled
```
Borra las instrucciones del canal, para que solo se apliquen las heredadas:
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels/slch_011CZkZmRt4vNq8sHbYw2KdX" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28" \
-d '{"settings": {"instructions": null}}'
```
```bash CLI
ant beta:organization:claude-tag:slack-channels update \
--id slch_011CZkZmRt4vNq8sHbYw2KdX \
--settings '{instructions: null}'
```
```python Python
client = anthropic.Anthropic()
channel = client.beta.organization.claude_tag.slack_channels.update(
"slch_011CZkZmRt4vNq8sHbYw2KdX",
settings={"instructions": None},
)
print(channel.settings.instructions)
```
```typescript TypeScript
const client = new Anthropic();
const channel = await client.beta.organization.claudeTag.slackChannels.update(
"slch_011CZkZmRt4vNq8sHbYw2KdX",
{ settings: { instructions: null } }
);
console.log(channel.settings.instructions);
```
```csharp C#
AnthropicClient client = new();
var channel = await client.Beta.Organization.ClaudeTag.SlackChannels.Update(
"slch_011CZkZmRt4vNq8sHbYw2KdX",
new() { Settings = new() { Instructions = null } }
);
Console.WriteLine(channel.Settings.Instructions);
```
```go Go
client := anthropic.NewClient()
channel, err := client.Beta.Organization.ClaudeTag.SlackChannels.Update(
context.Background(),
"slch_011CZkZmRt4vNq8sHbYw2KdX",
anthropic.BetaOrganizationClaudeTagSlackChannelUpdateParams{
Settings: anthropic.BetaClaudeTagSettingsUpdateParam{
Instructions: param.Null[string](),
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(channel.Settings.Instructions)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.BetaClaudeTagSettingsUpdate;
import com.anthropic.models.beta.organization.claudetag.slackchannels.SlackChannelUpdateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SlackChannelUpdateParams.builder()
.settings(BetaClaudeTagSettingsUpdate.builder()
.instructions(Optional.empty())
.build())
.build();
var channel = client.beta().organization().claudeTag().slackChannels()
.update("slch_011CZkZmRt4vNq8sHbYw2KdX", params);
IO.println(channel.settings().instructions().orElse(null));
}
```
```php PHP
use Anthropic\Beta\Organization\ClaudeTag\ClaudeTagSettingsUpdate;
// ...
$client = new Client();
// update() descarta los null dentro de arreglos, así que construye el 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
```
### Obtener la configuración efectiva de un canal
`GET /v1/organizations/claude_tag/slack_channels/{id}/effective` devuelve lo que se aplica en el canal y de dónde proviene cada valor. [Configuración almacenada y efectiva](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#stored-and-effective-settings) muestra una respuesta completa. En esta vista, `enabled` y `guest_policy` nunca son `null`. La vista se resuelve en cada lectura, por lo que no tiene `created_at` ni `updated_at`. Si no se puede leer un nivel, la solicitud falla con `503` en lugar de resolverse sin él. Requiere el alcance `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels/slch_011CZkZmRt4vNq8sHbYw2KdX/effective" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-channels:effective retrieve \
--id slch_011CZkZmRt4vNq8sHbYw2KdX
```
```python Python
client = anthropic.Anthropic()
effective = client.beta.organization.claude_tag.slack_channels.effective.retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
)
print(effective.settings.instructions)
```
```typescript TypeScript
const client = new Anthropic();
const effective = await client.beta.organization.claudeTag.slackChannels.effective.retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
);
console.log(effective.settings.instructions);
```
```csharp C#
AnthropicClient client = new();
var effective = await client.Beta.Organization.ClaudeTag.SlackChannels.Effective.Retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
);
Console.WriteLine(effective.Settings.Instructions);
```
```go Go
client := anthropic.NewClient()
effective, err := client.Beta.Organization.ClaudeTag.SlackChannels.Effective.Get(
context.Background(),
"slch_011CZkZmRt4vNq8sHbYw2KdX",
anthropic.BetaOrganizationClaudeTagSlackChannelEffectiveGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(effective.Settings.Instructions)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var effective = client.beta().organization().claudeTag().slackChannels().effective()
.retrieve("slch_011CZkZmRt4vNq8sHbYw2KdX");
IO.println(effective.settings().instructions().orElse(null));
```
```php PHP
$client = new Client();
$effective = $client->beta->organization->claudeTag->slackChannels->effective->retrieve(
id: 'slch_011CZkZmRt4vNq8sHbYw2KdX',
);
echo "{$effective->settings->instructions}\n";
```
```ruby Ruby
client = Anthropic::Client.new
channel_id = "slch_011CZkZmRt4vNq8sHbYw2KdX"
effective = client.beta.organization.claude_tag.slack_channels.effective.retrieve(channel_id)
puts effective.settings.instructions
```
### Eliminar un canal
`DELETE /v1/organizations/claude_tag/slack_channels/{id}` elimina un canal de Claude Tag. Es la misma eliminación que hace un propietario de la organización en claude.ai, con el mismo efecto. No elimina, archiva ni modifica el canal en Slack, ni ningún mensaje en él. Requiere el alcance `write:claude_tag`.
La eliminación no se puede deshacer. Elimina lo que Claude Tag guarda para el canal:
* su configuración almacenada y sus destinos de Bundle
* sus sesiones y sus transcripciones, incluidas las sesiones que están en ejecución
* su memoria, que es lo que Claude conserva sobre el canal de una sesión a la siguiente
* sus rutinas y los artefactos publicados desde él
```bash cURL
curl -X DELETE "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels/slch_011CZkZmRt4vNq8sHbYw2KdX" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-channels delete \
--id slch_011CZkZmRt4vNq8sHbYw2KdX
```
```python Python
client = anthropic.Anthropic()
deleted_channel = client.beta.organization.claude_tag.slack_channels.delete(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
)
print(deleted_channel.id)
```
```typescript TypeScript
const client = new Anthropic();
const deletedChannel = await client.beta.organization.claudeTag.slackChannels.delete(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
);
console.log(deletedChannel.id);
```
```csharp C#
AnthropicClient client = new();
var deletedChannel = await client.Beta.Organization.ClaudeTag.SlackChannels.Delete(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
);
Console.WriteLine(deletedChannel.ID);
```
```go Go
client := anthropic.NewClient()
deletedChannel, err := client.Beta.Organization.ClaudeTag.SlackChannels.Delete(
context.Background(),
"slch_011CZkZmRt4vNq8sHbYw2KdX",
anthropic.BetaOrganizationClaudeTagSlackChannelDeleteParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(deletedChannel.ID)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var deletedChannel = client.beta().organization().claudeTag().slackChannels()
.delete("slch_011CZkZmRt4vNq8sHbYw2KdX");
IO.println(deletedChannel.id());
```
```php PHP
$client = new Client();
$deletedChannel = $client->beta->organization->claudeTag->slackChannels->delete(
id: 'slch_011CZkZmRt4vNq8sHbYw2KdX',
);
echo "{$deletedChannel->id}\n";
```
```ruby Ruby
client = Anthropic::Client.new
channel_id = "slch_011CZkZmRt4vNq8sHbYw2KdX"
deleted_channel = client.beta.organization.claude_tag.slack_channels.delete(channel_id)
puts deleted_channel.id
```
```json Response
{
"type": "slack_channel_deleted",
"id": "slch_011CZkZmRt4vNq8sHbYw2KdX"
}
```
El `id` devuelve `404` en cuanto la solicitud responde, y el resto se elimina en segundo plano. Una eliminación repetida devuelve `404`.
**Eliminar un canal no detiene a Claude en él.** Claude sigue respondiendo según lo que el canal hereda, sin memoria del canal, y su siguiente uso puede volver a dar de alta el canal con un nuevo `id`.
* Para que Claude deje de responder en un canal, establece `enabled` en `false` en él.
* Para que un canal no almacene nada y conserve sus sesiones y su memoria, borra cada configuración y desvincula cada Bundle.
Hay dos tipos de canal que no se pueden eliminar aquí y devuelven `400`: uno que no está [configurado](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#configured-levels) (`error_code: "slack_channel_not_configured"`), y uno que contiene configuración que esta API no administra, como un grupo de runners o una configuración que solo tiene claude.ai. Un propietario de la organización elimina el segundo tipo en claude.ai.
## Espacios de trabajo de Slack
El objeto de espacio de trabajo es la vista almacenada de un espacio de trabajo de Slack. Tiene los mismos campos que el [objeto de canal](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#slack-channels), excepto que `type` es `slack_workspace`, `id` tiene el prefijo `slws_` y `slack` contiene solo `team_id`. La respuesta del [Inicio rápido](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#quick-start) muestra uno completo.
Un `id` que no tiene el prefijo `slws_` devuelve `400`. Un `id` que tiene el prefijo pero no corresponde a ningún espacio de trabajo de tu organización devuelve `404`.
### Listar espacios de trabajo
`GET /v1/organizations/claude_tag/slack_workspaces` lista los espacios de trabajo dados de alta que pertenecen a tu organización, del más reciente al más antiguo según `created_at`. El [Inicio rápido](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#quick-start) muestra la solicitud y la respuesta. Para encontrar un espacio de trabajo por el ID propio de Slack, agrega `slack_team_id`: `data` contiene ese espacio de trabajo, o está vacío cuando no está dado de alta, y un espacio de trabajo que no pertenece a tu organización devuelve `404`. Requiere el alcance `read:claude_tag`.
### Obtener un espacio de trabajo
`GET /v1/organizations/claude_tag/slack_workspaces/{id}` devuelve el objeto de espacio de trabajo. Requiere el alcance `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_workspaces/slws_011CZkZnWa7xPc3uJfZe5LgT" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-workspaces retrieve \
--id slws_011CZkZnWa7xPc3uJfZe5LgT
```
```python Python
client = anthropic.Anthropic()
workspace = client.beta.organization.claude_tag.slack_workspaces.retrieve(
"slws_011CZkZnWa7xPc3uJfZe5LgT"
)
print(workspace.settings.instructions)
```
```typescript TypeScript
const client = new Anthropic();
const workspace = await client.beta.organization.claudeTag.slackWorkspaces.retrieve(
"slws_011CZkZnWa7xPc3uJfZe5LgT"
);
console.log(workspace.settings.instructions);
```
```csharp C#
AnthropicClient client = new();
var workspace = await client.Beta.Organization.ClaudeTag.SlackWorkspaces.Retrieve(
"slws_011CZkZnWa7xPc3uJfZe5LgT"
);
Console.WriteLine(workspace.Settings.Instructions);
```
```go Go
client := anthropic.NewClient()
workspace, err := client.Beta.Organization.ClaudeTag.SlackWorkspaces.Get(
context.Background(),
"slws_011CZkZnWa7xPc3uJfZe5LgT",
anthropic.BetaOrganizationClaudeTagSlackWorkspaceGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(workspace.Settings.Instructions)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var workspace = client.beta().organization().claudeTag().slackWorkspaces()
.retrieve("slws_011CZkZnWa7xPc3uJfZe5LgT");
IO.println(workspace.settings().instructions().orElse(null));
```
```php PHP
$client = new Client();
$workspace = $client->beta->organization->claudeTag->slackWorkspaces->retrieve(
id: 'slws_011CZkZnWa7xPc3uJfZe5LgT',
);
echo "{$workspace->settings->instructions}\n";
```
```ruby Ruby
client = Anthropic::Client.new
workspace_id = "slws_011CZkZnWa7xPc3uJfZe5LgT"
workspace = client.beta.organization.claude_tag.slack_workspaces.retrieve(workspace_id)
puts workspace.settings.instructions
```
### Actualizar un espacio de trabajo
`POST /v1/organizations/claude_tag/slack_workspaces/{id}` cambia la configuración del espacio de trabajo y devuelve el objeto de espacio de trabajo. `settings` es obligatorio y sigue [Cambiar la configuración](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#changing-settings). Lo que establezcas aquí se aplica en cada canal del espacio de trabajo que no establezca su propio valor. Requiere el alcance `write:claude_tag`.
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/claude_tag/slack_workspaces/slws_011CZkZnWa7xPc3uJfZe5LgT" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28" \
-d '{"settings": {"guest_policy": {"type": "restrict"}}}'
```
```bash CLI
ant beta:organization:claude-tag:slack-workspaces update \
--id slws_011CZkZnWa7xPc3uJfZe5LgT \
--settings '{guest_policy: {type: restrict}}'
```
```python Python
client = anthropic.Anthropic()
workspace = client.beta.organization.claude_tag.slack_workspaces.update(
"slws_011CZkZnWa7xPc3uJfZe5LgT",
settings={"guest_policy": {"type": "restrict"}},
)
print(workspace.settings.guest_policy)
```
```typescript TypeScript
const client = new Anthropic();
const workspace = await client.beta.organization.claudeTag.slackWorkspaces.update(
"slws_011CZkZnWa7xPc3uJfZe5LgT",
{ settings: { guest_policy: { type: "restrict" } } }
);
console.log(workspace.settings.guest_policy?.type);
```
```csharp C#
using Anthropic.Models.Beta.Organization.ClaudeTag;
AnthropicClient client = new();
var workspace = await client.Beta.Organization.ClaudeTag.SlackWorkspaces.Update(
"slws_011CZkZnWa7xPc3uJfZe5LgT",
new() { Settings = new() { GuestPolicy = new BetaClaudeTagGuestPolicyRestrict() } }
);
Console.WriteLine(workspace.Settings.GuestPolicy?.Type.GetString());
```
```go Go
client := anthropic.NewClient()
workspace, err := client.Beta.Organization.ClaudeTag.SlackWorkspaces.Update(
context.Background(),
"slws_011CZkZnWa7xPc3uJfZe5LgT",
anthropic.BetaOrganizationClaudeTagSlackWorkspaceUpdateParams{
Settings: anthropic.BetaClaudeTagSettingsUpdateParam{
GuestPolicy: anthropic.BetaClaudeTagGuestPolicyUnionParam{
OfRestrict: &anthropic.BetaClaudeTagGuestPolicyRestrictParam{},
},
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(workspace.Settings.GuestPolicy.Type)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.BetaClaudeTagGuestPolicyRestrict;
import com.anthropic.models.beta.organization.claudetag.BetaClaudeTagSettingsUpdate;
import com.anthropic.models.beta.organization.claudetag.slackworkspaces.SlackWorkspaceUpdateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SlackWorkspaceUpdateParams.builder()
.settings(BetaClaudeTagSettingsUpdate.builder()
.guestPolicy(BetaClaudeTagGuestPolicyRestrict.builder().build())
.build())
.build();
var workspace = client.beta().organization().claudeTag().slackWorkspaces()
.update("slws_011CZkZnWa7xPc3uJfZe5LgT", params);
IO.println(workspace.settings().guestPolicy().map(policy -> policy.type().asString()).orElse(null));
}
```
```php PHP
$client = new Client();
$workspace = $client->beta->organization->claudeTag->slackWorkspaces->update(
id: 'slws_011CZkZnWa7xPc3uJfZe5LgT',
settings: ['guestPolicy' => ['type' => 'restrict']],
);
echo "{$workspace->settings->guestPolicy?->type}\n";
```
```ruby Ruby
client = Anthropic::Client.new
workspace_id = "slws_011CZkZnWa7xPc3uJfZe5LgT"
workspace = client.beta.organization.claude_tag.slack_workspaces.update(
workspace_id,
settings: {guest_policy: {type: :restrict}}
)
puts workspace.settings.guest_policy&.type
```
### Obtener la configuración efectiva de un espacio de trabajo
`GET /v1/organizations/claude_tag/slack_workspaces/{id}/effective` devuelve lo que se aplica en el espacio de trabajo, resuelto a partir del espacio de trabajo y los valores predeterminados de Slack, con la forma que muestra [Configuración almacenada y efectiva](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#stored-and-effective-settings), con `type` establecido en `slack_workspace_effective`. Requiere el alcance `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_workspaces/slws_011CZkZnWa7xPc3uJfZe5LgT/effective" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-workspaces:effective retrieve \
--id slws_011CZkZnWa7xPc3uJfZe5LgT
```
```python Python
client = anthropic.Anthropic()
effective = client.beta.organization.claude_tag.slack_workspaces.effective.retrieve(
"slws_011CZkZnWa7xPc3uJfZe5LgT"
)
print(effective.settings.enabled)
```
```typescript TypeScript
const client = new Anthropic();
const effective = await client.beta.organization.claudeTag.slackWorkspaces.effective.retrieve(
"slws_011CZkZnWa7xPc3uJfZe5LgT"
);
console.log(effective.settings.enabled);
```
```csharp C#
AnthropicClient client = new();
var effective = await client.Beta.Organization.ClaudeTag.SlackWorkspaces.Effective.Retrieve(
"slws_011CZkZnWa7xPc3uJfZe5LgT"
);
Console.WriteLine(effective.Settings.Enabled);
```
```go Go
client := anthropic.NewClient()
effective, err := client.Beta.Organization.ClaudeTag.SlackWorkspaces.Effective.Get(
context.Background(),
"slws_011CZkZnWa7xPc3uJfZe5LgT",
anthropic.BetaOrganizationClaudeTagSlackWorkspaceEffectiveGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(effective.Settings.Enabled)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var effective = client.beta().organization().claudeTag().slackWorkspaces().effective()
.retrieve("slws_011CZkZnWa7xPc3uJfZe5LgT");
IO.println(effective.settings().enabled().orElse(null));
```
```php PHP
$client = new Client();
$effective = $client->beta->organization->claudeTag->slackWorkspaces->effective->retrieve(
id: 'slws_011CZkZnWa7xPc3uJfZe5LgT',
);
echo json_encode($effective->settings->enabled) . "\n";
```
```ruby Ruby
client = Anthropic::Client.new
workspace_id = "slws_011CZkZnWa7xPc3uJfZe5LgT"
effective = client.beta.organization.claude_tag.slack_workspaces.effective.retrieve(workspace_id)
puts effective.settings.enabled
```
## Valores predeterminados de Slack
Tu organización tiene exactamente un objeto de valores predeterminados de Slack. Se aplica a cada espacio de trabajo y canal, no tiene `id` y no tiene vista efectiva, ya que no hay ningún nivel más amplio.
| Campo | Descripción |
| ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` | `slack_defaults`. |
| `settings` | Lo que almacenan los valores predeterminados, como en un [canal](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#slack-channels). |
| `agent_id` | Con el prefijo `cagt_`. `null` hasta que los valores predeterminados de Slack estén [dados de alta](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#set-up-channels-and-workspaces). |
### Obtener los valores predeterminados de Slack
`GET /v1/organizations/claude_tag/slack_defaults` devuelve el objeto. Una organización cuyos valores predeterminados de Slack no están dados de alta obtiene `200` con cada configuración y `agent_id` en `null`. Requiere el alcance `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_defaults" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-defaults retrieve
```
```python Python
client = anthropic.Anthropic()
defaults = client.beta.organization.claude_tag.slack_defaults.retrieve()
print(defaults.settings.guest_policy)
```
```typescript TypeScript
const client = new Anthropic();
const defaults = await client.beta.organization.claudeTag.slackDefaults.retrieve();
console.log(defaults.settings.guest_policy?.type);
```
```csharp C#
AnthropicClient client = new();
var defaults = await client.Beta.Organization.ClaudeTag.SlackDefaults.Retrieve();
Console.WriteLine(defaults.Settings.GuestPolicy?.Type.GetString());
```
```go Go
client := anthropic.NewClient()
defaults, err := client.Beta.Organization.ClaudeTag.SlackDefaults.Get(
context.Background(),
anthropic.BetaOrganizationClaudeTagSlackDefaultGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(defaults.Settings.GuestPolicy.Type)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var defaults = client.beta().organization().claudeTag().slackDefaults().retrieve();
IO.println(defaults.settings().guestPolicy().map(policy -> policy.type().asString()).orElse(null));
```
```php PHP
$client = new Client();
$defaults = $client->beta->organization->claudeTag->slackDefaults->retrieve();
echo "{$defaults->settings->guestPolicy?->type}\n";
```
```ruby Ruby
client = Anthropic::Client.new
defaults = client.beta.organization.claude_tag.slack_defaults.retrieve
puts defaults.settings.guest_policy&.type
```
### Actualizar los valores predeterminados de Slack
`POST /v1/organizations/claude_tag/slack_defaults` cambia los valores predeterminados y devuelve el objeto. `settings` es obligatorio y sigue [Cambiar la configuración](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#changing-settings). Una solicitud que establece un valor mientras los valores predeterminados de Slack no están dados de alta devuelve `400`. Requiere el alcance `write:claude_tag`.
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/claude_tag/slack_defaults" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28" \
-d '{
"settings": {
"instructions": "Keep replies under 200 words.",
"environment_id": "env_011CZkZqDx2zRf5tLjCs7NpV"
}
}'
```
```bash CLI
ant beta:organization:claude-tag:slack-defaults update \
--settings '{instructions: "Keep replies under 200 words.", environment_id: env_011CZkZqDx2zRf5tLjCs7NpV}'
```
```python Python
client = anthropic.Anthropic()
defaults = client.beta.organization.claude_tag.slack_defaults.update(
settings={
"instructions": "Keep replies under 200 words.",
"environment_id": "env_011CZkZqDx2zRf5tLjCs7NpV",
},
)
print(defaults.settings.environment_id)
```
```typescript TypeScript
const client = new Anthropic();
const defaults = await client.beta.organization.claudeTag.slackDefaults.update({
settings: {
instructions: "Keep replies under 200 words.",
environment_id: "env_011CZkZqDx2zRf5tLjCs7NpV"
}
});
console.log(defaults.settings.environment_id);
```
```csharp C#
AnthropicClient client = new();
var defaults = await client.Beta.Organization.ClaudeTag.SlackDefaults.Update(
new()
{
Settings = new()
{
Instructions = "Keep replies under 200 words.",
EnvironmentID = "env_011CZkZqDx2zRf5tLjCs7NpV",
},
}
);
Console.WriteLine(defaults.Settings.EnvironmentID);
```
```go Go
client := anthropic.NewClient()
defaults, err := client.Beta.Organization.ClaudeTag.SlackDefaults.Update(
context.Background(),
anthropic.BetaOrganizationClaudeTagSlackDefaultUpdateParams{
Settings: anthropic.BetaClaudeTagSettingsUpdateParam{
Instructions: anthropic.String("Keep replies under 200 words."),
EnvironmentID: anthropic.String("env_011CZkZqDx2zRf5tLjCs7NpV"),
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(defaults.Settings.EnvironmentID)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.BetaClaudeTagSettingsUpdate;
import com.anthropic.models.beta.organization.claudetag.slackdefaults.SlackDefaultUpdateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SlackDefaultUpdateParams.builder()
.settings(BetaClaudeTagSettingsUpdate.builder()
.instructions("Keep replies under 200 words.")
.environmentId("env_011CZkZqDx2zRf5tLjCs7NpV")
.build())
.build();
var defaults = client.beta().organization().claudeTag().slackDefaults().update(params);
IO.println(defaults.settings().environmentId().orElse(null));
}
```
```php PHP
$client = new Client();
$defaults = $client->beta->organization->claudeTag->slackDefaults->update(
settings: [
'instructions' => 'Keep replies under 200 words.',
'environmentID' => 'env_011CZkZqDx2zRf5tLjCs7NpV',
],
);
echo "{$defaults->settings->environmentID}\n";
```
```ruby Ruby
client = Anthropic::Client.new
defaults = client.beta.organization.claude_tag.slack_defaults.update(
settings: {
instructions: "Keep replies under 200 words.",
environment_id: "env_011CZkZqDx2zRf5tLjCs7NpV"
}
)
puts defaults.settings.environment_id
```
```json Response
{
"type": "slack_defaults",
"settings": {
"enabled": null,
"instructions": "Keep replies under 200 words.",
"model": null,
"environment_id": "env_011CZkZqDx2zRf5tLjCs7NpV",
"guest_policy": null
},
"agent_id": "cagt_011CZkZtKa8cUj4wPnFv6RsY"
}
```
## Bundles
Un Bundle es lo que claude.ai llama un [Access bundle](https://claude.com/docs/claude-tag/admins/add-connections): un conjunto de accesos con nombre, como conectores, repositorios y credenciales, que Claude puede usar en un canal o espacio de trabajo. Los propietarios de la organización crean, editan y eliminan Bundles en claude.ai. Esta API los lista y los vincula. Devuelve el nombre y la descripción de un Bundle y nunca lo que el Bundle otorga.
| Campo | Descripción |
| -------------------------- | ------------------------------------------------------------- |
| `type` | `bundle`. |
| `id` | Con el prefijo `capp_`. |
| `display_name` | El nombre del Bundle. |
| `description` | Para qué sirve el Bundle. `null` cuando no tiene ninguna. |
| `created_at`, `updated_at` | Cuándo se creó el Bundle y cuándo se modificó por última vez. |
Un `bundle_id` que no tiene el prefijo `capp_` devuelve `400`. Uno que tiene el prefijo pero no existe o pertenece a otra organización devuelve `404`, independientemente de lo que contenga el resto de la solicitud. Los Bundles que Claude Tag administra para sí mismo no se listan y devuelven `404`.
### Listar Bundles
`GET /v1/organizations/claude_tag/bundles` lista los Bundles de tu organización, del más reciente al más antiguo según `created_at`. Requiere el alcance `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/bundles" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:bundles list
```
```python Python
client = anthropic.Anthropic()
bundles = client.beta.organization.claude_tag.bundles.list()
# Obtiene automáticamente más páginas según sea necesario.
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();
// Solo esta página; para la siguiente, vuelve a llamar a list() con 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
}
```
### Obtener un Bundle
`GET /v1/organizations/claude_tag/bundles/{bundle_id}` devuelve el objeto Bundle. Requiere el alcance `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:bundles retrieve \
--bundle-id capp_011CZkZjLP1cWxj5EtMmdgbq
```
```python Python
client = anthropic.Anthropic()
bundle = client.beta.organization.claude_tag.bundles.retrieve(
"capp_011CZkZjLP1cWxj5EtMmdgbq"
)
print(bundle.display_name)
```
```typescript TypeScript
const client = new Anthropic();
const bundle = await client.beta.organization.claudeTag.bundles.retrieve(
"capp_011CZkZjLP1cWxj5EtMmdgbq"
);
console.log(bundle.display_name);
```
```csharp C#
AnthropicClient client = new();
var bundle = await client.Beta.Organization.ClaudeTag.Bundles.Retrieve(
"capp_011CZkZjLP1cWxj5EtMmdgbq"
);
Console.WriteLine(bundle.DisplayName);
```
```go Go
client := anthropic.NewClient()
bundle, err := client.Beta.Organization.ClaudeTag.Bundles.Get(
context.Background(),
"capp_011CZkZjLP1cWxj5EtMmdgbq",
anthropic.BetaOrganizationClaudeTagBundleGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(bundle.DisplayName)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var bundle = client.beta().organization().claudeTag().bundles()
.retrieve("capp_011CZkZjLP1cWxj5EtMmdgbq");
IO.println(bundle.displayName());
```
```php PHP
$client = new Client();
$bundle = $client->beta->organization->claudeTag->bundles->retrieve(
bundleID: 'capp_011CZkZjLP1cWxj5EtMmdgbq',
);
echo "{$bundle->displayName}\n";
```
```ruby Ruby
client = Anthropic::Client.new
bundle_id = "capp_011CZkZjLP1cWxj5EtMmdgbq"
bundle = client.beta.organization.claude_tag.bundles.retrieve(bundle_id)
puts bundle.display_name
```
## Destinos de Bundle
Un destino de Bundle es el registro de un Bundle vinculado a un canal o a un espacio de trabajo. Un Bundle vinculado a un espacio de trabajo se puede usar en el espacio de trabajo y en cada canal que contiene. Un Bundle vinculado a un canal solo se puede usar en ese canal.
| Campo | Descripción |
| -------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `type` | `slack_channel` o `slack_workspace`. |
| `id` | Con el prefijo `btgt_`. Es el `{target_id}` en las rutas, y nunca es el `id` propio del canal o del espacio de trabajo. |
| `slack_channel_id` | En un destino `slack_channel`: el `id` del canal, con el prefijo `slch_`. |
| `slack_workspace_id` | En un destino `slack_workspace`: el `id` del espacio de trabajo, con el prefijo `slws_`. |
| `created_at` | Cuándo se vinculó el Bundle. |
Un Bundle se vincula a un canal o espacio de trabajo como máximo una vez, y el mismo par siempre tiene el mismo `id`, incluso después de desvincularlo y volver a vincularlo. El `id` es opaco: obtenlo de la respuesta a una vinculación o de la lista. Un destino de Bundle no contiene el `id` de su Bundle, que sus rutas también necesitan, así que guarda ambos juntos.
El primer Bundle vinculado a un canal o espacio de trabajo lo deja [configurado](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#configured-levels). Vincular o desvincular no cambia ninguna configuración almacenada. Las sesiones que están en ejecución en el canal o espacio de trabajo reciben un aviso de que su acceso cambió.
El Bundle que claude.ai vincula como parte de una configuración de guardia se lista y se puede leer, pero no se puede vincular ni desvincular aquí, y no se puede vincular nada a un canal o espacio de trabajo administrado por una configuración de guardia, ni desvincular nada de él. Cada una de esas solicitudes devuelve `400`.
### Listar los destinos de un Bundle
`GET /v1/organizations/claude_tag/bundles/{bundle_id}/targets` lista los canales y espacios de trabajo a los que está vinculado el Bundle, del más reciente al más antiguo según `created_at`. Requiere el alcance `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq/targets" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:bundles:targets list \
--bundle-id capp_011CZkZjLP1cWxj5EtMmdgbq
```
```python Python
client = anthropic.Anthropic()
targets = client.beta.organization.claude_tag.bundles.targets.list(
"capp_011CZkZjLP1cWxj5EtMmdgbq"
)
# Obtiene automáticamente más páginas según sea necesario.
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',
);
// Solo esta página; para la siguiente, vuelve a llamar a list() con 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_011CZkZpBv9yQd6wKhAr8MnU",
"slack_channel_id": "slch_011CZkZmRt4vNq8sHbYw2KdX",
"created_at": "2026-10-19T16:21:44Z"
},
{
"type": "slack_workspace",
"id": "btgt_011CZkZuMc3dVk7xQpGw9StZ",
"slack_workspace_id": "slws_011CZkZnWa7xPc3uJfZe5LgT",
"created_at": "2026-09-12T08:17:02Z"
}
],
"next_page": null
}
```
Solo se listan las vinculaciones a canales y espacios de trabajo. Un Bundle que está vinculado en claude.ai a cualquier otra cosa, como **Default Slack access**, no tiene un destino de Bundle para ello, y tampoco lo tiene una regla que aplica un Bundle en muchos canales a la vez. Por lo tanto, los Bundles que Claude puede usar en un canal pueden ser más que los destinos que lo nombran. Ningún endpoint lista los Bundles vinculados a un canal o espacio de trabajo concreto.
### Vincular un Bundle
`POST /v1/organizations/claude_tag/bundles/{bundle_id}/targets` vincula el Bundle y devuelve el destino de Bundle. El cuerpo indica el `type` y el `id` correspondiente. El canal o espacio de trabajo ya debe estar dado de alta: vincular nunca da de alta un canal. Vincular un par que ya está vinculado devuelve `200` con el destino de Bundle existente. Requiere el alcance `write:claude_tag`.
Vincula un Bundle a un canal:
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq/targets" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28" \
-d '{"type": "slack_channel", "slack_channel_id": "slch_011CZkZmRt4vNq8sHbYw2KdX"}'
```
```bash CLI
ant beta:organization:claude-tag:bundles:targets create \
--bundle-id capp_011CZkZjLP1cWxj5EtMmdgbq \
--type slack_channel \
--slack-channel-id slch_011CZkZmRt4vNq8sHbYw2KdX
```
```python Python
client = anthropic.Anthropic()
target = client.beta.organization.claude_tag.bundles.targets.create(
"capp_011CZkZjLP1cWxj5EtMmdgbq",
type="slack_channel",
slack_channel_id="slch_011CZkZmRt4vNq8sHbYw2KdX",
)
print(target.id)
```
```typescript TypeScript
const client = new Anthropic();
const target = await client.beta.organization.claudeTag.bundles.targets.create(
"capp_011CZkZjLP1cWxj5EtMmdgbq",
{ type: "slack_channel", slack_channel_id: "slch_011CZkZmRt4vNq8sHbYw2KdX" }
);
console.log(target.id);
```
```csharp C#
using Anthropic.Models.Beta.Organization.ClaudeTag.Bundles.Targets;
AnthropicClient client = new();
var target = await client.Beta.Organization.ClaudeTag.Bundles.Targets.Create(
"capp_011CZkZjLP1cWxj5EtMmdgbq",
new()
{
BetaClaudeTagBundleTargetCreate = new BetaClaudeTagSlackChannelBundleTargetCreate
{
SlackChannelID = "slch_011CZkZmRt4vNq8sHbYw2KdX",
},
}
);
Console.WriteLine(target.ID);
```
```go Go
client := anthropic.NewClient()
target, err := client.Beta.Organization.ClaudeTag.Bundles.Targets.New(
context.Background(),
"capp_011CZkZjLP1cWxj5EtMmdgbq",
anthropic.BetaOrganizationClaudeTagBundleTargetNewParams{
BetaClaudeTagBundleTargetCreate: anthropic.BetaClaudeTagBundleTargetCreateUnionParam{
OfSlackChannel: &anthropic.BetaClaudeTagSlackChannelBundleTargetCreateParam{
SlackChannelID: "slch_011CZkZmRt4vNq8sHbYw2KdX",
},
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(target.ID)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.bundles.targets.TargetCreateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = TargetCreateParams.builder()
.slackChannelBetaClaudeTagBundleTargetCreate("slch_011CZkZmRt4vNq8sHbYw2KdX")
.build();
var target = client.beta().organization().claudeTag().bundles().targets()
.create("capp_011CZkZjLP1cWxj5EtMmdgbq", params);
IO.println(target.id());
}
```
```php PHP
$client = new Client();
$target = $client->beta->organization->claudeTag->bundles->targets->create(
bundleID: 'capp_011CZkZjLP1cWxj5EtMmdgbq',
betaClaudeTagBundleTargetCreate: [
'type' => 'slack_channel',
'slackChannelID' => 'slch_011CZkZmRt4vNq8sHbYw2KdX',
],
);
echo "{$target->id}\n";
```
```ruby Ruby
client = Anthropic::Client.new
bundle_id = "capp_011CZkZjLP1cWxj5EtMmdgbq"
target = client.beta.organization.claude_tag.bundles.targets.create(
bundle_id,
beta_claude_tag_bundle_target_create: {
type: :slack_channel,
slack_channel_id: "slch_011CZkZmRt4vNq8sHbYw2KdX"
}
)
puts target.id
```
```json Response
{
"type": "slack_channel",
"id": "btgt_011CZkZpBv9yQd6wKhAr8MnU",
"slack_channel_id": "slch_011CZkZmRt4vNq8sHbYw2KdX",
"created_at": "2026-10-19T16:21:44Z"
}
```
Vincula un Bundle a un espacio de trabajo:
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq/targets" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28" \
-d '{"type": "slack_workspace", "slack_workspace_id": "slws_011CZkZnWa7xPc3uJfZe5LgT"}'
```
```bash CLI
ant beta:organization:claude-tag:bundles:targets create \
--bundle-id capp_011CZkZjLP1cWxj5EtMmdgbq \
--type slack_workspace \
--slack-workspace-id slws_011CZkZnWa7xPc3uJfZe5LgT
```
```python Python
client = anthropic.Anthropic()
target = client.beta.organization.claude_tag.bundles.targets.create(
"capp_011CZkZjLP1cWxj5EtMmdgbq",
type="slack_workspace",
slack_workspace_id="slws_011CZkZnWa7xPc3uJfZe5LgT",
)
print(target.id)
```
```typescript TypeScript
const client = new Anthropic();
const target = await client.beta.organization.claudeTag.bundles.targets.create(
"capp_011CZkZjLP1cWxj5EtMmdgbq",
{ type: "slack_workspace", slack_workspace_id: "slws_011CZkZnWa7xPc3uJfZe5LgT" }
);
console.log(target.id);
```
```csharp C#
using Anthropic.Models.Beta.Organization.ClaudeTag.Bundles.Targets;
AnthropicClient client = new();
var target = await client.Beta.Organization.ClaudeTag.Bundles.Targets.Create(
"capp_011CZkZjLP1cWxj5EtMmdgbq",
new()
{
BetaClaudeTagBundleTargetCreate = new BetaClaudeTagSlackWorkspaceBundleTargetCreate
{
SlackWorkspaceID = "slws_011CZkZnWa7xPc3uJfZe5LgT",
},
}
);
Console.WriteLine(target.ID);
```
```go Go
client := anthropic.NewClient()
target, err := client.Beta.Organization.ClaudeTag.Bundles.Targets.New(
context.Background(),
"capp_011CZkZjLP1cWxj5EtMmdgbq",
anthropic.BetaOrganizationClaudeTagBundleTargetNewParams{
BetaClaudeTagBundleTargetCreate: anthropic.BetaClaudeTagBundleTargetCreateUnionParam{
OfSlackWorkspace: &anthropic.BetaClaudeTagSlackWorkspaceBundleTargetCreateParam{
SlackWorkspaceID: "slws_011CZkZnWa7xPc3uJfZe5LgT",
},
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(target.ID)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.bundles.targets.TargetCreateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = TargetCreateParams.builder()
.slackWorkspaceBetaClaudeTagBundleTargetCreate("slws_011CZkZnWa7xPc3uJfZe5LgT")
.build();
var target = client.beta().organization().claudeTag().bundles().targets()
.create("capp_011CZkZjLP1cWxj5EtMmdgbq", params);
IO.println(target.id());
}
```
```php PHP
$client = new Client();
$target = $client->beta->organization->claudeTag->bundles->targets->create(
bundleID: 'capp_011CZkZjLP1cWxj5EtMmdgbq',
betaClaudeTagBundleTargetCreate: [
'type' => 'slack_workspace',
'slackWorkspaceID' => 'slws_011CZkZnWa7xPc3uJfZe5LgT',
],
);
echo "{$target->id}\n";
```
```ruby Ruby
client = Anthropic::Client.new
bundle_id = "capp_011CZkZjLP1cWxj5EtMmdgbq"
target = client.beta.organization.claude_tag.bundles.targets.create(
bundle_id,
beta_claude_tag_bundle_target_create: {
type: :slack_workspace,
slack_workspace_id: "slws_011CZkZnWa7xPc3uJfZe5LgT"
}
)
puts target.id
```
Una vinculación a un canal tiene condiciones bajo las cuales se aplica, como solo mientras no haya ningún invitado de Slack en el canal. Las condiciones se establecen en claude.ai y no se devuelven aquí. Vincular a través de esta API usa las condiciones predeterminadas, y vincular un par que ya está vinculado deja sus condiciones sin cambios.
### Obtener un destino de Bundle
`GET /v1/organizations/claude_tag/bundles/{bundle_id}/targets/{target_id}` devuelve el destino de Bundle. Un `target_id` que no tiene el prefijo `btgt_` devuelve `400`. Uno que pertenece a otro Bundle, que fue desvinculado o que corresponde a un canal o espacio de trabajo que ya no está dado de alta devuelve `404`. Requiere el alcance `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq/targets/btgt_011CZkZpBv9yQd6wKhAr8MnU" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:bundles:targets retrieve \
--bundle-id capp_011CZkZjLP1cWxj5EtMmdgbq \
--target-id btgt_011CZkZpBv9yQd6wKhAr8MnU
```
```python Python
client = anthropic.Anthropic()
target = client.beta.organization.claude_tag.bundles.targets.retrieve(
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
bundle_id="capp_011CZkZjLP1cWxj5EtMmdgbq",
)
print(target.type)
```
```typescript TypeScript
const client = new Anthropic();
const target = await client.beta.organization.claudeTag.bundles.targets.retrieve(
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
{ bundle_id: "capp_011CZkZjLP1cWxj5EtMmdgbq" }
);
console.log(target.type);
```
```csharp C#
AnthropicClient client = new();
var target = await client.Beta.Organization.ClaudeTag.Bundles.Targets.Retrieve(
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
new() { BundleID = "capp_011CZkZjLP1cWxj5EtMmdgbq" }
);
Console.WriteLine(target.Type.GetString());
```
```go Go
client := anthropic.NewClient()
target, err := client.Beta.Organization.ClaudeTag.Bundles.Targets.Get(
context.Background(),
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
anthropic.BetaOrganizationClaudeTagBundleTargetGetParams{
BundleID: "capp_011CZkZjLP1cWxj5EtMmdgbq",
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(target.Type)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.bundles.targets.TargetRetrieveParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = TargetRetrieveParams.builder()
.bundleId("capp_011CZkZjLP1cWxj5EtMmdgbq")
.build();
var target = client.beta().organization().claudeTag().bundles().targets()
.retrieve("btgt_011CZkZpBv9yQd6wKhAr8MnU", params);
IO.println(target.type().asString());
}
```
```php PHP
$client = new Client();
$target = $client->beta->organization->claudeTag->bundles->targets->retrieve(
targetID: 'btgt_011CZkZpBv9yQd6wKhAr8MnU',
bundleID: 'capp_011CZkZjLP1cWxj5EtMmdgbq',
);
echo "{$target->type}\n";
```
```ruby Ruby
client = Anthropic::Client.new
bundle_id = "capp_011CZkZjLP1cWxj5EtMmdgbq"
target_id = "btgt_011CZkZpBv9yQd6wKhAr8MnU"
target = client.beta.organization.claude_tag.bundles.targets.retrieve(
target_id,
bundle_id: bundle_id
)
puts target.type
```
### Desvincular un Bundle
`DELETE /v1/organizations/claude_tag/bundles/{bundle_id}/targets/{target_id}` desvincula el Bundle. Una desvinculación repetida devuelve `404`. Requiere el alcance `write:claude_tag`.
```bash cURL
curl -X DELETE "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq/targets/btgt_011CZkZpBv9yQd6wKhAr8MnU" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:bundles:targets delete \
--bundle-id capp_011CZkZjLP1cWxj5EtMmdgbq \
--target-id btgt_011CZkZpBv9yQd6wKhAr8MnU
```
```python Python
client = anthropic.Anthropic()
deleted_target = client.beta.organization.claude_tag.bundles.targets.delete(
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
bundle_id="capp_011CZkZjLP1cWxj5EtMmdgbq",
)
print(deleted_target.id)
```
```typescript TypeScript
const client = new Anthropic();
const deletedTarget = await client.beta.organization.claudeTag.bundles.targets.delete(
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
{ bundle_id: "capp_011CZkZjLP1cWxj5EtMmdgbq" }
);
console.log(deletedTarget.id);
```
```csharp C#
AnthropicClient client = new();
var deletedTarget = await client.Beta.Organization.ClaudeTag.Bundles.Targets.Delete(
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
new() { BundleID = "capp_011CZkZjLP1cWxj5EtMmdgbq" }
);
Console.WriteLine(deletedTarget.ID);
```
```go Go
client := anthropic.NewClient()
deletedTarget, err := client.Beta.Organization.ClaudeTag.Bundles.Targets.Delete(
context.Background(),
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
anthropic.BetaOrganizationClaudeTagBundleTargetDeleteParams{
BundleID: "capp_011CZkZjLP1cWxj5EtMmdgbq",
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(deletedTarget.ID)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.bundles.targets.TargetDeleteParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = TargetDeleteParams.builder()
.bundleId("capp_011CZkZjLP1cWxj5EtMmdgbq")
.build();
var deletedTarget = client.beta().organization().claudeTag().bundles().targets()
.delete("btgt_011CZkZpBv9yQd6wKhAr8MnU", params);
IO.println(deletedTarget.id());
}
```
```php PHP
$client = new Client();
$deletedTarget = $client->beta->organization->claudeTag->bundles->targets->delete(
targetID: 'btgt_011CZkZpBv9yQd6wKhAr8MnU',
bundleID: 'capp_011CZkZjLP1cWxj5EtMmdgbq',
);
echo "{$deletedTarget->id}\n";
```
```ruby Ruby
client = Anthropic::Client.new
bundle_id = "capp_011CZkZjLP1cWxj5EtMmdgbq"
target_id = "btgt_011CZkZpBv9yQd6wKhAr8MnU"
deleted_target = client.beta.organization.claude_tag.bundles.targets.delete(
target_id,
bundle_id: bundle_id
)
puts deleted_target.id
```
```json Response
{
"type": "bundle_target_deleted",
"id": "btgt_011CZkZpBv9yQd6wKhAr8MnU"
}
```
## Valores no reconocidos
`guest_policy.type`, el `type` de una fuente, el `type` de un destino de Bundle y los códigos de error pueden incorporar nuevos valores en cualquier momento. Trata un valor que no reconozcas como tratarías cualquier cadena desconocida, en lugar de fallar.
## Limitación de velocidad
Las solicitudes se limitan por organización, en dos presupuestos que comparten todas las claves de tu organización y que son independientes de los demás límites de la Admin API de tu organización. Cada presupuesto permite una ráfaga y luego se recarga a un ritmo constante:
| Presupuesto | Solicitudes | Ráfaga | Recarga |
| ----------- | ---------------------- | ------ | ------------- |
| Lecturas | Cada `GET` | 120 | 2 por segundo |
| Cambios | Cada `POST` y `DELETE` | 60 | 1 por segundo |
Las solicitudes que superan un presupuesto devuelven **429 Too Many Requests** con un encabezado `retry-after`. Las respuestas incluyen los encabezados `anthropic-ratelimit-requests-limit`, `anthropic-ratelimit-requests-remaining` y `anthropic-ratelimit-requests-reset` del presupuesto del que consumió la solicitud.
## Paginación
Los endpoints de lista usan un **cursor opaco**. La primera solicitud devuelve hasta `limit` filas más un cursor `next_page`; pasa el cursor sin cambios como el parámetro `page` en la siguiente solicitud, y repite hasta que `next_page` sea `null`. Trata la cadena del cursor como opaca: no la analices, modifiques ni construyas tú mismo. [Listar canales](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#list-channels) puede devolver una página con menos de `limit` canales, o ninguno, mientras `next_page` sigue establecido, así que sigue solicitando páginas hasta que `next_page` sea `null`. Los iteradores de lista de los SDK de Python, TypeScript, C#, Go, Java y Ruby y la CLI (excepto con `--format raw`) lo hacen por ti. En PHP y curl, solicita cada página tú mismo y pasa su `next_page` como `page`.
`limit` tiene un valor predeterminado de 20, con un mínimo de 1 y un máximo de 100. Cada lista se ordena del más reciente al más antiguo según `created_at`, y no admite ningún otro orden.
## Respuestas de error
Las respuestas de error siguen la forma estándar documentada en [Errores](https://platform.claude.com/docs/es/api/errors). Indica el `request_id` del cuerpo de la respuesta cuando te comuniques con soporte.
| Estado | Significado |
| ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 400 | Entrada no válida, o la operación no se aplica a este canal, espacio de trabajo o Bundle (consulta la sección de cada endpoint). |
| 401 | Falta el encabezado `x-api-key`, o no se reconoce la clave. |
| 403 | La clave no es una clave con alcance a nivel de organización, le falta el alcance requerido, o tu organización no puede hacer este cambio. |
| 404 | Recurso no encontrado, o no pertenece a tu organización. También se devuelve cuando la solicitud omite el valor `anthropic-beta`, o la API no está habilitada para tu organización, de modo que los endpoints aparecen como inexistentes. |
| 409 | Otra cosa cambió o eliminó el recurso mientras se ejecutaba la solicitud. No se almacenó nada. Vuelve a leerlo y reenvía el cambio si todavía es necesario. |
| 429 | Se excedió el "rate limit" (límite de velocidad). Consulta [Limitación de velocidad](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#rate-limiting). |
| 500 | Error interno. |
| 503 | Temporal. En un cambio, no indica si el cambio se almacenó. Todos los cambios se pueden repetir de forma segura, así que vuelve a enviar la solicitud sin cambios. |
Cuando un estado tiene varias causas que manejarías de forma diferente, el error también incluye `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` | Estado | Significado y qué hacer |
| -------------------------------------------- | ------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `organization_level_scoped_api_key_required` | 403 | La credencial no es una clave de API de administrador con alcance que pertenezca a la organización en su conjunto. Pide una a tu propietario principal. |
| `api_key_scope_missing` | 403 | A la clave le falta `read:claude_tag` o `write:claude_tag`, según lo que requiera el endpoint. |
| `workspace_selection_not_accepted` | 400 | La solicitud envió el encabezado `anthropic-workspace-id`. Elimínalo. |
| `claude_tag_writes_not_enabled` | 403 | Tu organización puede leer a través de esta API, pero no está habilitada para hacer cambios. |
| `compliance_configuration_restricted` | 403 | Tu organización tiene una configuración de cumplimiento bajo la cual Claude Tag no almacena nada nuevo, como la retención de datos cero. Se rechazan dar de alta un canal, actualizar la configuración (incluso para borrarla) y vincular un Bundle. Desvincular un Bundle y eliminar un canal no se rechazan. |
| `environment_not_found` | 404 | `environment_id` no corresponde a ningún entorno que tu organización pueda usar aquí. El `id` de la ruta es correcto. |
| `environment_archived` | 400 | `environment_id` corresponde a un entorno archivado. |
| `slack_channel_set_up_settings_refused` | 400 | La solicitud dio de alta el canal y luego se rechazó `settings`. `details.slack_channel_id` es el canal. Consulta [Dar de alta un canal](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#set-up-a-channel). |
| `slack_channel_set_up_environment_not_found` | 404 | La solicitud dio de alta el canal y luego no se encontró `environment_id`. `details.slack_channel_id` es el canal. |
| `slack_channel_set_up_settings_conflict` | 409 | La solicitud dio de alta el canal y luego otro cambio se superpuso con `settings`. No se almacenó nada de `settings`. `details.slack_channel_id` es el canal. |
| `slack_channel_not_configured` | 400 | El canal no está [configurado](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#configured-levels), por lo que no se puede eliminar. |
Es posible que se agreguen nuevos códigos. Trata un código que no reconozcas de la misma forma en que tratas su estado. Un `404` sin `error_code` tiene una de dos causas. O bien no se encontró algo que la solicitud nombra (un `id` en la ruta, o un canal o espacio de trabajo de Slack en el cuerpo o en la consulta), o bien todos los endpoints aparecen como inexistentes porque la solicitud omite el valor `anthropic-beta` o la API no está habilitada para tu organización. Para distinguirlas, [obtén los valores predeterminados de Slack](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#get-the-slack-defaults) con la misma clave y los mismos encabezados: esa solicitud no nombra nada, por lo que devuelve `404` solo en el segundo caso.
## Eventos del Activity Feed
Cada cambio realizado a través de esta API se registra en el [Activity Feed de la Compliance API](https://platform.claude.com/docs/es/manage-claude/compliance-activity-feed) de tu organización, atribuido a la clave de API como un `api_actor` que lleva su ID `apikey_`. Los eventos son los mismos que el feed registra cuando se realiza el mismo cambio en claude.ai, por lo que una sola consulta encuentra un cambio sin importar cómo se haya realizado.
| Evento | Se emite cuando |
| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `ccr_agent_created` | Se da de alta un canal. |
| `ccr_agent_updated` | Cambia una configuración en un canal, un espacio de trabajo o los valores predeterminados de Slack, o un nivel pasa a estar [configurado](https://platform.claude.com/docs/es/manage-claude/claude-tag-api#configured-levels). |
| `ccr_agent_deleted` | Se elimina un canal. Sus destinos de Bundle se eliminan con él y no emiten ningún evento propio. |
| `ccr_agent_proxy_profile_bound` | Se vincula un Bundle. |
| `ccr_agent_proxy_profile_unbound` | Se desvincula un Bundle. |
Los eventos identifican un canal o espacio de trabajo por su `agent_id`, no por su `id`. Los dos eventos de Bundle identifican el Bundle en `profile_id` y el canal o espacio de trabajo en `scope_id`.
Un evento `ccr_agent_updated` enumera lo que cambió en `updated_fields`, con los nombres propios del feed:
| Configuración | Nombre en `updated_fields` |
| ----------------------------------- | -------------------------- |
| `enabled` | `slackbot_version` |
| `instructions` | `system_prompt_addendum` |
| `model` | `default_model` |
| `environment_id` | `default_environment_id` |
| `guest_policy` | `guest_policy` |
| (el nivel pasó a estar configurado) | `is_virtual` |
Las lecturas, las solicitudes que no cambian nada y las solicitudes que se rechazan antes de que se almacene algo no registran nada. Una solicitud de alta que da de alta un canal y cuyo `settings` se rechaza después registra `ccr_agent_created`.
## Consulta también
Donde tu propietario principal crea una clave con alcance definido.
Qué es Claude Tag, cómo configurarlo y qué hace cada configuración en Slack.
El registro de auditoría de cada cambio realizado aquí y en claude.ai.
Administra los plugins en tu organización de Claude Enterprise.