# WHOIS Lookup (`superlativetech/whois-lookup`) Actor

WHOIS domain registration data for any domain. Registrar, expiry dates, domain age, registrant, nameservers, DNSSEC. Domain ownership enrichment for lead scoring, expiry monitoring, fraud detection, and due diligence. Batch thousands or query one instantly via Standby API.

- **URL**: https://apify.com/superlativetech/whois-lookup.md
- **Developed by:** [Superlative](https://apify.com/superlativetech) (community)
- **Categories:** Lead generation, Automation, Open source
- **Stats:** 21 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## WHOIS Lookup

Look up WHOIS registration data for any domain — registrar, dates, domain age, registrant info, name servers, and DNSSEC status.

### What does WHOIS Lookup do?

WHOIS Lookup retrieves domain registration data from WHOIS servers for a list of domains, or queries a single domain instantly via the Standby API.

- **Registrar info** — registrar name and URL for every domain
- **Registration dates** — created, updated, and expiry dates in ISO 8601
- **Domain age** — days since registration and days until expiry
- **Registrant data** — name, organization, and country (when not redacted)
- **Name servers** — authoritative DNS servers
- **Status codes** — EPP status (clientTransferProhibited, serverDeleteProhibited, etc.)
- **DNSSEC** — whether DNSSEC signing is active
- **Multi-TLD support** — works with .com, .org, .net, .co.uk, .io, and hundreds more

### Use with AI Agents

Available as an MCP tool via the [Apify MCP Server](https://mcp.apify.com).

| Property | Value |
| --- | --- |
| Actor ID | `superlativetech/whois-lookup` |
| Standby URL | `https://superlativetech--whois-lookup.apify.actor` |
| Input | `domains` (string\[]) or `domain` (string) |
| Output | `{domain, registrar, createdDate, expiryDate, domainAge, nameServers[], status[]}` per domain |
| Pricing | Free — you only pay standard Apify platform usage |
| Idempotent | Yes — same input always produces same output |

#### Output schema

```json
{ "domain": "example.com", "registrar": "GoDaddy", "createdDate": "1997-09-15", "expiryDate": "2030-09-15", "domainAge": 10358, "nameServers": ["ns1.example.com"] }
```

#### Pipeline composability

Use WHOIS for domain intelligence pipelines:

1. **Extract domains** (from URLs/emails) → 2. **WHOIS** (this actor) → 3. **DNS Lookup** (records)

#### Standby (instant API)

```
GET https://superlativetech--whois-lookup.apify.actor?token=TOKEN&domain=example.com
```

### Why look up WHOIS data?

WHOIS records reveal registration and ownership details that aren't visible on a website:

- **Domain ownership** — registrant organization and country for due diligence
- **Registration history** — creation, update, and expiry dates show domain maturity
- **Infrastructure details** — registrar, name servers, and WHOIS server identification
- **Security signals** — EPP status codes and DNSSEC signing status

> **Need DNS records too?** [DNS Lookup](https://apify.com/superlativetech/dns-lookup?fpr=8e9l1) retrieves A, AAAA, MX, CNAME, TXT, NS, SOA, and DMARC records for any domain.

#### Use cases

**Technical:**

- Domain expiry monitoring and renewal tracking
- DNSSEC deployment auditing
- Name server validation and migration checks
- Registrar and WHOIS server identification

**Sales & Marketing:**

- Enrich prospect records with domain age for lead scoring
- Identify registrant organizations for account mapping
- Flag newly registered domains in phishing or fraud analysis
- Verify domain ownership for trademark and brand protection

### How to use WHOIS Lookup

1. Enter your domain names (without `https://` or `www.`)
2. Click **Start** and download your results

#### Single domain

```json
{
  "domain": "google.com"
}
```

#### Batch lookup

```json
{
  "domains": ["google.com", "github.com", "amazon.com"]
}
```

### Standby mode (instant API)

Standby mode keeps a warm container running so you get instant WHOIS lookups without cold-start delays. Instead of starting a full Actor run, you make a simple HTTP GET request and get results in seconds.

This is ideal for:

- **Clay enrichment steps** — single-domain lookups inline
- **Make / n8n HTTP modules** — real-time WHOIS checks in workflows
- **MCP agents** — AI tools that need instant domain registration data

#### Standby URL

```
https://superlativetech--whois-lookup.apify.actor?token=YOUR_API_TOKEN
```

Or use a Bearer token in the `Authorization` header instead of the `token` query parameter.

#### Example request

```bash
curl "https://superlativetech--whois-lookup.apify.actor?token=YOUR_API_TOKEN&domain=google.com"
```

#### Query parameters

| Parameter | Required | Description |
| --- | --- | --- |
| `domain` | Yes | Domain name to look up |

#### Response format

Success — same shape as batch output:

```json
{
  "domain": "google.com",
  "registrar": "MarkMonitor, Inc.",
  "registrarUrl": "http://www.markmonitor.com",
  "createdDate": "1997-09-15T04:00:00.000Z",
  "updatedDate": "2019-09-09T15:39:04.000Z",
  "expiresDate": "2028-09-14T04:00:00.000Z",
  "domainAgeDays": 10373,
  "expiresInDays": 949,
  "nameServers": ["ns1.google.com", "ns2.google.com", "ns3.google.com", "ns4.google.com"],
  "dnssec": "unsigned",
  "lookupStatus": "OK"
}
```

#### Error responses

| Code | Cause |
| --- | --- |
| 400 | Missing `domain`, invalid domain format |
| 405 | Non-GET request |
| 500 | Unexpected server error |

WHOIS failures return HTTP 200 with a non-OK `lookupStatus` — e.g., `"TLD not supported"`, `"No WHOIS data"`, or `"Lookup failed"`. These are not charged.

### How many domains can you query?

There's no limit. Query as many domains as you need — from a handful to hundreds of thousands. The Actor scales automatically.

For best performance, batch your requests. Processing 1,000 domains at once is more efficient than 10 separate runs of 100 domains each.

WHOIS lookups are slower than DNS due to TCP connections and server rate limits. Expect ~200-500 domains per minute in batch mode, or ~1-3 seconds per domain via Standby.

### How much will it cost you?

This Actor is **free to use** — there are no per-result charges. You only pay for the Apify platform compute your runs consume, which is typically negligible.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `domains` | array | — | List of domain names to query |
| `domain` | string | — | Single domain name (API shorthand) |

### During the Actor run

The Actor queries WHOIS servers for each domain in your list. You'll see progress updates as lookups complete.

If you provide invalid input (e.g., an empty list or URLs with protocols), the Actor will stop with an error message.

Results are available in real-time — you can start downloading records before the full run completes.

### Output format

Results are saved to the default dataset. Each domain is a separate item.

```json
[
  {
    "domain": "google.com",
    "registrar": "MarkMonitor, Inc.",
    "registrarUrl": "http://www.markmonitor.com",
    "createdDate": "1997-09-15T04:00:00.000Z",
    "updatedDate": "2019-09-09T15:39:04.000Z",
    "expiresDate": "2028-09-14T04:00:00.000Z",
    "domainAgeDays": 10373,
    "expiresInDays": 949,
    "registrant": null,
    "registrantOrg": "Google LLC",
    "registrantCountry": "US",
    "adminContact": null,
    "techContact": null,
    "nameServers": ["ns1.google.com", "ns2.google.com", "ns3.google.com", "ns4.google.com"],
    "status": ["clientDeleteProhibited", "clientTransferProhibited", "clientUpdateProhibited", "serverDeleteProhibited", "serverTransferProhibited", "serverUpdateProhibited"],
    "dnssec": "unsigned",
    "whoisServer": "whois.markmonitor.com",
    "lookupStatus": "OK",
    "checkedAt": "2026-02-08T18:00:00.000Z",
    "durationMs": 1842
  }
]
```

| Field | Type | Description |
| --- | --- | --- |
| `domain` | string | Domain that was looked up |
| `registrar` | string | Registrar name (e.g., "GoDaddy.com, LLC") |
| `registrarUrl` | string | Registrar website URL |
| `createdDate` | string | Creation date (ISO 8601) |
| `updatedDate` | string | Last updated date (ISO 8601) |
| `expiresDate` | string | Expiry date (ISO 8601) |
| `domainAgeDays` | integer | Days since domain was created |
| `expiresInDays` | integer | Days until domain expires |
| `registrant` | string | Registrant name |
| `registrantOrg` | string | Registrant organization |
| `registrantCountry` | string | Registrant country code |
| `adminContact` | string | Administrative contact name |
| `techContact` | string | Technical contact name |
| `nameServers` | array | Authoritative name servers |
| `status` | array | EPP status codes |
| `dnssec` | string | "signed" or "unsigned" |
| `whoisServer` | string | WHOIS server that provided the data |
| `lookupStatus` | string | "OK", "No WHOIS data", "TLD not supported", "No registration data", or "Lookup failed" |
| `checkedAt` | string | Timestamp of the lookup (ISO 8601) |
| `durationMs` | integer | Lookup duration in milliseconds |

### Integrations

WHOIS Lookup works with any tool that can call Apify Actors:

- **Clay** — Enrich prospect domains with registration age and registrant data
- **Make** — Automate domain monitoring and expiry tracking workflows
- **Zapier** — Trigger actions based on domain expiry dates
- **n8n** — Build custom domain intelligence pipelines

You can also use webhooks to trigger actions when a run completes.

### Using WHOIS Lookup with the Apify API

The Apify API gives you programmatic access to run Actors, retrieve results, and manage datasets.

**Node.js:**

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

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

const run = await client.actor('superlativetech/whois-lookup').call({
  domains: ['google.com', 'github.com'],
});

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

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('superlativetech/whois-lookup').call(run_input={
    'domains': ['google.com', 'github.com']
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

Check out the [Apify API reference](https://docs.apify.com/api) for full details, or click the **API** tab above for more code examples.

### Your feedback

We're always improving our Actors. If you have feature requests, find a bug, or need help with a specific use case, please [open an issue](https://console.apify.com/actors/rxJ7oulKr4S7NvnfT/issues) in the Actor's Issues tab.

When Apify asks to share your run data with us, we encourage you to opt in — it's the fastest way for us to spot edge cases and improve results. Sharing is completely optional (you can toggle it anytime under [Account Settings → Privacy](https://console.apify.com/account#/privacy)), and shared runs are automatically deleted by Apify based on your plan's data retention period. We only use shared data to debug issues and improve this Actor.

### Leave a review

If WHOIS Lookup helps with your workflows, please [leave a review](https://console.apify.com/actors/rxJ7oulKr4S7NvnfT). Your feedback helps other users discover the tool and helps us understand what's working well.

***

### More from Superlative

- **[DNS Lookup](https://apify.com/superlativetech/dns-lookup?fpr=8e9l1)** — DNS records: A, AAAA, MX, CNAME, TXT, NS, SOA, DMARC, and reverse lookups
- **[HTTP API](https://apify.com/superlativetech/http-api?fpr=8e9l1)** — General-purpose HTTP request utility

Built by Superlative

# Actor input Schema

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

List of domains to look up (e.g., \['google.com', 'github.com']). No limit — scales as needed on Apify.

## `domain` (type: `string`):

Single domain to look up — shorthand for API/integration callers. If both 'domain' and 'domains' are provided, 'domain' is prepended to the list.

## Actor input object example

```json
{
  "domains": [
    "google.com"
  ]
}
```

# Actor output Schema

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

No description

# 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": [
        "google.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("superlativetech/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": ["google.com"] }

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

```

## MCP server setup

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