Documentation Python quickstart Blog Free tools Enterprise solutions hello@quanticdata.ioLog in

Bulk WHOIS lookup over RDAP: one API call, 23 TLDs tested

A bulk WHOIS lookup through one API call: 23 domains on 23 TLDs go in, the collector asks each registry over RDAP or WHOIS, and 23 rows come back with registrar, dates, nameservers and DNSSEC; in our run 15 rows came over RDAP and 8 over WHOIS, in about 2 seconds.
A bulk WHOIS lookup through one API call: 23 domains on 23 TLDs go in, the collector asks each registry over RDAP or WHOIS, and 23 rows come back with registrar, dates, nameservers and DNSSEC; in our run 15 rows came over RDAP and 8 over WHOIS, in about 2 seconds.

A bulk WHOIS lookup sends a list of domains and gets one structured row per domain: registrar, creation and expiry dates, status codes, nameservers and DNSSEC. With the QuanticData WHOIS collector a run takes up to 25 domains; each is looked up at its own registry, over RDAP where the registry offers it and over WHOIS where it does not.

On 20 November 2026 we sent 23 domains on 23 different TLDs in one call. All 23 rows came back, 15 read over RDAP and 8 from a registry WHOIS server, and the run took about 2 seconds. The request, the answer and the per-TLD table are below.

RDAP and WHOIS in one paragraph each

WHOIS is the old protocol on port 43. You send a domain name and get back free text, and every registry formats that text its own way. It works, but parsing it for a thousand domains means maintaining a parser per registry.

RDAP (Registration Data Access Protocol) is its successor: an HTTPS request that returns JSON with the same field names everywhere. All generic TLDs such as .com, .org, .dev and .app have it, and a growing number of country TLDs. IANA publishes the list of RDAP servers by TLD, which is how a client knows where to ask.

A bulk lookup tool has to speak both, because a real list of domains always mixes TLDs. The row you get should look the same whichever protocol answered.

The request: 23 domains in one call

curl -s -X POST https://api.quanticdata.io/v1/scraper/collectors/whois_domain/run \
  -H "Authorization: Bearer $QD_API_KEY" -H "Content-Type: application/json" \
  -d '{"domains":["github.com","wikipedia.org","cloudflare.net","github.io","web.dev","google.app",
       "perplexity.ai","bund.de","lemonde.fr","bbc.co.uk","rijksoverheid.nl","repubblica.it","europa.eu",
       "belgium.be","admin.ch","onet.pl","svt.se","yahoo.co.jp","abc.net.au","usa.us","canada.ca",
       "unam.mx","globo.com.br"],"max_results":23}'

The call answered 202 in 304 ms with a run id and a URL to poll:

{"type":"response","message":"Collector run queued",
 "payload":{"run_id":"RUN_ID","status":"queued","statusUrl":"/api/v1/scraper/collectors/runs/RUN_ID"}}

Two things to set right. domains takes bare domains or full URLs. max_results defaults to 10, so set it to the length of your list, up to 25, or the run stops at ten.

The answer: 23 rows

$ curl -s https://api.quanticdata.io/v1/scraper/collectors/runs/RUN_ID -H "Authorization: Bearer $QD_API_KEY"
{"type":"response","message":"Collector run","payload":{"slug":"whois_domain","version":"1.3.1",
 "status":"done","count":23,"partial":false,
 "started_at":"2026-11-20T18:38:05.544Z","finished_at":"2026-11-20T18:38:07.582Z",
 "notes":["8 domain(s) answered by the registry's WHOIS (port 43) — TLD without RDAP"],
 "results":[
  {"rank":1,"domain":"github.com","registrar":"MarkMonitor Inc.","registrar_iana_id":"292",
   "created":"2007-10-09T18:20:50Z","expires":"2028-10-09T18:20:50Z","updated":"2026-09-07T09:22:52Z",
   "status":["client delete prohibited","client transfer prohibited","client update prohibited"],
   "nameservers":["dns1.p08.nsone.net","dns2.p08.nsone.net", ...],"dnssec":false,
   "url":"https://rdap.verisign.com/com/v1/domain/github.com"},
  ... 22 more rows]}}

The url field says where each record was read: an https:// address is the registry's RDAP record, and whois://server/domain means the registry's WHOIS server answered and the text was normalised into the same row.

What each TLD returned

Registries decide what they publish. Some give registrar and both dates, some only the delegation. A field the registry does not publish comes back as null; nothing is guessed. This is what our run returned, TLD by TLD:

TLDRead overRegistrarCreatedExpiresNameservers
.com, .netRDAPyesyesyesyes
.orgRDAPyesyesyesyes
.dev, .appRDAPyesyesyesyes
.aiRDAPyesyesyesyes
.co.ukRDAPyesyesyesyes
.frRDAPyesyesyesyes
.plRDAPyesyesyesyes
.caRDAPyesyesyesyes
.nlRDAPyesyesnot publishedyes
.com.brRDAPnot publishedyesyesyes
.chRDAPyesnot publishednot publishedyes
.net.auRDAPyesnot publishednot publishedyes
.deRDAPnot publishednot publishednot publishedyes
.ioWHOISyesyesyesyes
.itWHOISyesyesyesyes
.seWHOISyesyesyesyes
.usWHOISyesyesyesnot published for this domain
.mxWHOISyesyesyesyes
.co.jpWHOISnot publishedyesyesyes
.beWHOISyesyesnot publishedyes
.euWHOISyesnot publishednot publishedyes

Every one of the 23 rows carried the DNSSEC flag except .de and .fr, and every row carried the address of the record it was read from. One domain per TLD is a sample, not a census: a registry can publish a field for one domain and withhold it for another.

What to do with missing fields

  • Domain age: use created where it exists, and treat null as "unknown", not as "new". For .de, .ch and .eu the registry simply does not publish it.
  • Renewal monitoring: expires is the field to watch. For TLDs that do not publish it, track status and the nameservers for changes instead.
  • Infrastructure mapping: nameservers came back for 22 of the 23 domains, including every TLD where dates are withheld, so a hosting or DNS-provider breakdown works across the whole list.

Domains that do not resolve at the registry, and answers that carry no registration data, are listed under failed with the reason and are not billed. A TLD that does not exist is rejected before any lookup.

From 25 domains to thousands

One run holds up to 25 domains, so a long list is a loop over chunks of 25. In Python:

import os, time, requests

API = "https://api.quanticdata.io/v1/scraper/collectors"
H = {"Authorization": "Bearer " + os.environ["QD_API_KEY"]}

def lookup(domains):
    run = requests.post(API + "/whois_domain/run", headers=H, timeout=60,
                        json={"domains": domains, "max_results": len(domains)}).json()["payload"]
    while run.get("status") in ("queued", "running"):
        time.sleep(2)
        run = requests.get(API + "/runs/" + run["run_id"], headers=H, timeout=60).json()["payload"]
    return run["results"], run.get("failed", [])

domains = [line.strip() for line in open("domains.txt") if line.strip()]
for i in range(0, len(domains), 25):
    rows, failed = lookup(domains[i:i + 25])
    for r in rows:
        print(r["domain"], r["registrar"], r["created"], r["expires"], sep="\t")

Three habits keep a large job tidy:

  • Pace the loop to your tier. The pay-as-you-go tier allows 20 requests a minute per key; each chunk here is one run call plus a poll or two. If a call answers 429, wait the seconds in Retry-After before the next one. The pattern is in 429 Too Many Requests and, for Python, in retries in Python requests.
  • Clean the list first. Deduplicate, lower-case, and drop sample values left over from a template. An identical request sent again inside the dedup window returns the existing run instead of a new one.
  • Store the url. It is the proof of where each record came from, useful when someone asks why a field is empty.

Fields, limits and the price per domain are on the WHOIS API page. The same collector runs from an AI agent through the MCP server with run_collector, and the rest of the catalog is under collectors. Run options such as async are in the API reference.

Sources & further reading

FAQ

Quick answers on bulk WHOIS lookup.

Something else? Ask us

What is a bulk WHOIS lookup?

A lookup of many domains at once that returns one structured record per domain: registrar, creation and expiry dates, status, nameservers. In our test one API call looked up 23 domains on 23 TLDs and returned 23 rows.

What is the difference between RDAP and WHOIS?

WHOIS returns free text over port 43 in a format each registry chooses. RDAP returns JSON over HTTPS with the same field names everywhere. In our run 15 of the 23 registries answered over RDAP and 8 over WHOIS, and the rows had the same shape.

How many domains can I look up in one call?

Up to 25 per run of the WHOIS collector. Set max_results to the size of your list, since the default is 10. Longer lists are a loop over chunks of 25.

Does it work for .ch and .jp domains?

Yes in our run of 20 November 2026: admin.ch came back over RDAP with registrar and nameservers, and yahoo.co.jp over the registry WHOIS with creation and expiry dates and nameservers.

Why are some fields empty?

Because the registry does not publish them. In our run the .de registry returned the nameservers only, and .ch, .eu and .net.au returned no dates. Empty fields come back as null.

How fast is a run?

The 23-domain run started at 18:38:05.544 and finished at 18:38:07.582 UTC on 20 November 2026, about 2 seconds. The call itself returned a run id in 304 ms.

Look up your own list

One call, up to 25 domains, each read at its own registry and returned as the same row.

Collectors for this data

Related reading