Registrar Lookup API: Find a Domain Registrar in WHOIS JSON

Introduction

The registrar is one of the most useful administrative signals in a WHOIS record. It tells you which company currently manages the domain registration, where transfer and renewal operations are likely controlled, and which registrar-side changes deserve review.

WhoisJSON exposes registrar details through the documented WHOIS API endpoint. Query /api/v1/whois, read the registrar object, then combine it with whoisserver, status and nameserver fields for a more complete operational picture.

This article is intentionally narrower than the complete WHOIS JSON field reference. It focuses on registrar lookup, registrar drift and practical extraction patterns, not every WHOIS/RDAP field.

What Is a Registrar Lookup API?

A registrar lookup API accepts a domain name and returns structured data about the registrar of record. In WhoisJSON, registrar lookup is not a separate endpoint. It is a workflow built on top of the WHOIS endpoint.

The practical job is simple: normalize the registrar fields, store the values that matter to your workflow, and compare future responses against your approved baseline.

Registrar Lookup vs Domain Owner Lookup

Registrar lookup and owner lookup are often mixed together, but they answer different questions.

Registrar Fields to Read

Start with the registrar object, then add nearby WHOIS/RDAP fields that explain the administrative context around it.

Query Registrar Data with WHOIS

Authenticate with Authorization: TOKEN=YOUR_API_KEY and pass the domain in the domain query parameter.

curl "https://whoisjson.com/api/v1/whois?domain=example.com" \
  -H "Authorization: TOKEN=YOUR_API_KEY"

The complete response includes many WHOIS fields. A registrar-focused workflow can extract only the administrative subset it needs.

{
  "name": "example.com",
  "registered": true,
  "source": "rdap",
  "registrar": {
    "id": "376",
    "name": "Example Registrar, Inc.",
    "email": "[email protected]",
    "url": "https://www.example-registrar.test",
    "phone": "+1.5555550100"
  },
  "whoisserver": "whois.example-registrar.test",
  "status": [
    "clientTransferProhibited"
  ],
  "nameserver": [
    "ns1.example.net",
    "ns2.example.net"
  ]
}

Treat missing nested values as normal. Some registrars and registries return only registrar.name, while others include more contact fields.

How to Interpret Registrar Results

Registrar data is most useful when you compare it against an expected state instead of reading it in isolation.

Python Example: Extract Registrar Data

This example queries WHOIS, normalizes the registrar object, and returns a compact record that can be stored in a domain inventory.

import requests

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://whoisjson.com/api/v1"
HEADERS = {"Authorization": f"TOKEN={API_KEY}"}


def lookup_registrar(domain):
    response = requests.get(
        f"{BASE_URL}/whois",
        params={"domain": domain},
        headers=HEADERS,
        timeout=20,
    )
    response.raise_for_status()
    data = response.json()

    if not data.get("registered"):
        return {
            "domain": domain,
            "registered": False,
            "registrar": None,
        }

    registrar = data.get("registrar") or {}

    return {
        "domain": data.get("name", domain),
        "registered": True,
        "source": data.get("source"),
        "registrar_id": registrar.get("id"),
        "registrar_name": registrar.get("name"),
        "registrar_email": registrar.get("email"),
        "registrar_url": registrar.get("url"),
        "registrar_phone": registrar.get("phone"),
        "whoisserver": data.get("whoisserver"),
        "status": data.get("status") or [],
        "nameservers": data.get("nameserver") or [],
    }


print(lookup_registrar("example.com"))

Notice the defensive access pattern. Registrar fields are useful, but integrations should not fail when a source omits a nested value.

Node.js Example: Audit Registrar Drift

A common workflow is to store the expected registrar for important domains, then alert when the current registrar no longer matches the baseline.

const API_KEY = "YOUR_API_KEY";
const BASE_URL = "https://whoisjson.com/api/v1";

const expectedRegistrars = new Map([
  ["example.com", "Example Registrar, Inc."],
  ["example.org", "Corporate Registrar LLC"]
]);

async function lookupWhois(domain) {
  const url = new URL(`${BASE_URL}/whois`);
  url.searchParams.set("domain", domain);

  const response = await fetch(url, {
    headers: { Authorization: `TOKEN=${API_KEY}` }
  });

  if (!response.ok) {
    throw new Error(`${domain}: HTTP ${response.status}`);
  }

  return response.json();
}

function normalizeName(value) {
  return String(value || "")
    .trim()
    .replace(/\s+/g, " ")
    .toLowerCase();
}

for (const [domain, expected] of expectedRegistrars) {
  const data = await lookupWhois(domain);
  const current = data.registrar?.name || null;

  const drifted =
    normalizeName(current) !== normalizeName(expected);

  console.log({
    domain,
    registered: Boolean(data.registered),
    expectedRegistrar: expected,
    currentRegistrar: current,
    whoisserver: data.whoisserver || null,
    status: data.status || [],
    drifted
  });
}

For broader inventory work, combine this with the domain inventory API workflow so registrar data sits beside expiry, DNS and SSL state.

Common Registrar Lookup Use Cases

• Track registrar consistency across owned domains and subsidiaries.
• Detect unexpected registrar changes on critical domains.
• Enrich vendor domain reviews with registrar and WHOIS server context.
• Route abuse or support investigation using registrar contact hints when present.
• Identify domains that are still managed through consumer registrars instead of an enterprise registrar.
• Compare registrar-side nameservers with live DNS delegation during migrations.

Limits and Non-Goals

A precise registrar lookup workflow should be clear about what it cannot answer.

FAQ

Conclusion

Registrar lookup is a small but important part of WHOIS intelligence. Query /api/v1/whois, extract registrar fields defensively, and compare the result with the registrar you expect for each domain.

Keep the boundary clear: registrar data helps with audits, drift detection and escalation context. It does not replace ownership records, registrar account access, reverse WHOIS, renewal operations or historical storage.