Technical Protocol April 2026

RDAP vs. WHOIS: Why the 2026 Standard Has Changed the Game for Domain APIs

For decades, the WHOIS protocol was the only way to check whether a domain was registered. In 2026, RDAP — the Registration Data Access Protocol — has become the ICANN-mandated successor. If you're building any kind of domain availability feature, this is the most important protocol shift you need to understand.

The WHOIS problem, plainly stated

If you've ever tried to build domain availability checking from scratch, you know the pain. WHOIS responses are unstructured plain text. Every registrar formats them differently. Date fields look different from one TLD to the next. Some servers rate-limit you aggressively after just a few queries. Others silently return stale data.

Here's what a raw WHOIS response looks like when you query example.com:

# Raw WHOIS response — unstructured plain text
Domain Name: EXAMPLE.COM
Registry Domain ID: 2336799_DOMAIN_COM-VRSN
Registrar WHOIS Server: whois.iana.org
Updated Date: 2023-08-14T07:01:38Z
Creation Date: 1995-08-14T04:00:00Z
Registry Expiry Date: 2024-08-13T04:00:00Z
Registrar: RESERVED-Internet Assigned Numbers Authority
Domain Status: clientDeleteProhibited
# ... 40 more lines of inconsistent text ...

To extract even the basic "is this domain available?" signal, you need to write a parser. That parser will break when a registrar changes their format — and they do, without notice.

What RDAP actually changes

RDAP (Registration Data Access Protocol) is defined in RFC 7483 and was adopted as the ICANN-mandated successor to WHOIS starting in 2025. The core difference is simple: RDAP returns structured JSON directly from the registry.

Here's the same domain queried via RDAP:

// RDAP response — structured JSON from the registry
{
  "objectClassName": "domain",
  "ldhName": "EXAMPLE.COM",
  "status": ["client delete prohibited"],
  "events": [
    { "eventAction": "registration", "eventDate": "1995-08-14T04:00:00Z" },
    { "eventAction": "expiration", "eventDate": "2024-08-13T04:00:00Z" }
  ]
}

No parser needed. The fields are standardized across all registrars. The dates are always ISO 8601. The status codes are defined in the RFC. Your code doesn't break when a registrar updates their response format.

Side-by-side comparison

Dimension WHOIS RDAP
Output format Unstructured plain text Structured JSON (RFC 7483)
Consistency Varies by registrar — requires custom parsers per TLD Standardized across all ICANN-accredited registries
Rate limits Aggressive, undocumented, often silent Defined per registry, documented, HTTP 429 responses
Data source Often third-party aggregators, not the registry directly Directly from the authoritative registry
Date formats Multiple formats: "14-Aug-1995", "1995-08-14", etc. Always ISO 8601 (2026-04-11T00:00:00Z)
ICANN status in 2026 Deprecated, being phased out Mandatory standard since 2025

What this means for your domain availability API

If you're building domain availability checking today — whether for a SaaS name generator, a domain marketplace, or a registrar-adjacent product — you have two paths:

  1. Build on WHOIS: Maintain parsers per registrar, handle silent failures, accept inconsistent data, and watch your code break every few months when a registry changes format.
  2. Build on RDAP: Parse JSON once, trust the structure, query the registry directly, and get reliable results with documented error codes.

The technical argument for RDAP is overwhelming. The practical obstacle is that RDAP still doesn't cover every TLD in 2026 — which is exactly why a fallback to WHOIS remains necessary for full coverage.

How Domiquo handles this: The Domiquo API is RDAP-native — it queries the authoritative registry via RDAP first on every request. For TLDs where RDAP isn't yet available, it falls back to WHOIS automatically. Either way, you get the same structured JSON response with a confidence score. You never touch the raw protocol.

The Domiquo layer on top

Even with RDAP, there's still a gap: the raw response tells you the domain's registration status, not whether you should offer it to your user as available.

A domain can be registered but expiring in 48 hours. A domain can be technically "available" in RDAP but held by a brand with 10 active TLDs. RDAP doesn't tell you that — it just tells you the registry status.

Domiquo adds a decision layer on top of RDAP. Every response includes:

{
  "domain": "clavixor.com",
  "status": "AVAILABLE",
  "recommendable_for_purchase": true,
  "confidence": 0.92,
  "reason_code": "RDAP_AND_WHOIS_OK",
  "sources": {
    "rdap": { "status": "available", "latency_ms": 182 },
    "whois": { "status": "available_signal" }
  },
  "audit": { "engine_version": "2026.04.03" }
}

The recommendable_for_purchase boolean is what your UI actually needs. The confidence score tells you how certain the decision is. The sources block gives you the audit trail. You read one field — done.

Bottom line

RDAP is not just an upgrade to WHOIS. It's a protocol redesign that finally makes domain data machine-readable. In 2026, there's no reason to build on WHOIS directly. If you're still maintaining a WHOIS parser, the migration path to RDAP is straightforward — and the reliability improvement is immediate.

If you don't want to deal with the protocol layer at all, Domiquo abstracts it entirely. You send a domain name and get a structured decision back in under 200ms.

Try Domiquo free — 1,000 checks/month

No credit card required. RDAP-native, decision-ready JSON. Start querying in 60 seconds.

Get free API key →