# Bulk WHOIS Lookup over RDAP: 23 TLDs Tested

> Bulk WHOIS lookup by API: 23 domains on 23 TLDs in one run, 2 seconds. Which registries answer over RDAP, which over WHOIS, and the fields each returns.

[Home](https://quanticdata.io/) / [Blog](https://quanticdata.io/blog/) / Bulk WHOIS Lookup over RDAP: 23 TLDs Tested

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

Use cases · Nov 20, 2026 · 6 min read · By [Aldo Morese](https://quanticdata.io/about/), founder of QuanticData

![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.](https://quanticdata.io/blog/bulk-whois-lookup-rdap/hero.webp?v=20261120h)

On this page

- [RDAP and WHOIS in one paragraph each](https://quanticdata.io/blog/bulk-whois-lookup-rdap/#rdap-and-whois-in-one-paragraph-each)
- [The request: 23 domains in one call](https://quanticdata.io/blog/bulk-whois-lookup-rdap/#the-request-23-domains-in-one-call)
- [The answer: 23 rows](https://quanticdata.io/blog/bulk-whois-lookup-rdap/#the-answer-23-rows)
- [What each TLD returned](https://quanticdata.io/blog/bulk-whois-lookup-rdap/#what-each-tld-returned)
- [What to do with missing fields](https://quanticdata.io/blog/bulk-whois-lookup-rdap/#what-to-do-with-missing-fields)
- [From 25 domains to thousands](https://quanticdata.io/blog/bulk-whois-lookup-rdap/#from-25-domains-to-thousands)

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.

**Run it on the free credit.** Every QuanticData account gets $2 of free API usage per month.

[Start free — $2/month included](https://quanticdata.io/signup/?utm_source=blog&utm_medium=website&utm_campaign=blog-lead&utm_content=bulk-whois-lookup-rdap) · [Explore Ready-made scrapers: 100+ scraper APIs](https://quanticdata.io/collectors/)

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

```bash
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:

```json
{"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

```bash
$ 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.

**Try it on your own targets.** Every QuanticData account gets $2 of free API usage per month.

[Start free — $2/month included](https://quanticdata.io/signup/?utm_source=blog&utm_medium=website&utm_campaign=blog-inline&utm_content=bulk-whois-lookup-rdap) · [Explore Ready-made scrapers: 100+ scraper APIs](https://quanticdata.io/collectors/)

## 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 `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:

```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](https://quanticdata.io/blog/429-too-many-requests-web-scraping/) and, for Python, in [retries in Python requests](https://quanticdata.io/blog/python-requests-retry/).
- **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](https://quanticdata.io/collectors/whois-api/) page. The same collector runs from an AI agent through the [MCP server](https://quanticdata.io/mcp-server/) with `run_collector`, and the rest of the catalog is under [collectors](https://quanticdata.io/collectors/). Run options such as `async` are in the [API reference](https://quanticdata.io/docs/).

### Sources & further reading

- [RFC 9082: Registration Data Access Protocol (RDAP) Query Format](https://www.rfc-editor.org/rfc/rfc9082)
- [RFC 9083: JSON Responses for RDAP](https://www.rfc-editor.org/rfc/rfc9083)
- [IANA: Bootstrap Service Registry for Domain Name Space](https://www.iana.org/assignments/rdap-dns/rdap-dns.xhtml)
- [RFC 3912: WHOIS Protocol Specification](https://www.rfc-editor.org/rfc/rfc3912)
- [ICANN: Registration Data Access Protocol](https://www.icann.org/rdap)

## FAQ

Quick answers on bulk WHOIS lookup.

[Something else? Ask us](mailto:hello@quanticdata.io)

### 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.

[Start free — $2/month included](https://quanticdata.io/signup/?utm_source=blog&utm_medium=website&utm_campaign=blog-end&utm_content=bulk-whois-lookup-rdap) · [Explore Ready-made scrapers: 100+ scraper APIs](https://quanticdata.io/collectors/)

## Collectors for this data

- [WHOIS API](https://quanticdata.io/collectors/whois-api/): Collector · Domain registration data over RDAP — registrar, dates, status, nameservers.

## Related reading

- [Sentiment Analysis of Customer Reviews](https://quanticdata.io/blog/sentiment-analysis-of-customer-reviews/): Use cases · Sentiment analysis of customer reviews sorts each review into positive or negative, then tells you which words drive each side. We collected 150 fresh App Store reviews on 20 November 2026, trained a TF-IDF and logistic regression model on the star ratings, and reached 87% accuracy in 5-fold cross-validation. Code and output below.
- [Data Wrangling in Python: A Real Example](https://quanticdata.io/blog/data-wrangling-python/): Use cases · Data wrangling turns raw rows into a table you can analyse: gather, structure, clean, normalise, filter, enrich, validate. We ran every step in Python with pandas on 62 listings collected on 20 November 2026 from eBay.de and Amazon.com, in two languages and two currencies, and ended with 45 comparable rows and a price table.
- [Panel Data Example, Built in Python](https://quanticdata.io/blog/panel-data/): Use cases · Panel data observes the same entities, such as countries, firms or products, over several periods. We built a real panel on 20 November 2026: GDP per capita and inflation for five euro-area countries from 2015 to 2023, from two World Bank collector runs, and show the long and wide forms, the balance check and the within transformation in pandas.

---

Source: https://quanticdata.io/blog/bulk-whois-lookup-rdap/ · Site index for AI: https://quanticdata.io/llms.txt
