Edits the caller org's access policy for one channel and answers the policy as…

Edits the caller org's access policy for one channel and answers the policy as GET would, so both verbs return ONE shape. It requires ORG ADMIN.

PUT /v1/channels/allowlist

Channels → · All API references → · Six flows, four surfaces →


Address	`https://api.hanzo.ai/v1/channels/allowlist`
Method	`PUT`
Operation	`put_channels_allowlist`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Edits the caller org's access policy for one channel and answers the policy as GET would, so both verbs return ONE shape. It requires ORG ADMIN. Every field but channel is optional and applied only when provided: an empty policy string leaves that policy alone, an absent or null list leaves that list alone, and an EMPTY list clears it. It writes only CONFIG-sourced allow entries — senders approved through pairing belong to the approval flow, so a policy edit can never revoke one. An unknown channel is a 404.

Request

8 fields, body application/json (required).

Field	In	Type	Required	Description
`accessGroups`	body	object	—	AccessGroups REPLACES the org's named access groups, as group name -> channel -> entries.
`accessGroups.*`	body	object	—
`accessGroups..`	body	string[]	—
`channel`	body	string	—	Channel is the transport to edit: discord, slack, teams or telegram.
`dm`	body	string[]	—	DM REPLACES the config-managed DM allow entries. Absent or null leaves them alone; an empty list clears them.
`dmPolicy`	body	string	—	DMPolicy sets how direct messages are admitted: "pairing" (a person must be approved first), "allowlist" (only listed senders) or "open".
`group`	body	string[]	—	Group REPLACES the config-managed group allow entries.
`groupPolicy`	body	string	—	GroupPolicy sets how group and thread rooms are admitted: "open", "allowlist" or "disabled".

Response

Status	Body	Meaning
`200`	allowlistView	ok

200 body — 8 fields.

Field	In	Type	Always	Description
`accessGroups`	body	object	—	AccessGroups is the org's named sender sets, as group name -> channel -> member entries, held once for the whole org.
`accessGroups.*`	body	object	—
`accessGroups..`	body	string[]	—
`dm`	body	string[]	—	DM is the CONFIG-managed DM allow entries — the list PUT /v1/channels/allowlist owns and replaces wholesale.
`dmPolicy`	body	string	—	DMPolicy decides every inbound DIRECT message, defaulting to "pairing" when the org has never set one.
`group`	body	string[]	—	Group is the CONFIG-managed group allow entries, consulted only while GroupPolicy is "allowlist".
`groupPolicy`	body	string	—	GroupPolicy decides every inbound GROUP or THREAD message — a thread is a group surface — defaulting to "open". "open" admits every sender in the room.
`paired`	body	string[]	—	Paired is the senders admitted by PAIRING — the entries POST /v1/channels/pairing/approve minted, DM scope only.

Failure carries the platform error shape — see Errors.

Examples

hanzo channels allowlist replace

import { Configuration, ChannelsApi } from 'hanzoai';

const api = new ChannelsApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.putChannelsAllowlist({ accessGroups: {}, channel: "<channel>" });

from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import ChannelsApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = ChannelsApi(client).put_channels_allowlist(access_groups={}, channel="<channel>")

cfg := cloud.NewConfiguration()
cfg.AddDefaultHeader("Authorization", "Bearer "+os.Getenv("HANZO_API_KEY"))
client := cloud.NewAPIClient(cfg)

resp, _, err := client.ChannelsAPI.PutChannelsAllowlist(context.Background()).Execute()
if err != nil {
	return err
}

use hanzo_cloud::apis::{configuration::Configuration, channels_api};

let mut cfg = Configuration::new();
cfg.bearer_access_token = std::env::var("HANZO_API_KEY").ok();

let result = channels_api::put_channels_allowlist(&cfg, Default::default()).await?;

import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.ChannelsApi;

ApiClient client = new ApiClient();
client.setRequestInterceptor(b -> b.header("Authorization", "Bearer " + System.getenv("HANZO_API_KEY")));

var result = new ChannelsApi(client).putChannelsAllowlist();

curl -X PUT https://api.hanzo.ai/v1/channels/allowlist \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "accessGroups": {},
       "channel": "<channel>"
     }'

The door reaches channels through the channels tool, which names its 7 operations with its own verbs — this one among them, under a name only the door declares. describe explains any of them:

curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "describe",
         "arguments": {
           "op": "list_channels"
         }
       }
     }'

Channels API · All Hanzo APIs · Interactive reference

Edits the caller org's access policy for one channel and answers the policy as…

Request

Response

Examples

On this page