One read of Claude Developer Platformapi-20261023T193710Z

manage-claude/admin-api-keys Changed · +7 / -5 lines

manage-claude/claude-tag-api New page · 2549 lines, new page

## Endpoints ## Prerequisites ## Quick start ## Scopes ## Key concepts ### Names on this page and in claude.ai ### Set-up channels and workspaces ### IDs ### Settings ### Stored and inherited values ### Changing settings ### Read-only mode ### Group direct messages ## Example workflows ### Turn Claude on only in approved channels ### Keep configuration in version control ### Audit what applies everywhere ## Slack channels ### Set up a channel ### List channels ### Find a channel by its Slack IDs ### Get a channel ### Read what applies in a channel ### Update a channel ### Remove a channel ## Slack workspaces ### List workspaces ### Get a workspace ### Update a workspace ## Bundles ### List Bundles ### Get a Bundle ## Bundle targets ### List a Bundle's targets ### Attach a Bundle ### Get a Bundle target ### Detach a Bundle ## Unrecognized values ## Rate limiting ## Pagination ## Error responses ## Activity Feed events ## See also

A whole new page. There's nothing to diff it against, so here is what it says.

---
title: Claude Tag API
url: https://platform.claude.com/docs/en/manage-claude/claude-tag-api
description: "Manage Claude Tag in Slack for your Claude Enterprise organization from your own systems: read and change settings on Slack channels and workspaces, see which settings apply and why, and attach Access bundles."
---

[Claude Tag](https://claude.com/docs/claude-tag/overview) is Claude working as a teammate in Slack: someone mentions Claude in a channel and Claude answers in the thread. The Claude Tag API lets you read and change, from your own systems, the Claude Tag settings that an organization owner otherwise sets by hand in [claude.ai > Organization settings > Claude Tag](https://claude.ai/admin-settings/claude-tag). Use it to turn Claude on channel by channel from an approval workflow, keep your configuration in version control, or audit what applies in every channel.

Claude Tag is a claude.ai product. This API manages it for a Claude Enterprise organization and has nothing to do with Claude Platform workspaces, API usage, or the Claude Console.

<Check>
  **Scoped Admin API key required**

  These endpoints require an Admin API key with the `read:claude_tag` scope (for `GET` endpoints) or the `write:claude_tag` scope (for `POST` and `DELETE` endpoints); see [Scopes](https://platform.claude.com/docs/en/manage-claude/claude-tag-api#scopes). See [Create an Admin API key](https://platform.claude.com/docs/en/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization) for where your primary owner creates one.
</Check>

<Note>
  The Claude Tag API is in **beta** and is available to Claude Enterprise organizations only. It is not available to Claude Platform (Claude Console) organizations.

  Every request must include the [beta header](https://platform.claude.com/docs/en/api/beta-headers) `anthropic-beta: experimental-claude-tag-2026-10-21` (the SDK and the `ant` CLI send it for you). A request without it returns `404`, exactly as if the endpoint did not exist.
</Note>

## Endpoints

The API exposes 14 endpoints across four resources:

| Resource                                                                                                                                      | Endpoints                                                                                                                                                                                                                                                                                              |
| --------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Slack channels:** set a channel up, list the channels of a workspace or find one by its Slack IDs, read one, change its settings, remove it | `POST /v1/organizations/claude_tag/slack_channels`<br />`GET /v1/organizations/claude_tag/slack_channels`<br />`GET /v1/organizations/claude_tag/slack_channels/{id}`<br />`POST /v1/organizations/claude_tag/slack_channels/{id}`<br />`DELETE /v1/organizations/claude_tag/slack_channels/{id}`      |
| **Slack workspaces:** list your workspaces or find one by its Slack ID, read one, change its settings                                         | `GET /v1/organizations/claude_tag/slack_workspaces`<br />`GET /v1/organizations/claude_tag/slack_workspaces/{id}`<br />`POST /v1/organizations/claude_tag/slack_workspaces/{id}`                                                                                                                       |
| **Bundles:** list your organization's Access bundles, read one (read-only)                                                                    | `GET /v1/organizations/claude_tag/bundles`<br />`GET /v1/organizations/claude_tag/bundles/{bundle_id}`                                                                                                                                                                                                 |
| **Bundle targets:** list where a Bundle is attached, attach it to a channel or workspace, read one attachment, detach it                      | `GET /v1/organizations/claude_tag/bundles/{bundle_id}/targets`<br />`POST /v1/organizations/claude_tag/bundles/{bundle_id}/targets`<br />`GET /v1/organizations/claude_tag/bundles/{bundle_id}/targets/{target_id}`<br />`DELETE /v1/organizations/claude_tag/bundles/{bundle_id}/targets/{target_id}` |

This release covers Slack. Connecting and disconnecting a Slack workspace or Enterprise Grid, your organization's Slack defaults, creating and editing Access bundles, spend limits, and every Claude Tag setting other than the five in [Settings](https://platform.claude.com/docs/en/manage-claude/claude-tag-api#settings) stay in claude.ai.

## Prerequisites

* Your organization must be on a Claude Enterprise plan, with [Claude Tag set up](https://claude.com/docs/claude-tag/admins/setup-overview) and at least one Slack workspace or Enterprise Grid connected.
* Your primary owner creates an Admin API key with the `read:claude_tag` scope, the `write:claude_tag` scope, or both in [claude.ai > Organization settings > API](https://claude.ai/admin-settings/api-access). See [Create a key for a Claude Enterprise organization](https://platform.claude.com/docs/en/manage-claude/admin-api-keys#create-a-key-for-a-claude-enterprise-organization).
* Every request carries three headers: `x-api-key`, `anthropic-version: 2023-06-01` (see [API versions](https://platform.claude.com/docs/en/api/versioning)), and `anthropic-beta: experimental-claude-tag-2026-10-21`.

In Python, TypeScript, C#, Go, Java, PHP, and Ruby, the SDK exposes these endpoints under `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`), and the [`ant` CLI](https://platform.claude.com/docs/en/cli-sdks-libraries/cli/quickstart) under `ant beta:organization:claude-tag`; they send the `anthropic-version` and `anthropic-beta` headers for you. The examples on this page read the Admin API key from the `ANTHROPIC_API_KEY` environment variable. Where an SDK or the CLI fetches more pages for you, `limit` sets the page size, not the total (see [Pagination](https://platform.claude.com/docs/en/manage-claude/claude-tag-api#pagination)).

API keys belong to the organization and keep working after the person who created them leaves. Do not share them or check them into source control.

## Quick start

List your organization's Slack workspaces in Claude Tag:

<CodeGroup>
  ```bash cURL
  curl "https://api.anthropic.com/v1/organizations/claude_tag/slack_workspaces" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: experimental-claude-tag-2026-10-21"
  ```

  ```bash CLI
  ant beta:organization:claude-tag:slack-workspaces list
  ```

  ```python Python
  client = anthropic.Anthropic()

  workspaces = client.beta.organization.claude_tag.slack_workspaces.list()

  # Automatically fetches more pages as needed.
  for workspace in workspaces:
      print(f"{workspace.id}: {workspace.slack.workspace_id}")
  ```

  ```typescript TypeScript
  const client = new Anthropic();

  const workspaces = await client.beta.organization.claudeTag.slackWorkspaces.list();

  for await (const workspace of workspaces) {
    console.log(`${workspace.id}: ${workspace.slack.workspace_id}`);
  }
  ```

  ```csharp C#
  AnthropicClient client = new();

  var page = await client.Beta.Organization.ClaudeTag.SlackWorkspaces.List();

  await foreach (var workspace in page.Paginate())
  {
      Console.WriteLine($"{workspace.ID}: {workspace.Slack.WorkspaceID}");
  }
  ```

  ```go Go
  client := anthropic.NewClient()

  workspaces := client.Beta.Organization.ClaudeTag.SlackWorkspaces.ListAutoPaging(
  	context.Background(),
  	anthropic.BetaOrganizationClaudeTagSlackWorkspaceListParams{},
  )

  for workspaces.Next() {
  	workspace := workspaces.Current()
  	fmt.Printf("%s: %s\n", workspace.ID, workspace.Slack.WorkspaceID)
  }
  if err := workspaces.Err(); err != nil {
  	log.Fatal(err)
  }
  ```

  ```java Java
  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

  var workspaces = client.beta().organization().claudeTag().slackWorkspaces().list();

  for (var workspace : workspaces.autoPager()) {
      IO.println(workspace.id() + ": " + workspace.slack().workspaceId());
  }
  ```

  ```php PHP
  $client = new Client();

  $workspaces = $client->beta->organization->claudeTag->slackWorkspaces->list();

  // Only this page; for the next, call list() again with page: $workspaces->nextPage.
  foreach ($workspaces->getItems() as $workspace) {
      echo "{$workspace->id}: {$workspace->slack->workspaceID}\n";
  }
  ```

  ```ruby Ruby
  client = Anthropic::Client.new

  page = client.beta.organization.claude_tag.slack_workspaces.list

  page.auto_paging_each do |workspace|
    puts "#{workspace.id}: #{workspace.slack.workspace_id}"
  end
  ```
</CodeGroup>

```json Response
{
  "data": [
    {
      "type": "slack_workspace",
      "id": "slws_011CZkZnWa7xPc3uJfZe5LgT",
      "slack": {
        "workspace_id": "T01ABCD2EFG"
      },
      "settings": {
        "enabled": null,
        "instructions": "Answer in English unless asked otherwise.",
        "model": null,
        "environment_id": null,
        "guest_policy": null
      },
      "sources": {
        "enabled": null,
        "instructions": [
          {
            "type": "slack_workspace",
            "slack_workspace_id": "slws_011CZkZnWa7xPc3uJfZe5LgT"
          }
        ],
        "model": null,
        "environment_id": null,
        "guest_policy": null
      },
      "created_at": "2026-09-02T17:04:11Z",
      "updated_at": "2026-10-06T09:41:53Z"
    }
  ],
  "next_page": null
}
```

A setting that is `null` in `settings` is not set on this workspace, so the workspace inherits it and has no source for it. To read what applies instead, see [Stored and inherited values](https://platform.claude.com/docs/en/manage-claude/claude-tag-api#stored-and-inherited-values).

## Scopes

| Scope              | Grants                                                                                                                                  |
| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------- |
| `read:claude_tag`  | Every `GET` endpoint on this page.                                                                                                      |
| `write:claude_tag` | Every `POST` and `DELETE` endpoint on this page. It does not grant reads, although the response to a change holds the changed resource. |

A key can carry both scopes. An integration that looks a channel up and then changes it needs both. No other scope grants access to these endpoints, and a key created in the Claude Console does not work here.

The key must belong to the organization as a whole. The organization is always the one the key belongs to, and no request names one. The `anthropic-workspace-id` header is ignored, because nothing here belongs to a Claude Platform workspace.

## Key concepts

### Names on this page and in claude.ai

| This API         | claude.ai and Slack                                                                                                                                                                                |
| ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Slack workspace  | A Slack workspace. Slack's own API calls it a team, so Slack's own workspace ID on this page is the team ID there. It is unrelated to a Claude Platform workspace, whose IDs start with `wrkspc_`. |
| Slack defaults   | **Default Slack access**: the settings that apply to every workspace and channel. An organization owner changes them in claude.ai; this API shows where a channel or workspace inherits from them. |
| Settings level   | A [scope](https://claude.com/docs/claude-tag/admins/customize): a channel, a workspace, or the Slack defaults                                                                                      |
| Bundle           | An Access bundle ([Claude Tag glossary](https://claude.com/docs/claude-tag/concepts/glossary#access-bundle))                                                                                       |
| `enabled`        | The **Enable Claude Tag in Slack** toggle                                                                                                                                                          |
| `instructions`   | **Custom instructions**                                                                                                                                                                            |
| `model`          | **Model**                                                                                                                                                                                          |
| `environment_id` | **Environment**                                                                                                                                                                                    |
| `guest_policy`   | **How should Claude work in channels with guests**: `restrict` is **Restrict**, `channel_only` is **Channel only**, and `allow` is **Full access**                                                 |

### Set-up channels and workspaces

A channel or workspace is **set up** when Claude Tag holds a settings record for it. Only a set-up channel or workspace has an `id`, and only those are listed: Slack, not this API, holds the full list of a workspace's channels.

* A **workspace** is set up when an organization owner connects it in claude.ai. When an owner connects a Slack Enterprise Grid, the Grid's workspaces are set up shortly afterward. Claude's first use in a workspace, or the first channel you [set up](https://platform.claude.com/docs/en/manage-claude/claude-tag-api#set-up-a-channel) in it, sets up any that was not. No other endpoint sets up a workspace, and none removes one.
* A **channel** is set up in claude.ai, by Claude's first use in it, or with [Set up a channel](https://platform.claude.com/docs/en/manage-claude/claude-tag-api#set-up-a-channel).

Your organization owns a workspace while its connection to that workspace is active, and owns the channels in it. A Slack Enterprise Grid groups several workspaces under one company. While your organization's connection to a Grid is active, it also owns every workspace in the Grid that no other organization has connected. Such a workspace is a workspace like any other: once it is set up, it has an `id`, is listed, and can be read, changed, and given Bundles, and its channels can be listed. The Grid itself is not a resource of this API and has no `id`. A channel or workspace you do not own returns the same `404` as one that does not exist.

A workspace your organization owns only through a Grid returns that `404` until it is set up, wherever a request names it by Slack's own ID: when you find the workspace, list its channels, or look up a channel in it that is not set up. You can still [set up a channel](https://platform.claude.com/docs/en/manage-claude/claude-tag-api#set-up-a-channel) in it, which also sets the workspace up, with no settings stored.

A channel that is shared with a whole Grid can be stored under the Grid's own Slack ID, which starts with `E`, in place of a workspace's. That ID is then the channel's `slack.workspace_id`, and [listing channels](https://platform.claude.com/docs/en/manage-claude/claude-tag-api#list-channels) with it as `slack_workspace_id` returns those channels. No workspace object has it: if an owner stored settings on the Grid itself in claude.ai, `sources` can name them as a `slack_workspace` whose `id` returns `404` when you read it.

### IDs

You know a channel by the IDs Slack shows you. Look its `id` up once with [Find a channel by its Slack IDs](https://platform.claude.com/docs/en/manage-claude/claude-tag-api#find-a-channel-by-its-slack-ids), then store and use the `id`.

| ID                       | Prefix                                                                                                                                                                  | Where it appears                                                          |
| ------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- |
| Slack channel resource   | `slch_`                                                                                                                                                                 | `id` on a channel; `slack_channel_id` in request bodies and responses     |
| Slack workspace resource | `slws_`                                                                                                                                                                 | `id` on a workspace; `slack_workspace_id` in request bodies and responses |
| Bundle                   | `capp_`                                                                                                                                                                 | `id` on a Bundle; `{bundle_id}` in paths                                  |
| Bundle target            | `btgt_`                                                                                                                                                                 | `id` on a Bundle target; `{target_id}` in paths                           |
| Slack's own workspace ID | `T`, or `E` for a Grid's own ID (see [Set-up channels and workspaces](https://platform.claude.com/docs/en/manage-claude/claude-tag-api#set-up-channels-and-workspaces)) | `slack.workspace_id`; the `slack_workspace_id` query parameter            |
| Slack's own channel ID   | `C` or `G`                                                                                                                                                              | `slack.channel_id`; the `slack_channel_id` query parameter                |

<Warning>
  `slack_channel_id` and `slack_workspace_id` each mean two things. In a **query parameter** each is Slack's own ID (`C05HJKL6MNP`, `T01ABCD2EFG`). In a **request body or a response** each is the `id` this API issues (`slch_...`, `slws_...`). Slack's own IDs in a body or a response are always under `slack`.
</Warning>

A Slack channel ID in a query parameter or a request body that does not start with `C` or `G` returns `400`, and so does any Slack ID that has anything but capital letters and digits after its first letter or is longer than 32 characters.

An `id` does not change while the channel or workspace is set up, whatever you change on it, with one exception described in [Read-only mode](https://platform.claude.com/docs/en/manage-claude/claude-tag-api#read-only-mode). A channel or workspace that is removed and set up again has a new `id`, and the old one keeps returning `404`. When a stored `id` returns `404` with no `error_code`, [list your workspaces](https://platform.claude.com/docs/en/manage-claude/claude-tag-api#list-workspaces) with the same key and headers. That request names no channel or workspace, so if it returns `200`, the `id` is gone: find the channel or workspace again by its Slack IDs. Any other status says nothing about the `id`: keep your stored `id` values and see [Error responses](https://platform.claude.com/docs/en/manage-claude/claude-tag-api#error-responses).

### Settings

Each settings level stores the same five settings, all optional:

| Setting          | Type    | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| ---------------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `enabled`        | boolean | Whether Claude is on.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `instructions`   | string  | Standing guidance Claude reads in every session. At most 8,192 characters after leading and trailing white space is trimmed. Blank text clears the setting.                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| `model`          | string  | The model new sessions start on: a [model ID](https://platform.claude.com/docs/en/models/overview) your organization can use with Claude Tag. At most 128 characters.                                                                                                                                                                                                                                                                                                                                                                                                                         |
| `environment_id` | string  | The cloud environment sessions run in, prefixed `env_`. It must be active and belong to your organization.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| `guest_policy`   | object  | What Claude does in a channel while a Slack guest is in it, for everyone in the channel: `{"type": "allow"}` (Claude answers), `{"type": "restrict"}` (Claude does not answer), or `{"type": "channel_only"}` (Claude answers with only the Bundles attached to the channel itself; if `channel_only` is not available to your organization, a request that sets it returns `400`). See [Restrict guest channels](https://claude.com/docs/claude-tag/admins/restrict-access#restrict-guest-channels) for what it means in channels shared through Slack Connect or across an Enterprise Grid. |

`model` and `environment_id` are checked when you write them and not again: if the model or environment later changes, responses keep returning the stored value.

If an organization owner has put a settings level on a self-hosted runner pool in claude.ai, its `environment_id` returns the pool's ID, which starts with `ccpool_`. This API cannot set a runner pool, and returns `400` for a request that changes or clears `environment_id` on a settings level that stores one.

### Stored and inherited values

Settings exist at three levels: the channel, the workspace the channel is in, and your organization's Slack defaults, which an organization owner sets in claude.ai. Each level stores only what was set on it. The `settings` of a channel or workspace object can hold either of two things:

* **What it stores.** This is what a response holds unless you ask otherwise. A setting that is not set on the channel or workspace is `null`. Use it to compare against configuration you keep elsewhere.
* **What applies in it**, once every level is taken into account. To get this, add the query parameter `include_inherited=true` to any `GET` request that returns a channel or a workspace, the two lists included. Use it to audit, or to find out why Claude behaves as it does in one channel. The parameter defaults to `false`, and a value that is not a Boolean returns `400`. A request that sets a channel up or changes settings does not take the parameter and returns `400` if you send it; its response holds what is stored.

In both cases `sources` names, for each setting, the level that the value in `settings` comes from. Without `include_inherited`, the source of a setting that the channel or workspace stores names the channel or workspace itself, and a setting it does not store has no source: `null`, or an empty list for `instructions`. With `include_inherited=true`, every setting except `instructions` has a source, and a setting that no level sets has the source `{"type": "default"}`; when no level sets `instructions`, it is `null` and its source list is empty. So to tell a value the channel or workspace sets itself from one it inherits, look at its source, not at whether the value is `null`.

Each setting is resolved on its own:

| Setting          | Rule                                                                                                                                      | When no level sets it                           |
| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------- |
| `enabled`        | The nearest level that sets it determines the value, so `true` on a channel turns Claude on there even when its workspace stores `false`. | `true`                                          |
| `instructions`   | Additive. The text of every level that sets it is joined, broadest first, with a blank line between.                                      | `null`                                          |
| `model`          | The nearest level that sets it determines the value.                                                                                      | `null`: Claude uses the product's default model |
| `environment_id` | The nearest level that sets it determines the value.                                                                                      | `null`                                          |
| `guest_policy`   | The nearest level that sets it determines the value.                                                                                      | `restrict`                                      |

For example, an organization stores instructions on its Slack defaults, turns Claude off on a workspace, and sets a model on one channel of that workspace. Read with `include_inherited=true`, the channel shows the three values and where each comes from:

```json
{
  "type": "slack_channel",
  "id": "slch_011CZkZmRt4vNq8sHbYw2KdX",
  "slack": {
    "workspace_id": "T01ABCD2EFG",
    "channel_id": "C05HJKL6MNP"
  },
  "settings": {
    "enabled": false,
    "instructions": "Be brief.",
    "model": "claude-opus-5-5",
    "environment_id": null,
    "guest_policy": { "type": "restrict" }
  },
  "sources": {
    "enabled": {
      "type": "slack_workspace",
      "slack_workspace_id": "slws_011CZkZnWa7xPc3uJfZe5LgT"
    },
    "instructions": [{ "type": "slack_default" }],
    "model": {
      "type": "slack_channel",

Cut at 300 lines. The page has the rest.