List 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 → · All API references → · Get started →

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.

Examples

CLI

SDK

HTTP

MCP

hanzo domain health

.ts

.py

.go

.rs

.java

import { Configuration, DomainApi } from 'hanzoai';

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

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()

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
}

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?;

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();

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

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

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 · All Hanzo APIs · Interactive reference

Was this page useful?

PreviousList domains NextSearch domain