# Domain Availability Checker: Bulk RDAP Lookup (`fernandosord/domain-availability-checker`) Actor

Check hundreds of domains at once, or combine names with TLDs (acme x com, io, ca). Each result says available or registered from the registry's official RDAP server, with registrar, creation and expiry dates, status codes and nameservers. TLDs without RDAP fall back to DNS, marked as such.

- **URL**: https://apify.com/fernandosord/domain-availability-checker.md
- **Developed by:** [Plainsource](https://apify.com/fernandosord) (community)
- **Categories:** Developer tools, Business
- **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 checkeds

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

This domain availability checker tells you, for hundreds of domains at once, whether each one is registered or free. It asks each registry's official RDAP server (the modern replacement for WHOIS), so a registered domain also comes back with its registrar, creation and expiry dates, status codes and nameservers. Give it a list of domains, or a list of names plus a list of TLDs and it checks every combination. No API key or registrar account needed.

- **Names times TLDs.** `acme` and `getacme` with `com`, `io`, `ca` and `ai` gives 8 checks in one go.
- **Straight from the registry.** The RDAP server for each TLD comes from IANA's official bootstrap file, so answers come from Verisign for .com, CIRA for .ca, Nominet for .uk and so on, not from a reseller's cache.
- **Honest about the gaps.** Some TLDs (.io, .co, .de and others) have no RDAP server. For those the Actor checks DNS instead and says so in `method` and `confidence`.
- **Expiry watch.** `daysToExpiry` and `pendingDelete` show which registered domains are about to lapse.

### What data you get

| Field | What it holds |
|---|---|
| `domain`, `name`, `tld` | The domain and its two parts (`domainAscii` holds the punycode form of names like bücher.de) |
| `available`, `status` | `true` / `available` when the registry has no record, `false` / `registered` when it does |
| `method`, `confidence` | `rdap` with `high` confidence, or `dns` with `high`, `medium` or `low` for TLDs without RDAP |
| `registrar`, `registrarIanaId` | Who the domain is registered through |
| `createdAt`, `updatedAt`, `expiresAt`, `daysToExpiry` | Registration, last change and expiry dates, and days left until expiry |
| `statusCodes` | Registry status codes such as `client transfer prohibited`, `redemption period` or `pending delete` |
| `nameservers` | Nameservers of a registered domain |
| `premium`, `reserved`, `pendingDelete`, `note` | Flags when the registry's answer mentions them, with a plain-language note |
| `rdapServer`, `source`, `checkedAt` | Which server answered, which input the check came from, and when |

### How to use it

1. Add full domains, or names plus TLDs, or both.
2. Set **Max checks** so a big names-times-TLDs list can't grow beyond what you want to pay for.
3. Run it and export to JSON, CSV or Excel, or call it from the API, Make, Zapier, n8n or an AI agent through the Apify MCP server.

The Actor checks up to 12 domains at a time but never more than 2 at once against the same registry, and it backs off when a registry answers "Too Many Requests". In our test, 321 domains across 8 TLDs took about one minute.

#### Example input

```json
{
  "domains": ["apify.com"],
  "names": ["acme", "getacme"],
  "tlds": ["com", "io", "ca", "ai"],
  "maxChecks": 50
}
```

#### Example output (three of the nine results)

A registered domain, answered by Verisign's RDAP server:

```json
{
  "domain": "acme.com",
  "domainAscii": "acme.com",
  "name": "acme",
  "tld": "com",
  "available": false,
  "status": "registered",
  "method": "rdap",
  "confidence": "high",
  "registrar": "eNom, LLC",
  "registrarIanaId": "48",
  "createdAt": "1991-04-17T04:00:00.000Z",
  "updatedAt": "2026-04-17T09:07:22.000Z",
  "expiresAt": "2027-04-18T04:00:00.000Z",
  "daysToExpiry": 170,
  "statusCodes": ["client transfer prohibited"],
  "nameservers": ["ns1.hover.com", "ns2.hover.com"],
  "premium": null,
  "reserved": null,
  "pendingDelete": false,
  "note": null,
  "rdapServer": "rdap.verisign.com",
  "inputDomain": null,
  "source": "acme x com",
  "checkedAt": "2026-10-30T02:39:36.849Z"
}
```

A free domain, answered by the .ai registry:

```json
{
  "domain": "getacme.ai",
  "available": true,
  "status": "available",
  "method": "rdap",
  "confidence": "high",
  "registrar": null,
  "expiresAt": null,
  "statusCodes": [],
  "nameservers": [],
  "rdapServer": "rdap.identitydigital.services",
  "source": "getacme x ai"
}
```

A .io domain, where only DNS could be checked:

```json
{
  "domain": "getacme.io",
  "available": true,
  "status": "available",
  "method": "dns",
  "confidence": "low",
  "note": "dns-only, not certain: this TLD has no RDAP server and the name has no DNS records. It may still be registered without nameservers, reserved or premium. Check at a registrar.",
  "rdapServer": null,
  "source": "getacme x io"
}
```

### How much does it cost?

You pay per domain with a result: $0.002 per domain, plus $0.0005 once per run. 1,000 domains cost about $2.00. Apify's free plan credit of $5 a month covers about 2,500 checks.

Invalid names (a space, a TLD that does not exist) and lookups that fail are free. They are listed with the reason in the `SUMMARY` record of the run's key-value store.

### Use cases

- **Naming a startup or product:** try 30 name ideas against the 6 extensions you care about in one run.
- **Brand protection:** check which variants and country extensions of your brand are still open.
- **Expiring domain watch:** run your list on a schedule and sort by `daysToExpiry`, or filter on `pendingDelete`.
- **Portfolio audit:** pull registrar, expiry and nameservers for every domain your company owns.
- **Lead research:** see who registered a set of domains, and when.

### FAQ

**Does "available" mean I can buy it at the normal price?**
No. `available: true` means the registry has no record of the domain. Premium pricing, registry reservations and registrar-specific rules are not part of RDAP for most registries, so `premium` and `reserved` are only set when the registry's answer mentions them, and `null` does not mean "normal price". Always check the price and final availability at a registrar before you count on a name.

**Which TLDs have no RDAP server?**
As of October 2026, IANA's bootstrap file has no RDAP server for, among others, .io, .co, .me, .de, .eu, .us, .jp, .es, .it, .ch, .se, .be, .at, .mx, .ru, .cn, .gg, .so and .sh. The Actor reads the bootstrap file fresh on every run, so new RDAP servers are picked up on their own. For these TLDs it checks DNS:

- Nameservers found: registered, `confidence: "high"`.
- The name exists in DNS but its nameservers fail or are missing: registered, `confidence: "medium"`.
- No DNS records at all: `available: true` with `confidence: "low"` and a note, because a domain can be registered without nameservers.

Registrar and dates are not available through DNS.

**How accurate is the RDAP result?**
It is the registry's own answer at the time of the check: HTTP 404 means not registered, a domain record means registered. A domain that was just deleted, or is in a drop or auction, can still change minutes later.

**What happens with subdomains and URLs?**
They are trimmed to the registrable domain using the public suffix list, so `https://www.bbc.co.uk/news` is checked as `bbc.co.uk` and the original is kept in `inputDomain`.

**Will registries block me?**
Registries limit how fast one IP can ask. The Actor keeps at most 2 requests in flight per registry, spaces them out, and pauses that registry when it answers 429. In our 321-domain test, Google's registry asked for a few short pauses and every check still finished. If a huge run keeps getting 403 or 429, turn on Apify Proxy.

**Is this legal?**
RDAP is the public lookup service that ICANN requires of generic TLD registries, and many country registries run it too. Most registries redact registrants' personal data themselves.

### Other Actors by this developer

- [Domain Profile: WHOIS and DNS](https://apify.com/fernandosord/domain-profile-whois-dns): full WHOIS, DNS records and age for domains that are already registered.
- [Website Tech Stack Detector](https://apify.com/fernandosord/website-tech-stack-detector): see what a registered domain's website runs on.
- [Email Security Audit: SPF, DKIM, DMARC](https://apify.com/fernandosord/email-security-audit-spf-dkim-dmarc): check a domain's email setup.
- [Website Change Monitor](https://apify.com/fernandosord/website-change-monitor): get told when a page on a domain changes.

# Actor input Schema

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

Full domain names to check, for example acme.com or bücher.de. URLs and subdomains are trimmed to the registrable domain (www.bbc.co.uk becomes bbc.co.uk).

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

Optional. Names without an extension, such as acme or getacme. Each name is checked with every TLD in the list below.

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

Extensions to combine with the names above, without the dot: com, io, ca, ai, co.uk. Needed when you give names.

## `maxChecks` (type: `integer`):

The Actor checks at most this many domains per run, after removing duplicates. Names times TLDs grows fast: 50 names and 10 TLDs is 500 checks.

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

Optional. RDAP servers are public and usually answer without a proxy. Turn on Apify Proxy only if a registry keeps answering 429 or 403 in the log for very large runs.

## Actor input object example

```json
{
  "domains": [
    "apify.com"
  ],
  "names": [
    "acme",
    "getacme"
  ],
  "tlds": [
    "com",
    "io",
    "ca",
    "ai"
  ],
  "maxChecks": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One item per domain: available or registered, with registry details for registered ones.

# 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"
    ],
    "names": [
        "acme",
        "getacme"
    ],
    "tlds": [
        "com",
        "io",
        "ca",
        "ai"
    ],
    "maxChecks": 50,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fernandosord/domain-availability-checker").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"],
    "names": [
        "acme",
        "getacme",
    ],
    "tlds": [
        "com",
        "io",
        "ca",
        "ai",
    ],
    "maxChecks": 50,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fernandosord/domain-availability-checker").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"
  ],
  "names": [
    "acme",
    "getacme"
  ],
  "tlds": [
    "com",
    "io",
    "ca",
    "ai"
  ],
  "maxChecks": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fernandosord/domain-availability-checker --silent --output-dataset

```

## MCP server setup

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

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/5czyPnAavNP0Pogqo/builds/QuYVX0ErDHJBhDYyn/openapi.json