A Record Lookup API: Check A and AAAA Records in JSON

Introduction

A and AAAA records are the DNS records most teams notice only when traffic goes somewhere unexpected. They decide which IPv4 and IPv6 addresses a hostname resolves to, which CDN or hosting edge receives web traffic, and whether an application still points at the infrastructure the team expects.

WhoisJSON exposes A and AAAA records through the documented DNS Lookup API /nslookup endpoint. Query a domain or hostname, read the A and AAAA arrays, then compare those values with your expected provider, stored baseline, or domain inventory.

This article focuses on web-routing DNS records. For the broad record-type overview, start with the DNS Lookup API guide. For aliases that point one hostname to another, use the CNAME record lookup API guide.

What Is an A Record Lookup API?

An A record lookup API accepts a domain or hostname, queries DNS, and returns IPv4 address records as structured JSON. In the same response, WhoisJSON can also return AAAA records for IPv6 addresses.

The endpoint returns all available DNS fields in one response. There is no A-only endpoint and no type=A parameter in the documented API. Filter A and AAAA client-side when your workflow only needs address records.

Why A and AAAA Records Matter

Address records are simple, but they are operationally sensitive. A single unexpected A record can route users to the wrong origin, bypass a CDN, expose a legacy server, or break a customer-domain onboarding flow.

A vs AAAA Records

A and AAAA records answer the same practical question with different address families: where should traffic for this hostname go?

Query A and AAAA Records in JSON

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

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

The response can include many DNS fields. For address-record workflows, read A and AAAA as arrays of strings.

{
  "A": [
    "203.0.113.10",
    "203.0.113.11"
  ],
  "AAAA": [
    "2001:db8::10"
  ],
  "CNAME": [],
  "MX": []
}

Empty or missing A/AAAA arrays can be a valid DNS result. Interpret them against the hostname role and the expected configuration.

How to Interpret A Lookup Results

The correct result depends on whether the hostname is a root website, application subdomain, CDN edge, internal dependency, parked domain, or customer-managed domain.

Python Example: Check Web Routing

This example queries /nslookup, extracts A and AAAA records, normalizes the arrays, and compares them with expected values.

import requests

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


def normalize(values):
    return sorted({
        str(value).strip()
        for value in values or []
        if str(value).strip()
    })


def lookup_address_records(domain, expected_a=None, expected_aaaa=None):
    response = requests.get(
        f"{BASE_URL}/nslookup",
        headers=HEADERS,
        params={"domain": domain},
        timeout=10,
    )
    response.raise_for_status()
    data = response.json()

    current_a = normalize(data.get("A"))
    current_aaaa = normalize(data.get("AAAA"))
    expected_a = normalize(expected_a)
    expected_aaaa = normalize(expected_aaaa)

    return {
        "domain": domain,
        "a": current_a,
        "aaaa": current_aaaa,
        "has_ipv4": bool(current_a),
        "has_ipv6": bool(current_aaaa),
        "a_matches_expected": (
            current_a == expected_a if expected_a else None
        ),
        "aaaa_matches_expected": (
            current_aaaa == expected_aaaa if expected_aaaa else None
        ),
    }


print(lookup_address_records(
    "example.com",
    expected_a=["203.0.113.10"],
    expected_aaaa=["2001:db8::10"],
))

Node.js Example: Detect A/AAAA Drift

Store a baseline in your domain inventory. On each scheduled run, compare sets instead of relying on array order.

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

function normalize(values = []) {
  return [...new Set(
    values
      .map((value) => String(value).trim())
      .filter(Boolean)
  )].sort();
}

function diff(previous, current) {
  const before = new Set(normalize(previous));
  const now = new Set(normalize(current));

  return {
    added: [...now].filter((value) => !before.has(value)).sort(),
    removed: [...before].filter((value) => !now.has(value)).sort(),
  };
}

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

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

  if (!response.ok) {
    throw new Error(`DNS lookup failed: ${response.status}`);
  }

  const data = await response.json();
  return {
    A: normalize(data.A ?? []),
    AAAA: normalize(data.AAAA ?? []),
  };
}

async function compareAddressBaseline(domain, baseline) {
  const current = await getAddressRecords(domain);
  const aDiff = diff(baseline.A ?? [], current.A);
  const aaaaDiff = diff(baseline.AAAA ?? [], current.AAAA);

  return {
    domain,
    current,
    changed: Boolean(
      aDiff.added.length ||
      aDiff.removed.length ||
      aaaaDiff.added.length ||
      aaaaDiff.removed.length
    ),
    A: aDiff,
    AAAA: aaaaDiff,
  };
}

compareAddressBaseline("example.com", {
  A: ["203.0.113.10"],
  AAAA: ["2001:db8::10"],
})
  .then(console.log)
  .catch(console.error);

A/AAAA Audits for Domain Portfolios

Address-record checks are useful inside a broader domain operations workflow. They answer a narrower question than full inventory: is this hostname resolving to the addresses we expect right now?

• Production domains: compare A and AAAA records with approved CDN, load balancer, or hosting values.
• Customer-domain onboarding: verify that the customer has pointed the hostname at the expected address records before activation.
• Migration review: track old and new address records during hosting or CDN moves.
• IPv6 rollout: report which domains publish AAAA records and which still only expose IPv4.

For portfolio-wide ownership, expiry, DNS and SSL context, use the domain inventory API guide. For detecting zone updates before comparing record arrays, use the SOA record lookup API guide.

A Records vs CNAME Records

A and AAAA records point directly to IP addresses. CNAME records point a hostname to another hostname. Keep those workflows separate in code because they answer different operational questions.

Many hostnames use one or the other. Some DNS responses can include both alias and address context depending on resolver behavior and the queried name. Preserve the raw response and filter for the fields your workflow needs.

What an A Record Lookup Cannot Prove

FAQ

Conclusion

An A record lookup API gives teams a clean way to inspect web-routing DNS records in code. Use /nslookup, read A and AAAA arrays, compare values as sets, and store baselines for domains where unexpected routing changes matter.

Keep the boundary precise: A and AAAA records show address resolution. They do not prove propagation, uptime, IP reputation, or service health. Combine them with CNAME, SOA, SSL, subdomain discovery and inventory workflows when you need the full domain operations picture.