# WHOIS Domain Lookup (RDAP): Bulk Domain Age, Expiry & Registrar (`datawright-labs/whois-rdap-domain-lookup`) Actor

WHOIS lookup, domain age and expiry date check for any list of domains: registrar, creation and expiry dates, nameservers, DNS provider, EPP status, DNSSEC and availability from official registry RDAP. No personal data. Callable by AI agents via MCP. $1 per 1,000 domains.

- **URL**: https://apify.com/datawright-labs/whois-rdap-domain-lookup.md
- **Developed by:** [Datawright Labs](https://apify.com/datawright-labs) (community)
- **Categories:** Developer tools, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 domain looked ups

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**For AI agents:** Use when asked for a WHOIS lookup, domain age, domain expiry date, registrar, nameservers or whether a domain is available. Call with `domains` (domains, emails or URLs; required), optional `outputFilter` (`all`, `problems`, `available`, `registered`) and `warnDays`. Returns one row per domain: `status` (registered/available/no-rdap/error), `registrar`, `createdAt`, `expiresAt`, `daysUntilExpiry`, `domainAgeYears`, `nameservers`, `dnsProvider`, `statuses` (EPP), `transferLocked`, `dnssec`, `problems`. Cost: $0.001 per domain ($1 per 1,000); failed lookups and TLDs without RDAP free.

**For people:** Tell your AI agent "look up the registrar, age and expiry date of these 200 domains and tell me which expire this year" and it hands the list to this tool, then reads back a clean table. No WHOIS parsing, no CAPTCHAs, and 1,000 domains cost $1.

**Bulk WHOIS lookup for hundreds or thousands of domains in one run, from the official source.** Paste a list of domains, email addresses or website URLs and this domain lookup asks each domain's **registry** over **RDAP** (the standardized JSON successor of WHOIS, run by the registries themselves) for its **registrar**, **creation date and domain age**, **expiry date and days left**, **nameservers and DNS provider**, **EPP status codes** (transfer lock, hold, redemption, pending delete), **DNSSEC** and whether the domain is **registered or available**. Every domain gets a plain-English **problems list**: expiring, expired, on hold, about to be deleted, no transfer lock or parked.

No proxies, no API keys, no WHOIS text scraping and **no personal data**: registries are found through the official **IANA RDAP bootstrap** (1,200+ TLDs incl. .com, .net, .org, .uk, .ai, .app, .dev, .fr, .nl, .ca, .au, .xyz plus .io, .co, .me, .us, .de and .ch), registrant contact fields are never saved, and results export to **CSV, Excel, JSON or Google Sheets** or run on a **schedule** as a domain expiry monitor.

### What does this WHOIS domain lookup do?

- 🏢 **Registrar** name, IANA ID, website and **abuse contact** (email and phone), straight from the registry.
- 📅 **Creation date, last update and expiry date**, plus **domain age** in days and years and **days until expiry** (negative = already expired).
- 🌐 **Nameservers** and the **DNS provider** detected from them (Cloudflare, Amazon Route 53, Google Cloud DNS, Azure, GoDaddy, Namecheap, NS1, Vercel, Wix, Squarespace, Shopify and 50+ more, incl. multi-provider setups and **parking / for-sale services** like Sedo, Dan.com, Afternic, HugeDomains).
- 🔒 **EPP status codes** in camelCase (`clientTransferProhibited`, `serverHold`, `redemptionPeriod`, `pendingDelete`...), a `transferLocked` flag and **DNSSEC** (delegation signed or not).
- ✅ **Availability**: domains the registry doesn't know come back as `status: "available"`, `registered: false`, so the same run works as a **bulk domain availability checker**.
- 🚦 **Problems list** per domain and an `expiryStatus` of `ok`, `expiring` (within your warning window, default 30 days) or `expired`.
- 🧹 **Bulk-friendly input**: domains, emails (`jane@acme.com` -> `acme.com`) and URLs are reduced to the **registrable domain** with the Public Suffix List (`blog.example.co.uk` -> `example.co.uk`) and de-duplicated; up to 50 lookups in parallel, at most 4 per registry, with retries on rate limits.

### Use cases

- **Domain expiry monitoring**: schedule a weekly run over your company's or clients' domains with **Only problems** on and get alerted before a domain expires or loses its transfer lock.
- **Lead qualification and enrichment**: add **domain age**, registrar and DNS provider (Cloudflare vs GoDaddy vs Shopify) to a list of company websites; very young domains are a classic fraud and spam signal.
- **Fraud, phishing and brand protection**: check lookalike domains for creation date, registrar abuse contact and whether they're parked.
- **Domain investing and naming**: check which names in a list are **available** and when registered ones expire or enter redemption.
- **IT and security audits**: verify transfer locks, DNSSEC and nameserver delegation across a whole domain portfolio.

### How to use it

1. Paste domains, emails or URLs into **Domains, emails or URLs**, one per line.
2. Optionally pick **Which domains to save** (all, only problems, only available, only registered) and the **Expiry warning** window in days.
3. Click **Start**, then open the **Overview** table or export the results. For monitoring, add a **Schedule** plus an email, Slack or webhook integration in Apify Console.

#### Input example

```json
{
  "domains": ["apify.com", "jane@github.com", "https://www.bbc.co.uk/news", "my-new-startup-name.com"],
  "outputFilter": "all",
  "warnDays": 30
}
```

### Output example

```json
{
  "domain": "github.com",
  "status": "registered",
  "registered": true,
  "registrar": "MarkMonitor Inc.",
  "registrarIanaId": "292",
  "registrarAbuseEmail": "abusecomplaints@markmonitor.com",
  "createdAt": "2007-10-09T18:20:50.000Z",
  "updatedAt": "2026-09-07T09:22:52.000Z",
  "expiresAt": "2028-10-09T18:20:50.000Z",
  "domainAgeDays": 6954,
  "domainAgeYears": 19,
  "daysUntilExpiry": 716,
  "expiryStatus": "ok",
  "statuses": ["clientDeleteProhibited", "clientTransferProhibited", "clientUpdateProhibited"],
  "transferLocked": true,
  "nameservers": ["dns1.p08.nsone.net", "dns2.p08.nsone.net", "ns-1283.awsdns-32.org", "ns-421.awsdns-52.com"],
  "dnsProvider": "NS1",
  "dnsProviders": ["NS1", "Amazon Route 53"],
  "dnssec": false,
  "rdapServer": "rdap.verisign.com",
  "problems": [],
  "checkedAt": "2026-10-24T14:16:46.407Z"
}
```

Unregistered domains come back as `status: "available"`. TLDs whose registry has no public RDAP service (for example .jp, .eu, .it, .es) come back as `status: "no-rdap"` and are **free**. A **SUMMARY** record in the key-value store has counts per status.

### How much does a bulk WHOIS lookup cost?

You pay **$0.001 per domain looked up** ($1 per 1,000 domains), registered or available. **Failed lookups, TLDs without RDAP and invalid inputs are free**, and domains skipped by **Which domains to save** are **free** too. No start fee.

| Job | Domains | Cost |
|---|---|---|
| Your 20 domains, expiry check every week | ~80/month | **~$0.08/month** |
| Agency: 500 client domains, monthly | 500/month | **$0.50/month** |
| Enrich a lead list of 25,000 company domains with age and registrar | 25,000 | **$25** |

- Apify's **free plan includes $5 of monthly credit**, enough for about **5,000 domains a month**.
- Paid Apify plans get automatic discounts: **Silver -10%**, **Gold and above -20%**.
- Set **Maximum cost per run** to cap spend; the Actor stops cleanly at the limit.

### RDAP domain lookup vs. the alternatives

| | This Actor | Free online WHOIS sites | Port-43 WHOIS scrapers | WHOIS API subscriptions |
|---|---|---|---|---|
| Bulk lists (thousands of domains) | ✅ | ❌ one at a time, CAPTCHAs | ✅ but rate-limited text | ✅ |
| Source | official registry RDAP (JSON) | mixed | free-text WHOIS, format differs per TLD | resold WHOIS / RDAP |
| Registrar, dates, age, nameservers, EPP status, DNSSEC in one row | ✅ | ✅ | needs parsing | ✅ |
| DNS provider and parking detection | ✅ | ❌ | ❌ | sometimes |
| Availability check in the same run | ✅ | separate tool | sometimes | separate endpoint |
| Personal data | never saved | shown when not redacted | often stored | often stored |
| Cost model | $1 per 1,000 domains, no subscription | free, manual | per result | monthly plan |

### Use it as an API (Python, JavaScript, cURL)

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("datawright-labs/whois-rdap-domain-lookup").call(run_input={"domains": ["example.com", "jane@acme.com"]})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["domain"], item["status"], item.get("registrar"), item.get("expiresAt"), item.get("domainAgeYears"))
```

#### JavaScript / Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('datawright-labs/whois-rdap-domain-lookup').call({ domains: ['example.com'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/datawright-labs~whois-rdap-domain-lookup/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" -d '{"domains":["example.com"],"outputFilter":"all"}'
```

### Use it from your AI agent (MCP)

Your AI assistant or agent can run this Actor as a tool through [Apify's MCP server](https://docs.apify.com/platform/integrations/mcp), so it can do WHOIS / RDAP domain lookups on its own while you chat. Add this server to any MCP client that supports remote (Streamable HTTP) servers:

```json
{
  "mcpServers": {
    "datawright-whois-rdap-domain-lookup": {
      "url": "https://mcp.apify.com?tools=datawright-labs/whois-rdap-domain-lookup"
    }
  }
}
```

On first use your browser opens to sign in to Apify (OAuth). If your client can't do OAuth, add `"headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }` instead. The tool shows up as `datawright-labs--whois-rdap-domain-lookup`, with the same input fields as above, and the agent reads the results with `get-dataset-items`. Then just ask, for example:

> Look up the registrar, age and expiry date of these 30 domains and list the ones that expire in the next 90 days.

Want several Datawright tools at once? Comma-separate them: `https://mcp.apify.com?tools=datawright-labs/whois-rdap-domain-lookup,datawright-labs/ssl-certificate-checker`. Runs are billed per result, exactly like normal runs.

### FAQ

#### What is RDAP and how is it different from WHOIS?

RDAP (Registration Data Access Protocol) is the IETF standard that replaced port-43 WHOIS for gTLDs in 2025. It returns the same registration data (registrar, dates, nameservers, status) as structured JSON over HTTPS, straight from the registry, so there is no per-TLD text parsing and no scraping.

#### How do I check a domain's age or creation date?

Run the domain and read `createdAt`, `domainAgeDays` and `domainAgeYears`. Note that the creation date is the current registration: a domain that was dropped and re-registered shows the new date.

#### How do I check when a domain expires?

`expiresAt` is the registry expiry date and `daysUntilExpiry` the days left. Set **Expiry warning** to your window (e.g. 60) and **Which domains to save** to "Only problems" for an alert-only run. A few registries (for example .de and .ch) don't publish expiry dates; those rows have `expiresAt: null`.

#### Can I check if a domain is available?

Yes. Domains the registry has no record of return `status: "available"` and `registered: false`. Choose "Only available" to keep just those. Reserved or premium names can also be unregistered, so confirm at a registrar before you count on one.

#### Why do I get "no-rdap" for some domains?

A few country-code registries (for example .jp, .eu, .it, .es, .ru, .cn) still only run legacy WHOIS and no public RDAP service. This Actor deliberately doesn't scrape WHOIS text, so those rows are flagged `no-rdap` and are free.

#### Does it return the registrant's name, email or address?

No. Registrant, admin and tech contact fields are never saved, even when a registry publishes them. You get registry and registrar data only (registrar abuse contacts are business contacts published for abuse reports).

### More tools from Datawright Labs

- [SSL Certificate Checker](https://apify.com/datawright-labs/ssl-certificate-checker): bulk SSL certificate and domain expiry checks with alerts for expiring, invalid or outdated TLS.
- [Security Headers Checker](https://apify.com/datawright-labs/security-headers-checker): bulk HTTP security headers audit (HSTS, CSP, X-Frame-Options, cookies, HTTPS redirect) with an A-F grade per URL.
- [SPF, DMARC & DKIM Checker](https://apify.com/datawright-labs/email-domain-dns-checker): bulk email domain audit of SPF (10-lookup limit), DMARC, DKIM, MX provider, BIMI and MTA-STS.
- [Broken Link Checker](https://apify.com/datawright-labs/broken-link-checker): find broken links, images and redirects across a whole site.
- [Sitemap URL Extractor](https://apify.com/datawright-labs/sitemap-url-extractor): get every URL of a site from its sitemaps.
- [Bulk PageSpeed & Core Web Vitals Checker](https://apify.com/datawright-labs/pagespeed-auditor): audit PageSpeed / Lighthouse scores for many URLs.
- [Website Screenshot API](https://apify.com/datawright-labs/website-screenshot): bulk full-page screenshots and PDFs.
- [Google Autocomplete Keyword Scraper](https://apify.com/datawright-labs/autocomplete-keyword-scraper): long-tail keyword ideas from Google, YouTube and Bing.
- [Greenhouse, Lever & Ashby Jobs Scraper](https://apify.com/datawright-labs/ats-jobs-scraper): normalized job feeds from 5 ATS platforms.
- [App Store Top Charts & Rank Tracker](https://apify.com/datawright-labs/app-store-top-charts): daily top free/paid/grossing app rankings with rank changes.

Tip: pair it with the **SSL Certificate Checker** to monitor certificate and domain expiry together.

Made by **Datawright Labs**: reliable, fairly priced web data tools. Questions or a missing feature? Open an issue on the Issues tab; we usually reply within a day.

# Actor input Schema

## `domains` (type: `array`):

One per line: bare domains (example.com), email addresses (jane@example.com) or URLs (https://blog.example.co.uk/page). Each is reduced to its registrable domain (blog.example.co.uk -> example.co.uk) and duplicates are merged.

## `outputFilter` (type: `string`):

Domains that don't match are skipped and not charged. Use "Only problems" for scheduled expiry alerts and "Only available" for bulk availability checks.

## `warnDays` (type: `integer`):

Domains that expire within this many days are flagged as expiring.

## `keepSubdomains` (type: `boolean`):

Off (recommended): www.blog.example.com is looked up as example.com, because registries only hold registrable domains. Turn on only if your registry answers for subdomains.

## `includeRaw` (type: `boolean`):

Add the full registry RDAP JSON to each row (large; useful for debugging or fields not mapped above).

## `timeoutSecs` (type: `integer`):

Timeout per RDAP request. Slow or rate-limited registries are retried up to 3 times.

## `concurrency` (type: `integer`):

How many domains to look up at the same time (never more than 4 at once per registry server).

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "github.com",
    "bbc.co.uk"
  ],
  "outputFilter": "all",
  "warnDays": 30,
  "keepSubdomains": false,
  "includeRaw": false,
  "timeoutSecs": 20,
  "concurrency": 10
}
```

# Actor output Schema

## `results` (type: `string`):

Per-domain RDAP / WHOIS results.

## `summary` (type: `string`):

SUMMARY record: domains looked up and counts by status.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "domains": [
        "apify.com",
        "github.com",
        "bbc.co.uk"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datawright-labs/whois-rdap-domain-lookup").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "domains": [
        "apify.com",
        "github.com",
        "bbc.co.uk",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("datawright-labs/whois-rdap-domain-lookup").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "domains": [
    "apify.com",
    "github.com",
    "bbc.co.uk"
  ]
}' |
apify call datawright-labs/whois-rdap-domain-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datawright-labs/whois-rdap-domain-lookup"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/L0mQ8gmRZxhaefWQk/builds/ydTibMQgEmBmO6QBt/openapi.json