DomainIntelligence

Quickstart

Get registrar prices directly from your server or terminal. No browser visit or WHOIS lookup is needed. Create a key in My Settings, set WHOIS_API_KEY in your server's environment, then run:

curl --fail-with-body --silent --show-error --max-time 30 \
  -H "X-API-Key: ${WHOIS_API_KEY}" \
  "https://whois.cx/api/v1/prices/example.com"

2. Read the result. registrars[] contains register, renew and transfer prices. Check currency and scraped_at; a null price is unavailable, not free. An empty list means no comparison data is available. See runnable clients for parsing and error handling.

Choose the endpoint for your task

Optional: try without a key

Anonymous access must be enabled and shares a smaller per-IP quota. A 401 means you need a valid key; successful anonymous responses include _notice.

curl --fail-with-body --silent --show-error --max-time 30 \
  "https://whois.cx/api/v1/prices/example.com"

The cURL examples require cURL 7.76+ for --fail-with-body. For registration data instead, see WHOIS Lookup; that endpoint also accepts IPv4/IPv6 addresses.

Endpoints

Base URL: https://whois.cx/api/v1. The paths below are relative to this URL.

WHOIS Lookup

Look up WHOIS/RDAP registration data for a domain name or an IP address. The server picks the best protocol per TLD (RDAP / WHOIS / hybrid).

Parameters

Response

{
  "domain": "google.com",
  "registrar": "MarkMonitor Inc.",
  "registrar_iana_id": "292",
  "registrar_abuse_email": "[email protected]",
  "creation_date": "1997-09-15T04:00:00Z",
  "updated_date": "2019-09-09T15:39:04Z",
  "expiry_date": "2028-09-14T04:00:00Z",
  "nameservers": [
    "ns1.google.com",
    "ns2.google.com",
    "ns3.google.com",
    "ns4.google.com"
  ],
  "status": [
    "client delete prohibited",
    "client transfer prohibited",
    "client update prohibited",
    "server delete prohibited",
    "server transfer prohibited",
    "server update prohibited"
  ],
  "dnssec": "unsigned",
  "_meta": {
    "protocol": "rdap",
    "duration_ms": 245
  }
}

Response Fields

Price Comparison

Compare registration, renewal and transfer prices across registrars for a domain's TLD, including supported multi-part suffixes such as co.uk. Pass a domain name such as example.com, not an IP address. Use ASCII/Punycode for internationalized names. Malformed names and IP addresses return 400.

Uses the same X-API-Key authentication and optional anonymous tier as WHOIS. Each request consumes one unit from the same per-key or per-IP quota, including requests served from the server cache. It does not perform a WHOIS lookup or make a live upstream pricing request.

curl -H "X-API-Key: whois_your_key" \
  https://whois.cx/api/v1/prices/example.com

Response

{
  "domain": "example.com",
  "tld": "com",
  "currency": "USD",
  "scraped_at": "2026-10-01T00:00:00Z",
  "count": 1,
  "source": "tldes.com",
  "registrars": [
    {
      "registrar": "Example Registrar",
      "slug": "example-registrar",
      "register": 9.99,
      "register_usual": 12.99,
      "register_promo": "EXAMPLE3",
      "renew": 14.99,
      "renew_usual": 14.99,
      "renew_promo": null,
      "transfer": 10.99,
      "transfer_usual": 10.99,
      "transfer_promo": null
    }
  ]
}

No comparison data

An unsupported dataset suffix or unavailable dataset returns 200 with an empty list, not a fabricated price. Metadata such as currency and timestamp is omitted:

{
  "domain": "example.com",
  "tld": "com",
  "count": 0,
  "registrars": []
}

If price comparison is disabled, this endpoint returns 404 with {"error":"Price comparison is not available"}. Authentication and quota errors use the standard error codes.

Include prices with WHOIS

curl -H "X-API-Key: whois_your_key" \
  "https://whois.cx/api/v1/whois/example.com?prices=1"

The lookup response gains a prices object containing the comparison fields above, without the repeated domain. This costs no extra quota unit. If comparison is disabled or no dataset rows exist, prices is omitted and the normal lookup continues. IP lookups never include it.

Understand Your Response

Check the HTTP status first, then the payload. A successful request does not guarantee that a price exists.

Website Pricing APIs

For integrations, use the versioned Price Comparison API above. The website also uses these separate public read routes. Paths here are complete paths from https://whois.cx, not relative to /api/v1; their normal reads do not require login or an API key.

Understanding a null pricing summary

/api/pricing/{domain} behaves the same for browsers, curl and server-side callers. The website sends the same GET request; it does not fetch provider prices separately or write them back. _meta.fetch_mode: "client_async" describes frontend request timing, not a requirement to visit the domain page or a promise that an external provider will be queried.

Read _meta.status to distinguish these successful 200 responses. A local miss is not proof that no provider has a price for the domain.

_meta.lookup_mode is local_only for ordinary reads and provider_fallback for an administrator's forced refresh. It identifies the permitted resolution policy, not evidence that a provider was actually called: local data may satisfy a refresh, or providers may be disabled or unconfigured.

{
  "domain": "example.com",
  "pricing": null,
  "_meta": {
    "fetch_mode": "client_async",
    "display": {
      "show_register": true,
      "show_renew": true,
      "show_transfer": true,
      "show_restore": false
    },
    "status": "local_miss",
    "lookup_mode": "local_only",
    "message": "No usable cached price, domain override, or TLD base price is available. Public requests do not fetch external pricing providers."
  }
}

To supply missing summaries, an administrator can configure local domain overrides or TLD base prices, or explicitly force a refresh against configured, enabled providers. Opening the domain page does not populate missing provider data. An API key does not grant administrator access. For cross-registrar TLD comparison data, use /api/v1/prices/{domain}; those comparisons are not domain-specific quotes.

Account Info

Returns your current tier's limits and live usage. The response shape depends on whether you passed a key.

With API key

{
  "tier": "api_key",
  "key_name": "My App",
  "key_prefix": "whois_a1b2c3",
  "total_requests": 1542,
  "rate_limits": { "1m": 10, "1h": 200, "1d": 2000 },
  "rate_usage": {
    "1m": {"limit": 10,   "remaining": 7,    "reset": 1709740800, "requests": 3},
    "1h": {"limit": 200,  "remaining": 155,  "reset": 1709740800, "requests": 45},
    "1d": {"limit": 2000, "remaining": 1688, "reset": 1709769600, "requests": 312}
  },
  "created_at": "2025-01-15 10:30:00"
}

Anonymous (no key)

{
  "tier": "anonymous",
  "rate_limits": { "1m": 3, "1h": 30, "1d": 100 },
  "rate_usage": {
    "1m": {"limit": 3,   "remaining": 2,  "reset": 1709740800, "requests": 1},
    "1h": {"limit": 30,  "remaining": 29, "reset": 1709740800, "requests": 1},
    "1d": {"limit": 100, "remaining": 99, "reset": 1709769600, "requests": 1}
  },
  "_notice": "You're using the anonymous tier (3/min, 30/hour, 100/day). Sign in at https://whois.cx to create an API key with higher limits."
}

Rate Limits

The versioned WHOIS and price-comparison endpoints share a quota: anonymous (when enabled, no key, per-IP) or API key (per-key). A dedicated prices request uses one unit; adding ?prices=1 to WHOIS uses no additional unit. Server-cache hits still count. /account reads usage without consuming a lookup unit.

Anonymous tier — no key required

API key tier

WHOIS and price requests that reach the quota check include these minute-window headers. Authentication failures and account responses do not necessarily include them:

X-RateLimit-Limit: 3
X-RateLimit-Remaining: 2
X-RateLimit-Reset: 1709740800
Retry-After: 42            ← only on 429

When a per-IP or per-key quota window is exhausted, you'll get a 429 Too Many Requests with the full window snapshot and (for anonymous callers) the _notice:

{
  "error": "Rate limit exceeded",
  "limits": {
    "1m": {"allowed": false, "limit": 3,   "remaining": 0, "reset": 1709740860, "requests": 3},
    "1h": {"allowed": true,  "limit": 30,  "remaining": 26, "reset": 1709743200, "requests": 4},
    "1d": {"allowed": true,  "limit": 100, "remaining": 96, "reset": 1709769600, "requests": 4}
  },
  "_notice": "You're using the anonymous tier (3/min, 30/hour, 100/day). Sign in at https://whois.cx to create an API key with higher limits."
}

Authentication

Authentication is optional only when anonymous access is enabled. Otherwise, a missing key returns 401. An invalid or expired supplied key also returns 401; it does not fall back to the anonymous tier. The public API must be enabled for either tier.

Generate a key from My Settings, then pass it via the X-API-Key header:

curl -H "X-API-Key: whois_your_api_key_here" \
  https://whois.cx/api/v1/whois/google.com

Error Codes

All error responses are JSON with at minimum an error string:

{"error": "Description of what went wrong"}

Code Examples

These clients fetch example.com price comparisons, check failures and print every available price. Set WHOIS_API_KEY in the environment for the recommended authenticated tier; without it, anonymous access must be enabled. All clients optionally accept WHOIS_API_BASE, defaulting to https://whois.cx/api/v1. Keep that base URL trusted: a configured key is sent to it.

Save the selected example as a script and run it from your terminal. A successful empty result prints No comparison data available.; transport, HTTP and malformed-response failures exit unsuccessfully instead.

#!/usr/bin/env bash
base="${WHOIS_API_BASE:-https://whois.cx/api/v1}"
headers=(-H "Accept: application/json")
if [ -n "${WHOIS_API_KEY:-}" ]; then
  headers+=(-H "X-API-Key: ${WHOIS_API_KEY}")
fi

response_headers=$(mktemp) || exit 1
trap 'rm -f "$response_headers"' EXIT
if ! response=$(curl --fail-with-body --silent --show-error --dump-header "$response_headers" \
  --connect-timeout 10 --max-time 30 "${headers[@]}" \
  "${base%/}/prices/example.com"); then
  # Show Retry-After and quota headers when the request fails.
  cat "$response_headers" >&2
  printf '%s\n' "$response" >&2
  exit 1
fi

printf '%s\n' "$response" | jq -er '
  def price: if . == null then "unavailable" else tostring end;
  if (.registrars | type) != "array" then
    error("Invalid price response")
  elif (.registrars | length) == 0 then
    "No comparison data available."
  else
    "Currency: \(.currency // "unknown") | Dataset updated: \(.scraped_at // "unknown")",
    (.registrars[] | "\(.registrar): register=\(.register | price), renew=\(.renew | price), transfer=\(.transfer | price)")
  end
'

import json
import os
import sys
from urllib.error import HTTPError, URLError
from urllib.request import Request, urlopen

base = os.environ.get("WHOIS_API_BASE", "https://whois.cx/api/v1").rstrip("/")
key = os.environ.get("WHOIS_API_KEY")
headers = {"Accept": "application/json"}
if key:
    headers["X-API-Key"] = key

request = Request(f"{base}/prices/example.com", headers=headers)
try:
    with urlopen(request, timeout=30) as response:
        data = json.load(response)
except HTTPError as error:
    message = str(error.reason)
    try:
        body = json.load(error)
        if isinstance(body, dict):
            message = body.get("error", message)
    except ValueError:
        pass
    retry = error.headers.get("Retry-After")
    hint = f"; retry after {retry}s" if error.code == 429 and retry else ""
    sys.exit(f"HTTP {error.code}: {message}{hint}")
except (URLError, TimeoutError, ValueError) as error:
    sys.exit(f"Request failed: {error}")

if not isinstance(data, dict) or not isinstance(data.get("registrars"), list):
    sys.exit("Invalid price response")

rows = data["registrars"]
if not rows:
    print("No comparison data available.")
else:
    print(f"Currency: {data.get('currency') or 'unknown'} | "
          f"Dataset updated: {data.get('scraped_at') or 'unknown'}")
    def price(value):
        return "unavailable" if value is None else str(value)
    for row in rows:
        print(f"{row['registrar']}: register={price(row.get('register'))}, "
              f"renew={price(row.get('renew'))}, transfer={price(row.get('transfer'))}")

const base = (process.env.WHOIS_API_BASE || "https://whois.cx/api/v1").replace(/\/$/, "");
const key = process.env.WHOIS_API_KEY;
const headers = { Accept: "application/json" };
if (key) headers["X-API-Key"] = key;

try {
  const res = await fetch(`${base}/prices/example.com`, {
    headers,
    signal: AbortSignal.timeout(30_000),
  });
  let data;
  try {
    data = await res.json();
  } catch {
    throw new Error(`HTTP ${res.status}: invalid JSON response`);
  }
  if (!res.ok) {
    const retry = res.headers.get("Retry-After");
    const hint = res.status === 429 && retry ? `; retry after ${retry}s` : "";
    throw new Error(`HTTP ${res.status}: ${data?.error || res.statusText}${hint}`);
  }
  if (!Array.isArray(data?.registrars)) throw new Error("Invalid price response");

  if (data.registrars.length === 0) {
    console.log("No comparison data available.");
  } else {
    console.log(`Currency: ${data.currency ?? "unknown"} | Dataset updated: ${data.scraped_at ?? "unknown"}`);
    const price = (value) => value == null ? "unavailable" : String(value);
    for (const row of data.registrars) {
      console.log(`${row.registrar}: register=${price(row.register)}, renew=${price(row.renew)}, transfer=${price(row.transfer)}`);
    }
  }
} catch (error) {
  console.error(error.message);
  process.exitCode = 1;
}

<?php
$base = rtrim(getenv('WHOIS_API_BASE') ?: 'https://whois.cx/api/v1', '/');
$key = getenv('WHOIS_API_KEY');
$headers = ['Accept: application/json'];
if ($key) $headers[] = "X-API-Key: $key";

try {
    $ch = curl_init("$base/prices/example.com");
    $retryAfter = null;
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER => $headers,
        CURLOPT_CONNECTTIMEOUT => 10,
        CURLOPT_TIMEOUT => 30,
        CURLOPT_HEADERFUNCTION => static function ($ch, $line) use (&$retryAfter) {
            if (stripos($line, 'Retry-After:') === 0) {
                $retryAfter = trim(substr($line, strlen('Retry-After:')));
            }
            return strlen($line);
        },
    ]);
    $body = curl_exec($ch);
    $code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    $error = curl_error($ch);
    curl_close($ch);
    if ($body === false) throw new RuntimeException("Request failed: $error");

    try {
        $data = json_decode($body, true, 512, JSON_THROW_ON_ERROR);
    } catch (JsonException $error) {
        throw new RuntimeException("HTTP $code: invalid JSON response", 0, $error);
    }
    if ($code !== 200) {
        $message = is_array($data) ? ($data['error'] ?? 'Request failed') : 'Request failed';
        $hint = $code === 429 && $retryAfter !== null ? "; retry after {$retryAfter}s" : '';
        throw new RuntimeException("HTTP $code: $message$hint");
    }
    if (!is_array($data) || !is_array($data['registrars'] ?? null)) {
        throw new RuntimeException('Invalid price response');
    }

    if (!$data['registrars']) {
        echo "No comparison data available.\n";
    } else {
        echo 'Currency: ' . ($data['currency'] ?? 'unknown')
            . ' | Dataset updated: ' . ($data['scraped_at'] ?? 'unknown') . "\n";
        $price = static fn($value): string => $value === null ? 'unavailable' : (string) $value;
        foreach ($data['registrars'] as $row) {
            echo $row['registrar'] . ': register=' . $price($row['register'] ?? null)
                . ', renew=' . $price($row['renew'] ?? null)
                . ', transfer=' . $price($row['transfer'] ?? null) . "\n";
        }
    }
} catch (Throwable $error) {
    fwrite(STDERR, $error->getMessage() . "\n");
    exit(1);
}