---
title: Claude Tag API
url: https://platform.claude.com/docs/it/manage-claude/claude-tag-api
description: "Gestisci Claude Tag in Slack per la tua organizzazione Claude Enterprise dai tuoi sistemi: leggi e modifica le impostazioni dei canali, dei workspace e dei valori predefiniti Slack della tua organizzazione, scopri quali impostazioni si applicano e perché, e collega gli Access bundle."
---
[Claude Tag](https://claude.com/docs/claude-tag/overview) è Claude che lavora come un collega in Slack: qualcuno menziona Claude in un canale e Claude risponde nel thread. La Claude Tag API ti consente di leggere e modificare, dai tuoi sistemi, le impostazioni di Claude Tag che altrimenti un proprietario dell'organizzazione imposta manualmente in [claude.ai > Organization settings > Claude Tag](https://claude.ai/admin-settings/claude-tag). Usala per attivare Claude canale per canale da un flusso di approvazione, mantenere la tua configurazione sotto controllo di versione o verificare cosa si applica in ogni canale.
Claude Tag è un prodotto di claude.ai. Questa API lo gestisce per un'organizzazione Claude Enterprise e non ha nulla a che fare con i workspace di Claude Platform, l'utilizzo dell'API o la Claude Console.
**È richiesta una chiave Admin API con scope**
Questi endpoint richiedono una chiave Admin API con lo scope `read:claude_tag` (per gli endpoint `GET`) o lo scope `write:claude_tag` (per gli endpoint `POST` e `DELETE`); consulta [Scope](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#scopes). Consulta [Creare una chiave API Admin](https://platform.claude.com/docs/it/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization) per sapere dove il tuo proprietario principale ne crea una. Passa la chiave nell'header `x-api-key` in ogni richiesta, insieme all'header [`anthropic-version`](https://platform.claude.com/docs/it/api/versioning) e all'header beta mostrato nella nota seguente.
La Claude Tag API è in **beta** ed è disponibile solo per le organizzazioni Claude Enterprise. Non è disponibile per le organizzazioni Claude Platform (Claude Console).
Ogni richiesta deve includere l'[header beta](https://platform.claude.com/docs/it/api/beta-headers) `anthropic-beta: claude-tag-2026-09-28` (l'SDK e la CLI `ant` lo inviano per te). Una richiesta senza di esso restituisce `404`, esattamente come se l'endpoint non esistesse.
## Endpoint
L'API espone 18 endpoint distribuiti su cinque risorse:
| Risorsa | Endpoint |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Canali Slack:** configura un canale, elenca i canali di un workspace o trovane uno tramite i suoi ID Slack, leggine uno, modificane le impostazioni, scopri cosa si applica in esso, rimuovilo | `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}` |
| **Workspace Slack:** elenca i tuoi workspace connessi o trovane uno tramite il suo ID Slack, leggine uno, modificane le impostazioni, scopri cosa si applica in esso | `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` |
| **Valori predefiniti Slack:** leggi e modifica le impostazioni che si applicano a ogni workspace e canale | `GET /v1/organizations/claude_tag/slack_defaults`
`POST /v1/organizations/claude_tag/slack_defaults` |
| **Bundle:** elenca gli Access bundle della tua organizzazione, leggine uno (sola lettura) | `GET /v1/organizations/claude_tag/bundles`
`GET /v1/organizations/claude_tag/bundles/{bundle_id}` |
| **Bundle target:** elenca dove è collegato un Bundle, collegalo a un canale o workspace, leggi un collegamento, scollegalo | `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}` |
Questa versione copre Slack. La connessione e disconnessione di un workspace Slack, la creazione e modifica degli Access bundle, i limiti di spesa e ogni impostazione di Claude Tag diversa dalle cinque in [Impostazioni](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#settings) restano in claude.ai.
## Prerequisiti
* La tua organizzazione deve avere un piano Claude Enterprise, con [Claude Tag configurato](https://claude.com/docs/claude-tag/admins/setup-overview) e almeno un workspace Slack connesso.
* Il tuo proprietario principale crea una chiave Admin API con lo scope `read:claude_tag`, lo scope `write:claude_tag` o entrambi in [claude.ai > Organization settings > API](https://claude.ai/admin-settings/api-access). Consulta [Creare una chiave API Admin](https://platform.claude.com/docs/it/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization).
* Ogni richiesta include tre header: `x-api-key`, `anthropic-version: 2023-06-01` e `anthropic-beta: claude-tag-2026-09-28`.
Gli SDK Python, TypeScript, C#, Go, Java, PHP e Ruby espongono questi endpoint sotto `client.beta.organization.claude_tag` (typescript: `client.beta.organization.claudeTag`; csharp, go: `client.Beta.Organization.ClaudeTag`; java: `client.beta().organization().claudeTag()`; php: `$client->beta->organization->claudeTag`), e la [CLI `ant`](https://platform.claude.com/docs/it/cli-sdks-libraries/cli/quickstart) sotto `ant beta:organization:claude-tag`; inviano per te gli header `anthropic-version` e `anthropic-beta`. Gli esempi in questa pagina usano il client predefinito di ciascun SDK che, come la CLI, legge la chiave Admin API dalla variabile d'ambiente `ANTHROPIC_API_KEY`; gli esempi curl leggono la chiave dalla stessa variabile e la passano nell'header `x-api-key`. Quando un SDK o la CLI recupera altre pagine per te, `limit` imposta la dimensione della pagina, non il totale (consulta [Paginazione](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#pagination)).
Le chiavi API appartengono all'organizzazione e continuano a funzionare anche dopo che la persona che le ha create se ne va. Non condividerle e non inserirle nel controllo del codice sorgente.
## Avvio rapido
Elenca i workspace Slack che la tua organizzazione ha connesso 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()
# Recupera automaticamente altre pagine quando necessario.
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 questa pagina; per la successiva, richiama 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
}
```
Un'impostazione che vale `null` non è impostata su questo workspace, quindi il workspace la eredita. Consulta [Impostazioni memorizzate ed effettive](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#stored-and-effective-settings).
## Scope
| Scope | Concede |
| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------- |
| `read:claude_tag` | Ogni endpoint `GET` in questa pagina. |
| `write:claude_tag` | Ogni endpoint `POST` e `DELETE` in questa pagina. Non concede le letture, anche se la risposta a una modifica contiene la risorsa modificata. |
Una chiave può avere entrambi gli scope. Un'integrazione che cerca un canale e poi lo modifica ha bisogno di entrambi. Nessun altro scope concede l'accesso a questi endpoint.
La chiave deve appartenere all'organizzazione nel suo complesso. L'organizzazione è sempre quella a cui appartiene la chiave, e nessuna richiesta ne specifica una. Una richiesta che invia l'header `anthropic-workspace-id` restituisce `400`, perché nulla qui appartiene a un workspace di Claude Platform.
## Concetti chiave
### Nomi in questa pagina e in claude.ai
| Questa API | claude.ai e Slack |
| ------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Workspace Slack | Un workspace Slack (che Slack chiama anche team). Non ha relazione con un workspace di Claude Platform, i cui ID iniziano con `wrkspc_`. |
| Valori predefiniti Slack | **Default Slack access** |
| Livello di impostazioni | Uno [scope](https://claude.com/docs/claude-tag/admins/customize): un canale, un workspace o i valori predefiniti Slack |
| Bundle | Un [Access bundle](https://claude.com/docs/claude-tag/concepts/glossary#access-bundle) |
| `enabled` | L'interruttore **Enable Claude Tag in Slack** |
| `instructions` | **Custom instructions** |
| `model` | **Model** |
| `environment_id` | **Environment** |
| `guest_policy` | **How should Claude work in channels with guests**: `restrict` corrisponde a **Restrict**, `channel_only` a **Channel only** e `allow` a **Full access** |
### Canali e workspace configurati
Un canale o workspace è **configurato** ("set up") quando Claude Tag conserva un record di impostazioni per esso. Solo un canale o workspace configurato ha un `id`, e solo questi vengono elencati: è Slack, non questa API, a conservare l'elenco completo dei canali di un workspace.
* Un **workspace** viene configurato quando un proprietario dell'organizzazione lo connette in claude.ai. Nessun endpoint configura o rimuove un workspace.
* Un **canale** viene configurato in claude.ai, al primo utilizzo di Claude in esso, oppure con [Configurare un canale](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#set-up-a-channel).
* I **valori predefiniti Slack** vengono configurati la prima volta che qualcuno configura Claude Tag: un proprietario connette un workspace Slack, oppure un membro accede a Claude in Slack o lo usa per la prima volta.
La tua organizzazione possiede un workspace finché la sua connessione è attiva, e possiede i canali al suo interno. Un canale o workspace che non possiedi restituisce lo stesso `404` di uno che non esiste.
### ID
Conosci un canale tramite gli ID che Slack ti mostra. Cerca il suo `id` una volta con [Trovare un canale tramite i suoi ID Slack](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#find-a-channel-by-its-slack-ids), poi memorizza e usa l'`id`.
| ID | Prefisso | Dove compare |
| ----------------------- | --------- | ------------------------------------------------------------------------------------- |
| Risorsa canale Slack | `slch_` | `id` su un canale; `slack_channel_id` nei corpi delle richieste e nelle risposte |
| Risorsa workspace Slack | `slws_` | `id` su un workspace; `slack_workspace_id` nei corpi delle richieste e nelle risposte |
| Bundle | `capp_` | `id` su un Bundle; `{bundle_id}` nei percorsi |
| Bundle target | `btgt_` | `id` su un Bundle target; `{target_id}` nei percorsi |
| ID del team di Slack | `T` | `slack.team_id`; il parametro di query `slack_team_id` |
| ID del canale di Slack | `C` o `G` | `slack.channel_id`; il parametro di query `slack_channel_id` |
`slack_channel_id` ha due significati. In un **parametro di query** è l'ID proprio di Slack (`C05HJKL6MNP`). In un **corpo di richiesta o in una risposta** è l'`id` emesso da questa API (`slch_...`). Gli ID propri di Slack in un corpo o in una risposta si trovano sempre sotto `slack`.
Un `id` non cambia finché il canale o workspace resta configurato, qualunque cosa tu modifichi su di esso, con un'eccezione descritta in [Modalità di sola lettura](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#read-only-mode). Un canale o workspace che viene rimosso e configurato di nuovo ha un nuovo `id`, e quello vecchio continua a restituire `404`. Quando un `id` memorizzato restituisce `404` senza `error_code`, [ottieni i valori predefiniti Slack](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#get-the-slack-defaults) con la stessa chiave e gli stessi header. Quella richiesta non specifica alcun canale o workspace, quindi qualsiasi stato diverso da `404` significa che l'`id` non esiste più: trova di nuovo il canale o workspace tramite i suoi ID Slack. Un `404` anche lì non dice nulla sull'`id`: conserva i valori `id` memorizzati e consulta [Risposte di errore](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#error-responses).
`agent_id` (con prefisso `cagt_`) è il modo in cui la [Compliance API](https://platform.claude.com/docs/it/manage-claude/compliance-api) identifica lo stesso canale o workspace, sia come proprietario delle sessioni che Claude ha eseguito lì sia negli [eventi dell'Activity Feed](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#activity-feed-events). Dura quanto l'`id`.
### Impostazioni
Ogni livello di impostazioni memorizza le stesse cinque impostazioni, tutte facoltative:
| Impostazione | Tipo | Descrizione |
| ---------------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `enabled` | boolean | Se Claude è attivo. |
| `instructions` | string | Indicazioni permanenti che Claude legge in ogni sessione. Al massimo 8.192 caratteri dopo la rimozione degli spazi iniziali e finali. Un testo vuoto cancella l'impostazione. |
| `model` | string | Il modello con cui iniziano le nuove sessioni: un [ID di modello](https://platform.claude.com/docs/it/models/overview) che la tua organizzazione può usare con Claude Tag. Al massimo 128 caratteri. |
| `environment_id` | string | L'ambiente cloud in cui vengono eseguite le sessioni, con prefisso `env_`. Deve essere attivo e appartenere alla tua organizzazione. |
| `guest_policy` | object | Cosa fa Claude in un canale mentre vi è presente un ospite Slack, per tutti nel canale: `{"type": "allow"}` (Claude risponde), `{"type": "restrict"}` (Claude non risponde) oppure `{"type": "channel_only"}` (Claude risponde solo con i Bundle collegati al canale stesso). Consulta [Limitare i canali con ospiti](https://claude.com/docs/claude-tag/admins/restrict-access#restrict-guest-channels) per sapere cosa significa nei canali condivisi tramite Slack Connect o attraverso un Enterprise Grid. |
`model` e `environment_id` vengono verificati quando li scrivi e non più in seguito: se il modello o l'ambiente cambiano successivamente, entrambe le viste continuano a restituire il valore memorizzato.
Se un proprietario dell'organizzazione ha assegnato un livello di impostazioni a un pool di runner self-hosted in claude.ai, il suo `environment_id` restituisce l'ID del pool, che inizia con `ccpool_`. Questa API non può impostare un pool di runner e restituisce `400` per una richiesta che modifica o cancella `environment_id` su un livello di impostazioni che ne memorizza uno.
### Impostazioni memorizzate ed effettive
Le impostazioni esistono su tre livelli: il canale, il workspace in cui si trova il canale e i valori predefiniti Slack della tua organizzazione. Ogni livello memorizza solo ciò che è stato impostato su di esso. L'API ti offre due viste:
* La vista **memorizzata** ([Ottenere un canale](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#get-a-channel), [Ottenere un workspace](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#get-a-workspace)) contiene ciò che il canale o workspace stesso memorizza. Un'impostazione non impostata lì vale `null`. Usala per confrontarla con la configurazione che conservi altrove.
* La vista **effettiva** ([Ottenere le impostazioni effettive di un canale](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#get-a-channels-effective-settings), [Ottenere le impostazioni effettive di un workspace](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#get-a-workspaces-effective-settings)) contiene ciò che si applica una volta considerati tutti i livelli, e `sources` indica il livello da cui proviene ciascun valore. Usala per le verifiche, o per scoprire perché Claude si comporta in un certo modo in un canale.
Ogni impostazione viene risolta separatamente:
| Impostazione | Regola | Quando nessun livello la imposta |
| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
| `enabled` | Decide il livello più vicino che la imposta, quindi `true` su un canale attiva Claude lì anche quando il suo workspace memorizza `false`. | `true` |
| `instructions` | Additiva. Il testo di ogni livello che la imposta viene unito, dal più ampio al più specifico, con una riga vuota tra l'uno e l'altro. | `null` |
| `model` | Decide il livello più vicino che la imposta. | `null`: Claude usa il modello predefinito del prodotto |
| `environment_id` | Decide il livello più vicino che la imposta. | `null` |
| `guest_policy` | Decide il livello più vicino che la imposta. | `restrict` in un'organizzazione i cui valori predefiniti Slack sono configurati |
Ad esempio, un'organizzazione memorizza delle istruzioni nei suoi valori predefiniti Slack, disattiva Claude su un workspace e imposta un modello su un canale di quel workspace. La vista effettiva del canale mostra i tre valori e la provenienza di ciascuno:
```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 fonte è una delle seguenti:
| `type` | Significato |
| ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `slack_channel` | Il canale, indicato in `slack_channel_id`. |
| `slack_workspace` | Il workspace, indicato in `slack_workspace_id`. |
| `slack_parent_channel` | Il canale padre di un canale di codice, indicato in `slack_channel_id`. Un canale di codice è un canale avviato da un altro canale. Finché il padre è un canale pubblico nello stesso workspace, si colloca tra il canale e il workspace e contribuisce solo con `instructions` e `environment_id`. |
| `slack_defaults` | I valori predefiniti Slack della tua organizzazione, che non hanno ID. |
| `default` | Nessun livello imposta un valore, quindi si applica il valore predefinito integrato. |
`sources.instructions` è un elenco, dal più ampio al più specifico, di ogni livello che contribuisce con del testo, ed è vuoto quando nessuno lo fa. L'ID su una fonte può essere `null` in un'organizzazione che raggiunge il canale tramite una connessione Slack Enterprise Grid anziché tramite il workspace del canale stesso.
### Modificare le impostazioni
I tre endpoint di aggiornamento e [Configurare un canale](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#set-up-a-channel) accettano un oggetto `settings` secondo le stesse regole:
* **Un'impostazione che ometti resta invariata.** `{"settings": {"enabled": false}}` disattiva Claude e lascia le altre quattro impostazioni come sono.
* **Un'impostazione che invii come `null` viene cancellata**, quindi il livello torna a ereditarla.
* **Tutto o niente.** Se un qualsiasi valore in una richiesta viene rifiutato, nessuna impostazione della richiesta viene memorizzata.
* **Sicuro da ripetere.** Ogni modifica lascia la risorsa come l'ha lasciata la prima richiesta identica, quindi nessun endpoint accetta un `Idempotency-Key`. Una richiesta che non altera nulla non scrive nulla e non registra alcun evento nell'Activity Feed.
* **Vince l'ultima scrittura.** Nessuna richiesta accetta una precondizione. Due chiamanti che leggono ciascuno una risorsa e poi modificano la stessa impostazione si sovrascrivono a vicenda. Un `409` viene restituito solo quando un'altra modifica si sovrappone alla tua richiesta mentre è in esecuzione; nulla della tua richiesta è stato memorizzato, quindi leggi di nuovo la risorsa e invia di nuovo la modifica se è ancora necessaria.
Una modifica a `guest_policy` su un canale può terminare le sessioni in esecuzione in quel canale. Terminano in background e la risposta non attende che ciò avvenga.
### Livelli personalizzati
Un livello di impostazioni è **personalizzato** ("configured") una volta che una persona o una chiave ha modificato un'impostazione su di esso o vi ha collegato un Bundle. Da quel momento resta personalizzato, anche dopo che ogni impostazione è stata cancellata e ogni Bundle scollegato. Un canale configurato dal primo utilizzo di Claude, o tramite questa API senza alcuna impostazione, non è personalizzato fino alla sua prima modifica o al suo primo Bundle. Questo conta in due casi: solo un canale personalizzato può essere [rimosso](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#remove-a-channel), e solo un canale non personalizzato può ricevere un nuovo `id` (consulta [Modalità di sola lettura](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#read-only-mode)).
### Modalità di sola lettura
**API / Terraform read-only mode** è un'impostazione che un proprietario dell'organizzazione attiva e disattiva nelle impostazioni di Claude Tag di claude.ai. Il nome descrive claude.ai e Slack: mentre la modalità è attiva, questi rifiutano le modifiche di una persona a ciò che questa API gestisce, quindi solo le chiavi apportano tali modifiche. Non rende questa API di sola lettura. Ogni endpoint in questa pagina risponde allo stesso modo sia che la modalità sia attiva sia che sia disattivata, e nessun endpoint la legge o la modifica.
Mentre la modalità è disattivata, persone e chiavi modificano le stesse impostazioni e collegano e scollegano gli stessi Bundle, e ogni modifica sostituisce ciò che è memorizzato. Attivala se la tua pipeline deve essere l'unica fonte di modifiche.
Mentre la modalità è attiva, claude.ai e Slack rifiutano:
* La modifica di una qualsiasi delle cinque impostazioni su un canale, un workspace o i valori predefiniti Slack.
* La configurazione di un canale, la rimozione di un canale o la disconnessione di un workspace in claude.ai.
* Il collegamento di un Bundle a un canale o workspace, il suo scollegamento o l'eliminazione di un Bundle collegato a uno di essi.
Alcune cose restano possibili in entrambi i casi: un proprietario può comunque connettere un nuovo workspace, creare e modificare Bundle e modificare le impostazioni di Claude Tag che questa API non gestisce. Il primo utilizzo di Claude configura comunque un canale, l'eliminazione di un canale in Slack lo rimuove comunque e la disinstallazione dell'app Slack di Claude disconnette comunque quel workspace.
Mentre la modalità è disattivata, configurare in claude.ai un canale che è già configurato e non è [personalizzato](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#configured-levels) può sostituire il record del canale. Il canale ha quindi un nuovo `id` e un nuovo `agent_id`, e il vecchio `id` restituisce `404`. L'`id` di un canale personalizzato dura finché il canale non viene rimosso.
### Messaggi diretti di gruppo
Un messaggio diretto di gruppo di Slack ha un ID nel formato di un canale, quindi l'utilizzo di Claude in uno di essi lo configura come un canale: ha un `id`, viene elencato e può essere letto. Configurarne uno tramite questa API, modificarne un'impostazione e collegarvi un Bundle restituiscono ciascuno `400`. Scollegare un Bundle da uno di essi è consentito.
## Flussi di lavoro di esempio
### Attivare Claude solo nei canali approvati
Qualsiasi membro può invitare Claude in un canale pubblico. Per mantenere Claude attivo solo dove lo hai approvato:
1. Disattiva Claude ovunque impostando `enabled` su `false` nei [valori predefiniti Slack](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#update-the-slack-defaults).
2. Quando il tuo sistema di approvazione approva un canale, [configura il canale](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#set-up-a-channel) con `"settings": {"enabled": true}`. La richiesta accetta gli ID propri di Slack e restituisce il canale indipendentemente dal fatto che fosse già configurato, quindi è sicura da ripetere.
3. Nella stessa esecuzione, [collega](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#attach-a-bundle) i Bundle per cui il team è stato approvato, in modo che la prima sessione del canale abbia già i suoi strumenti.
### Mantenere la configurazione sotto controllo di versione
1. Indicizza la tua configurazione in base agli ID che Slack mostra per ogni canale, e [trova ogni canale](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#find-a-channel-by-its-slack-ids) tramite essi.
2. Confronta la vista **memorizzata** con ciò che dichiara il tuo repository. La vista effettiva includerebbe i valori ereditati.
3. Invia solo le impostazioni che differiscono, e invia `null` per un'impostazione che il tuo repository non dichiara più.
4. Chiedi a un proprietario dell'organizzazione di attivare la [modalità di sola lettura](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#read-only-mode), in modo che nessuno modifichi manualmente le stesse impostazioni.
### Verificare cosa si applica ovunque
1. [Elenca i tuoi workspace](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#list-workspaces), poi [elenca i canali di ogni workspace](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#list-channels).
2. Leggi le [impostazioni effettive](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#get-a-channels-effective-settings) di ogni canale e segnala ciò che la tua policy vieta, come un canale in cui `enabled` è `true` senza un'approvazione registrata, o in cui `guest_policy` è `allow`.
3. [Elenca i tuoi Bundle](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#list-bundles), poi [i target di ogni Bundle](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#list-a-bundles-targets), per vedere dove è collegato l'accesso a sistemi sensibili.
## Canali Slack
L'oggetto canale è la vista memorizzata di un canale Slack:
| Campo | Descrizione |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` | `slack_channel`. |
| `id` | Con prefisso `slch_`. Consulta [ID](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#ids). |
| `slack` | Gli ID propri di Slack: `team_id` per il workspace in cui si trova il canale e `channel_id` per il canale. |
| `settings` | Ciò che il canale stesso memorizza. Sempre presente, con tutte e cinque le [impostazioni](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#settings); un'impostazione non impostata vale `null`. |
| `agent_id` | Con prefisso `cagt_`. Consulta [ID](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#ids). |
| `created_at` | Quando il canale è stato configurato. |
| `updated_at` | Quando il record del canale in Claude Tag è cambiato l'ultima volta. Si aggiorna a ogni modifica di un'impostazione, qui, in claude.ai o in Slack, e può aggiornarsi anche per una modifica che nessuna risposta qui mostra. Considera un valore più recente come un motivo per leggere di nuovo il canale, non come la prova che un'impostazione è cambiata. Collegare o scollegare un Bundle non lo aggiorna di per sé. |
Un `id` privo del prefisso `slch_` restituisce `400`. Un `id` che ha il prefisso ma non identifica alcun canale della tua organizzazione restituisce `404`.
### Configurare un canale
`POST /v1/organizations/claude_tag/slack_channels` configura un canale Slack e lo restituisce. `slack.team_id` e `slack.channel_id` sono obbligatori e sono gli ID propri di Slack. `settings` è facoltativo e segue [Modificare le impostazioni](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#changing-settings). Se il canale è già configurato, la richiesta restituisce il canale esistente e applica `settings`; la risposta è `200` in entrambi i casi. Richiede lo scope `write:claude_tag`.
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28" \
-d '{
"slack": {"team_id": "T01ABCD2EFG", "channel_id": "C05HJKL6MNP"},
"settings": {"instructions": "Answer in the language of the question."}
}'
```
```bash CLI
ant beta:organization:claude-tag:slack-channels create \
--slack '{team_id: T01ABCD2EFG, channel_id: C05HJKL6MNP}' \
--settings '{instructions: "Answer in the language of the question."}'
```
```python Python
client = anthropic.Anthropic()
channel = client.beta.organization.claude_tag.slack_channels.create(
slack={"team_id": "T01ABCD2EFG", "channel_id": "C05HJKL6MNP"},
settings={"instructions": "Answer in the language of the question."},
)
print(channel.id)
```
```typescript TypeScript
const client = new Anthropic();
const channel = await client.beta.organization.claudeTag.slackChannels.create({
slack: { team_id: "T01ABCD2EFG", channel_id: "C05HJKL6MNP" },
settings: { instructions: "Answer in the language of the question." }
});
console.log(channel.id);
```
```csharp C#
AnthropicClient client = new();
var channel = await client.Beta.Organization.ClaudeTag.SlackChannels.Create(
new()
{
Slack = new() { TeamID = "T01ABCD2EFG", ChannelID = "C05HJKL6MNP" },
Settings = new() { Instructions = "Answer in the language of the question." },
}
);
Console.WriteLine(channel.ID);
```
```go Go
client := anthropic.NewClient()
channel, err := client.Beta.Organization.ClaudeTag.SlackChannels.New(
context.Background(),
anthropic.BetaOrganizationClaudeTagSlackChannelNewParams{
Slack: anthropic.BetaClaudeTagSlackChannelIdentifiersParam{
TeamID: "T01ABCD2EFG",
ChannelID: "C05HJKL6MNP",
},
Settings: anthropic.BetaClaudeTagSettingsCreateParam{
Instructions: anthropic.String("Answer in the language of the question."),
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(channel.ID)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.BetaClaudeTagSettingsCreate;
import com.anthropic.models.beta.organization.claudetag.slackchannels.BetaClaudeTagSlackChannelIdentifiers;
import com.anthropic.models.beta.organization.claudetag.slackchannels.SlackChannelCreateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SlackChannelCreateParams.builder()
.slack(BetaClaudeTagSlackChannelIdentifiers.builder()
.teamId("T01ABCD2EFG")
.channelId("C05HJKL6MNP")
.build())
.settings(BetaClaudeTagSettingsCreate.builder()
.instructions("Answer in the language of the question.")
.build())
.build();
var channel = client.beta().organization().claudeTag().slackChannels().create(params);
IO.println(channel.id());
}
```
```php PHP
$client = new Client();
$channel = $client->beta->organization->claudeTag->slackChannels->create(
slack: ['teamID' => 'T01ABCD2EFG', 'channelID' => 'C05HJKL6MNP'],
settings: ['instructions' => 'Answer in the language of the question.'],
);
echo "{$channel->id}\n";
```
```ruby Ruby
client = Anthropic::Client.new
channel = client.beta.organization.claude_tag.slack_channels.create(
slack: {team_id: "T01ABCD2EFG", channel_id: "C05HJKL6MNP"},
settings: {instructions: "Answer in the language of the question."}
)
puts channel.id
```
```json Response
{
"type": "slack_channel",
"id": "slch_011CZkZmRt4vNq8sHbYw2KdX",
"slack": {
"team_id": "T01ABCD2EFG",
"channel_id": "C05HJKL6MNP"
},
"settings": {
"enabled": null,
"instructions": "Answer in the language of the question.",
"model": null,
"environment_id": null,
"guest_policy": null
},
"agent_id": "cagt_011CZkZsHz6bTh2vNmEu4QrX",
"created_at": "2026-10-19T16:20:05Z",
"updated_at": "2026-10-19T16:20:05Z"
}
```
Prima che un canale venga configurato, l'app Slack di Claude verifica con Slack che il canale si trovi nel workspace, non sia archiviato e sia visibile all'app. Un canale che non supera questa verifica restituisce `404`, così come un workspace in cui non è installata l'app Slack di Claude.
Configurare il canale e applicare `settings` sono due passaggi. Quando il primo riesce e il secondo viene rifiutato, la risposta è il rifiuto e il canale resta configurato senza nulla di memorizzato. Quel rifiuto contiene un `error_code` che inizia con `slack_channel_set_up_` e l'`id` del nuovo canale in `error.details.slack_channel_id` (consulta [Risposte di errore](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#error-responses)). Correggi `settings` e invialo in un [aggiornamento](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#update-a-channel) a quell'`id`, oppure invia di nuovo la richiesta di configurazione.
### Elencare i canali
`GET /v1/organizations/claude_tag/slack_channels` elenca i canali configurati di un workspace, dal più recente per `created_at`. `slack_team_id` è obbligatorio ed è l'ID proprio di Slack per il workspace. Una pagina può contenere meno di `limit` canali, o nessuno, mentre `next_page` è ancora impostato, quindi continua a richiedere pagine finché `next_page` non è `null` (consulta [Paginazione](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#pagination)). Richiede lo scope `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels?slack_team_id=T01ABCD2EFG" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-channels list --slack-team-id T01ABCD2EFG
```
```python Python
client = anthropic.Anthropic()
channels = client.beta.organization.claude_tag.slack_channels.list(
slack_team_id="T01ABCD2EFG"
)
# Recupera automaticamente altre pagine quando necessario.
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 questa pagina; per la successiva, richiama 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 risposta è `{"data": [...], "next_page": ...}`, dove ogni elemento è un oggetto canale. Uno `slack_team_id` che indica un workspace non posseduto dalla tua organizzazione restituisce `404`.
### Trovare un canale tramite i suoi ID Slack
Aggiungi `slack_channel_id`, l'ID proprio di Slack per il canale, per cercare un singolo canale. `data` contiene quel canale, oppure è vuoto quando il canale non è configurato. Una ricerca ignora `limit` e `page`, e il suo `next_page` è `null`. È così che trovi l'`id` di un canale.
```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
```
Passare un ID `slch_` come `slack_channel_id` restituisce `400`.
### Ottenere un canale
`GET /v1/organizations/claude_tag/slack_channels/{id}` restituisce l'oggetto canale. Richiede lo scope `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels/slch_011CZkZmRt4vNq8sHbYw2KdX" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-channels retrieve \
--id slch_011CZkZmRt4vNq8sHbYw2KdX
```
```python Python
client = anthropic.Anthropic()
channel = client.beta.organization.claude_tag.slack_channels.retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
)
print(channel.settings.enabled)
```
```typescript TypeScript
const client = new Anthropic();
const channel = await client.beta.organization.claudeTag.slackChannels.retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
);
console.log(channel.settings.enabled);
```
```csharp C#
AnthropicClient client = new();
var channel = await client.Beta.Organization.ClaudeTag.SlackChannels.Retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
);
Console.WriteLine(channel.Settings.Enabled);
```
```go Go
client := anthropic.NewClient()
channel, err := client.Beta.Organization.ClaudeTag.SlackChannels.Get(
context.Background(),
"slch_011CZkZmRt4vNq8sHbYw2KdX",
anthropic.BetaOrganizationClaudeTagSlackChannelGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(channel.Settings.Enabled)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var channel = client.beta().organization().claudeTag().slackChannels()
.retrieve("slch_011CZkZmRt4vNq8sHbYw2KdX");
IO.println(channel.settings().enabled().orElse(null));
```
```php PHP
$client = new Client();
$channel = $client->beta->organization->claudeTag->slackChannels->retrieve(
id: 'slch_011CZkZmRt4vNq8sHbYw2KdX',
);
echo json_encode($channel->settings->enabled) . "\n";
```
```ruby Ruby
client = Anthropic::Client.new
channel_id = "slch_011CZkZmRt4vNq8sHbYw2KdX"
channel = client.beta.organization.claude_tag.slack_channels.retrieve(channel_id)
puts channel.settings.enabled
```
### Aggiornare un canale
`POST /v1/organizations/claude_tag/slack_channels/{id}` modifica le impostazioni del canale e restituisce l'oggetto canale. `settings` è obbligatorio e segue [Modificare le impostazioni](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#changing-settings). Richiede lo scope `write:claude_tag`.
Disattiva Claude in un canale e lascia le sue altre impostazioni come sono:
```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
```
Cancella le istruzioni del canale, in modo che si applichino solo quelle ereditate:
```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() scarta i null negli array, quindi costruisci l'oggetto settings per inviare 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
```
### Ottenere le impostazioni effettive di un canale
`GET /v1/organizations/claude_tag/slack_channels/{id}/effective` restituisce ciò che si applica nel canale e da dove proviene ciascun valore. [Impostazioni memorizzate ed effettive](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#stored-and-effective-settings) mostra una risposta completa. In questa vista `enabled` e `guest_policy` non sono mai `null`. La vista viene risolta a ogni lettura, quindi non ha `created_at` né `updated_at`. Se un livello non può essere letto, la richiesta fallisce con `503` anziché risolvere senza di esso. Richiede lo scope `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_channels/slch_011CZkZmRt4vNq8sHbYw2KdX/effective" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-channels:effective retrieve \
--id slch_011CZkZmRt4vNq8sHbYw2KdX
```
```python Python
client = anthropic.Anthropic()
effective = client.beta.organization.claude_tag.slack_channels.effective.retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
)
print(effective.settings.instructions)
```
```typescript TypeScript
const client = new Anthropic();
const effective = await client.beta.organization.claudeTag.slackChannels.effective.retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
);
console.log(effective.settings.instructions);
```
```csharp C#
AnthropicClient client = new();
var effective = await client.Beta.Organization.ClaudeTag.SlackChannels.Effective.Retrieve(
"slch_011CZkZmRt4vNq8sHbYw2KdX"
);
Console.WriteLine(effective.Settings.Instructions);
```
```go Go
client := anthropic.NewClient()
effective, err := client.Beta.Organization.ClaudeTag.SlackChannels.Effective.Get(
context.Background(),
"slch_011CZkZmRt4vNq8sHbYw2KdX",
anthropic.BetaOrganizationClaudeTagSlackChannelEffectiveGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(effective.Settings.Instructions)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var effective = client.beta().organization().claudeTag().slackChannels().effective()
.retrieve("slch_011CZkZmRt4vNq8sHbYw2KdX");
IO.println(effective.settings().instructions().orElse(null));
```
```php PHP
$client = new Client();
$effective = $client->beta->organization->claudeTag->slackChannels->effective->retrieve(
id: 'slch_011CZkZmRt4vNq8sHbYw2KdX',
);
echo "{$effective->settings->instructions}\n";
```
```ruby Ruby
client = Anthropic::Client.new
channel_id = "slch_011CZkZmRt4vNq8sHbYw2KdX"
effective = client.beta.organization.claude_tag.slack_channels.effective.retrieve(channel_id)
puts effective.settings.instructions
```
### Rimuovere un canale
`DELETE /v1/organizations/claude_tag/slack_channels/{id}` rimuove un canale da Claude Tag. È la stessa rimozione che un proprietario dell'organizzazione effettua in claude.ai, con lo stesso effetto. Non elimina, archivia né modifica il canale in Slack, né alcun messaggio al suo interno. Richiede lo scope `write:claude_tag`.
La rimozione non può essere annullata. Elimina ciò che Claude Tag conserva per il canale:
* le sue impostazioni memorizzate e i suoi Bundle target
* le sue sessioni e le relative trascrizioni, incluse le sessioni in esecuzione
* la sua memoria, ovvero ciò che Claude conserva sul canale da una sessione all'altra
* le sue routine e gli artifact pubblicati da esso
```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"
}
```
L'`id` restituisce `404` non appena la richiesta ritorna, e il resto viene eliminato in background. Una rimozione ripetuta restituisce `404`.
**Rimuovere un canale non impedisce a Claude di operare al suo interno.** Claude continua a rispondere secondo ciò che il canale eredita, senza memoria del canale, e il suo utilizzo successivo può configurare di nuovo il canale con un nuovo `id`.
* Per impedire a Claude di rispondere in un canale, imposta invece `enabled` su `false` per quel canale.
* Per fare in modo che un canale non memorizzi nulla e mantenga le sue sessioni e la sua memoria, cancella invece ogni impostazione e scollega ogni Bundle.
Due tipi di canale non possono essere rimossi qui e restituiscono `400`: uno che non è [personalizzato](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#configured-levels) (`error_code: "slack_channel_not_configured"`), e uno che contiene una configurazione che questa API non gestisce, come un pool di runner o un'impostazione presente solo in claude.ai. Un proprietario dell'organizzazione rimuove il secondo tipo in claude.ai.
## Workspace Slack
L'oggetto workspace è la vista memorizzata di un workspace Slack. Ha gli stessi campi dell'[oggetto canale](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#slack-channels), tranne per il fatto che `type` è `slack_workspace`, `id` ha il prefisso `slws_` e `slack` contiene solo `team_id`. La risposta dell'[Avvio rapido](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#quick-start) ne mostra uno completo.
Un `id` privo del prefisso `slws_` restituisce `400`. Un `id` che ha il prefisso ma non identifica alcun workspace della tua organizzazione restituisce `404`.
### Elencare i workspace
`GET /v1/organizations/claude_tag/slack_workspaces` elenca i workspace configurati che la tua organizzazione possiede, dal più recente per `created_at`. L'[Avvio rapido](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#quick-start) mostra la richiesta e la risposta. Per trovare un workspace tramite l'ID proprio di Slack, aggiungi `slack_team_id`: `data` contiene quel workspace, oppure è vuoto quando non è configurato, e un workspace che la tua organizzazione non possiede restituisce `404`. Richiede lo scope `read:claude_tag`.
### Ottenere un workspace
`GET /v1/organizations/claude_tag/slack_workspaces/{id}` restituisce l'oggetto workspace. Richiede lo scope `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_workspaces/slws_011CZkZnWa7xPc3uJfZe5LgT" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-workspaces retrieve \
--id slws_011CZkZnWa7xPc3uJfZe5LgT
```
```python Python
client = anthropic.Anthropic()
workspace = client.beta.organization.claude_tag.slack_workspaces.retrieve(
"slws_011CZkZnWa7xPc3uJfZe5LgT"
)
print(workspace.settings.instructions)
```
```typescript TypeScript
const client = new Anthropic();
const workspace = await client.beta.organization.claudeTag.slackWorkspaces.retrieve(
"slws_011CZkZnWa7xPc3uJfZe5LgT"
);
console.log(workspace.settings.instructions);
```
```csharp C#
AnthropicClient client = new();
var workspace = await client.Beta.Organization.ClaudeTag.SlackWorkspaces.Retrieve(
"slws_011CZkZnWa7xPc3uJfZe5LgT"
);
Console.WriteLine(workspace.Settings.Instructions);
```
```go Go
client := anthropic.NewClient()
workspace, err := client.Beta.Organization.ClaudeTag.SlackWorkspaces.Get(
context.Background(),
"slws_011CZkZnWa7xPc3uJfZe5LgT",
anthropic.BetaOrganizationClaudeTagSlackWorkspaceGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(workspace.Settings.Instructions)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var workspace = client.beta().organization().claudeTag().slackWorkspaces()
.retrieve("slws_011CZkZnWa7xPc3uJfZe5LgT");
IO.println(workspace.settings().instructions().orElse(null));
```
```php PHP
$client = new Client();
$workspace = $client->beta->organization->claudeTag->slackWorkspaces->retrieve(
id: 'slws_011CZkZnWa7xPc3uJfZe5LgT',
);
echo "{$workspace->settings->instructions}\n";
```
```ruby Ruby
client = Anthropic::Client.new
workspace_id = "slws_011CZkZnWa7xPc3uJfZe5LgT"
workspace = client.beta.organization.claude_tag.slack_workspaces.retrieve(workspace_id)
puts workspace.settings.instructions
```
### Aggiornare un workspace
`POST /v1/organizations/claude_tag/slack_workspaces/{id}` modifica le impostazioni del workspace e restituisce l'oggetto workspace. `settings` è obbligatorio e segue [Modificare le impostazioni](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#changing-settings). Ciò che imposti qui si applica in ogni canale del workspace che non imposta un proprio valore. Richiede lo scope `write:claude_tag`.
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/claude_tag/slack_workspaces/slws_011CZkZnWa7xPc3uJfZe5LgT" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28" \
-d '{"settings": {"guest_policy": {"type": "restrict"}}}'
```
```bash CLI
ant beta:organization:claude-tag:slack-workspaces update \
--id slws_011CZkZnWa7xPc3uJfZe5LgT \
--settings '{guest_policy: {type: restrict}}'
```
```python Python
client = anthropic.Anthropic()
workspace = client.beta.organization.claude_tag.slack_workspaces.update(
"slws_011CZkZnWa7xPc3uJfZe5LgT",
settings={"guest_policy": {"type": "restrict"}},
)
print(workspace.settings.guest_policy)
```
```typescript TypeScript
const client = new Anthropic();
const workspace = await client.beta.organization.claudeTag.slackWorkspaces.update(
"slws_011CZkZnWa7xPc3uJfZe5LgT",
{ settings: { guest_policy: { type: "restrict" } } }
);
console.log(workspace.settings.guest_policy?.type);
```
```csharp C#
using Anthropic.Models.Beta.Organization.ClaudeTag;
AnthropicClient client = new();
var workspace = await client.Beta.Organization.ClaudeTag.SlackWorkspaces.Update(
"slws_011CZkZnWa7xPc3uJfZe5LgT",
new() { Settings = new() { GuestPolicy = new BetaClaudeTagGuestPolicyRestrict() } }
);
Console.WriteLine(workspace.Settings.GuestPolicy?.Type.GetString());
```
```go Go
client := anthropic.NewClient()
workspace, err := client.Beta.Organization.ClaudeTag.SlackWorkspaces.Update(
context.Background(),
"slws_011CZkZnWa7xPc3uJfZe5LgT",
anthropic.BetaOrganizationClaudeTagSlackWorkspaceUpdateParams{
Settings: anthropic.BetaClaudeTagSettingsUpdateParam{
GuestPolicy: anthropic.BetaClaudeTagGuestPolicyUnionParam{
OfRestrict: &anthropic.BetaClaudeTagGuestPolicyRestrictParam{},
},
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(workspace.Settings.GuestPolicy.Type)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.BetaClaudeTagGuestPolicyRestrict;
import com.anthropic.models.beta.organization.claudetag.BetaClaudeTagSettingsUpdate;
import com.anthropic.models.beta.organization.claudetag.slackworkspaces.SlackWorkspaceUpdateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SlackWorkspaceUpdateParams.builder()
.settings(BetaClaudeTagSettingsUpdate.builder()
.guestPolicy(BetaClaudeTagGuestPolicyRestrict.builder().build())
.build())
.build();
var workspace = client.beta().organization().claudeTag().slackWorkspaces()
.update("slws_011CZkZnWa7xPc3uJfZe5LgT", params);
IO.println(workspace.settings().guestPolicy().map(policy -> policy.type().asString()).orElse(null));
}
```
```php PHP
$client = new Client();
$workspace = $client->beta->organization->claudeTag->slackWorkspaces->update(
id: 'slws_011CZkZnWa7xPc3uJfZe5LgT',
settings: ['guestPolicy' => ['type' => 'restrict']],
);
echo "{$workspace->settings->guestPolicy?->type}\n";
```
```ruby Ruby
client = Anthropic::Client.new
workspace_id = "slws_011CZkZnWa7xPc3uJfZe5LgT"
workspace = client.beta.organization.claude_tag.slack_workspaces.update(
workspace_id,
settings: {guest_policy: {type: :restrict}}
)
puts workspace.settings.guest_policy&.type
```
### Ottenere le impostazioni effettive di un workspace
`GET /v1/organizations/claude_tag/slack_workspaces/{id}/effective` restituisce ciò che si applica nel workspace, risolto a partire dal workspace e dai valori predefiniti Slack, nella forma mostrata in [Impostazioni memorizzate ed effettive](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#stored-and-effective-settings), con `type` impostato su `slack_workspace_effective`. Richiede lo scope `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_workspaces/slws_011CZkZnWa7xPc3uJfZe5LgT/effective" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-workspaces:effective retrieve \
--id slws_011CZkZnWa7xPc3uJfZe5LgT
```
```python Python
client = anthropic.Anthropic()
effective = client.beta.organization.claude_tag.slack_workspaces.effective.retrieve(
"slws_011CZkZnWa7xPc3uJfZe5LgT"
)
print(effective.settings.enabled)
```
```typescript TypeScript
const client = new Anthropic();
const effective = await client.beta.organization.claudeTag.slackWorkspaces.effective.retrieve(
"slws_011CZkZnWa7xPc3uJfZe5LgT"
);
console.log(effective.settings.enabled);
```
```csharp C#
AnthropicClient client = new();
var effective = await client.Beta.Organization.ClaudeTag.SlackWorkspaces.Effective.Retrieve(
"slws_011CZkZnWa7xPc3uJfZe5LgT"
);
Console.WriteLine(effective.Settings.Enabled);
```
```go Go
client := anthropic.NewClient()
effective, err := client.Beta.Organization.ClaudeTag.SlackWorkspaces.Effective.Get(
context.Background(),
"slws_011CZkZnWa7xPc3uJfZe5LgT",
anthropic.BetaOrganizationClaudeTagSlackWorkspaceEffectiveGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(effective.Settings.Enabled)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var effective = client.beta().organization().claudeTag().slackWorkspaces().effective()
.retrieve("slws_011CZkZnWa7xPc3uJfZe5LgT");
IO.println(effective.settings().enabled().orElse(null));
```
```php PHP
$client = new Client();
$effective = $client->beta->organization->claudeTag->slackWorkspaces->effective->retrieve(
id: 'slws_011CZkZnWa7xPc3uJfZe5LgT',
);
echo json_encode($effective->settings->enabled) . "\n";
```
```ruby Ruby
client = Anthropic::Client.new
workspace_id = "slws_011CZkZnWa7xPc3uJfZe5LgT"
effective = client.beta.organization.claude_tag.slack_workspaces.effective.retrieve(workspace_id)
puts effective.settings.enabled
```
## Valori predefiniti Slack
La tua organizzazione ha esattamente un oggetto di valori predefiniti Slack. Si applica a ogni workspace e canale, non ha `id` e non ha una vista effettiva, poiché non esiste un livello più ampio.
| Campo | Descrizione |
| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `type` | `slack_defaults`. |
| `settings` | Ciò che i valori predefiniti memorizzano, come per un [canale](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#slack-channels). |
| `agent_id` | Con prefisso `cagt_`. `null` finché i valori predefiniti Slack non sono [configurati](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#set-up-channels-and-workspaces). |
### Ottenere i valori predefiniti Slack
`GET /v1/organizations/claude_tag/slack_defaults` restituisce l'oggetto. Un'organizzazione i cui valori predefiniti Slack non sono configurati riceve `200` con ogni impostazione e `agent_id` a `null`. Richiede lo scope `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_defaults" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:slack-defaults retrieve
```
```python Python
client = anthropic.Anthropic()
defaults = client.beta.organization.claude_tag.slack_defaults.retrieve()
print(defaults.settings.guest_policy)
```
```typescript TypeScript
const client = new Anthropic();
const defaults = await client.beta.organization.claudeTag.slackDefaults.retrieve();
console.log(defaults.settings.guest_policy?.type);
```
```csharp C#
AnthropicClient client = new();
var defaults = await client.Beta.Organization.ClaudeTag.SlackDefaults.Retrieve();
Console.WriteLine(defaults.Settings.GuestPolicy?.Type.GetString());
```
```go Go
client := anthropic.NewClient()
defaults, err := client.Beta.Organization.ClaudeTag.SlackDefaults.Get(
context.Background(),
anthropic.BetaOrganizationClaudeTagSlackDefaultGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(defaults.Settings.GuestPolicy.Type)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var defaults = client.beta().organization().claudeTag().slackDefaults().retrieve();
IO.println(defaults.settings().guestPolicy().map(policy -> policy.type().asString()).orElse(null));
```
```php PHP
$client = new Client();
$defaults = $client->beta->organization->claudeTag->slackDefaults->retrieve();
echo "{$defaults->settings->guestPolicy?->type}\n";
```
```ruby Ruby
client = Anthropic::Client.new
defaults = client.beta.organization.claude_tag.slack_defaults.retrieve
puts defaults.settings.guest_policy&.type
```
### Aggiornare i valori predefiniti Slack
`POST /v1/organizations/claude_tag/slack_defaults` modifica i valori predefiniti e restituisce l'oggetto. `settings` è obbligatorio e segue [Modificare le impostazioni](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#changing-settings). Una richiesta che imposta un valore mentre i valori predefiniti Slack non sono configurati restituisce `400`. Richiede lo scope `write:claude_tag`.
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/claude_tag/slack_defaults" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28" \
-d '{
"settings": {
"instructions": "Keep replies under 200 words.",
"environment_id": "env_011CZkZqDx2zRf5tLjCs7NpV"
}
}'
```
```bash CLI
ant beta:organization:claude-tag:slack-defaults update \
--settings '{instructions: "Keep replies under 200 words.", environment_id: env_011CZkZqDx2zRf5tLjCs7NpV}'
```
```python Python
client = anthropic.Anthropic()
defaults = client.beta.organization.claude_tag.slack_defaults.update(
settings={
"instructions": "Keep replies under 200 words.",
"environment_id": "env_011CZkZqDx2zRf5tLjCs7NpV",
},
)
print(defaults.settings.environment_id)
```
```typescript TypeScript
const client = new Anthropic();
const defaults = await client.beta.organization.claudeTag.slackDefaults.update({
settings: {
instructions: "Keep replies under 200 words.",
environment_id: "env_011CZkZqDx2zRf5tLjCs7NpV"
}
});
console.log(defaults.settings.environment_id);
```
```csharp C#
AnthropicClient client = new();
var defaults = await client.Beta.Organization.ClaudeTag.SlackDefaults.Update(
new()
{
Settings = new()
{
Instructions = "Keep replies under 200 words.",
EnvironmentID = "env_011CZkZqDx2zRf5tLjCs7NpV",
},
}
);
Console.WriteLine(defaults.Settings.EnvironmentID);
```
```go Go
client := anthropic.NewClient()
defaults, err := client.Beta.Organization.ClaudeTag.SlackDefaults.Update(
context.Background(),
anthropic.BetaOrganizationClaudeTagSlackDefaultUpdateParams{
Settings: anthropic.BetaClaudeTagSettingsUpdateParam{
Instructions: anthropic.String("Keep replies under 200 words."),
EnvironmentID: anthropic.String("env_011CZkZqDx2zRf5tLjCs7NpV"),
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(defaults.Settings.EnvironmentID)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.BetaClaudeTagSettingsUpdate;
import com.anthropic.models.beta.organization.claudetag.slackdefaults.SlackDefaultUpdateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = SlackDefaultUpdateParams.builder()
.settings(BetaClaudeTagSettingsUpdate.builder()
.instructions("Keep replies under 200 words.")
.environmentId("env_011CZkZqDx2zRf5tLjCs7NpV")
.build())
.build();
var defaults = client.beta().organization().claudeTag().slackDefaults().update(params);
IO.println(defaults.settings().environmentId().orElse(null));
}
```
```php PHP
$client = new Client();
$defaults = $client->beta->organization->claudeTag->slackDefaults->update(
settings: [
'instructions' => 'Keep replies under 200 words.',
'environmentID' => 'env_011CZkZqDx2zRf5tLjCs7NpV',
],
);
echo "{$defaults->settings->environmentID}\n";
```
```ruby Ruby
client = Anthropic::Client.new
defaults = client.beta.organization.claude_tag.slack_defaults.update(
settings: {
instructions: "Keep replies under 200 words.",
environment_id: "env_011CZkZqDx2zRf5tLjCs7NpV"
}
)
puts defaults.settings.environment_id
```
```json Response
{
"type": "slack_defaults",
"settings": {
"enabled": null,
"instructions": "Keep replies under 200 words.",
"model": null,
"environment_id": "env_011CZkZqDx2zRf5tLjCs7NpV",
"guest_policy": null
},
"agent_id": "cagt_011CZkZtKa8cUj4wPnFv6RsY"
}
```
## Bundle
Un Bundle è ciò che claude.ai chiama [Access bundle](https://claude.com/docs/claude-tag/admins/add-connections): un insieme denominato di accessi, come connettori, repository e credenziali, che Claude può utilizzare in un canale o in un workspace. I proprietari dell'organizzazione creano, modificano ed eliminano i Bundle in claude.ai. Questa API li elenca e li collega. Restituisce il nome e la descrizione di un Bundle e mai ciò che il Bundle concede.
| Campo | Descrizione |
| -------------------------- | ------------------------------------------------------------ |
| `type` | `bundle`. |
| `id` | Con prefisso `capp_`. |
| `display_name` | Il nome del Bundle. |
| `description` | A cosa serve il Bundle. `null` quando non ne ha una. |
| `created_at`, `updated_at` | Quando il Bundle è stato creato e modificato l'ultima volta. |
Un `bundle_id` privo del prefisso `capp_` restituisce `400`. Uno che ha il prefisso ma non esiste o appartiene a un'altra organizzazione restituisce `404`, indipendentemente da cos'altro contenga la richiesta. I Bundle che Claude Tag gestisce per sé non vengono elencati e restituiscono `404`.
### Elencare i Bundle
`GET /v1/organizations/claude_tag/bundles` elenca i Bundle della tua organizzazione, dal più recente per `created_at`. Richiede lo scope `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/bundles" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:bundles list
```
```python Python
client = anthropic.Anthropic()
bundles = client.beta.organization.claude_tag.bundles.list()
# Recupera automaticamente altre pagine quando necessario.
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 questa pagina; per la successiva, richiama 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
}
```
### Ottenere un Bundle
`GET /v1/organizations/claude_tag/bundles/{bundle_id}` restituisce l'oggetto Bundle. Richiede lo scope `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:bundles retrieve \
--bundle-id capp_011CZkZjLP1cWxj5EtMmdgbq
```
```python Python
client = anthropic.Anthropic()
bundle = client.beta.organization.claude_tag.bundles.retrieve(
"capp_011CZkZjLP1cWxj5EtMmdgbq"
)
print(bundle.display_name)
```
```typescript TypeScript
const client = new Anthropic();
const bundle = await client.beta.organization.claudeTag.bundles.retrieve(
"capp_011CZkZjLP1cWxj5EtMmdgbq"
);
console.log(bundle.display_name);
```
```csharp C#
AnthropicClient client = new();
var bundle = await client.Beta.Organization.ClaudeTag.Bundles.Retrieve(
"capp_011CZkZjLP1cWxj5EtMmdgbq"
);
Console.WriteLine(bundle.DisplayName);
```
```go Go
client := anthropic.NewClient()
bundle, err := client.Beta.Organization.ClaudeTag.Bundles.Get(
context.Background(),
"capp_011CZkZjLP1cWxj5EtMmdgbq",
anthropic.BetaOrganizationClaudeTagBundleGetParams{},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(bundle.DisplayName)
```
```java Java
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var bundle = client.beta().organization().claudeTag().bundles()
.retrieve("capp_011CZkZjLP1cWxj5EtMmdgbq");
IO.println(bundle.displayName());
```
```php PHP
$client = new Client();
$bundle = $client->beta->organization->claudeTag->bundles->retrieve(
bundleID: 'capp_011CZkZjLP1cWxj5EtMmdgbq',
);
echo "{$bundle->displayName}\n";
```
```ruby Ruby
client = Anthropic::Client.new
bundle_id = "capp_011CZkZjLP1cWxj5EtMmdgbq"
bundle = client.beta.organization.claude_tag.bundles.retrieve(bundle_id)
puts bundle.display_name
```
## Bundle target
Un Bundle target è il record di un Bundle collegato a un canale o a un workspace. Un Bundle collegato a un workspace può essere utilizzato nel workspace e in ogni canale al suo interno. Un Bundle collegato a un canale può essere utilizzato solo in quel canale.
| Campo | Descrizione |
| -------------------- | ----------------------------------------------------------------------------------------------------------- |
| `type` | `slack_channel` o `slack_workspace`. |
| `id` | Con prefisso `btgt_`. È il `{target_id}` nei percorsi e non è mai l'`id` del canale o del workspace stesso. |
| `slack_channel_id` | Su un target `slack_channel`: l'`id` del canale, con prefisso `slch_`. |
| `slack_workspace_id` | Su un target `slack_workspace`: l'`id` del workspace, con prefisso `slws_`. |
| `created_at` | Quando il Bundle è stato collegato. |
Un Bundle viene collegato a un canale o a un workspace al massimo una volta, e la stessa coppia ha sempre lo stesso `id`, anche dopo uno scollegamento e un nuovo collegamento. L'`id` è opaco: ottienilo dalla risposta a un collegamento o dall'elenco. Un Bundle target non contiene l'`id` del suo Bundle, che è necessario anche nei suoi percorsi, quindi conserva i due insieme.
Il primo Bundle collegato a un canale o a un workspace lo rende [personalizzato](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#configured-levels). Collegare o scollegare non modifica alcuna impostazione memorizzata. Le sessioni in esecuzione nel canale o nel workspace vengono informate che il suo accesso è cambiato.
Il Bundle che claude.ai collega come parte di una configurazione di reperibilità (on-call) viene elencato e può essere letto, ma non può essere collegato o scollegato qui, e nulla può essere collegato a un canale o workspace gestito da una configurazione di reperibilità, né scollegato da esso. Ciascuna di queste richieste restituisce `400`.
### Elencare i target di un Bundle
`GET /v1/organizations/claude_tag/bundles/{bundle_id}/targets` elenca i canali e i workspace a cui il Bundle è collegato, dal più recente per `created_at`. Richiede lo scope `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq/targets" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:bundles:targets list \
--bundle-id capp_011CZkZjLP1cWxj5EtMmdgbq
```
```python Python
client = anthropic.Anthropic()
targets = client.beta.organization.claude_tag.bundles.targets.list(
"capp_011CZkZjLP1cWxj5EtMmdgbq"
)
# Recupera automaticamente altre pagine quando necessario.
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 questa pagina; per la successiva, richiama 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
}
```
Vengono elencati solo i collegamenti a canali e workspace. Un Bundle collegato in claude.ai a qualcos'altro, come **Default Slack access**, non ha un Bundle target corrispondente, e lo stesso vale per una regola che applica un Bundle in molti canali contemporaneamente. Quindi i Bundle che Claude può utilizzare in un canale possono essere più dei target che lo nominano. Nessun endpoint elenca i Bundle collegati a un singolo canale o workspace.
### Collegare un Bundle
`POST /v1/organizations/claude_tag/bundles/{bundle_id}/targets` collega il Bundle e restituisce il Bundle target. Il corpo indica il `type` e l'`id` corrispondente. Il canale o il workspace deve essere già configurato: il collegamento non configura mai un canale. Collegare una coppia già collegata restituisce `200` con il Bundle target esistente. Richiede lo scope `write:claude_tag`.
Collega un Bundle a un canale:
```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"
}
```
Collega un Bundle a un workspace:
```bash cURL
curl -X POST "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq/targets" \
-H "content-type: application/json" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: 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
```
Un collegamento a un canale ha delle condizioni in base alle quali si applica, ad esempio solo finché nel canale non è presente alcun ospite Slack. Le condizioni vengono impostate in claude.ai e non vengono restituite qui. Il collegamento tramite questa API utilizza le condizioni predefinite, e collegare una coppia già collegata lascia invariate le sue condizioni.
### Ottenere un Bundle target
`GET /v1/organizations/claude_tag/bundles/{bundle_id}/targets/{target_id}` restituisce il Bundle target. Un `target_id` privo del prefisso `btgt_` restituisce `400`. Uno che appartiene a un altro Bundle, è stato scollegato o identifica un canale o workspace non più configurato restituisce `404`. Richiede lo scope `read:claude_tag`.
```bash cURL
curl "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq/targets/btgt_011CZkZpBv9yQd6wKhAr8MnU" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:bundles:targets retrieve \
--bundle-id capp_011CZkZjLP1cWxj5EtMmdgbq \
--target-id btgt_011CZkZpBv9yQd6wKhAr8MnU
```
```python Python
client = anthropic.Anthropic()
target = client.beta.organization.claude_tag.bundles.targets.retrieve(
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
bundle_id="capp_011CZkZjLP1cWxj5EtMmdgbq",
)
print(target.type)
```
```typescript TypeScript
const client = new Anthropic();
const target = await client.beta.organization.claudeTag.bundles.targets.retrieve(
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
{ bundle_id: "capp_011CZkZjLP1cWxj5EtMmdgbq" }
);
console.log(target.type);
```
```csharp C#
AnthropicClient client = new();
var target = await client.Beta.Organization.ClaudeTag.Bundles.Targets.Retrieve(
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
new() { BundleID = "capp_011CZkZjLP1cWxj5EtMmdgbq" }
);
Console.WriteLine(target.Type.GetString());
```
```go Go
client := anthropic.NewClient()
target, err := client.Beta.Organization.ClaudeTag.Bundles.Targets.Get(
context.Background(),
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
anthropic.BetaOrganizationClaudeTagBundleTargetGetParams{
BundleID: "capp_011CZkZjLP1cWxj5EtMmdgbq",
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(target.Type)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.bundles.targets.TargetRetrieveParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = TargetRetrieveParams.builder()
.bundleId("capp_011CZkZjLP1cWxj5EtMmdgbq")
.build();
var target = client.beta().organization().claudeTag().bundles().targets()
.retrieve("btgt_011CZkZpBv9yQd6wKhAr8MnU", params);
IO.println(target.type().asString());
}
```
```php PHP
$client = new Client();
$target = $client->beta->organization->claudeTag->bundles->targets->retrieve(
targetID: 'btgt_011CZkZpBv9yQd6wKhAr8MnU',
bundleID: 'capp_011CZkZjLP1cWxj5EtMmdgbq',
);
echo "{$target->type}\n";
```
```ruby Ruby
client = Anthropic::Client.new
bundle_id = "capp_011CZkZjLP1cWxj5EtMmdgbq"
target_id = "btgt_011CZkZpBv9yQd6wKhAr8MnU"
target = client.beta.organization.claude_tag.bundles.targets.retrieve(
target_id,
bundle_id: bundle_id
)
puts target.type
```
### Scollegare un Bundle
`DELETE /v1/organizations/claude_tag/bundles/{bundle_id}/targets/{target_id}` scollega il Bundle. Uno scollegamento ripetuto restituisce `404`. Richiede lo scope `write:claude_tag`.
```bash cURL
curl -X DELETE "https://api.anthropic.com/v1/organizations/claude_tag/bundles/capp_011CZkZjLP1cWxj5EtMmdgbq/targets/btgt_011CZkZpBv9yQd6wKhAr8MnU" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: claude-tag-2026-09-28"
```
```bash CLI
ant beta:organization:claude-tag:bundles:targets delete \
--bundle-id capp_011CZkZjLP1cWxj5EtMmdgbq \
--target-id btgt_011CZkZpBv9yQd6wKhAr8MnU
```
```python Python
client = anthropic.Anthropic()
deleted_target = client.beta.organization.claude_tag.bundles.targets.delete(
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
bundle_id="capp_011CZkZjLP1cWxj5EtMmdgbq",
)
print(deleted_target.id)
```
```typescript TypeScript
const client = new Anthropic();
const deletedTarget = await client.beta.organization.claudeTag.bundles.targets.delete(
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
{ bundle_id: "capp_011CZkZjLP1cWxj5EtMmdgbq" }
);
console.log(deletedTarget.id);
```
```csharp C#
AnthropicClient client = new();
var deletedTarget = await client.Beta.Organization.ClaudeTag.Bundles.Targets.Delete(
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
new() { BundleID = "capp_011CZkZjLP1cWxj5EtMmdgbq" }
);
Console.WriteLine(deletedTarget.ID);
```
```go Go
client := anthropic.NewClient()
deletedTarget, err := client.Beta.Organization.ClaudeTag.Bundles.Targets.Delete(
context.Background(),
"btgt_011CZkZpBv9yQd6wKhAr8MnU",
anthropic.BetaOrganizationClaudeTagBundleTargetDeleteParams{
BundleID: "capp_011CZkZjLP1cWxj5EtMmdgbq",
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(deletedTarget.ID)
```
```java Java
import com.anthropic.models.beta.organization.claudetag.bundles.targets.TargetDeleteParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = TargetDeleteParams.builder()
.bundleId("capp_011CZkZjLP1cWxj5EtMmdgbq")
.build();
var deletedTarget = client.beta().organization().claudeTag().bundles().targets()
.delete("btgt_011CZkZpBv9yQd6wKhAr8MnU", params);
IO.println(deletedTarget.id());
}
```
```php PHP
$client = new Client();
$deletedTarget = $client->beta->organization->claudeTag->bundles->targets->delete(
targetID: 'btgt_011CZkZpBv9yQd6wKhAr8MnU',
bundleID: 'capp_011CZkZjLP1cWxj5EtMmdgbq',
);
echo "{$deletedTarget->id}\n";
```
```ruby Ruby
client = Anthropic::Client.new
bundle_id = "capp_011CZkZjLP1cWxj5EtMmdgbq"
target_id = "btgt_011CZkZpBv9yQd6wKhAr8MnU"
deleted_target = client.beta.organization.claude_tag.bundles.targets.delete(
target_id,
bundle_id: bundle_id
)
puts deleted_target.id
```
```json Response
{
"type": "bundle_target_deleted",
"id": "btgt_011CZkZpBv9yQd6wKhAr8MnU"
}
```
## Valori non riconosciuti
`guest_policy.type`, il `type` di una fonte, il `type` di un Bundle target e i codici di errore possono acquisire nuovi valori in qualsiasi momento. Tratta un valore che non riconosci come faresti con qualsiasi stringa sconosciuta, anziché generare un errore.
## Limitazione della velocità
Le richieste sono soggette a un "rate limit" (limite di velocità) per organizzazione, in due budget condivisi da tutte le chiavi della tua organizzazione e separati dagli altri limiti dell'Admin API della tua organizzazione. Ogni budget consente una raffica di richieste e poi si ricarica a un ritmo costante:
| Budget | Richieste | Raffica | Ricarica |
| --------- | ---------------------- | ------- | ------------ |
| Letture | Ogni `GET` | 120 | 2 al secondo |
| Modifiche | Ogni `POST` e `DELETE` | 60 | 1 al secondo |
Le richieste che superano un budget restituiscono **429 Too Many Requests** con un header `retry-after`. Le risposte includono gli header `anthropic-ratelimit-requests-limit`, `anthropic-ratelimit-requests-remaining` e `anthropic-ratelimit-requests-reset` per il budget da cui la richiesta ha attinto.
## Paginazione
Gli endpoint di elenco utilizzano un **"opaque cursor" (cursore opaco)**. La prima richiesta restituisce fino a `limit` righe più un cursore `next_page`; passa il cursore invariato come parametro `page` nella richiesta successiva e ripeti finché `next_page` non è `null`. Tratta la stringa del cursore come opaca: non analizzarla, modificarla o costruirla tu stesso. [Elencare i canali](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#list-channels) può restituire una pagina con meno di `limit` canali, o nessuno, mentre `next_page` è ancora impostato, quindi continua a richiedere pagine finché `next_page` non è `null`. Gli iteratori di elenco degli SDK Python, TypeScript, C#, Go, Java e Ruby e la CLI (tranne con `--format raw`) lo fanno per te. In PHP e curl, richiedi ogni pagina tu stesso e passa il suo `next_page` come `page`.
`limit` ha come valore predefinito 20, con un minimo di 1 e un massimo di 100. Ogni elenco è ordinato dal più recente per `created_at` e non accetta altri ordinamenti.
## Risposte di errore
Le risposte di errore seguono la forma standard documentata in [Errori](https://platform.claude.com/docs/it/api/errors). Cita il `request_id` dal corpo della risposta quando contatti il supporto.
| Stato | Significato |
| ----- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 400 | Input non valido, oppure l'operazione non si applica a questo canale, workspace o Bundle (vedi la sezione di ciascun endpoint). |
| 401 | Header `x-api-key` mancante, oppure la chiave non è riconosciuta. |
| 403 | La chiave non è una chiave con scope a livello di organizzazione, manca dello scope richiesto, oppure la tua organizzazione non può effettuare questa modifica. |
| 404 | Risorsa non trovata, o non appartenente alla tua organizzazione. Restituito anche quando la richiesta omette il valore `anthropic-beta`, o l'API non è abilitata per la tua organizzazione, in modo che gli endpoint risultino inesistenti. |
| 409 | Qualcos'altro ha modificato o rimosso la risorsa mentre la richiesta era in esecuzione. Non è stato memorizzato nulla. Leggila di nuovo e reinvia la modifica se è ancora necessaria. |
| 429 | Superato il "rate limit" (limite di velocità). Vedi [Limitazione della velocità](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#rate-limiting). |
| 500 | Errore interno. |
| 503 | Errore temporaneo. Nel caso di una modifica, non indica se la modifica è stata memorizzata. Ogni modifica può essere ripetuta in sicurezza, quindi invia di nuovo la richiesta invariata. |
Quando uno stato ha diverse cause che gestiresti in modo diverso, l'errore contiene anche `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` | Stato | Significato e cosa fare |
| -------------------------------------------- | ----- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `organization_level_scoped_api_key_required` | 403 | La credenziale non è una chiave Admin API con scope che appartiene all'organizzazione nel suo complesso. Chiedine una al tuo proprietario principale. |
| `api_key_scope_missing` | 403 | Alla chiave manca `read:claude_tag` o `write:claude_tag`, a seconda di quale richieda l'endpoint. |
| `workspace_selection_not_accepted` | 400 | La richiesta ha inviato l'header `anthropic-workspace-id`. Rimuovilo. |
| `claude_tag_writes_not_enabled` | 403 | La tua organizzazione può leggere tramite questa API ma non è abilitata per le modifiche. |
| `compliance_configuration_restricted` | 403 | La tua organizzazione ha una configurazione di conformità in base alla quale Claude Tag non memorizza nulla di nuovo, come la conservazione zero dei dati. La configurazione di un canale, l'aggiornamento delle impostazioni (anche per cancellarle) e il collegamento di un Bundle vengono rifiutati. Lo scollegamento di un Bundle e la rimozione di un canale no. |
| `environment_not_found` | 404 | `environment_id` non identifica alcun ambiente che la tua organizzazione possa utilizzare qui. L'`id` nel percorso è corretto. |
| `environment_archived` | 400 | `environment_id` identifica un ambiente archiviato. |
| `slack_channel_set_up_settings_refused` | 400 | La richiesta ha configurato il canale, poi `settings` è stato rifiutato. `details.slack_channel_id` è il canale. Vedi [Configurare un canale](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#set-up-a-channel). |
| `slack_channel_set_up_environment_not_found` | 404 | La richiesta ha configurato il canale, poi `environment_id` non è stato trovato. `details.slack_channel_id` è il canale. |
| `slack_channel_set_up_settings_conflict` | 409 | La richiesta ha configurato il canale, poi un'altra modifica si è sovrapposta a `settings`. Nulla di `settings` è stato memorizzato. `details.slack_channel_id` è il canale. |
| `slack_channel_not_configured` | 400 | Il canale non è [personalizzato](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#configured-levels), quindi non può essere rimosso. |
Potrebbero essere aggiunti nuovi codici. Tratta un codice che non riconosci nel modo in cui tratti il suo stato. Un `404` senza `error_code` ha una di due cause. O qualcosa che la richiesta nomina non è stato trovato (un `id` nel percorso, oppure un canale o workspace Slack nel corpo o nella query), oppure ogni endpoint risulta inesistente perché la richiesta omette il valore `anthropic-beta` o l'API non è abilitata per la tua organizzazione. Per distinguerle, [ottieni i valori predefiniti Slack](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#get-the-slack-defaults) con la stessa chiave e gli stessi header: quella richiesta non nomina nulla, quindi restituisce `404` solo nel secondo caso.
## Eventi dell'Activity Feed
Ogni modifica effettuata tramite questa API viene registrata nel [Compliance API Activity Feed](https://platform.claude.com/docs/it/manage-claude/compliance-activity-feed) della tua organizzazione, attribuita alla chiave API come `api_actor` con il relativo ID `apikey_`. Gli eventi sono gli stessi che il feed registra quando la stessa modifica viene effettuata in claude.ai, quindi un'unica query trova una modifica indipendentemente dal modo in cui è stata effettuata.
| Evento | Emesso quando |
| --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `ccr_agent_created` | Viene configurato un canale. |
| `ccr_agent_updated` | Cambia un'impostazione su un canale, un workspace o i valori predefiniti Slack, oppure un livello diventa [personalizzato](https://platform.claude.com/docs/it/manage-claude/claude-tag-api#configured-levels). |
| `ccr_agent_deleted` | Viene rimosso un canale. I suoi Bundle target vengono rimossi con esso e non emettono alcun evento proprio. |
| `ccr_agent_proxy_profile_bound` | Viene collegato un Bundle. |
| `ccr_agent_proxy_profile_unbound` | Viene scollegato un Bundle. |
Gli eventi identificano un canale o un workspace tramite il suo `agent_id`, non tramite il suo `id`. I due eventi Bundle identificano il Bundle in `profile_id` e il canale o il workspace in `scope_id`.
Un evento `ccr_agent_updated` elenca ciò che è cambiato in `updated_fields`, con i nomi propri del feed:
| Impostazione | Nome in `updated_fields` |
| --------------------------------------- | ------------------------ |
| `enabled` | `slackbot_version` |
| `instructions` | `system_prompt_addendum` |
| `model` | `default_model` |
| `environment_id` | `default_environment_id` |
| `guest_policy` | `guest_policy` |
| (il livello è diventato personalizzato) | `is_virtual` |
Le letture, le richieste che non modificano nulla e le richieste rifiutate prima che venga memorizzato qualcosa non registrano nulla. Una richiesta di configurazione che configura un canale e il cui `settings` viene poi rifiutato registra `ccr_agent_created`.
## Vedi anche
Dove il tuo proprietario principale crea una chiave con scope definito.
Cos'è Claude Tag, come configurarlo e cosa fa ciascuna impostazione in Slack.
La traccia di controllo di ogni modifica effettuata qui e in claude.ai.
Gestisci i plugin nella tua organizzazione Claude Enterprise.