# Bulk WHOIS & Domain Lookup: Availability, Expiry, DNS (RDAP) (`stazis/domain-rdap-api`) Actor

Bulk domain lookup from official RDAP registries: registered/available/unknown, registrar, created and expiry dates, days to expiry, nameservers, DNSSEC, DNS records. Names x TLDs input and an expiring-within-days filter.

- **URL**: https://apify.com/stazis/domain-rdap-api.md
- **Developed by:** [Stanislav](https://apify.com/stazis) (community)
- **Categories:** Developer tools, SEO tools, Lead generation
- **Security:** Limited permissions
- **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 results

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 & Domain Availability Checker (RDAP): Expiry, DNS

Look up **thousands of domains** at once from the **official RDAP registries** (the modern WHOIS): availability, registrar, created/updated/**expiry dates**, days until expiry, status, nameservers, DNSSEC and live DNS records. Give a list of domains, or **names × TLDs** to find which brand names are free.

- **Who it's for:** domain investors and brand teams, security and fraud analysts, agencies managing client domains, lead enrichment.
- **Source:** IANA RDAP bootstrap and each registry's RDAP server, plus DNS. No API key, no login; personal registrant data is not returned.
- **Trustworthy availability:** `available` only when the registry itself answers "not found"; anything doubtful is `unknown` with a note.
- **Output:** JSON, CSV or Excel; pay per domain returned (see the Pricing tab).

### Quick start (one click)

Open the Actor and press **Start**: the form is prefilled with this input.

```json
{
  "domains": [
    "apify.com",
    "example.org",
    "bbc.co.uk"
  ]
}
```

Sample output (one row, more fields in the dataset):

| domain | registered | registrar | registrarIanaId | createdAt |
|---|---|---|---|---|
| github.com | true | MarkMonitor Inc. | 292 | 2007-10-09T18:20:50Z |

### Use cases

**Brainstorm names across TLDs.** Every name in every TLD, with availability.

```json
{"names": ["acmerobotics", "acmebots"], "tlds": ["com", "io", "ai", "co"], "includeDns": false}
```

**Portfolio expiry monitoring.** Your domains expiring within 60 days; schedule weekly.

```json
{"domains": ["example.com", "example.org"], "expiringWithinDays": 60}
```

**Lead enrichment from DNS.** Registrar, nameservers and mail provider (MX) for a list of company domains.

```json
{"domains": ["apify.com", "bbc.co.uk"], "includeDns": true, "dnsRecordTypes": ["MX", "NS"]}
```

**Brand-protection triage.** Which lookalike domains are registered, and by which registrar.

```json
{"names": ["examp1e", "exampel"], "tlds": ["com", "net", "org"]}
```

### How it compares

Checked against the most-used domain / WHOIS lookup actors in the Apify Store (their Store pages, input forms, reviews and Issues tabs, 23 Oct 2026). Alternatives are described generically; every claim about them is visible on their public pages.

| | This actor | Common in the alternatives |
|---|---|---|
| "Available" verdict | `availability` is `available` **only** when the authoritative RDAP registry answers "not found"; otherwise `registered` or `unknown` with an `availabilityNote` | An open issue on one alternative reports domains shown as available that were not (missing DNS was treated as available) |
| Bulk input | List of domains, or `names` × `tlds` (e.g. 50 names × 6 TLDs = 300 checks in one run) | Usually a plain domain list; one offers names × TLDs |
| Expiring domains | `expiresInDays` on every row + `expiringWithinDays` filter (rows outside the window are not returned and not charged) | Rare |
| Plan gating | No free-plan or batch-size gate: 1,000+ domains run the same way on any Apify plan | An open issue on the most-used alternative: a 1,000-domain run refused, saying the user was on a free plan |
| Extras | DNS records (A, AAAA, MX, NS, TXT...), registrar, created/updated/expiry dates, DNSSEC, nameservers | Varies |
| Price | $2 per 1,000 domains + $0.005 per run (see the Pricing tab) | From free to about $10 per 1,000 plus start fees |
| Not included | Registrant names/emails (redacted by registries; we don't return personal data) | Same |

#### Ready-to-copy inputs

Find which brand names are free across six TLDs:

```json
{"names": ["acmerobotics", "acme-robotics"], "tlds": ["com", "net", "org", "io", "co", "ai"]}
```

Domains in your list that expire within 60 days:

```json
{"domains": ["example.com", "example.net", "example.org"], "expiringWithinDays": 60}
```

### Features and details of this WHOIS domain lookup API

Bulk-check domains using **RDAP**, the official ICANN successor of WHOIS, routed through the **IANA RDAP bootstrap** to each registry's own server, plus live **DNS records** via DNS-over-HTTPS. No API key, no proxies, no scraping of WHOIS websites.

#### What you get per domain

| field | example |
|---|---|
| domain, unicodeName | `github.com` |
| registered | `true` / `false` (RDAP 404) / `null` (unknown) |
| registrar, registrarIanaId, registrarUrl | `MarkMonitor Inc.`, `292` |
| status | `["client delete prohibited", ...]` |
| createdAt, updatedAt, expiresAt | ISO 8601 |
| nameservers | `["dns1.p08.nsone.net", ...]` |
| dnssec | `true/false` |
| dns | `{"A":[...],"AAAA":[...],"MX":[...],"NS":[...],"TXT":[...]}` |
| days_until_expiry | `137` (whole days to `expiresAt`; negative if expired; `null` when the registry publishes no expiry) |
| expiring_soon | `true` if expiring within `expiringSoonDays` (default 30) or already expired, else `false`; `null` without an expiry date |
| registrar_abuse_email | `abusecomplaints@markmonitor.com`: the registrar's abuse desk, only when RDAP lists it and the address is an abuse role address; otherwise `null` |
| rdapServer, registrarRdapUrl, registeredSource, error, checkedAt | provenance |

#### Privacy by design

Only registry/technical data is returned. **All registrant, administrative, technical, billing and abuse contacts, vCards and remarks are dropped** before output; only the registrar's (company) name and IANA id are kept. The one exception is `registrar_abuse_email`: the registrar's own abuse desk, returned only if its local part contains "abuse" (e.g. `abuse@`, `abusecomplaints@`); any other address, such as a named person's, is returned as `null`. No personal data is stored.

#### Coverage & limits

All gTLDs (.com, .net, .org, .dev, .app, .xyz, .ai ...) and ccTLDs that publish RDAP (.uk, .fr, ...). Some ccTLDs (.de, .ru, .eu, .io) have no RDAP in the IANA bootstrap: you still get DNS records and `registered` inferred from NS (`registeredSource: "dns"`), with `error: tld_not_in_rdap_bootstrap`.
**Input `expiringSoonDays`** (optional, default 30) sets the `expiring_soon` flag only; it does not drop rows. To return only expiring domains, use `expiringWithinDays`.
Each RDAP server is rate-limited separately (default 1 request/s per server), `Retry-After` and 429/5xx are honored with exponential backoff.

#### Pricing

Pay per result: one charge per domain returned, plus a small per-run start fee. You can cap spend with "Max charge per run".

### How to use the WHOIS domain lookup API

1. Open the Actor, fill in the input form (or paste the JSON below).
2. Click **Start**. Results land in the dataset as JSON, CSV, Excel or via the Apify API.
3. For alerts or regular refreshes, add an Apify **Schedule**. You can cap spend with "Max charge per run".

### Input example

```json
{
  "domains": [
    "apify.com",
    "https://www.bbc.co.uk/news",
    "nic.ai"
  ],
  "includeDns": true,
  "dnsRecordTypes": [
    "A",
    "MX",
    "NS",
    "TXT"
  ],
  "maxResults": 1000
}
```

### Output example

```json
{
  "domain": "github.com",
  "registered": true,
  "registrar": "MarkMonitor Inc.",
  "registrarIanaId": "292",
  "status": [
    "client delete prohibited"
  ],
  "createdAt": "2007-10-09T18:20:50Z",
  "expiresAt": "2026-10-09T18:20:50Z",
  "nameservers": [
    "dns1.p08.nsone.net"
  ],
  "dnssec": false,
  "days_until_expiry": 137,
  "expiring_soon": false,
  "registrar_abuse_email": "abusecomplaints@markmonitor.com",
  "dns": {
    "MX": [
      "..."
    ]
  }
}
```

Values above are illustrative; field names match the dataset schema.

### FAQ

#### Is RDAP the same as WHOIS?

RDAP is ICANN's official replacement for WHOIS. It returns structured JSON from each registry instead of free-text WHOIS output.

#### Do you return registrant names or emails?

No. All registrant, admin, tech and billing contacts are dropped. Only the registrar company, its abuse-desk role address (`registrar_abuse_email`, abuse@-style only) and technical data remain.

#### Which TLDs are covered?

All gTLDs and ccTLDs that publish RDAP. Some ccTLDs (.de, .ru, .eu, .io) have no RDAP; for them you get DNS records and an inferred registered flag with an error note.

#### How much does it cost?

$2 per 1,000 domains plus $0.005 per run.

#### Are there limits I should know about?

Yes. Results are only as complete and current as the official source. If a source is down, the run logs the error instead of returning made-up data. Report problems in the Issues tab.

### Use it from code, AI agents and automations

The same input as the form above works everywhere. Results are the run's dataset (JSON, CSV, Excel). You need an Apify API token (Console → Settings → API & Integrations).

**Python** (`pip install apify-client`)

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("stazis/domain-rdap-api").call(run_input={
  "domains": [
    "apify.com",
    "example.org",
    "bbc.co.uk"
  ]
})
for item in client.dataset(run.default_dataset_id).iterate_items():  # apify-client < 3: run["defaultDatasetId"]
    print(item)
```

**JavaScript / TypeScript** (`npm i apify-client`)

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('stazis/domain-rdap-api').call({
  "domains": [
    "apify.com",
    "example.org",
    "bbc.co.uk"
  ]
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**HTTP, one call** (waits for the run, up to 5 minutes, and returns the items)

```bash
curl -X POST "https://api.apify.com/v2/acts/stazis~domain-rdap-api/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"domains": ["apify.com", "example.org", "bbc.co.uk"]}'
```

**AI agents (MCP).** This Actor runs with limited permissions, so AI agents can use it through the hosted Apify MCP server (Claude, Cursor, VS Code, Codex and other MCP clients). Add this to your MCP client config and sign in with Apify on first use:

```json
{ "mcpServers": { "domain-rdap-api": { "url": "https://mcp.apify.com?tools=stazis/domain-rdap-api" } } }
```

Agents without an Apify account can pay per run in USDC through [agi.apify.com](https://agi.apify.com) (x402). Pricing is pay-per-event, so an agent pays only for the results it gets.

**LangChain** (`pip install langchain-apify`, set `APIFY_TOKEN`): `from langchain_apify import ApifyActorsTool` and `tool = ApifyActorsTool("stazis/domain-rdap-api")` gives your agent this Actor as a tool.

**No-code and scheduling:** use the Apify app in Make, n8n or Zapier ("Run an Actor", then pick `stazis/domain-rdap-api`), or create a Schedule in Apify Console to run it daily and send results to a webhook, Slack or Google Drive through Apify integrations.

### Other data APIs by stazis

- [Greenhouse, Lever & Ashby Jobs Scraper API](https://apify.com/stazis/ats-jobs-api): Scrape job postings from company career sites via official Greenhouse, Lever, Ashby, Workable, SmartRecruiters and Recruitee job-board APIs.
- [UK Companies House Search API: Bulk Company Data](https://apify.com/stazis/companies-house-api): Search all ~5.
- [Grants.gov & SAM.gov API: US Federal Grants and Contracts](https://apify.com/stazis/gov-opportunities-api): Get US federal grant opportunities from Grants.
- [SEC EDGAR Filings Scraper API: 8-K, 10-K, Full-Text Search](https://apify.com/stazis/sec-edgar-filings-api): Search SEC EDGAR filings by full text, form type (8-K, 10-K, 10-Q, S-1, Form D), date and state, or list recent filings for any ticker or CIK.
- [OpenAlex API: Scholarly Paper Search, Citations, Abstracts](https://apify.com/stazis/openalex-works-api): Search 250M+ scholarly papers from OpenAlex (CC0): title, DOI, year, venue, open-access link, citation count, authors, institutions, topics and abstract.

# Actor input Schema

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

Domains or URLs, e.g. example.com, https://www.github.io/x. Normalized and de-duplicated.

## `names` (type: `array`):

Brand or keyword names without a TLD, e.g. acme. Combined with 'TLDs' (acme.com, acme.io, …) and added to Domains. Good for bulk availability checks.

## `tlds` (type: `array`):

TLDs to combine with each name, e.g. com, io, co.uk.

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

Resolve live DNS records.

## `dnsRecordTypes` (type: `array`):

Record types to resolve.

## `followRegistrarRdap` (type: `boolean`):

Extra request for thin registries.

## `maxResults` (type: `integer`):

Max domains to process.

## `concurrency` (type: `integer`):

Parallel lookups (each RDAP server is still rate-limited separately).

## `perServerIntervalSec` (type: `string`):

Politeness delay per server; 429 Retry-After is always honored.

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

Keep only registered domains whose expiry date is within N days (expired ones included). Others are left out and not charged. Note: some registries (e.g. many ccTLDs) do not publish expiry dates.

## `expiringSoonDays` (type: `integer`):

Sets the expiring_soon output flag: true when the domain expires within this many days (or already expired). Does not filter rows; use 'Only domains expiring within N days' for that.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "example.org",
    "bbc.co.uk"
  ],
  "tlds": [
    "com",
    "net",
    "org",
    "io",
    "co",
    "ai"
  ],
  "includeDns": true,
  "dnsRecordTypes": [
    "A",
    "AAAA",
    "MX",
    "NS",
    "TXT"
  ],
  "followRegistrarRdap": true,
  "maxResults": 1000,
  "concurrency": 5,
  "perServerIntervalSec": "1.0",
  "expiringSoonDays": 30
}
```

# 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": [
        "apify.com",
        "example.org",
        "bbc.co.uk"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("stazis/domain-rdap-api").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",
        "example.org",
        "bbc.co.uk",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("stazis/domain-rdap-api").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",
    "example.org",
    "bbc.co.uk"
  ]
}' |
apify call stazis/domain-rdap-api --silent --output-dataset

```

## MCP server setup

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

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/nRp2PGGkORaSHAbb4/builds/aa5gZ5TOrO6NkJ4n7/openapi.json