# List call

URL: https://docs.hanzo.ai/docs/openapi/meet/meetcall

> Answers where a room's call happens, for a caller who may join it.

`GET /v1/meet/call`

> [Meet →](https://docs.hanzo.ai/docs/openapi/meet) · [All API references →](https://docs.hanzo.ai/docs/openapi) · [Get started →](https://docs.hanzo.ai/docs/guides)

|               |                                        |
| ------------- | -------------------------------------- |
| **Address**   | `https://api.hanzo.ai/v1/meet/call`    |
| **Method**    | `GET`                                  |
| **Operation** | `meetCall`                             |
| **Auth**      | `Authorization: Bearer $HANZO_API_KEY` |

Answers where a room's call happens, for a caller who may join it.

It is the "resolved at render" half of HIP-0523 §12: a surface showing a channel
asks for the room's call at the moment it draws one, rather than reading a media
room name someone stored on the room. Nothing here is persisted and nothing is
created — a media room begins existing when the first participant connects and
stops when the last leaves, so there is no call to create and none to clean up.

AUTHORIZATION IS THE JOIN DECISION, unchanged and shared. It delegates to
state.admits, the same function POST /v1/meet/getToken and all three recording
operations admit on, so a caller who is told where a call is, is a caller who
could have joined it. Answering the address to someone who cannot join would make
this a space-membership oracle for anyone who can guess a room id.

It deliberately does NOT report whether a call is in progress. That is a fact the
media server holds and this binary would have to ask for it over the network,
which is a different decision with a different failure mode — and reporting
"nobody is in this call" when the question could not be asked would be exactly the
unknown-rendered-as-zero this surface refuses elsewhere.

## Request

2 fields.

| Field   | In    | Type   | Required | Description                                                                    |
| ------- | ----- | ------ | -------- | ------------------------------------------------------------------------------ |
| `space` | query | string | yes      | Space is the space uuid holding the room, as GET /v1/team/rooms reports it.    |
| `room`  | query | string | yes      | Room is the room's own id within that space, as GET /v1/team/rooms reports it. |

## Response

| Status    | Body            | Meaning |
| --------- | --------------- | ------- |
| `200`     | meet.venue      | ok      |
| `default` | problem-details | refused |

`200` body — 3 fields.

| Field   | In   | Type    | Always | Description                                                                                                                              |
| ------- | ---- | ------- | ------ | ---------------------------------------------------------------------------------------------------------------------------------------- |
| `name`  | body | string  | —      | Name is the media room to join: the value POST /v1/meet/getToken takes as roomName, and the value the media server keys participants on. |
| `ready` | body | boolean | —      | Ready reports that this deployment can mint a join token for this room.                                                                  |
| `ws`    | body | string  | —      | WS is where the media plane is — the address a client opens its own browser-to-server connection to.                                     |

Failure carries the platform error shape — see [Errors](https://docs.hanzo.ai/docs/errors).

## Examples

**CLI**

```bash
hanzo meet call \
  --space <space> \
  --room <room>
```

**SDK**

**.ts**

```ts
import { Configuration, MeetApi } from 'hanzoai';

const api = new MeetApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.meetCall({ space: 'space', room: 'room' });
```

**.py**

```python
from hanzoai.cloud import ApiClient, Configuration
from hanzoai.cloud.api import MeetApi

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = MeetApi(client).meet_call(space='space', room='room')
```

**.go**

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

resp, _, err := client.MeetAPI.MeetCall(context.Background()).Execute()
if err != nil {
	return err
}
```

**.rs**

```rust
use hanzo_client::apis::{configuration::Configuration, meet_api};

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

let result = meet_api::meet_call(&cfg, Default::default()).await?;
```

**.java**

```java
import ai.hanzo.cloud.ApiClient;
import ai.hanzo.cloud.api.MeetApi;

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

var result = new MeetApi(client).meetCall();
```

**HTTP**

```bash
curl https://api.hanzo.ai/v1/meet/call?space=%3Cspace%3E&room=%3Croom%3E \
  -H "Authorization: Bearer $HANZO_API_KEY"
```

**MCP**

Tool `meet`, op `meetCall` — POST the JSON-RPC envelope to `https://api.hanzo.ai/v1/mcp`.

```bash
curl -X POST https://api.hanzo.ai/v1/mcp \
  -H "Authorization: Bearer $HANZO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "meet",
         "arguments": {
           "op": "meetCall",
           "input": {
             "space": "<space>",
             "room": "<room>"
           }
         }
       }
     }'
```

---

[Meet API](https://docs.hanzo.ai/docs/openapi/meet) · [All Hanzo APIs](https://docs.hanzo.ai/docs/openapi) · [Interactive reference](https://docs.hanzo.ai/docs/openapi/reference)