# List health

URL: https://docs.hanzo.ai/docs/openapi/domain/get-domain-health

> Reports registrar reachability honestly: ok only when the wholesale credentials are present AND name.com accepted them on a live call made while you waited.

`GET /v1/domain/health`

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

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

Reports registrar reachability honestly: ok only when the wholesale
credentials are present AND name.com accepted them on a live call made while you
waited.

Missing credentials or an unreachable registrar is 503 carrying configured,
reachable and the reason, so an operator reads the blocker instead of guessing at
it. It takes no principal, like every subsystem health probe.

## Request

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

## Response

| Status    | Body                | Meaning             |
| --------- | ------------------- | ------------------- |
| `200`     | domain.reachability | ok                  |
| `503`     | domain.reachability | service unavailable |
| `default` | problem-details     | refused             |

`200` body — 7 fields.

| Field        | In   | Type    | Always | Description                                                                                                |
| ------------ | ---- | ------- | ------ | ---------------------------------------------------------------------------------------------------------- |
| `configured` | body | boolean | —      | Configured is whether the wholesale credentials are present at all.                                        |
| `env`        | body | string  | —      | Env is the registrar environment.                                                                          |
| `error`      | body | string  | —      | Error is the blocker, so an operator reads it instead of guessing at it.                                   |
| `reachable`  | body | boolean | —      | Reachable is whether the registrar accepted those credentials on a live call made while the caller waited. |
| `registrar`  | body | string  | —      | Registrar names the wholesale registrar behind it.                                                         |
| `service`    | body | string  | —      | Service names the subsystem answering.                                                                     |
| `status`     | body | string  | —      | Status is "ok" when a live call succeeded, else "degraded".                                                |

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

## Examples

**CLI**

```bash
hanzo domain health
```

**SDK**

**.ts**

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

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

**.py**

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

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

**.go**

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

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

**.rs**

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

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

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

**.java**

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

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

var result = new DomainApi(client).getDomainHealth();
```

**HTTP**

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

**MCP**

Tool `domain`, op `get_domain_health` — 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": "domain",
         "arguments": {
           "op": "get_domain_health",
           "input": {}
         }
       }
     }'
```

---

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