# WHOIS Lookup: Bulk Registrar & Expiry Date (RDAP) (`ucchiii/whois-lookup`) Actor

Bulk WHOIS lookup over RDAP: one row per domain with registrar, creation, update and expiry dates, days to expiry, status codes, nameservers and DNSSEC. Registrant contacts are never returned. Empty input = free demo.

- **URL**: https://apify.com/ucchiii/whois-lookup.md
- **Developed by:** [Actor Factory](https://apify.com/ucchiii) (community)
- **Categories:** Developer tools, SEO tools, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.05 / 1,000 looked-up domains

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

**WHOIS lookup in bulk: registrar, creation and expiry dates, days to expiry, status codes, nameservers and DNSSEC for up to 1,000 domains per run — straight from the registries over RDAP.**

> **Acceptable use:** Follow the terms of use of the registries' RDAP services. Do not use the data for spam or bulk marketing, and do not use it to register domains that contain someone else's trademark or brand.

Paste a list of domains and get **one row per domain** with the registration data a WHOIS search shows — without the personal data. The Actor asks each registry directly through **RDAP** (the official, structured successor of WHOIS): no scraping of WHOIS websites, no proxies, no API keys.

**Try it free:** leave the input empty and press **Start** — three domains are looked up as a demo (not charged, rows carry `_demo: true`).

### What you get

| domain | status | registrar | createdAt | expiresAt | daysToExpiry | nameservers | dnssecSigned |
|---|---|---|---|---|---|---|---|
| example-shop.com | found | Example Registrar, Inc. | 2012-05-14T09:00:00Z | 2027-05-14T09:00:00Z | 191 | ns1.example-dns.net, ns2.example-dns.net | false |
| example-charity.org | found | Sample Registry Services | 2004-02-01T00:00:00Z | 2026-12-01T00:00:00Z | 27 | a.ns.example.org, b.ns.example.org | true |
| surely-not-registered-9f3k2.com | not_found | | | | | | |
| something.nordf | unknown | | | | | | |

*(illustrative rows showing the output format; the free demo shows real results)*

- **Renewal tracking**: `expiresAt` and `daysToExpiry` (negative when expired) for every registered name — sort by days left and renew in time.
- **Who manages it**: registrar name and IANA registrar ID, registry status codes such as `client transfer prohibited`, nameservers and DNSSEC.
- **Messy input is fine**: URLs are cut down to the host name, `www.` and other subdomains use their registered domain's record, duplicates are removed, typos come back as free `invalid` rows.

### How to use

1. **Domains**: one per line (up to 1,000 per run).
2. Optional: **Concurrency** (1–5, default 3) and **Timeout** per request (default 15 s).

```json
{
  "domains": ["apify.com", "python.org", "example.com"],
  "concurrency": 3
}
```

### Output fields

- `domain` — the name as looked up (punycode for international names).
- `status` — `found` (registration data returned), `not_found` (the registry reports no such domain — usually not registered), `unknown` (no answer: the TLD has no RDAP service, or a timeout or rate limit — run it again later), `invalid` (not a domain name).
- `registered` — `true` for `found`, `false` for `not_found`, empty otherwise.
- `registrar`, `registrarIanaId` — the registrar company and its IANA ID.
- `createdAt`, `updatedAt`, `expiresAt` — ISO dates in UTC; `daysToExpiry` and `expired`.
- `domainStatus` — registry status codes (EPP status); `nameservers`; `dnssecSigned`.
- `rdapServer`, `rdapDomain` — which registry answered, and for which name (the parent domain for subdomains).
- `registrantRedacted` — always `true`; `error` — why a row is `unknown` or `invalid`; `checkedAt`.
- **STATS** record: counts of found, not found, unknown, invalid and charged domains.

### Privacy: no personal data

Registrant, administrative, technical and billing contacts are **never read or returned** — no names, e-mails, phone numbers or addresses, even where a registry publishes them. Only the registrar (a company), dates, status codes, nameservers and DNSSEC are used. E-mail addresses typed into the input are rejected as invalid, not looked up.

### What it does not do

No DNS records beyond the nameservers in the registry record. For A, MX, TXT, SPF or DMARC records use the DNS Records Lookup or Domain WHOIS & DNS Lookup Actors from the same developer. For "is this name free to register?" use the Domain Availability Checker, which also double-checks DNS before saying "available".

### Limits (cannot be raised by input)

- **1,000 domains per run**; concurrency 1–5.
- **Polite to the registries**: at most 2 connections and at least 0.25 s between requests per registry server; rdap.org (used only for TLDs missing from the IANA list) at most 1 request per 1.1 s. Rate limits (HTTP 429) and server errors are retried up to 3 times with a growing pause, honouring `Retry-After`.
- TLDs without an RDAP service (for example many country codes) come back `unknown` and are free.
- `.uk` domains (including `.co.uk`) are not looked up: the .uk registry's terms forbid commercial use of its data. They come back `unknown` with `error: tld_excluded_by_registry_terms` and are free.
- Set a **maximum charge per run** to cap spend: the Actor checks it before starting, never looks up more domains than it can charge for and stops cleanly when it is reached.

### Pricing

Pay per event: **$0.0015 per looked-up domain** — a domain the registry answered for (`found` or `not_found`). That is **$1.50 per 1,000 domains**, with no start fee.
`invalid` and `unknown` rows and the demo are **free**.
Store discounts apply automatically: BRONZE −10%, SILVER −20%, GOLD −30%.
On the Apify Free plan, the $5 of monthly platform credit covers about 3,300 domains a month.

### FAQ

**Is RDAP the same as WHOIS?** RDAP is the official replacement for the old WHOIS protocol, run by the same registries. It returns the same registration data in a structured form; ICANN requires it for all generic TLDs.

**Why is the registrant missing?** By design. Since GDPR most registries redact it anyway, and this Actor never collects personal data.

**Why does a domain I know exists show `not_found`?** Some names are managed below the registry that answered (for example a university name under a country's academic zone): the parent registry has no record for them. Check such names with the Domain WHOIS & DNS Lookup Actor, which also looks at DNS.

**Why `unknown`?** The TLD has no RDAP service, or the registry did not answer in time or rate-limited the request. Unknown rows are free; run them again later.

If this Actor saved you time, a rating on the Store helps others find it.

### More tools from the same developer

- [Domain WHOIS & DNS Lookup](https://apify.com/ucchiii/domain-whois) — bulk WHOIS (RDAP) and DNS lookup: registrar, expiry, days left, A/MX/NS, no personal data
- [Domain Age Checker](https://apify.com/ucchiii/domain-age-checker) — how old is a domain: registration date, age in years and days and an age band for up to 1,000 domains, oldest first
- [Domain Availability Checker](https://apify.com/ucchiii/domain-availability-checker) — bulk domain availability check via RDAP: registered or likely available
- [DNS Lookup](https://apify.com/ucchiii/dns-records-lookup) — bulk DNS lookup: A, AAAA, MX, NS, TXT, SPF and DMARC per domain
- [Website Technology Detector](https://apify.com/ucchiii/website-technology-detector) — tech stack of websites in bulk: CMS, frameworks, analytics and tag IDs, CDN, consent tools

# Actor input Schema

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

Domain names to look up, one per entry, e.g. 'example.com'. URLs ('https://www.example.com/page') are cut down to the host name and subdomains use their registered domain's record; internationalized names (münchen.de) are converted to punycode. Duplicates are removed. Up to 1,000 domains per run. Leave empty for a free demo (not charged). Follow the terms of use of the registries' RDAP services; do not use the data for spam or bulk marketing.

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

Timeout for each request, in seconds. Failed requests (including rate limits, HTTP 429) are retried up to 3 times with a growing pause. Allowed range 1 to 60 (default 15).

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

How many domains are looked up in parallel. Allowed range 1 to 5 (default 3). At most 2 connections per registry server are used at a time, with at least 0.25 s between requests to the same server, whatever you set here.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "python.org",
    "example.com"
  ],
  "timeoutSecs": 15,
  "concurrency": 3
}
```

# Actor output Schema

## `domains` (type: `string`):

One item per domain: status, registered, registrar, registrarIanaId, createdAt, updatedAt, expiresAt, daysToExpiry, expired, domainStatus, nameservers, dnssecSigned, rdapServer, rdapDomain, error, checkedAt.

## `stats` (type: `string`):

Record STATS: domains given, found, not found, unknown, invalid, charged, and whether the run stopped early.

# 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",
        "python.org",
        "example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ucchiii/whois-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",
        "python.org",
        "example.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("ucchiii/whois-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",
    "python.org",
    "example.com"
  ]
}' |
apify call ucchiii/whois-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ucchiii/whois-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/DVMNG57HuSRQt2qTg/builds/vfrAN5zaiSiBIOgrj/openapi.json
