🌐 Whois Domain Lookup – Bulk WHOIS & RDAP Domain Data Extraction

The Whois Domain Lookup actor performs fast, structured WHOIS and RDAP queries for any domain name, returning registrar details, nameservers, EPP status codes, and the full registration lifecycle — registration date, expiry date and last update — as clean JSON rows. Feed it one domain or a list of thousands, and it resolves each one through the RDAP protocol, the modern JSON-based successor to legacy WHOIS text records.

Domain intelligence underpins a surprising amount of everyday work: verifying that an inbound lead's company domain is genuinely established rather than registered last week, monitoring expiry dates across a corporate portfolio, mapping which DNS provider a competitor uses, or triaging a suspicious link during a phishing investigation. This Whois domain lookup tool gives you that data in a machine-readable shape, without parsing free-text WHOIS output or juggling per-registry quirks yourself.

---

📊 What Data Can You Extract with This Whois Domain Lookup Scraper?

Every row is a single domain's RDAP record, normalised into a flat, predictable structure. Here is how the real output fields group together.

Category	Fields	What You Get
🏷️ Domain identity	domain	The domain name as returned by the registry, typically upper-cased
✅ Query result	success, error	Whether the lookup resolved, and the failure reason when it did not
🔐 Registry status	status	Array of EPP status codes such as client transfer prohibited or client delete prohibited
🗄️ DNS infrastructure	nameservers	Array of authoritative nameserver hostnames, revealing the DNS or CDN provider in use
🏢 Registrar record	registrar	Object containing the registrar's name and IANA id
📅 Lifecycle dates	registrationDate, expirationDate, lastUpdated	ISO-8601 timestamps for creation, expiry and the most recent registry update

The status array is the field most people underuse. Those EPP codes tell you whether a domain is locked against transfer, deletion or update — which is exactly how you distinguish a well-managed, protected asset from one sitting unlocked and vulnerable to hijacking, or one already flagged for pending deletion.

---

🌟 Key Features of the Whois Domain Lookup Scraper

Feature	Description
📋 Bulk domain processing	Supply an array of domains via domains and the actor resolves every one of them in a single run
🔎 Single-domain mode	The domain field handles quick one-off lookups without building an array
🧬 RDAP-based queries	Uses the RDAP protocol via rdap.org, returning structured JSON rather than unparsed legacy WHOIS text
📆 Full lifecycle dates	Captures registrationDate, expirationDate and lastUpdated as ISO-8601 timestamps ready for date arithmetic
🔐 EPP status codes	Returns the complete status array so you can detect transfer locks, deletion holds and pending states
🗺️ Nameserver mapping	Extracts every authoritative nameserver, making DNS provider identification trivial across a portfolio
🏢 Registrar identification	Provides both the registrar's display name and its numeric IANA identifier for reliable matching
🛡️ Per-domain error isolation	A domain that fails to resolve produces a row with success: false and an error message; the rest of the batch continues
🌍 Automatic proxy rotation	Outbound requests are routed through Apify's proxy network automatically, reducing the risk of rate limiting on large batches

---

🚀 Why Choose This Whois Domain Lookup Scraper?

Structured output instead of raw WHOIS text. Classic WHOIS returns unstructured text that varies wildly between registries, and parsing it reliably is a maintenance treadmill. This Whois domain lookup uses RDAP, which is a JSON protocol by design, so the fields you get are consistent whether the domain is a .com, a .org or a country-code TLD.

Built for portfolios, not single queries. The domains array means one run can cover an entire corporate domain estate, a competitor watchlist, or a batch of newly observed domains from a security feed. Results land in one dataset you can sort, filter and export in a single step.

Failure never breaks the batch. Non-existent domains, unsupported TLDs and registry timeouts are captured as rows with success: false and a populated error field. You get a complete accounting of what resolved and what did not, rather than a run that dies on the first bad input.

Expiry monitoring that actually computes. Because expirationDate comes back as an ISO-8601 timestamp rather than a locale-specific string, you can diff it against today's date directly in a spreadsheet, a SQL query or a scheduled script — no date parsing gymnastics required.

---

📥 Input

The Whois domain lookup accepts a single domain, a list of domains, or both. Neither field is strictly required, and both ship with working defaults.

{
  "domain": "example.com",
  "domains": [
    "google.com",
    "github.com",
    "wikipedia.org"
  ]
}

🔧 Whois Domain Lookup Input Fields

Field	Type	Required	Default	Description
domain	string	❌ No	"example.com"	A single domain to check.
domains	array	❌ No	["google.com", "github.com", "wikipedia.org"]	A list of domains to check.

💡 Input Examples

Quick single-domain lookup

{
  "domain": "example.com"
}

Bulk portfolio expiry audit

{
  "domains": [
    "acme-corp.com",
    "acme-corp.net",
    "acme-corp.org",
    "acmecorp.io",
    "acme.co.uk"
  ]
}

Competitor and watchlist monitoring

{
  "domain": "competitor-flagship.com",
  "domains": [
    "competitor-eu.com",
    "competitor-apac.com",
    "competitor-blog.io"
  ]
}

---

📤 Output

Each dataset item is one domain's resolved WHOIS/RDAP record. Below is a real item from an actual run of the Whois domain lookup:

{
  "domain": "EXAMPLE.COM",
  "success": true,
  "status": [
    "client delete prohibited",
    "client transfer prohibited",
    "client update prohibited"
  ],
  "nameservers": [
    "ELLIOTT.NS.CLOUDFLARE.COM",
    "HERA.NS.CLOUDFLARE.COM"
  ],
  "registrar": {
    "name": "RESERVED-Internet Assigned Numbers Authority",
    "id": "376"
  },
  "registrationDate": "1995-08-14T04:00:00Z",
  "expirationDate": "2026-08-13T04:00:00Z",
  "lastUpdated": "2026-01-16T18:26:50Z"
}

A domain that cannot be resolved returns a failure row instead:

{
  "domain": "this-domain-does-not-exist-12345.com",
  "success": false,
  "error": "Domain not found in registry"
}

🧾 Whois Domain Lookup Output Fields

Field	Type	Description
domain	string | null	Domain name of the item.
success	boolean | null	Whether the lookup operation succeeded.
status	array | null	Registry status of the item — the EPP status codes attached to the domain.
nameservers	array | null	Nameservers values collected for the item.
registrar	object | null	Registrar of the item, containing the registrar's name and IANA id.
registrationDate	string | null	Date of the registration, as an ISO-8601 timestamp.
expirationDate	string | null	Date of the expiration, as an ISO-8601 timestamp.
lastUpdated	string | null	Last updated of the item — when the registry record was most recently modified.
error	string | null	Error message, if the item failed to process.

---

💻 How to Use the Whois Domain Lookup Scraper (Step by Step)

Step 1: Assemble Your Domain List

Decide what you actually want to know before you build the list. An expiry audit calls for every domain your organisation owns, including defensive registrations and country-code variants that are easy to forget. A competitive study calls for a competitor's primary domain plus the regional and product subdomain-hosting domains they operate. A security triage calls for the domains extracted from suspicious links. Strip protocols and paths — submit example.com, not https://example.com/pricing.

Step 2: Choose Between domain and domains

The domain field takes one string and is convenient for ad-hoc checks straight from the Console. The domains field takes an array and is the right choice for anything at scale. You can populate both in the same run; the actor handles a single domain and a list together without conflict. For repeatable automation, prefer domains even when the list has one entry, because it keeps your input shape stable.

Step 3: Run the Whois Domain Lookup

Launch from the Apify Console with the Start button, or trigger the run over the API. Lookups are resolved through RDAP endpoints via rdap.org, which routes each query to the correct registry or registrar RDAP service automatically. Requests go out over Apify's proxy network, which keeps large batches from tripping per-IP rate limits at the registries.

Step 4: Check the success Flag Before Analysing

The first thing to do with the resulting dataset is split it on success. Rows where success is true carry the full record; rows where it is false carry an error string explaining why. Typical failures are domains that were never registered, TLDs whose registries do not publish RDAP, and transient timeouts worth retrying. Doing this split up front stops null dates from silently skewing any aggregate you compute.

Step 5: Interpret the Status Codes and Nameservers

The status array contains EPP status codes, which are the registry's own machine-readable statements about what may be done to the domain. Codes containing "prohibited" indicate protective locks; codes referencing pending states indicate a transfer, deletion or restoration in flight. The nameservers array, meanwhile, is a direct fingerprint of DNS infrastructure — Cloudflare, Route 53, a registrar's default DNS or a self-hosted setup are all immediately identifiable from the hostnames.

Step 6: Compute Days to Expiry and Set Thresholds

With expirationDate in ISO-8601 form, calculating time remaining is a subtraction. Export the dataset to a spreadsheet and add a column computing the difference from today, or do it in code during post-processing. Sorting on that column surfaces the domains needing renewal attention, and bucketing at thirty, sixty and ninety days gives you a practical alerting ladder.

Step 7: Schedule Recurring Portfolio Checks

Domain records change: registrars are switched, nameservers migrate, and locks are applied or lifted. Attach an Apify schedule to run the Whois domain lookup weekly or monthly against your full list, then compare each run's lastUpdated, registrar and nameservers values against the previous snapshot. Any change is worth a look, and unexpected changes to nameservers or registrar on a domain you own deserve immediate investigation.

---

🔌 API Access & Integrations

Run the Whois domain lookup and get dataset items back in one synchronous call:

curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~whois-domain-lookup/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "domains": ["google.com", "github.com", "wikipedia.org"]
  }'

The equivalent in Python with the official client, including a days-to-expiry calculation:

from datetime import datetime, timezone
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run_input = {
    "domains": ["acme-corp.com", "acme-corp.net", "acme-corp.org"],
}

run = client.actor("scrapers-hub/whois-domain-lookup").call(run_input=run_input)

now = datetime.now(timezone.utc)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if not item.get("success"):
        print("FAILED", item.get("domain"), item.get("error"))
        continue

    expires = item.get("expirationDate")
    days_left = None
    if expires:
        days_left = (datetime.fromisoformat(expires.replace("Z", "+00:00")) - now).days

    registrar = (item.get("registrar") or {}).get("name")
    print(item["domain"], registrar, days_left, item.get("nameservers"))

The actor also plugs into Zapier, Make, Google Sheets, Slack and any custom endpoint through Apify webhooks — so an expiry alert can post straight into a Slack channel, or a fresh lookup can append rows to a shared spreadsheet automatically.

---

💡 Best Use Cases for Whois Domain Lookup Data

🗓️ Domain Portfolio Expiry Monitoring

An expired domain can take down email, break single sign-on and hand a valuable asset to a squatter. Running the Whois domain lookup across your full estate and sorting on expirationDate produces a renewal calendar in minutes. Pair it with status to confirm each domain also carries the appropriate client-side locks.

🕵️ Phishing and Fraud Investigation

Newly registered domains are heavily overrepresented in phishing campaigns. Checking a suspicious domain's registrationDate immediately tells you whether it appeared days ago or has a decade of history, while registrar and nameservers help cluster related malicious infrastructure that shares a provider.

🏷️ Brand Protection and Typosquat Detection

Generate the plausible misspellings and TLD variants of your brand, run them all through the lookup, and see which are registered. A success: true result on a domain you do not own is a lead: registrationDate tells you how recently it was taken, and registrar tells you where to file a complaint.

💼 Sales Prospecting and Lead Verification

Company age is a useful qualification signal. Feeding inbound lead domains through this Whois domain lookup and reading registrationDate separates established businesses from entities registered last month. The nameservers field adds a technographic layer, revealing which hosting and CDN stack the prospect already runs.

🔄 DNS Migration and Infrastructure Auditing

During a DNS provider migration, the nameservers array is the ground truth for what has actually propagated at the registry. Running the lookup across every domain before, during and after a cutover gives you a definitive checklist of which domains still point at the old provider.

🏛️ M&A and Domain Acquisition Research

Before approaching an owner about a domain, the record tells you what you are dealing with. registrationDate indicates how long it has been held, expirationDate shows how far ahead the owner has renewed, and status reveals whether the domain is locked or drifting toward deletion — all of which shape negotiating position and timing.

📉 Competitor and Market Intelligence

Tracking a competitor's domain footprint over time reveals strategy. A cluster of new country-code domains registered in the same week signals international expansion; a lastUpdated change accompanied by different nameservers signals an infrastructure or agency change. Scheduled runs turn these one-off observations into a trend line.

---

⚙️ Tips for Better Whois Domain Lookup Results

• Submit bare domain names. Strip https://, www. where it is not part of the registered name, ports, paths and query strings. The registry knows example.com, not the full URL you copied from your browser.
• Query the registrable domain, not a subdomain. WHOIS and RDAP records exist at the registrable level. Looking up blog.example.com will not return a record; look up example.com instead.
• Expect coverage gaps on some ccTLDs. RDAP adoption is close to universal for gTLDs but uneven across country-code registries. Some ccTLDs publish limited data or none at all, which surfaces as a success: false row.
• Retry timeouts before treating them as failures. Registry RDAP endpoints occasionally throttle or time out under load. Re-running only the failed domains from the previous dataset usually resolves most of them.
• Snapshot each run for change detection. The real value of this data is longitudinal. Store every run's dataset and diff registrar, nameservers and status between snapshots to catch unauthorised or unexpected changes.
• Do not expect registrant contact details. Since GDPR, registries and registrars redact personal registrant information from public records. This actor returns what is published — registrar, nameservers, status and dates — not the registrant's name or address.

---

🛠️ Troubleshooting

Why does a domain I know exists return success: false? The most common cause is a TLD whose registry does not expose an RDAP service, or exposes one with restricted data. Country-code registries vary considerably in what they publish. A second cause is a transient timeout at the registry endpoint, which usually clears on a retry of just that domain.

Why is the registrar object empty or missing a name? Not every registry populates the registrar entity in its RDAP response, and some return only an IANA identifier without a display name. Where the registry omits the data, the actor cannot invent it. The IANA id alone is still usable for lookups against the public registrar list.

Why can I not see the registrant's name, email or address? Public WHOIS and RDAP records have been redacted for privacy since GDPR came into force. Registrant contact details are no longer published for the overwhelming majority of domains, so no lookup tool — this one included — can return them from public sources.

Why are nameservers empty on a domain that clearly resolves? A domain can resolve through cached or delegated DNS while the registry record itself lists no nameservers, which typically happens with domains in a parked, pending-delete or newly registered state. Cross-check with a live DNS query if you need the currently answering nameservers rather than the registry-recorded ones.

Why did a large batch produce several failed rows? Registry RDAP services rate-limit aggressive querying. Although requests are routed through Apify's proxy network to spread load, a very large batch can still hit per-registry limits. Splitting the list into smaller runs, or re-running only the failures, generally recovers the missing records.

---

❓ Frequently Asked Questions About Whois Domain Lookup

What is a Whois domain lookup and what does it tell me? A Whois domain lookup queries the public registration record for a domain name. It returns who the domain is registered through, which nameservers are authoritative for it, what registry status codes apply, and the key dates in its lifecycle — when it was created, when it expires, and when the record was last changed.

What is the difference between WHOIS and RDAP? WHOIS is the older protocol and returns free-form text that differs between registries, making it awkward to parse. RDAP is its modern replacement and returns structured JSON with standardised fields. This actor uses RDAP, which is why the output is consistent across TLDs.

How many domains can I look up in one run? Pass as many as you need in the domains array. There is no fixed cap in the input schema. For very large lists, splitting into several runs reduces the chance of hitting registry rate limits.

Can I look up a subdomain such as blog.example.com? No. Registration records exist only at the registrable domain level. Query example.com and you will get the record that governs every subdomain beneath it.

Does this Whois domain lookup work for country-code TLDs? It works wherever the registry publishes an RDAP service. Coverage is essentially complete for generic TLDs such as .com, .net and .org, and good but uneven across ccTLDs. Where a registry does not support RDAP, the domain returns success: false.

Can I find out who owns a domain? Not from public data in most cases. Registrant names, emails and postal addresses are redacted under GDPR and similar privacy regimes. What you do get is the registrar the domain sits with, which is the appropriate contact point for abuse reports and legal notices.

How do I check when a domain expires? Read the expirationDate field, which is an ISO-8601 timestamp. Subtract today's date from it to get days remaining, then sort or alert on that value. The Python example above shows the calculation.

What do the EPP status codes in the status array mean? They are the registry's machine-readable statements about the domain's state. Codes describing prohibited actions indicate protective locks against transfer, deletion or update. Codes describing pending actions indicate an operation currently in progress at the registry.

Can I tell if a domain is available to register? Indirectly. A domain that returns success: false with a not-found style error is generally unregistered, while one returning a full record is taken. For a definitive availability answer, confirm with a registrar's own availability API, since some registries treat reserved and premium names specially.

Does the actor need a proxy configuration from me? No. Proxy rotation is handled automatically through Apify's proxy network, and there is no proxy field in the input schema for you to set.

Why do domain names come back in uppercase? That is how many registries return them in their RDAP responses. Domain names are case-insensitive, so EXAMPLE.COM and example.com refer to the same domain. Normalise the case in post-processing if your downstream system expects lowercase.

Can I use this Whois domain lookup to monitor changes over time? Yes, and it is one of the strongest uses. Schedule recurring runs and diff the registrar, nameservers, status and lastUpdated fields between consecutive datasets to detect transfers, DNS migrations and lock changes.

What happens if I supply both domain and domains? Both are processed. The single domain value and every entry in the domains array are looked up in the same run, and each produces its own dataset row.

In what formats can I export the Whois data? The Apify dataset supports JSON, JSONL, CSV, Excel, XML and RSS export from the Console, plus programmatic access through the dataset API and the apify_client library.

Is this Whois domain lookup free to run? The actor is listed with a free pricing model on the Apify platform. Apify's own platform usage terms and compute unit accounting still apply to any run, as they do for every actor.

---

🆘 Support & Feedback

Hit an unexpected error, found a TLD that will not resolve, or spotted a field that looks wrong? Open a ticket on the Issues tab of this actor with the domain and the run ID. That is the fastest route to a fix and leaves a public record other users can learn from.

Need something more specific? Custom domain intelligence work — bulk availability checks, historical record archiving, automated expiry alerting wired into your own systems, or a private variant tuned to your portfolio — is available. Email scraperhubapi@gmail.com with a description of what you are trying to achieve.

If this Whois domain lookup saves you time, a review on the actor page is genuinely appreciated. Ratings and written feedback shape what gets improved next.

---

⚖️ Disclaimer

This Whois domain lookup actor retrieves only publicly published domain registration data made available by registries and registrars through the RDAP protocol. It does not bypass access controls, authenticate to restricted WHOIS ports, or attempt to obtain redacted information by any means.

You are responsible for ensuring your use of this data complies with applicable law, with registry and registrar acceptable use policies, and with the terms of service of the platforms involved. Registration data is published for technical and administrative purposes; using it to send unsolicited commercial email, for mass marketing, or to enable domain hijacking is prohibited by most registry policies and may be unlawful.

Where a domain record contains personal data — which since GDPR is uncommon but still occurs, particularly for organisational contacts and in some ccTLD registries — you act as the data controller for any further processing you perform. Ensure you have a lawful basis under the GDPR, the UK GDPR, the CCPA or any other applicable privacy framework, apply data minimisation, retain records no longer than necessary, and honour data subject access and erasure requests.

If you believe data returned through this actor should be removed, or you have a privacy concern relating to a specific record, contact scraperhubapi@gmail.com and the request will be reviewed promptly.