# List policy

URL: https://docs.hanzo.ai/docs/openapi/ai/get-ai-router-policy

> The HTTP transport binding for the RESTful router-config nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and /v1/ai/org/settings[/list]).

`GET /v1/ai/router/policy`

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

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

The HTTP transport binding for the RESTful router-config
nouns (/v1/ai/router/{policy,defaults,ledger,rewards,artifact-meta} and
/v1/ai/org/settings\[/list]). It dispatches IN-PROCESS through dispatchGateway —
the SAME canonical ZAP gateway registry (zap\_registry.go) that the MsgType 200
handler serves over the gateway transport. The native ZAP
handler is the ONE and ONLY implementation of these routes; this is purely the
api.hanzo.ai HTTP binding, so there is NO controller twin to drift from and the
split-brain the router refactor removed stays removed.

Why a bridge and not a twin controller method: one handler serves both
transports, so the HTTP route and the ZAP message read and write router settings
through the same code and cannot come to disagree about them. Routing these nouns
through the ZAP handler over one adapter keeps a single source of truth.

Identity is the request's own Bearer credential (Authorization header), which
the native handlers resolve exactly as the gateway does — every caller
(console, chat, app) already sends it. The dispatched handler returns a ZAP
message whose status is field 0 and body is field 4 (BuildCloudResponse /
BuildGatewayResponse layout); both are relayed verbatim. The route is mapped
"\*" (any verb) because the native handler is method-aware: /v1/ai/router/policy
splits GET (read) vs PUT (write), /v1/ai/org/settings GET/PUT/DELETE, and returns
405 for a verb it does not own.

## Request

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

## Response

| Status | Body        | Meaning                                             |
| ------ | ----------- | --------------------------------------------------- |
| `200`  | ai.Response | Success.                                            |
| `401`  | —           | No credential, or one this service does not accept. |
| `403`  | —           | A valid credential that may not do this.            |

`200` body — 5 fields.

| Field    | In   | Type   | Always | Description |
| -------- | ---- | ------ | ------ | ----------- |
| `code`   | body | string | —      |             |
| `data`   | body | any    | —      |             |
| `data2`  | body | any    | —      |             |
| `msg`    | body | string | —      |             |
| `status` | body | string | —      |             |

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

## Examples

**CLI**

```bash
hanzo ai router policy get
```

**SDK**

**.ts**

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

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

**.py**

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

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

**.go**

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

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

**.rs**

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

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

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

**.java**

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

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

var result = new AiApi(client).getAiRouterPolicy();
```

**HTTP**

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

**MCP**

MCP declares no tool for **ai** — `tools/list` on `https://api.hanzo.ai/v1/mcp` names the products it does reach. Use HTTP or an SDK.

---

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