# Bulk WHOIS & RDAP Domain Lookup — Age, Expiry, Registrar, DNS (`probelane/bulk-domain-whois-rdap`) Actor

Bulk WHOIS lookup for thousands of domains via official RDAP + WHOIS. Get registrar, creation & expiry date, domain age, days to expiry, status, name servers, DNSSEC, MX/A records and availability. No API key, GDPR-safe.

- **URL**: https://apify.com/probelane/bulk-domain-whois-rdap.md
- **Developed by:** [Probelane](https://apify.com/probelane) (community)
- **Stats:** 2 total users, 1 monthly users, 100.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. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Bulk WHOIS & RDAP Domain Lookup — Age, Expiry, Registrar, DNS

**Look up WHOIS data for thousands of domains in one run.** Paste a list of domains, URLs or email addresses and get back the registrar, creation date, expiry date, domain age, days until expiry, EPP status codes, transfer lock, name servers, DNSSEC, abuse contact, availability, MX/A records, and the DNS and email provider. Results download as JSON, CSV or Excel, or you can call the Actor through the API.

This bulk WHOIS checker uses **RDAP**, the official structured replacement for WHOIS that ICANN now requires. For ccTLDs that still have no RDAP server (such as .io, .co.za, .de and .si), it falls back automatically to the registry's official port-43 WHOIS server. It doesn't scrape any websites or need an API key, and it **never outputs personal registrant data**.

### What can this WHOIS lookup tool do?

- ✅ **Bulk WHOIS / RDAP lookup.** Process hundreds of thousands of domains in parallel.
- ✅ **Domain age checker.** Get creation date, `domainAgeDays` and `domainAgeYears`.
- ✅ **Domain expiry checker.** Get expiry date and `daysUntilExpiry`, with an "Expiry watch" view for renewals, drop-catching and portfolio audits.
- ✅ **Registrar lookup.** Get registrar name, IANA ID and abuse email/phone.
- ✅ **Domain availability checker.** Each domain is flagged `registered`, `likely_available` or `unknown`.
- ✅ **DNS records.** Get A, AAAA, MX and NS records, SPF/DMARC presence, and optionally all TXT records.
- ✅ **Provider detection.** Identifies DNS hosts (Cloudflare, Route 53, GoDaddy, …), email providers (Google Workspace, Microsoft 365, Proofpoint, …), and parked or for-sale domains (Sedo, Afternic, Bodis, …).
- ✅ **Flexible input.** Accepts URLs and emails: `https://www.bbc.co.uk/news` → `bbc.co.uk`, `jane@mail.google.com` → `google.com`.
- ✅ **Works on any TLD.** Covers .com, .net, .org, every new gTLD, and ccTLDs including .uk, .io, .co.za, .de, .si, .us and more.

### Who uses it?

- **Sales prospecting and lead generation.** Enrich a lead list with domain age (an established-business signal), email provider (Google Workspace vs Microsoft 365) and DNS host before outreach; drop parked and dead domains.
- **Agencies.** Run a domain and DNS audit for every client or prospect in one go, then schedule it to catch renewals.
- **Domain research.** Check availability, expiry dates and registrars across thousands of names for investing, brand protection or drop-catching.
- **Domain investors.** Audit a portfolio, find expiring names and spot parked domains.
- **Sales and lead-gen teams.** Enrich company lists with domain age (a trust signal), email provider and DNS host.
- **Security and fraud teams.** Flag newly registered domains, check registrars and get abuse contacts for phishing reports.
- **SEO agencies.** Check domain age and expiry before buying expired domains or backlinks.
- **IT and MSPs.** Inventory client domains, catch renewals before they lapse, and check DNSSEC and transfer locks.

### Pricing: pay per result, nothing else

This Actor uses Apify **pay-per-event** pricing, so the price is simple and predictable:

| You pay | When |
|---|---|
| **$0.002 per domain** ($2 per 1,000) | Once for each domain that returns a result (event `domain-checked`). Every charged row in the dataset has `"charged": true`. |
| $0.00005 per run | Apify's standard Actor-start fee. |
| **$0** | Invalid inputs (typos, public suffixes like `gov.za`), domains where neither RDAP nor WHOIS answered (`status: partial`, DNS data only) and unexpected errors. A domain that turns out to be unregistered (`availability: likely_available`) is a real answer and is charged. |

There are **no platform-usage fees on top** of the event price: compute, storage and traffic are included.

| Run size | Cost |
|---|---|
| 100 domains | $0.20 |
| 1,000 domains | $2.00 |
| 10,000 domains | $20.00 |
| 100,000 domains | $200.00 |

**Control your spend.** Set **Max cost per run** (Run options → "Maximum cost per run", or `maxTotalChargeUsd` in the API). The Actor checks your remaining budget before every domain, stops cleanly when the limit is reached and never charges beyond it. The status message tells you how many domains were left unprocessed.

**Try it free.** Apify's free plan includes $5 of monthly credit, enough for about 2,500 domains.

### Input

```json
{
  "domains": ["apify.com", "https://www.github.com/features", "jane@bbc.co.uk", "takealot.co.za"],
  "includeDns": true,
  "whoisFallback": true,
  "maxConcurrency": 10
}
```

| Field | Description |
|---|---|
| `domains` | List of domains, URLs or emails. These are de-duplicated and reduced to the registrable domain. |
| `domainsText` | Bulk paste a list separated by new lines, commas or spaces. |
| `includeDns` | A/AAAA/MX/NS records, SPF/DMARC flags, provider detection and parked flag (default on). |
| `includeTxtRecords` | Adds all TXT records. |
| `whoisFallback` | Uses port-43 WHOIS for TLDs without RDAP (default on). |
| `includeRawRdap` | Attaches the full registry RDAP JSON. |
| `maxConcurrency` | Number of parallel lookups (default 10). |

### Output example

```json
{
  "domain": "takealot.co.za",
  "availability": "registered",
  "dataSource": "whois:whois.registry.net.za",
  "registrar": "CSC Corporate Domains Inc",
  "registrarIanaId": "299",
  "createdDate": "2011-06-01T17:03:29Z",
  "expiryDate": "2027-06-01T17:03:29Z",
  "domainAgeYears": 15.3,
  "daysUntilExpiry": 237,
  "statuses": ["ok"],
  "transferLocked": false,
  "nameServers": ["gordon.ns.cloudflare.com", "lia.ns.cloudflare.com"],
  "dnssec": false,
  "abuseEmail": "tldsupport@cscglobal.com",
  "registrantCountry": "ZA",
  "mxRecords": [{"priority": 1, "host": "aspmx.l.google.com"}],
  "hasSpf": true,
  "hasDmarc": true,
  "dnsProvider": "Cloudflare",
  "mailProvider": "Google Workspace",
  "parked": false,
  "status": "ok",
  "charged": true
}
```

The Console shows two table views: **Overview** and **Expiry watch**.

### FAQ

**Is WHOIS lookup legal?** Yes. RDAP and WHOIS are public registry services designed for this purpose. The Actor only returns registration metadata and drops personal registrant details, which registries redact under GDPR anyway.

**Why use RDAP instead of WHOIS?** RDAP returns standardised JSON, so dates and statuses are reliable across registries. Plain WHOIS text differs from one registry to the next. Since 2025, ICANN has required gTLD registries to support RDAP.

**Why is the registrar empty for some ccTLDs?** Some registries, such as DENIC (.de), publish almost nothing through public WHOIS. You still get registered/available status and DNS data.

**How accurate is "likely_available"?** It means the authoritative registry returned *not found*. Premium, reserved or blocked names can still be unavailable to register, so always confirm with your registrar.

**Can I schedule it?** Yes. Use Apify Schedules to re-check a portfolio weekly and send changes to Google Sheets, Slack or a webhook.

**What is the `charged` field?** It is `true` on every row you paid for, so you can reconcile your bill with the dataset. Invalid and failed rows are delivered too (with an `error` message) but are free.

**Can AI agents use it?** Yes. It runs with limited permissions and per-result pricing, so it works through the Apify API, the Apify MCP server and other AI-agent integrations.

**Rate limits?** The Actor respects registry limits with retries and per-server throttling. Keep `maxConcurrency` at 10–20 for very large lists.

### Related Actors by the same publisher

- ⭐ **[Security & Website Pain Prospect Finder](https://apify.com/probelane/security-prospect-finder):** selling to SMBs? It runs this check *plus* DMARC spoofing, SSL, outdated WordPress/PHP, downtime and domain expiry, then ranks companies by opportunity score (0–100) with evidence and a ready cold-open line. Built for MSPs, security consultants and web agencies.
- **[Bulk DMARC, SPF & DKIM Checker](https://apify.com/probelane/email-domain-security-auditor):** audits email-domain security with a grade and fixes.
- **[Bulk Website Tech Stack, SSL Expiry & Security Headers Checker](https://apify.com/probelane/website-tech-stack-health):** shows the tech stack, uptime, SSL and headers grade for each site.

*Keywords: bulk whois lookup, whois api, rdap lookup, domain age checker, domain expiry checker, registrar lookup, domain availability checker, bulk domain checker, domain research, lead generation, sales prospecting, lead enrichment, email provider lookup, dns lookup, agencies, domain intelligence.*

# Actor input Schema

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

Domains to look up. You can paste bare domains (example.com), full URLs (https://www.example.com/page) or email addresses (jane@example.com) — each is reduced to its registrable domain and de-duplicated.

## `domainsText` (type: `string`):

Optional: paste a large list separated by new lines, commas or spaces.

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

Adds A, AAAA, MX, NS records, SPF/DMARC presence, DNS and email provider detection, and a parked-domain flag.

## `includeTxtRecords` (type: `boolean`):

Adds all TXT records (verification tokens, SPF, etc.) to each row.

## `whoisFallback` (type: `boolean`):

Some ccTLDs (.io, .co.za, .de …) have no RDAP server. When on, the Actor falls back to the official port-43 WHOIS server for that TLD.

## `includeRawRdap` (type: `boolean`):

Attach the full registry RDAP response to each row (bigger dataset).

## `maxConcurrency` (type: `integer`):

Parallel lookups. Registries rate-limit aggressive clients; 10 is a safe default.

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

Optional cap on how many domains to process (0 = no cap).

## `dnsServers` (type: `array`):

Optional list of resolver IPs, e.g. \["1.1.1.1", "8.8.8.8"]. Leave empty to use the platform default.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "github.com",
    "bbc.co.uk",
    "takealot.co.za"
  ],
  "includeDns": true,
  "includeTxtRecords": false,
  "whoisFallback": true,
  "includeRawRdap": false,
  "maxConcurrency": 10,
  "maxItems": 0
}
```

# Actor output Schema

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

All results in the 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": [
        "apify.com",
        "github.com",
        "bbc.co.uk",
        "takealot.co.za"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("probelane/bulk-domain-whois-rdap").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",
        "github.com",
        "bbc.co.uk",
        "takealot.co.za",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("probelane/bulk-domain-whois-rdap").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",
    "github.com",
    "bbc.co.uk",
    "takealot.co.za"
  ]
}' |
apify call probelane/bulk-domain-whois-rdap --silent --output-dataset

```

## MCP server setup

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

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/J3RZKpB9jn3gyy6lb/builds/qbNIaPRwCvog3RGDa/openapi.json