# WHOIS & DNS Enrichment (`cynix_dev/whois-enrichment`) Actor

Enrich domains with structured WHOIS data (registrar, registration/expiration dates, status, nameservers) and optional DNS records (A, AAAA, MX, NS, TXT) via free public RDAP and DNS-over-HTTPS. No API key required. Great for lead enrichment, domain due-diligence, and security triage.

- **URL**: https://apify.com/cynix\_dev/whois-enrichment.md
- **Developed by:** [Cynix Dev](https://apify.com/cynix_dev) (community)
- **Categories:** Automation, SEO tools, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.17 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## 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 & DNS Enrichment

Enrich a list of domains with **structured WHOIS/RDAP data** — registrar, registration and expiry dates, status flags and nameservers — plus optional **DNS records** (A, AAAA, MX, NS, TXT). No API key, no per-lookup subscription.

### What it does

Paste a list of domains and get one clean record per domain. The Actor queries **RDAP** (the modern, structured successor to text WHOIS) via the public `rdap.org` bootstrap service, so you get parsed fields instead of registrar-specific free text you have to regex your way through.

Turn on `includeDns` and each record is additionally resolved over **DNS-over-HTTPS**, adding A/AAAA/MX/NS/TXT answers — enough to tell at a glance who hosts the domain, who handles its mail, and which verification records are present.

### Features

- **Bulk input** — pass hundreds of domains in one run via a simple list field.
- **Structured RDAP fields** — registrar, `registrationDate`, `expirationDate`, `lastChanged`, status, nameservers.
- **Optional DNS enrichment** — A, AAAA, MX, NS and TXT records over DNS-over-HTTPS.
- **No API key and no third-party WHOIS subscription** — public RDAP and DoH endpoints only.
- **No proxy needed** — the endpoints are public APIs, so proxy is off by default and runs stay cheap.
- **Predictable, flat output** — ideal for spreadsheets, CRM enrichment and SQL loads.

### What people use it for

- Lead enrichment — attach domain age and registrar to inbound signups to gauge legitimacy.
- Security triage — check a suspicious domain's registration date and mail setup in seconds.
- Domain portfolio management — monitor expiry dates across every domain you own.
- M\&A and due diligence — verify who really controls a company's web assets.
- SEO and competitive research — see how long a competitor's domain has existed and where it's hosted.

### Why RDAP instead of classic WHOIS

Legacy WHOIS returns free-form text that differs per registry, so parsing it reliably is a permanent maintenance tax. RDAP is the IETF-standard JSON replacement mandated by ICANN, which is why this Actor uses it: fields arrive already typed and named.

Two consequences worth knowing:

- **Redaction is normal.** Since GDPR, registrant names, emails and addresses are redacted for most gTLDs, especially for individuals. Registrar, dates, status and nameservers remain available.
- **Coverage varies by TLD.** Nearly all gTLDs (`.com`, `.net`, `.org`, `.io`, …) have RDAP. Some ccTLDs still don't, and those domains return sparse records.

#### DNS enrichment

`includeDns` adds one DNS-over-HTTPS lookup per record type per domain. It roughly multiplies the work per domain, so leave it off for very large lists unless you need the hosting and mail picture.

### Input

Only `domains` is required. Add bare domains (`example.com`) — strip `https://` and any path.

| Field | Type | Default | What it does |
| --- | --- | --- | --- |
| `domains` **(required)** | array | `[]` | List of domains to enrich, e.g. \["google.com", "openai.com"]. |
| `includeDns` | boolean | `false` | Also resolve A/AAAA/MX/NS/TXT records via DNS-over-HTTPS (extra calls per domain). |
| `proxyConfiguration` | object | see below | RDAP and DNS-over-HTTPS are public and do not require a proxy. Leave disabled. |

#### Input example

```json
{
  "domains": [
    "google.com",
    "openai.com"
  ],
  "includeDns": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

### Output

One record per domain. `nameservers` is a delimited string of the authoritative nameservers; `dns` is populated only when `includeDns` is enabled.

Every dataset record contains: `domain`, `status`, `registrar`, `registrationDate`, `expirationDate`, `lastChanged`, `nameservers`, `dns`, `fetchedAt`.

#### Output example

A real record from a run of this Actor:

```json
{
  "domain": "google.com",
  "status": "client delete prohibited; client transfer prohibited; client update prohibited; server delete prohibited; server transfer prohibited; server update prohibited",
  "registrar": "MarkMonitor Inc.",
  "registrationDate": "1997-09-15T04:00:00Z",
  "expirationDate": "2028-09-14T04:00:00Z",
  "lastChanged": "2019-09-09T15:39:04Z",
  "nameservers": "NS1.GOOGLE.COM; NS2.GOOGLE.COM; NS3.GOOGLE.COM; NS4.GOOGLE.COM",
  "dns": "",
  "fetchedAt": "2026-08-21T13:15:11.214Z"
}
```

Export the dataset as JSON, CSV, Excel, XML or JSONL from the Console, or pull it programmatically through the Apify API and any of the official clients.

### How to use it

1. Click **Try for free** (or **Start** if you already have an Apify account).
2. Fill in the input fields described above — the defaults already produce a working run.
3. Press **Start** and watch the log; results stream into the dataset as they are found.
4. When the run finishes, open the **Output/Storage** tab and export as JSON, CSV or Excel.

Runs can be scheduled (hourly, daily, weekly) and wired into Slack, Google Sheets, Zapier, Make, webhooks or your own backend through Apify integrations. Everything the Console does is also available over the [Apify API](https://docs.apify.com/api/v2).

### Proxy configuration

This Actor accepts a standard Apify **proxy configuration** object. Residential proxy is the default because the target site rate-limits datacenter IP ranges; you can select a specific exit country or supply your own proxy URLs.

```json
{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

### Pricing

This Actor is billed on Apify's **pay-per-event** model: a small charge when a run starts, plus a charge for each result written to the dataset. You only pay for records you actually receive — a run that finds nothing costs only the start event. Current rates are always shown on the **Pricing** tab of this page, and the run log prints your usage as it goes.

Free-plan credits from Apify cover a large amount of light usage, so you can evaluate the Actor before committing to anything.

### FAQ

#### Do I need a WHOIS API key or paid plan?

No. The Actor uses the public RDAP bootstrap service and public DNS-over-HTTPS resolvers, so there is nothing to sign up for.

#### Why is the registrant's name missing?

GDPR-driven redaction. Registries and registrars now withhold personal registrant details for most domains. Registrar, dates, status flags and nameservers are still returned.

#### What do the status flags mean?

They are EPP status codes such as `clientTransferProhibited` (a transfer lock, common on valuable domains) or `pendingDelete`. They tell you how locked down and how healthy a registration is.

#### Can I check thousands of domains?

Yes — pass them all in `domains`. Keep `includeDns` off for very large batches, and be aware that public RDAP endpoints rate-limit, so extremely large runs are best split into several scheduled batches.

#### Should I enable the proxy?

No. RDAP and DoH are public APIs that don't block datacenter IPs, so the proxy is disabled by default and enabling it only adds cost.

### Other Actors by cynix\_dev

| Actor | What it does |
| --- | --- |
| [Company Tech Stack & Hiring Intelligence](https://apify.com/cynix_dev/company-tech-intel) | Detect technologies from company websites, extract tech requirements from job postings, discover competitors. |
| [Job Postings — ATS Boards Extractor](https://apify.com/cynix_dev/job-postings-ats) | Pull live job postings straight from companies' public applicant-tracking boards — Greenhouse, Lever, Ashby, SmartRecruiters, and … |
| [SEC EDGAR Filings Extractor](https://apify.com/cynix_dev/sec-edgar-filings) | Search and extract SEC EDGAR filings: full-text search across all filings or company filing histories by CIK. |
| [News & Press Release Monitor](https://apify.com/cynix_dev/news-press-monitor) | Watch company newsrooms, blogs, and press pages and get one clean record per article — with new-item detection between runs, so a … |
| [Website to RAG Chunks](https://apify.com/cynix_dev/web-to-rag-chunks) | Crawl any website and turn its pages into clean, chunked, metadata-rich Markdown records ready for RAG pipelines, vector stores, … |
| [Dataset Drift & QA Monitor](https://apify.com/cynix_dev/dataset-drift-qa) | Stop finding out your scrapers broke three days late. Point this actor at any Apify dataset or JSON endpoint and it watches the … |
| [Page Change Monitor](https://apify.com/cynix_dev/page-change-monitor) | Monitor web pages for content changes. Diffs each run against the previous snapshot and emits structured change records with … |
| [OpenStreetMap Geocoder](https://apify.com/cynix_dev/osm-geocoder) | Forward and reverse geocoding via the free Komoot Photon / OpenStreetMap service. No API key, no scraping, ODbL data. |

### Legal and responsible use

This Actor collects only publicly available information. You are responsible for how you use the data, including compliance with the target site's Terms of Service, robots directives, copyright, and data protection law such as GDPR and CCPA. Do not use it to gather personal data without a lawful basis.

### Support and feedback

Found a bug, hit a site change, or need an extra field? Open a ticket on the **Issues** tab of this Actor — issues are read and fixed. Feature requests and custom-scraper enquiries are welcome through the same channel.

# Actor input Schema

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

List of domains to enrich, e.g. \["google.com", "openai.com"].

## `includeDns` (type: `boolean`):

Also resolve A/AAAA/MX/NS/TXT records via DNS-over-HTTPS (extra calls per domain).

## `proxyConfiguration` (type: `object`):

RDAP and DNS-over-HTTPS are public and do not require a proxy. Leave disabled.

## Actor input object example

```json
{
  "domains": [],
  "includeDns": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Queried domain.

## `status` (type: `string`):

Semicolon-separated EPP status codes.

## `registrar` (type: `string`):

Registrar name.

## `registrationDate` (type: `string`):

Registration date.

## `expirationDate` (type: `string`):

Expiration date.

## `lastChanged` (type: `string`):

Last-update date.

## `nameservers` (type: `string`):

Semicolon-separated nameservers.

## `dns` (type: `string`):

JSON object of DNS records (when includeDns is true).

## `fetchedAt` (type: `string`):

ISO timestamp of retrieval.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("cynix_dev/whois-enrichment").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("cynix_dev/whois-enrichment").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 '{}' |
apify call cynix_dev/whois-enrichment --silent --output-dataset

```

## MCP server setup

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

```

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/k7OUHfMbbzMlnulkU/builds/TtdWMKeGAh1piiFQX/openapi.json