# Bulk Domain Availability & WHOIS Checker (RDAP) (`clever_firebox/domain-availability-whois-rdap`) Actor

Check thousands of domains at once: available or registered, registrar, creation and expiry dates, days to expiry, nameservers, EPP status, DNSSEC. Uses official registry RDAP (the WHOIS successor) for 1,200+ TLDs, plus name-idea x TLD generator. No API key.

- **URL**: https://apify.com/clever_firebox/domain-availability-whois-rdap.md
- **Developed by:** [Agentic Hobby](https://apify.com/clever_firebox) (community)
- **Categories:** Developer tools, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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 Domain Availability & WHOIS Checker (RDAP)

Check **thousands of domain names at once**: is it **available or registered**, who is the **registrar**, when was it **created**, when does it **expire** (and in how many days), which **nameservers** and **EPP status codes** it has, and whether **DNSSEC** is on. Paste domains or URLs, or type **name ideas** and let the Actor try every extension you pick (.com, .io, .ai, .co…). Use it as a **bulk domain availability checker**, a **bulk WHOIS lookup**, an **expiring-domains monitor**, or a **domain name generator check** for branding.

Data comes from **RDAP**, the official successor to WHOIS run by the registries themselves (RFC 9082/9083). The Actor finds the right registry server through the **IANA RDAP bootstrap** (1,200+ TLDs: .com, .net, .org, .ai, .app, .dev, .xyz, .uk, .fr, .nl, .ca, .au, .in, .br and most new gTLDs). For extensions without public RDAP (for example .de, .co, .eu) it falls back to a DNS check. No API key, no login, no scraping of registrar websites, no CAPTCHAs.

### Why this one

- **Registry-grade answers:** availability comes from the registry that owns the extension, not a reseller's search box that pushes upsells.
- **Fast and polite:** parallel checks across registries, at most 4 at a time per registry, automatic retry on rate limits.
- **Fair pricing:** you pay per domain result. Domains that could not be checked are listed in the run summary and are not charged.

### Input examples

Bulk check a list (domains or URLs):

```json
{"domains": ["apify.com", "https://www.example.org/page", "mybrandidea.ai"]}
```

Name ideas across extensions, keep only the free ones:

```json
{"keywords": ["brightdesk", "brightdeskhq", "getbrightdesk"], "tlds": ["com", "io", "ai", "co", "app"], "availableOnly": true}
```

Expiry and registrar audit of a portfolio, with registrar-level WHOIS detail:

```json
{"domains": ["example.com", "example.net"], "followRegistrar": true}
```

### Output fields

`domain, tld, available (true/false), status (registered | available | likely_available), method (rdap | dns), rdapServer, registrar, registrarIanaId, registrarUrl, abuseEmail, abusePhone, registrantOrg, registrantCountry, statuses[], registrationDate, expirationDate, lastChangedDate, domainAgeDays, daysUntilExpiry, nameservers[], dnssec, registrarRdapUrl, checkedAt`

Real samples are in `samples/`. `registrantOrg` and `registrantCountry` are filled only when the registry or registrar publishes them (most personal registrations are privacy-redacted under GDPR/ICANN rules; the Actor never tries to unmask them).

### How availability is decided

- **RDAP 404 at the registry** → `available` (not registered). Premium or registry-reserved names can still cost extra or be blocked: confirm at your registrar before you buy.
- **RDAP record found** → `registered`, with full details.
- **DNS fallback** (TLDs without RDAP): NS records → `registered`; NXDOMAIN → `likely_available` (a registered domain with no DNS is rare but possible).

### Pricing

Pay per domain result saved. With **Output available domains only**, registered domains are skipped and free. Unsupported or failed lookups are free. Cap spend with **Max results**.

### Notes

Not affiliated with IANA, ICANN or any registry. Registry RDAP servers apply their own rate limits; very large lists are processed in batches and may take a few minutes.

# Actor input Schema

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

Domains or URLs to check (one per line). URLs and www. are cleaned up automatically. Up to 100,000 per run.

## `keywords` (type: `array`):

Brand or name ideas without an extension, e.g. 'brightdesk'. Each is checked in every TLD below.

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

Extensions combined with each keyword.

## `availableOnly` (type: `boolean`):

Only available domains are saved (and charged). Registered ones are counted in the run summary.

## `followRegistrar` (type: `boolean`):

For registered domains, also query the registrar's RDAP server for registrant organisation/country (when not privacy-redacted) and abuse contacts. Slower.

## `dnsFallback` (type: `boolean`):

For extensions whose registry has no public RDAP (e.g. .de, .co, .eu), check DNS: NS records mean registered; NXDOMAIN means likely available.

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

Overall parallel lookups. At most 4 at a time hit any one registry, to stay polite.

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

You are charged per domain result saved.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "agentic-hobby-free-name-test.com",
    "wikipedia.org",
    "openai.ai",
    "bbc.co.uk"
  ],
  "tlds": [
    "com",
    "net",
    "org",
    "io",
    "ai",
    "co"
  ],
  "availableOnly": false,
  "followRegistrar": false,
  "dnsFallback": true,
  "maxConcurrency": 10,
  "maxResults": 1000
}
```

# Actor output Schema

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

One item per checked domain (availability + RDAP/WHOIS data). Opens the Overview view by default; the dataset contains all fields.

## `runSummary` (type: `string`):

JSON record with counts for this run (RUN_SUMMARY in the default key-value store).

# 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",
        "agentic-hobby-free-name-test.com",
        "wikipedia.org",
        "openai.ai",
        "bbc.co.uk"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("clever_firebox/domain-availability-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",
        "agentic-hobby-free-name-test.com",
        "wikipedia.org",
        "openai.ai",
        "bbc.co.uk",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("clever_firebox/domain-availability-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",
    "agentic-hobby-free-name-test.com",
    "wikipedia.org",
    "openai.ai",
    "bbc.co.uk"
  ]
}' |
apify call clever_firebox/domain-availability-whois-rdap --silent --output-dataset

```

## MCP server setup

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