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:
| TLD | Read over | Registrar | Created | Expires | Nameservers |
|---|---|---|---|---|---|
| .com, .net | RDAP | yes | yes | yes | yes |
| .org | RDAP | yes | yes | yes | yes |
| .dev, .app | RDAP | yes | yes | yes | yes |
| .ai | RDAP | yes | yes | yes | yes |
| .co.uk | RDAP | yes | yes | yes | yes |
| .fr | RDAP | yes | yes | yes | yes |
| .pl | RDAP | yes | yes | yes | yes |
| .ca | RDAP | yes | yes | yes | yes |
| .nl | RDAP | yes | yes | not published | yes |
| .com.br | RDAP | not published | yes | yes | yes |
| .ch | RDAP | yes | not published | not published | yes |
| .net.au | RDAP | yes | not published | not published | yes |
| .de | RDAP | not published | not published | not published | yes |
| .io | WHOIS | yes | yes | yes | yes |
| .it | WHOIS | yes | yes | yes | yes |
| .se | WHOIS | yes | yes | yes | yes |
| .us | WHOIS | yes | yes | yes | not published for this domain |
| .mx | WHOIS | yes | yes | yes | yes |
| .co.jp | WHOIS | not published | yes | yes | yes |
| .be | WHOIS | yes | yes | not published | yes |
| .eu | WHOIS | yes | not published | not published | yes |
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
createdwhere it exists, and treatnullas "unknown", not as "new". For .de, .ch and .eu the registry simply does not publish it. - Renewal monitoring:
expiresis the field to watch. For TLDs that do not publish it, trackstatusand 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-Afterbefore 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.


