# WHOIS Domain Lookup: Registrar, Age, Expiry, Status, DNSSEC (`deriverge/whois-domain-lookup`) Actor

WHOIS lookup in bulk for any TLD: registrar, IANA ID, creation, update and expiry dates, domain age, days to expiry, statuses, nameservers and DNSSEC, straight from the registry via RDAP or WHOIS. Expiring-soon filter; JSON, CSV, API.

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

## Pricing

from $0.50 / 1,000 domain registry rows

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 Domain Lookup

### What does WHOIS Domain Lookup do?

**WHOIS Domain Lookup** returns the registry record of any domain as a clean row: registrar and its IANA ID, creation, update, expiry and transfer dates, domain age in days, days until expiry, registry statuses such as transfer locks, nameservers and whether the delegation is DNSSEC signed. Paste a thousand domains, get a thousand rows.

The data comes from the registries themselves through **RDAP**, the machine-readable successor of WHOIS, with classic WHOIS over port 43 as the fallback for the few registries that do not run RDAP yet. No browser, no proxies, no API key, and no registrant contacts.

You pay only for domains returned, from $0.50 per 1,000, with no start fee. The $5 of monthly credit in Apify's Free plan covers about 5,000 domains, so you can try it for free.

### Any input, one registrable domain

Paste bare names, URLs, email addresses or hostnames. Each is reduced to its registrable domain with the public suffix list, so `https://www.example.co.uk/about` and `press@example.co.uk` both become `example.co.uk`, looked up once.

### Fields

| Field | What you get |
|---|---|
| `registered` | `true`, `false`, or `null` when no registry service answered. |
| `registrar`, `registrarIanaId`, `registrarUrl` | The sponsoring registrar, as the registry publishes it. |
| `createdAt`, `updatedAt`, `expiresAt`, `transferredAt` | Real timestamps, whatever format the registry used. |
| `domainAgeDays`, `daysUntilExpiry` | Computed at run time. |
| `statuses` | Registry statuses, for example `client transfer prohibited`. |
| `nameservers`, `dnssec` | Delegation and whether it is signed. |
| `lookupSource`, `rdapServer`, `whoisServer` | Which service answered. |

Nothing is guessed. A field the registry did not publish is `null`.

### An expiry and transfer monitor

Turn on `changesOnly`, give the run a watch name or save it as a task, and schedule it daily. Each run compares every domain with the previous snapshot and returns only domains whose registrar, expiry date, statuses or nameservers changed, plus new domains. The `CHANGES` record lists every difference with the old and the new value. `expiringWithinDays` keeps only domains that expire within N days, which turns a portfolio into a renewal reminder.

### How much does it cost to do a bulk WHOIS lookup?

You pay per result. There is no start fee and no charge for compute time or proxies.

| | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| 1,000 domains | $1.00 | $0.80 | $0.65 | $0.50 |

For example, a WHOIS lookup of 1,000 domains costs $1.00 on the Free plan and $0.50 on the Business plan. The $5 of monthly credit in Apify's Free plan covers about 5,000 domains.

### How to do a bulk WHOIS lookup

1. Click **Try for free** (or **Start** if you are signed in) to open the actor in Apify Console.
2. In **Domains**, add domains, URLs or email addresses, one per line.
3. Click **Start**. Rows appear in the **Output** tab within seconds.
4. Download the results as JSON, CSV, Excel or HTML, or read them through the API.
5. To repeat it, click **Save as a task** and add a schedule. A scheduled task keeps its own snapshot, so change and new-only modes work without any setup.

### Input

```json
{
  "domains": ["apify.com", "wikipedia.org", "bbc.co.uk", "zoom.us", "seznam.cz"],
  "expiringWithinDays": 0,
  "changesOnly": false
}
```

### Output

```json
{
  "type": "domain",
  "key": "domain:wikipedia.org",
  "input": "wikipedia.org",
  "hostname": "wikipedia.org",
  "domain": "wikipedia.org",
  "tld": "org",
  "publicSuffix": "org",
  "registered": true,
  "lookupSource": "rdap",
  "rdapServer": "https://rdap.publicinterestregistry.org/rdap/",
  "whoisServer": null,
  "registrar": "MarkMonitor Inc.",
  "registrarIanaId": "292",
  "registrarUrl": null,
  "createdAt": "2001-01-13T00:12:14.000Z",
  "updatedAt": "2026-08-12T00:00:00.000Z",
  "expiresAt": "2027-01-13T00:12:14.000Z",
  "transferredAt": "2012-03-09T00:00:00.000Z",
  "domainAgeDays": 9384,
  "daysUntilExpiry": 111,
  "statuses": ["client delete prohibited", "client transfer prohibited", "client update prohibited"],
  "nameservers": ["ns0.wikimedia.org", "ns1.wikimedia.org", "ns2.wikimedia.org"],
  "dnssec": false,
  "checkedAt": "2026-09-23T11:40:12.000Z",
  "notes": []
}
```

DNS fields (`a`, `mx`, `spf` and so on) are present in the row for schema compatibility with our Domain WHOIS and DNS Lookup and stay empty here.

### Integrations and API

Connect the actor to **Make**, **Zapier**, **n8n**, **Google Sheets**, **Slack** or any webhook, or call it from your own code. With the Python client:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("deriverge/whois-domain-lookup").call(run_input={"domains": ["apify.com", "https://blog.github.com", "bbc.co.uk"]})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["domain"], row.get("registrar"), row.get("expiresAt"))
```

The **API** tab on this page has the same call for Node.js and cURL, and AI agents can run the actor through the Apify MCP server.

### Is it legal to do WHOIS lookups?

Registries publish registration data through RDAP and WHOIS so it can be looked up. The actor returns registrar, dates and status only, never registrant contacts.

### FAQ

#### Which TLDs work?

Every generic TLD and most country codes through RDAP, using the IANA bootstrap registry plus registries that run RDAP without being listed there yet (Germany, Switzerland, Norway, Argentina, Slovenia, the United States, .io). Registries without RDAP are read over WHOIS port 43 and return whatever they publish, which for some (for example .de and .jp) is statuses and nameservers without dates. `lookupSource` tells you which path answered.

#### Why no registrant name or email?

Since 2018 nearly every registry redacts them, and where one does not, we do not collect them. The row describes the domain, not the people behind it.

#### Why is `registrar` sometimes a code?

Some registries publish the registrar's handle rather than its name, for example `REG-GANDI` at CZ.NIC. The value is passed through as published.

#### How many domains per run?

As many as you like; six are looked up at a time and a thousand domains take a few minutes.

### Related scrapers

- [Tech Stack Detector](https://apify.com/deriverge/tech-stack-detector): what any website is built with, 7,600 technologies
- [Domain WHOIS and DNS Lookup](https://apify.com/deriverge/domain-whois-dns-lookup): registry data plus DNS and mail setup

### Support and feedback

Missing a field or found something that does not work? Open an issue in the **Issues** tab and it will be answered, usually within a day. If the actor saves you time, a short review helps other people find it.

# Actor input Schema

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

Domain names in any form: bare names, URLs, email addresses, hostnames with a subdomain. Each is reduced to its registrable domain with the public suffix list, so blog.example.co.uk becomes example.co.uk.

## `expiringWithinDays` (type: `integer`):

Keep only domains whose registry expiry date is within this many days. Other domains are dropped and never charged. Leave empty to keep everything.

## `changesOnly` (type: `boolean`):

Keeps a snapshot per watch name (or per saved task) and returns only domains whose registrar, expiry date, statuses or nameservers changed, plus new domains. Schedule it daily and you have an expiry and transfer monitor that bills only for what moved.

## `watchName` (type: `string`):

Name of the snapshot used by the changes-only mode, for example "our-domains". Runs from a saved task get a snapshot automatically even without a name.

## `maxItems` (type: `integer`):

Hard cap on returned domains in the run.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "https://blog.github.com",
    "bbc.co.uk"
  ],
  "changesOnly": false,
  "maxItems": 10000
}
```

# Actor output Schema

## `rows` (type: `string`):

One row per domain with registrar, dates, age, days to expiry, statuses, nameservers and DNSSEC.

## `changes` (type: `string`):

Domains whose registrar, expiry, statuses, nameservers or key DNS records changed, with the old and new values, compared with the previous snapshot of the same watch name or task.

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

Counts, what was charged, lookups that failed and notes.

# 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",
        "https://blog.github.com",
        "bbc.co.uk"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("deriverge/whois-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",
        "https://blog.github.com",
        "bbc.co.uk",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("deriverge/whois-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",
    "https://blog.github.com",
    "bbc.co.uk"
  ]
}' |
apify call deriverge/whois-domain-lookup --silent --output-dataset

```

## MCP server setup

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