WHOIS / RDAP Domain Lookup

Look up WHOIS and RDAP registration data in bulk, including registrar, expiry dates, domain status flags, nameservers, DNSSEC, contact summaries, abuse contacts, and optional raw RDAP JSON.

Use it for domain portfolio monitoring, SEO aged-domain research, brand protection, merchant risk checks, cybersecurity OSINT, and developer-friendly domain intelligence exports.

At a glance

• Bulk domain lookup: Paste domains, hostnames, or URLs and get one normalized output row per unique input domain.
• Registration details: Export registrar, IANA ID, creation date, update date, expiry date, calculated age/countdown, statuses, and nameservers.
• Risk and compliance context: Review abuse contacts, DNSSEC delegation status, notices, and lookup errors.
• Raw RDAP option: Include the full RDAP JSON payload when you need auditability or custom downstream parsing.
• API-ready output: Download CSV/JSON/Excel exports or call the actor from Apify API, MCP, Make, Zapier, or agents.

Ready-to-run examples

Open an example, review the input, and run it as-is or adjust the domains:

• Domain RDAP expiry check: Check renewal and expiry dates for public domains.
• Bulk WHOIS registrar audit: Compare registrar names and IANA IDs across a domain list.
• Brand protection domain check: Review domains that may matter for brand monitoring.
• SEO aged domain research: Export creation and expiry context for aged-domain screening.
• RDAP raw JSON export: Include full RDAP payloads for auditing or custom parsing.

What can it do?

WHOIS / RDAP Domain Lookup normalizes each input, calls public RDAP endpoints, and saves structured domain registration records to an Apify dataset.

• Normalize inputs: Accept bare domains, hostnames, or URLs such as example.com, www.example.com/path, or https://example.com.
• Fetch RDAP records: Query direct registry RDAP endpoints for common TLDs and fall back to rdap.org.
• Save success and error rows: Keep invalid entries in mixed batches, unsupported TLDs, timeouts, and registry failures visible in the dataset. An invalid-only list fails before billing.
• Control reliability: Tune concurrency, retry count, and request timeout for registry rate limits.
• Export clean records: Use fields for registrar audits, expiry monitoring, nameserver inventories, risk checks, and dashboards.

Common workflows

• Domain portfolio expiry monitoring: Track expiresAt, registrarName, statuses, and nameservers.
• Brand protection: Check suspicious or lookalike domains for registrar, dates, and status flags.
• SEO aged-domain research: Compare domain creation dates, status flags, nameservers, and raw RDAP records.
• Merchant or vendor risk checks: Add domain age and registrar context to CRM, onboarding, or risk-review workflows.
• Security OSINT: Export RDAP records for domains related to investigations, phishing reports, or infrastructure mapping.

Output fields

The actor returns one dataset row per unique input domain.

Field	Description
inputDomain	Original input string
normalizedDomain	Normalized ASCII domain used for lookup
lookupUrl	RDAP endpoint URL used for the lookup
success	Whether the lookup returned a usable RDAP record
error	Error message for invalid or failed lookups
registryDomainId	Registry domain identifier when available
handle	RDAP handle
ldhName	LDH domain name
unicodeName	Unicode domain name when available
registrarName	Registrar name
registrarIanaId	Registrar IANA ID
registrarUrl	Registrar URL from RDAP entities
registrarAbuseEmail	Registrar abuse email when published
registrarAbusePhone	Registrar abuse phone when published
statuses	RDAP domain status flags
createdAt	Registration date when published
updatedAt	Last update date when published
expiresAt	Expiry date when published
domainAgeDays	Whole days since the published registration date
daysUntilExpiry	Days remaining until the published expiry date; negative means expired
rdapConformance	RDAP profile/extension identifiers returned by the authority
nameservers	Nameserver list
secureDnsDelegationSigned	DNSSEC delegation status when available
contacts	Summary of RDAP entities and contact roles
notices	Registry notices and remarks
rawRdap	Full RDAP JSON payload when includeRawRdap is enabled

Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

Event	What is charged	Price
start	One-time fee charged when a run starts. Covers fixed startup cost (init, proxy warmup, first HTTP setup).	$0.005

Event	What is charged	Free / no discount	Starter / Bronze	Scale / Silver	Business / Gold	Custom / Platinum	Custom / Diamond
item	Charged only for a successful RDAP record after it is saved. Invalid or failed lookup rows are uncharged.	$0.08065 / 1,000	$0.07013 / 1,000	$0.05470 / 1,000	$0.04208 / 1,000	$0.02805 / 1,000	$0.01964 / 1,000

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

Input configuration

Setting	JSON key	Use it for	Example
Domains	domains	Required list of domains, hostnames, or URLs to normalize and look up.	["example.com","https://apify.com"]
Include raw RDAP response	includeRawRdap	Save the complete RDAP JSON payload in rawRdap.	true
Maximum concurrency	maxConcurrency	Number of domains to look up in parallel.	3
Retry count	retryCount	Retries for temporary RDAP failures such as 429 or 5xx responses.	2
Request timeout seconds	timeoutSecs	Per-domain RDAP request timeout.	20

Example input

{
  "domains": [
    "example.com",
    "iana.org",
    "https://apify.com"
  ],
  "includeRawRdap": true,
  "maxConcurrency": 3,
  "retryCount": 2,
  "timeoutSecs": 20
}

Example output

{
  "inputDomain": "example.com",
  "normalizedDomain": "example.com",
  "lookupUrl": "https://rdap.verisign.com/com/v1/domain/example.com",
  "success": true,
  "error": null,
  "registrarName": "RESERVED-Internet Assigned Numbers Authority",
  "registrarIanaId": "376",
  "registrarAbuseEmail": null,
  "statuses": ["client delete prohibited", "client transfer prohibited"],
  "createdAt": "1995-08-14T04:00:00Z",
  "updatedAt": "2024-08-14T07:01:39Z",
  "expiresAt": "2026-08-13T04:00:00Z",
  "domainAgeDays": 11300,
  "daysUntilExpiry": 390,
  "rdapConformance": ["rdap_level_0"],
  "nameservers": ["A.IANA-SERVERS.NET", "B.IANA-SERVERS.NET"],
  "secureDnsDelegationSigned": true,
  "contacts": [],
  "notices": [],
  "rawRdap": {}
}

Search and data tips

• Use bare domains when possible: URLs are accepted, but bare domains make input lists easier to review.
• Keep concurrency modest: Registries can rate-limit RDAP traffic; increase maxConcurrency gradually.
• Turn off raw RDAP for small exports: Set includeRawRdap to false when you only need flat fields.
• Check error rows: Invalid domains, unsupported TLDs, and temporary registry failures are visible in success and error.
• Schedule expiry checks: Run the same list weekly or monthly to monitor renewal windows.

Limits and practical notes

• RDAP coverage varies by TLD and registry.
• Some registries redact contact details or do not publish dates in the same format.
• contacts summarizes public RDAP entities; it is not a guaranteed lead/contact list.
• WHOIS privacy and registry policy can leave registrar abuse or registrant fields empty.
• This actor does not bypass access controls or query private registrar accounts.

API usage

cURL

curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~whois-rdap-domain-lookup/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"domains":["example.com","iana.org"],"includeRawRdap":false}'

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/whois-rdap-domain-lookup').call({
  domains: ['example.com', 'iana.org'],
  includeRawRdap: false
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("fetch_cat/whois-rdap-domain-lookup").call(run_input={
    "domains": ["example.com", "iana.org"],
    "includeRawRdap": False,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)

MCP and AI agents

Use this actor from MCP-compatible tools through Apify MCP Server.

MCP URL:

https://mcp.apify.com/?tools=fetch_cat/whois-rdap-domain-lookup

Example prompts:

• "Look up these domains and flag any that expire within 90 days."
• "Export registrar and nameserver data for this domain portfolio."
• "Check these suspicious domains and summarize creation dates and status flags."

Legality and responsible use

This actor queries public RDAP domain registration records.

Use the data responsibly, follow registry and Apify terms, and comply with privacy, anti-spam, security, and data-protection laws in your jurisdiction.

Related actors

Explore related actors from the same Apify account:

• Website Content Crawler Lite
• Website Contact Finder
• Bing SERP & Search Results Scraper
• Google News Scraper
• GitHub Repositories Search Scraper

Changelog

0.1

• Initial version with configurable inputs and structured results.

Support

Start with a few known domains, keep maxConcurrency low, and inspect success, error, lookupUrl, and rawRdap before scaling to larger domain lists.

Privacy and data handling

This Actor only requests the permissions needed to run the input you provide. It uses your input (such as URLs, search terms, identifiers, filters, and limits) only to fetch the requested public data from the relevant source site or API for this Actor, then writes results to your Apify dataset/key-value store.

Data may pass through Apify platform services and Apify Proxy during the run, and requests are sent only to the target site or public data provider required for this Actor's results. FetchCat does not send your inputs or outputs to advertising networks, data brokers, or model-training services, and does not retain run data outside Apify storage after the run except when you explicitly share run details for transient support debugging.

You are responsible for using this Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs. Review the output before storing, sharing, or combining it with other data.