# List rooms

URL: https://docs.hanzo.ai/docs/openapi/team/get-team-rooms

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

`GET /v1/team/rooms`

> [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/rooms`   |
| **Method**    | `GET`                                  |
| **Operation** | `get_team_rooms`                       |
| **Auth**      | `Authorization: Bearer $HANZO_API_KEY` |

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

A signed-in TEAM MEMBER reads every room 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 room 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/rooms` takes no parameters and no body — the credential is the whole request.

## Response

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

`200` body — 12 fields.

| Field              | In   | Type             | Always | Description                                                                                                                                                                                                                 |
| ------------------ | ---- | ---------------- | ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `rooms`            | body | team.teamRoom\[] | —      | Rooms is every room of every space the caller's org owns, each with the work facet it carries.                                                                                                                              |
| `rooms[].archived` | body | boolean          | —      | Archived reports that the room has been closed.                                                                                                                                                                             |
| `rooms[].bindings` | body | string\[]        | —      | Bindings are what this room is ABOUT, each a "\<kind>:\<ref>" string — "project:acme/web", "repo:hanzoai/cloud", "issue:1010".                                                                                              |
| `rooms[].direct`   | body | boolean          | —      | Direct reports that this is a room between people rather than a named room.                                                                                                                                                 |
| `rooms[].id`       | body | string           | —      | ID is the room document's own id, and the value the bind op addresses.                                                                                                                                                      |
| `rooms[].kind`     | body | string           | —      | Kind is what sort of room this is: "channel" (open to everyone in the space), "private" (open to its members) or "dm" (a conversation between the people in it).                                                            |
| `rooms[].life`     | body | string           | —      | Life is the room's lifecycle INTENT — "standing" or "bound" (HIP-0523 §2).                                                                                                                                                  |
| `rooms[].members`  | body | string\[]        | —      | Members are the account uuids in the room, 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 rooms an agent is in. |
| `rooms[].name`     | body | string           | —      | Name is what a person sees in a sidebar.                                                                                                                                                                                    |
| `rooms[].private`  | body | boolean          | —      | Private reports that the room is restricted to its members.                                                                                                                                                                 |
| `rooms[].space`    | body | string           | —      | Space is the space uuid holding this room.                                                                                                                                                                                  |
| `rooms[].topic`    | body | string           | —      | Topic is the room'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 rooms 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.getTeamRooms();
```

**.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_rooms()
```

**.go**

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

resp, _, err := client.TeamAPI.GetTeamRooms(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_rooms(&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).getTeamRooms();
```

**HTTP**

```bash
curl https://api.hanzo.ai/v1/team/rooms \
  -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)