# List channels URL: https://docs.hanzo.ai/docs/openapi/team/get-team-channels > Returns the channels the caller may see, with the kind and work facet each carries. `GET /v1/team/channels` > [Team →](https://docs.hanzo.ai/docs/openapi/team) · [All API references →](https://docs.hanzo.ai/docs/openapi) · [Get started →](https://docs.hanzo.ai/docs/guides) | | | | ------------- | --------------------------------------- | | **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 "\:\" 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](https://docs.hanzo.ai/docs/errors). ## Examples **CLI** ```bash hanzo team channels list ``` **SDK** **.ts** ```ts import { Configuration, TeamApi } from 'hanzoai'; const api = new TeamApi(new Configuration({ accessToken: process.env.HANZO_API_KEY })); const { data } = await api.getTeamChannels(); ``` **.py** ```python 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() ``` **.go** ```go 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 } ``` **.rs** ```rust 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?; ``` **.java** ```java 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. `hanzoai@8.5.914` (npm) and `hanzoai@8.5.914` (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 →](https://docs.hanzo.ai/docs/sdks) **HTTP** ```bash curl https://api.hanzo.ai/v1/team/channels \ -H "Authorization: Bearer $HANZO_API_KEY" ``` **MCP** 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: ```bash 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](https://docs.hanzo.ai/docs/openapi/team) · [All Hanzo APIs](https://docs.hanzo.ai/docs/openapi) · [Interactive reference](https://docs.hanzo.ai/docs/openapi/reference)