# List world

URL: https://docs.hanzo.ai/docs/openapi/world/get-world

> Answers GET /v1/world — the product's public endpoint, naming every wire this surface answers on.

`GET /v1/world`

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

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

Answers GET /v1/world — the product's public endpoint, naming every wire
this surface answers on.

It exists because two of those wires are INVISIBLE to the generated document.
/v1/world/mcp and /v1/world/zap are carved off the cloud catch-all by the
ingress and answered by world-gw, so the cloud router never serves them — and
openapi.Describe renders prose only for a route the router actually serves,
which is the very property that keeps the document from being able to claim an
operation nothing answers. Both addresses are real and public, so without this
op the only way to learn they exist is to read the ingress config. This is
where that fact lives, in the product's own surface.

Public on purpose: discovery precedes credentials. It reports addresses and
protocols only — never feed data, and never the caller's plan, which
GET /v1/world/limits owns — so there is nothing here to leak.

## Request

`GET /v1/world` takes no parameters and no body — the credential is the whole request.

## Response

| Status    | Body             | Meaning |
| --------- | ---------------- | ------- |
| `200`     | world.worldIndex | ok      |
| `default` | problem-details  | refused |

`200` body — 8 fields.

| Field              | In   | Type               | Always | Description                                                                                         |
| ------------------ | ---- | ------------------ | ------ | --------------------------------------------------------------------------------------------------- |
| `product`          | body | string             | —      | Product is the product's name as customers know it.                                                 |
| `summary`          | body | string             | —      | Summary is one sentence naming what this surface serves.                                            |
| `wires`            | body | world.worldWire\[] | —      | Wires is every protocol entry point onto World, REST first.                                         |
| `wires[].auth`     | body | string             | —      | Auth states what the wire asks of the caller, including which parts of it answer without a token.   |
| `wires[].name`     | body | string             | —      | Name is the wire's short id — rest, mcp or zap.                                                     |
| `wires[].path`     | body | string             | —      | Path is the address the wire answers on, under this same origin.                                    |
| `wires[].protocol` | body | string             | —      | Protocol names what the wire speaks, so a caller knows which client to point at it.                 |
| `wires[].spec`     | body | string             | —      | Spec is where this wire's operations are enumerated, when they are enumerated in a document at all. |

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

## Examples

**CLI**

```bash
hanzo world get
```

**SDK**

**.ts**

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

const api = new WorldApi(new Configuration({ accessToken: process.env.HANZO_API_KEY }));
const { data } = await api.getWorld();
```

**.py**

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

client = ApiClient(Configuration(access_token=os.environ["HANZO_API_KEY"]))
result = WorldApi(client).get_world()
```

**.go**

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

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

**.rs**

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

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

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

**.java**

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

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

var result = new WorldApi(client).getWorld();
```

**HTTP**

```bash
curl https://api.hanzo.ai/v1/world \
  -H "Authorization: Bearer $HANZO_API_KEY"
```

**MCP**

MCP reaches **world** through the `world` tool, which names its 5 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_worlds"
         }
       }
     }'
```

---

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