Domain WHOIS / RDAP Lookup

Look up who a domain is registered with, when it was created, when it expires, what its EPP statuses and nameservers are, and whether it is registered at all. Pass one domain or a list of up to 1,000 in a single run, and get a record back for each. The answer comes from the registry's own RDAP service, and when no registry can answer, the Actor says so instead of guessing.

What you get

One dataset item per domain you send. Here is one of them, for input example.com:

{
  "domain": "example.com",
  "registered": true,
  "reasonCode": "registered",
  "registrar": "RESERVED-Internet Assigned Numbers Authority",
  "creationDate": "1995-08-14T04:00:00Z",
  "expirationDate": "2027-08-13T04:00:00Z",
  "nameServers": ["ELLIOTT.NS.CLOUDFLARE.COM", "HERA.NS.CLOUDFLARE.COM"],
  "status": [
    "client delete prohibited",
    "client transfer prohibited",
    "client update prohibited"
  ]
}

Use it when

• You are checking whether a name has a registration record before you try to buy it.
• You are watching expiry dates across a portfolio of domains.
• You are scoring a lead or a signup domain, where a name registered last week means something different from one registered in 2003.
• You need the EPP status codes, for example to see that a domain is locked, on hold, or in a redemption period.
• An agent is enriching a list of domains and needs one typed record per name.

Input

Field	Type	Required	What it does
domains	array of strings	yes	The domains to look up, up to 1,000 per run. A URL or an email address is accepted and reduced to its host, so https://example.com/cart and jane@example.com both mean example.com. A subdomain is kept as written and comes back possible_subdomain. Internationalized names are converted to their punycode form.

Each distinct domain gets one dataset item and one charge. Example.com, https://example.com/ and example.com. are the same domain, so a list that repeats one is answered and charged once for it.

Output

Field	What it means
registered	true, false, or null when the lookup was inconclusive. Read reasonCode before you act on it.
reasonCode	registered, not_registered, no_rdap_service, possible_subdomain, or invalid_domain.
registrar	The sponsoring registrar's name, from the RDAP registrar entity.
creationDate, expirationDate	ISO 8601 timestamps from the registry's own event records.
nameServers	Nameservers as the registry holds them, which can differ from what DNS currently answers.
status	EPP status codes, for example client transfer prohibited.

Registrant contact details are not returned. Since GDPR, registries redact them, and this Actor does not claim to have data it cannot get.

Pricing

Pay per event, $3.00 per 1,000 lookups ($0.003 each), charged on the domain-whois-checked event.

A conclusive answer is charged whichever way it goes. "This domain is registered to X" and "the registry has no registration record for this domain" are both real answers. No record is not a guarantee the name can be bought: registries reserve, block and premium-price names that have no record. An inconclusive lookup is free:

reasonCode	Charged
registered	yes
not_registered	yes
no_rdap_service (the TLD runs no RDAP service, so nobody can be asked)	no
possible_subdomain (a registry holds no record of a subdomain)	no
invalid_domain (an IP, a bare TLD, localhost, a malformed name)	no
resolve_error (the registry lookup failed or was rate limited)	no

If you set a maximum total charge for a run, the Actor stops as soon as that limit is reached instead of working for free. Items after that point are left out of the dataset and not charged, and the run log says how many; submit them in a new run.

Why a not_registered answer is trustworthy

A wrong "no registration record" is the most expensive mistake a lookup like this can make, so the Actor runs two checks before it says so.

Before any lookup, the name is checked against the public suffix list, ICANN section only. foo.co.uk is a registrable domain and gets a real verdict. news.bbc.co.uk is not, and a registry's 404 for it looks exactly like a 404 for a name nobody has taken. That is reported as possible_subdomain and charged nothing.

When a registry returns a bare 404 with no explanation, the Actor consults IANA's RFC 9224 registry of which TLDs publish RDAP at all before reading that 404 as not_registered. If IANA has no RDAP entry for the TLD, the result is no_rdap_service, not a claim that no record exists. Around 300 TLDs fall in that group today.

How it works

The Actor queries RDAP over HTTPS, the structured JSON successor to port-43 WHOIS, and finds each TLD's server through the standard bootstrap. Requests retry on 429 and 5xx responses and on transport failures, honor a Retry-After header, and carry a per-attempt deadline so a hung registry cannot hold your run open.

One item per domain

Domains are looked up in the order you send them, each written as its own dataset item. There is no start fee, so a list of 1,000 domains pays one container start for the whole run instead of one per name:

const run = await client.actor('pontio/domain-whois').call({
  domains: ['example.com', 'example.org'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();

If you set a maximum charge for the run and the batch reaches it, the run stops there rather than carrying on with work it cannot charge for. A run that reaches its timeout stops the same way. Either way the items already written stay in the dataset, and each names what it answers, so you can re-run the remainder.

Need DNS records, MX, and SPF/DMARC/DKIM grading alongside the registration data? Use Domain Analyzer, which returns all of it as one report.