List domains

The domains your org has bought here, newest registration first, each carrying the name, when it was registered, when it expires, what the org paid, the registrar order id and the nameservers it points at.

GET /v1/domain/domains

Domain → · All API references → · Get started →

Address	`https://api.hanzo.ai/v1/domain/domains`
Method	`GET`
Operation	`get_domain_domains`
Auth	`Authorization: Bearer $HANZO_API_KEY`

Scoped to the validated principal's org — 401 without one, and there is no parameter that reaches another org's holdings.

This is the deployment's OWN ownership record, not a query to the registrar: it lists what was bought THROUGH this surface, so a domain the org holds elsewhere is not here. The default store is in-process, so a deployment that has not swapped in a durable store answers from what this process registered.

Request

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

Response

Status	Body	Meaning
`200`	domain.holdings	ok
`default`	problem-details	refused

200 body — 9 fields.

Field	In	Type	Always	Description
`domains`	body	domain.Holding[]	—	Domains is the caller org's domains, newest registration first.
`domains[].costCents`	body	integer (int64)	—	wholesale cost
`domains[].domain`	body	string	—	the name owned
`domains[].expiresAt`	body	string	—	when the registration lapses, RFC3339
`domains[].nameservers`	body	string[]	—	the authoritative nameservers the name points at
`domains[].order`	body	integer (int64)	—	registrar order id
`domains[].org`	body	string	—	the org that owns the domain
`domains[].priceCents`	body	integer (int64)	—	what the customer paid (sell)
`domains[].registeredAt`	body	integer (int64)	—	unix seconds

Failure carries the platform error shape — see Errors.

Examples

CLI

SDK

HTTP

MCP

hanzo domain domains

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

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

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

resp, _, err := client.DomainAPI.GetDomainDomains(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_domains(&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).getDomainDomains();

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

MCP reaches domain through the domain tool, which names its 7 operations with its own verbs — this one among them, under a name only MCP declares. describe explains any of them:

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": "get_domain_availability"
         }
       }
     }'

Domain API · All Hanzo APIs · Interactive reference

Was this page useful?

PreviousList availability NextList health