List channels

Returns the channels the caller may see, with the kind and work facet each carries.

GET /v1/team/channels

Team → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/team/channels`
Method	`GET`
Operation	`get_team_channels`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Returns the channels the caller may see, with the kind and work facet each carries.

A signed-in TEAM MEMBER reads every channel of every space they are in that is open to them: public channels, and the private channels and direct messages that name them. An APPLICATION of the org (its own machine credential) reads the public channels of the org's spaces and nothing that belongs to particular people. Anybody else without a team session is 401.

It reads the SAME Chunter documents the transactor serves, so a channel opened in the Team client appears here with no sync, and a facet written here is read by anything holding the document.

Request

GET /v1/team/channels takes no parameters and no body — the credential is the whole request.

Response

Status	Body	Meaning
`200`	team.teamChannels	ok
`default`	problem-details	refused

200 body — 12 fields.

Field	In	Type	Always	Description
`channels`	body	team.teamChannel[]	—	Channels is every channel of every space the caller's org owns, each with the work facet it carries.
`channels[].archived`	body	boolean	—	Archived reports that the channel has been closed.
`channels[].bindings`	body	string[]	—	Bindings are what this channel is ABOUT, each a "<kind>:<ref>" string — "project:acme/web", "repo:hanzoai/cloud", "issue:1010".
`channels[].direct`	body	boolean	—	Direct reports that this is a channel between people rather than a named channel.
`channels[].id`	body	string	—	ID is the channel document's own id, and the value the bind op addresses.
`channels[].kind`	body	string	—	Kind is what sort of channel this is: "public" (open to everyone in the space), "private" (open to its members) or "dm" (a conversation between the people in it).
`channels[].life`	body	string	—	Life is the channel's lifecycle INTENT — "standing" or "bound" (HIP-0523 §2).
`channels[].members`	body	string[]	—	Members are the account uuids in the channel, agents included: an agent projects as a space member under a uuid derived from its id, so a caller comparing this against GET /v1/bot/members learns which channels an agent is in.
`channels[].name`	body	string	—	Name is what a person sees in a sidebar.
`channels[].private`	body	boolean	—	Private reports that the channel is restricted to its members.
`channels[].space`	body	string	—	Space is the space uuid holding this channel.
`channels[].topic`	body	string	—	Topic is the channel's own one-line subject, as the Team client sets it.

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo team channels list

.ts

.py

.go

.rs

.java

import { Configuration, TeamApi } from 'hanzoai';

const api = new TeamApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.getTeamChannels();

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

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = TeamApi(client).get_team_channels()

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

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

use hanzo_client::apis::{configuration::Configuration, team_api};

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

let result = team_api::get_team_channels(&cfg, Default::default()).await?;

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

ApiClient client = new ApiClient();
client.setBearerToken(System.getenv("HANZO_API_KEY"));

var result = new TeamApi(client).getTeamChannels();

The method above is the one at the current release of the document. [email protected] (npm) and [email protected] (PyPI) were generated from an earlier release, where this operation carried a different id, so it spells the method differently — regenerating the clients is what makes the two agree. SDKs →

curl https://api.hanzo.ai/v1/team/channels \
  -H "Authorization: Bearer $HANZO_API_KEY"

MCP reaches team through the team tool, which names its 33 operations with its own verbs — this one among them, under a name only MCP 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_team_account_providers"
         }
       }
     }'

Team API · All Hanzo APIs · Interactive reference

Was this page useful?

Broken link or missing step? Drop it in #docs on Discord or open a PR.

PreviousList messages NextList collaborator