# WHOIS & Domain Availability MCP Server (RDAP) (`wintersworks/domain-whois-mcp-server`) Actor

MCP server (Streamable HTTP, Standby mode) for AI agents: WHOIS-style domain lookup, expiry dates, nameservers and availability checks via official RDAP. $2.00 per 1,000 domains.

- **URL**: https://apify.com/wintersworks/domain-whois-mcp-server.md
- **Developed by:** [Winters Works](https://apify.com/wintersworks) (community)
- **Categories:** AI, Developer tools, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 domain looked ups

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Availability MCP Server (RDAP)

An MCP (Model Context Protocol) server that gives AI agents and MCP clients such as Claude Desktop and Cursor live **WHOIS-style domain data**: registrar, creation / expiry / last-updated dates, days until expiry, nameservers, DNSSEC, status codes, abuse contact, and whether a domain is **likely available to register**. Data comes from the official **RDAP** registries through the IANA bootstrap, not scraped WHOIS sites.

MCP is an open standard that lets AI assistants call external tools. This Actor runs in Apify **Standby mode**, so it answers tool calls over HTTP within moments and you pay only per domain looked up.

### Connect

**Easiest: through Apify's hosted MCP server, no token to paste.** Add this URL as a remote MCP server (custom connector) in your client. It signs you in to Apify with OAuth and exposes the same three tools:

```
https://mcp.apify.com?actors=wintersworks/domain-whois-mcp-server
```

**Direct endpoint** (Streamable HTTP, stateless), if you prefer a Bearer token:

```
https://wintersworks--domain-whois-mcp-server.apify.actor/mcp
```

Authenticate with your Apify API token as a Bearer header: `Authorization: Bearer <YOUR_APIFY_TOKEN>`.

**Claude Desktop / Cursor / most MCP clients** (`mcpServers` config, using the `mcp-remote` bridge for clients without native HTTP support):

```json
{
  "mcpServers": {
    "domain-whois": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://wintersworks--domain-whois-mcp-server.apify.actor/mcp",
               "--header", "Authorization: Bearer <YOUR_APIFY_TOKEN>"]
    }
  }
}
```

Clients with native Streamable HTTP support (Cursor, Claude Code and others) can use the URL plus the `Authorization` header directly, for example `claude mcp add --transport http domain-whois https://wintersworks--domain-whois-mcp-server.apify.actor/mcp --header "Authorization: Bearer <YOUR_APIFY_TOKEN>"`.

### Tools

- **`lookup_domain`** `{ domain, checkDns? }` returns the full record for one domain: registrar, createdDate, expiryDate, updatedDate, daysUntilExpiry, nameservers, dnssec, statusCodes, registrantOrg, registrantCountry, abuseEmail, available, status.
- **`lookup_domains`** `{ domains[], checkDns? }` the same for up to 50 domains in one call.
- **`check_availability`** `{ domains[] }` returns `[{ domain, available, status }]` for up to 50 domains.

Inputs can be plain domains or URLs (`https://www.shop.example.co.uk/page` becomes `example.co.uk`). With `checkDns` you also get `hasA`, `hasMx`, `mxRecords`, `dnsNameservers`, `hasSpf`. Results come back as JSON text and as structured content.

Example `lookup_domain` result (shortened):

```json
{ "domain": "apify.com", "status": "registered", "available": false, "registrar": "Amazon Registrar, Inc.",
  "expiryDate": "2035-06-02T17:14:10Z", "daysUntilExpiry": 3156, "dnssec": true, "rdapServer": "https://rdap.verisign.com" }
```

### Pricing

Pay per event: **$0.002 per domain looked up** ($2.00 per 1,000). Failed lookups (registry unreachable, unsupported TLD) are free, and duplicates inside one call are only counted once. If the run's spending limit is reached, the tool result says so and no further lookups are made.

### Use cases

- Let an assistant check whether a batch of brand or name ideas is free to register.
- Domain expiry monitoring inside an agent workflow.
- Due diligence and lead enrichment: registrar, domain age, nameserver and hosting hints.

### Normal (non-Standby) runs

If you start the Actor as a regular run instead, it looks up the `domains` from the input (default `example.com`), stores one record per domain in the dataset, and exits. This is handy for testing; the main use is Standby mode.

### Limitations

- Data comes from registry RDAP servers listed in the IANA bootstrap (`data.iana.org/rdap/dns.json`). Some ccTLDs have no RDAP service and return an error (not charged).
- Registrant personal details are mostly redacted under GDPR and come back null. Registrant organization, country and abuse email appear only if the registry publishes them.
- "Available" means the registry answered 404 (not registered). It can still be reserved, premium or restricted, so confirm with a registrar.
- Requests to each RDAP server are paced (300 ms), retried with backoff on 429/5xx, and time out after 20 s. Public RDAP servers can still rate-limit large batches.

### FAQ

**Is this legal?** It queries the official, public RDAP service that registries run for this purpose, not WHOIS websites or port 43. It only returns data the registry publishes, and redacted fields stay null. Use the results in line with data-protection and anti-spam law. You are responsible for how you use them.

**Why is the registrant empty?** Since GDPR most registries and registrars redact personal registrant data. The server returns `null` rather than guessing.

**Which TLDs work?** Every TLD in the IANA RDAP bootstrap (about 1,200).

**Do you store my queries?** The server keeps no session state between calls. Normal Apify run logs apply.

### About

Made by Winters Works. Also see our Bulk WHOIS Lookup & Domain Expiry Checker Actor for large batch exports to CSV or Excel.

# Actor input Schema

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

Domains to look up in a regular run. Ignored when the Actor runs as an MCP server in Standby mode.

## `checkDns` (type: `boolean`):

Normal runs only: add A, MX, NS and SPF info.

## Actor input object example

```json
{
  "domains": [
    "example.com"
  ],
  "checkDns": false
}
```

# Actor output Schema

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

All result items from the run's default dataset.

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

// Run the Actor and wait for it to finish
const run = await client.actor("wintersworks/domain-whois-mcp-server").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": ["example.com"] }

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

```

## MCP server setup

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

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/6iwHgGkwm7AmsbFvq/builds/bazqzPSiF8AR70ctr/openapi.json