WHOIS Domain Lookup

Look up WHOIS and RDAP registration data for any domain in bulk. Get registrar details, creation and expiry dates, nameservers, domain age, registrant info, DNSSEC status, and EPP status codes -- all without needing any API key. This actor queries the official RDAP infrastructure maintained by ICANN registries as its primary source, then automatically falls back to a secondary WHOIS API for maximum TLD coverage. Pass in a list of domains and receive structured, machine-readable JSON for every single one.

---

Why use WHOIS Domain Lookup?

Traditional WHOIS tools force you to query domains one at a time through clunky web forms, deal with inconsistent plain-text output that is painful to parse, and hit rate limits that block bulk research. Many paid WHOIS APIs charge per lookup and still require you to handle normalization yourself.

WHOIS Domain Lookup eliminates all of that. It processes up to 1,000 domains per run, normalizes every response into a clean JSON schema with computed fields like domainAge and expiresIn, and costs a fraction of a cent on the Apify platform. The dual-source architecture (RDAP primary, who-dat backup) means you get results for virtually every TLD without configuring a single API key. Whether you are a domain investor screening hundreds of expiring domains, a security analyst triaging suspicious URLs, or a brand protection team auditing typosquatting variants, this actor gives you production-ready data in seconds.

---

Key features

• Bulk domain lookup -- process up to 1,000 domains in a single run, each returned as its own dataset row.
• Dual-source reliability -- queries the official RDAP protocol first and automatically falls back to the who-dat WHOIS API when RDAP is unavailable for a TLD.
• No API key required -- uses free, public RDAP and WHOIS endpoints so there is nothing to configure beyond your domain list.
• Domain availability detection -- returns available: true when RDAP reports a 404, giving you a quick way to check if a domain is unregistered.
• Computed age and expiry fields -- domainAge (days since registration) and expiresIn (days until expiry) are calculated automatically so you can sort and filter without date math.
• Rich registration metadata -- registrar name, IANA registrar ID, registrant organization, DNSSEC delegation status, nameservers, and full EPP status codes.
• vCard parsing -- extracts registrar and registrant names from RDAP vCard structures, checking both fn (formatted name) and org fields with nested entity support.
• Smart input cleaning -- handles full URLs (https://example.com/page), trailing slashes, mixed case, and whitespace so you can paste messy lists directly.
• Polite rate limiting -- built-in 500 ms delay between requests prevents throttling and ensures reliable results even for large batches.
• 15-second timeout per request -- prevents a single slow response from stalling the entire run.

---

How to use WHOIS Domain Lookup

Using Apify Console

1. Go to the WHOIS Domain Lookup actor page on Apify and click Try for free.
2. In the Domains field, enter your domains one per line. You can paste full URLs like https://example.com/about -- the actor strips everything down to the bare domain automatically.
3. Optionally adjust Max Results to limit how many domains are processed (default is 100, maximum is 1,000).
4. Click Start and wait for the run to complete. Each domain is processed sequentially with a half-second delay between lookups.
5. When the run finishes, switch to the Dataset tab to preview your results. Download in JSON, CSV, Excel, or any other supported format.

Using the API

You can start a run programmatically using the Apify API, official Python or JavaScript client libraries, or a simple cURL request. See the API & Integration section below for ready-to-use code examples.

---

Input parameters

Field	Type	Required	Default	Description
domains	string[]	Yes	--	List of domains to look up. Full URLs are auto-cleaned to bare domains.
maxResults	integer	No	100	Maximum number of domains to process (min: 1, max: 1,000).

Example input (JSON)

{
    "domains": [
        "google.com",
        "stripe.com",
        "https://github.com/about",
        "EXAMPLE.COM",
        "   shopify.com   "
    ],
    "maxResults": 100
}

Tips for input

• Paste raw URLs freely. You do not need to strip https:// or trailing paths. The actor normalizes every entry to a clean, lowercase domain.
• Mixed formatting is fine. Uppercase letters, leading/trailing whitespace, and protocol prefixes are all handled automatically.
• One domain per line in the Apify Console string list editor, or provide a JSON array via the API.
• Set maxResults lower for testing. Start with 5--10 domains to verify output before running large batches.

---

Output

Each domain produces one object in the dataset. Below is a realistic example for stripe.com:

{
    "domain": "stripe.com",
    "available": false,
    "registrar": "SafeNames Ltd.",
    "registrarIanaId": "447",
    "registrant": "Stripe, Inc.",
    "createdDate": "2010-01-12T00:00:00Z",
    "expiryDate": "2030-01-12T00:00:00Z",
    "updatedDate": "2024-06-18T09:14:22Z",
    "status": [
        "client delete prohibited",
        "client transfer prohibited",
        "client update prohibited"
    ],
    "nameservers": [
        "ns-cloud-a1.googledomains.com",
        "ns-cloud-a2.googledomains.com",
        "ns-cloud-a3.googledomains.com",
        "ns-cloud-a4.googledomains.com"
    ],
    "dnssec": true,
    "domainAge": 5508,
    "expiresIn": 1432,
    "rawRdapUrl": "https://rdap.org/domain/stripe.com",
    "error": null
}

When a domain is not found (likely unregistered):

{
    "domain": "this-domain-is-available-12345.com",
    "available": true,
    "registrar": null,
    "registrarIanaId": null,
    "registrant": null,
    "createdDate": null,
    "expiryDate": null,
    "updatedDate": null,
    "status": [],
    "nameservers": [],
    "dnssec": null,
    "domainAge": null,
    "expiresIn": null,
    "rawRdapUrl": "https://rdap.org/domain/this-domain-is-available-12345.com",
    "error": null
}

Output fields

Field	Type	Description
domain	string	Cleaned, lowercase domain name.
available	boolean	true if RDAP returned 404 (domain appears unregistered).
registrar	string|null	Registrar name extracted from the RDAP vCard.
registrarIanaId	string|null	IANA-assigned registrar ID number.
registrant	string|null	Registrant organization or name. Often null due to GDPR redaction.
createdDate	string|null	Domain registration date in ISO 8601 format.
expiryDate	string|null	Domain expiry date in ISO 8601 format.
updatedDate	string|null	Date of last WHOIS record change in ISO 8601 format.
status	string[]	Array of EPP status codes (e.g., clientDeleteProhibited).
nameservers	string[]	List of authoritative nameservers, lowercased.
dnssec	boolean|null	Whether DNSSEC delegation signing is enabled.
domainAge	number|null	Computed number of days since the domain was first registered.
expiresIn	number|null	Computed number of days until the domain expires.
rawRdapUrl	string	The RDAP lookup URL used for the query.
error	string|null	Error message if both RDAP and the backup API failed; null on success.

---

Use cases

• Domain investing and flipping -- screen hundreds of candidate domains to find undervalued or expiring assets by sorting on expiresIn and domainAge.
• Brand protection -- monitor typosquatting and look-alike domains by pulling registrar and registrant details, then flag newly registered copycats for legal review.
• Cybersecurity and threat intelligence -- investigate suspicious domains by examining creation dates, nameservers, DNSSEC status, and EPP status codes to assess phishing or malware risk.
• Sales and lead generation research -- enrich prospect lists with domain age and registrar data to distinguish established businesses from newly launched startups.
• SEO link auditing -- audit backlink domains in bulk to verify age, ownership, and registration status before building or disavowing links.
• Compliance and due diligence -- verify domain ownership details for mergers, acquisitions, or vendor onboarding where digital asset provenance matters.
• Expiry monitoring -- schedule regular runs to track expiresIn across a portfolio of domains and get early warnings before renewals lapse.
• Academic and market research -- study domain registration trends across industries, TLDs, or time periods using structured, exportable data.
• IT asset management -- maintain an up-to-date inventory of your organization's domain portfolio with registrar, nameserver, and expiry data for each asset.
• Competitive intelligence -- discover which registrars and DNS providers competitors use, and track when they register new domains for upcoming product launches.

---

API & Integration

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("M7WwJi9RsIxqCtxsh").call(run_input={
    "domains": ["google.com", "stripe.com", "github.com"],
    "maxResults": 100,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['domain']} -- registrar: {item['registrar']}, age: {item['domainAge']} days")

JavaScript

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("M7WwJi9RsIxqCtxsh").call({
    domains: ["google.com", "stripe.com", "github.com"],
    maxResults: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.log(`${item.domain} -- registrar: ${item.registrar}, age: ${item.domainAge} days`);
});

cURL

# Start a run
curl -X POST "https://api.apify.com/v2/acts/M7WwJi9RsIxqCtxsh/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "domains": ["google.com", "stripe.com", "github.com"],
    "maxResults": 100
  }'

# Fetch results (replace DATASET_ID with the value from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_API_TOKEN"

Integrations

Connect WHOIS Domain Lookup with hundreds of other tools:

• Zapier -- trigger a WHOIS lookup from a Google Sheets row and write results back automatically.
• Make (Integromat) -- build visual automation workflows that feed domains into this actor and route results to Slack, email, CRMs, or databases.
• Google Sheets -- export dataset results directly to a Google Sheet using the Apify Google Sheets integration.
• Webhooks -- configure a webhook URL in your run settings to get notified with results the moment a run finishes.
• GitHub Actions / CI pipelines -- call the actor from CI/CD workflows for automated domain monitoring as part of your DevOps or security pipeline.
• Slack / Microsoft Teams -- pipe run completion notifications and summary data into team channels for real-time awareness.

---

How it works

WHOIS Domain Lookup uses a dual-source strategy to maximize reliability across all TLDs. Every domain goes through an input cleaning stage first, then hits the official RDAP protocol. If RDAP fails or does not cover the TLD, the actor automatically retries against a backup WHOIS API. Responses from either source are normalized into the same output schema, with computed fields added on top.

1. Input cleaning -- each domain is trimmed, lowercased, and stripped of https://, http://, and any trailing URL paths.
2. RDAP lookup -- the actor queries rdap.org/domain/{domain} with an application/rdap+json Accept header. A 404 response flags the domain as available: true. A successful response is parsed using vCard extraction for registrar/registrant names, event-based date extraction (registration, expiration, last changed), and entity role-based lookup with nested entity support.
3. Fallback to who-dat -- if RDAP returns an error or times out, the actor queries who-dat.as93.net/{domain} as a backup, parsing its different response format into the same output schema.
4. Computed fields -- domainAge (days since registration) and expiresIn (days until expiry) are calculated from the extracted dates.
5. Dataset push -- each result is pushed to the Apify dataset immediately, so partial results are available even if later lookups fail.

Input Domains
     |
     v
URL Cleaning (strip protocol, paths, lowercase, trim)
     |
     v
RDAP Lookup (rdap.org) ----[fail]----> who-dat API (who-dat.as93.net)
     |                                        |
     | [success]                               | [success]
     v                                        v
vCard Parsing (fn/org fields, entity roles)   Response Normalization
     |                                        |
     +-------------------+--------------------+
                         |
                         v
              Computed Fields (domainAge, expiresIn)
                         |
                         v
                      Dataset

---

Performance & cost

The actor runs on the Apify platform and consumes compute units (CUs) based on memory and run time. It uses minimal memory (256 MB) because it only makes lightweight HTTP API calls -- no browser or crawler is involved.

Domains	Approx. Run Time	Estimated Cost (USD)
10	~10 seconds	< $0.01
50	~30 seconds	< $0.01
100	~60 seconds	~$0.01
500	~5 minutes	~$0.04
1,000	~10 minutes	~$0.08

Run time is dominated by the 500 ms polite delay between requests plus actual API response latency. Domains that fall back to the who-dat API may take slightly longer. There are no proxy costs or external API fees -- every data source is free and public. Free-tier Apify accounts receive $5 of monthly platform credits, which is enough for thousands of WHOIS lookups.

---

Limitations

• RDAP coverage varies by TLD. While most major gTLDs and many ccTLDs have RDAP servers registered with IANA, some older or less common TLDs may only be reachable through the who-dat fallback or may not be covered at all.
• Registrant data is often redacted. Due to GDPR and ICANN privacy regulations, many registrars and registries mask registrant names, emails, and addresses. The registrant field will be null in these cases.
• Domain availability is indicative, not definitive. A 404 from RDAP strongly suggests a domain is unregistered, but edge cases exist (e.g., reserved names, registry maintenance). Always confirm availability with a registrar before purchasing.
• Rate limits from upstream servers. Although the actor includes a polite 500 ms delay, some RDAP servers may impose their own rate limits on very large batches. If you encounter errors on specific TLDs, try re-running just those domains.
• No historical WHOIS data. The actor returns the current registration record only. It does not provide historical ownership changes or past WHOIS snapshots.
• 15-second timeout per request. If an RDAP or who-dat server is exceptionally slow, the request will time out and the actor will attempt the fallback or record an error.
• Maximum 1,000 domains per run. For larger batches, split your domain list across multiple runs.

---

Responsible use

This actor queries publicly available RDAP and WHOIS data in accordance with ICANN policies and the terms of the RDAP protocol. Please use it responsibly:

• Respect rate limits. The built-in 500 ms delay is designed to be polite to public infrastructure. Do not modify or bypass this delay if running a self-hosted version.
• Do not use for spam. Extracting registrant contact information (when available) for the purpose of sending unsolicited bulk email violates ICANN's WHOIS terms of use and may violate anti-spam laws in your jurisdiction.
• Comply with GDPR and privacy regulations. Registrant data obtained through WHOIS/RDAP is subject to data protection laws. Store, process, and share it only for legitimate purposes and in compliance with applicable regulations.
• Verify before acting. Domain availability checks, registrant names, and other data are provided as-is from the registry. Always verify critical data through official channels before making business or legal decisions.
• Attribute data appropriately. If you publish or redistribute WHOIS data, credit the original registries and comply with their acceptable use policies.

---

FAQ

Does this actor require any API key or subscription? No. It uses the public RDAP protocol and a free backup WHOIS API. No credentials or external API keys are needed.

Which TLDs are supported? All TLDs that have an RDAP server registered with IANA are supported, which covers .com, .net, .org, .io, .co, most country-code TLDs, and hundreds of new gTLDs. The who-dat backup API extends coverage to additional TLDs.

Can I check if a domain is available for registration? Yes. When RDAP returns a 404 for a domain, the actor sets available: true. This is a strong signal but not a guarantee -- always confirm with a registrar before purchasing.

Why is registrant null for some domains? Many registrars redact registrant information to comply with GDPR and ICANN privacy regulations. The actor returns whatever the RDAP response includes; it cannot bypass privacy protections.

What are the EPP status codes in the status array? These are Extensible Provisioning Protocol status codes such as clientDeleteProhibited, clientTransferProhibited, and serverHold. They indicate what operations are locked or allowed on the domain. See ICANN's EPP status code documentation for a full reference.

How accurate is the domainAge field? It is calculated as the number of days between the createdDate reported by the registry and the current run date. It is as accurate as the registry's own records.

What happens when both data sources fail? The actor writes a result row with error set to a descriptive message and all other fields set to null or empty. This way you can easily filter on error != null to identify domains that need re-processing.

Is there a rate limit? The actor includes a built-in 500 ms delay between lookups. RDAP servers may impose their own limits, but the polite pacing keeps runs reliable for batches up to 1,000 domains.

Can I run this on a schedule? Yes. Use Apify Schedules to run the actor daily, weekly, or on any cron expression. This is ideal for monitoring domain expiry dates or tracking newly registered look-alike domains over time.

What is the difference between RDAP and traditional WHOIS? RDAP (Registration Data Access Protocol) is the modern replacement for the legacy WHOIS text protocol. It returns structured JSON instead of free-form text, supports standardized access control, and is mandated by ICANN for all new gTLDs. This actor uses RDAP as its primary source for these reasons.

Can I export results as CSV or Excel? Yes. Apify datasets support export in JSON, CSV, Excel, XML, HTML, and RSS formats. Use the Dataset tab in the Console or append ?format=csv to the dataset API URL.

How do I handle domains that returned errors? Filter your results for rows where error is not null. These domains can be retried in a separate run. Errors are typically caused by temporary RDAP server unavailability or unsupported TLDs.

---

Related actors

Actor	Description
DNS Record Lookup	Retrieve A, AAAA, MX, TXT, CNAME, NS, and SOA records for any domain.
SSL Certificate Search	Search Certificate Transparency logs to find all SSL/TLS certificates issued for a domain.
IP Geolocation Lookup	Geolocate IP addresses to get country, city, ISP, and organization data.
Website Tech Stack Detector	Detect the technologies, frameworks, and services running on any website.
Brand Protection Monitor	Monitor the web for brand impersonation, counterfeit listings, and unauthorized trademark use.
URL Unshortener	Expand shortened URLs to reveal the final destination domain before running a WHOIS lookup.