# Bulk Domain Availability Checker (RDAP) (`jakob_jerich/domain-availability-checker`) Actor

Check whether domains are available or registered, in bulk or as name ideas × TLDs, using official registry RDAP data with a DNS fallback. Returns registrar, creation and expiry dates, and nameservers.

- **URL**: https://apify.com/jakob_jerich/domain-availability-checker.md
- **Developed by:** [Jakob Jerič](https://apify.com/jakob_jerich) (community)
- **Categories:** Developer tools, SEO tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.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

## Bulk Domain Availability Checker (RDAP)

Check if domains are **available or registered**, for a list of domains or for name ideas combined with many TLDs. For registered domains you also get the **registrar, creation date, expiry date, days until expiry, EPP status, nameservers and DNSSEC**.

Data comes from the domain registries' official **RDAP** services (the standard that replaces WHOIS for registry data), found through the IANA bootstrap file. TLDs whose registry has no public RDAP are checked through DNS instead. No API key, account or proxy is needed.

### What you can do with it

- **Name brainstorming:** check 20 name ideas across `.com`, `.io`, `.ai`, `.dev` and more in one run.
- **Portfolio monitoring:** track expiry dates and registrars for your own domains, and schedule the run to catch renewals you missed.
- **Expiring-domain research:** sort by `daysUntilExpiry` to see which domains on a watch list expire soon.
- **Lead and brand checks:** confirm a list of brand or typo domains is registered, and by which registrar.

### Input

| Field | What it does |
|---|---|
| `domains` | Domains, hostnames or URLs. `https://www.bbc.co.uk/news` is checked as `bbc.co.uk`. |
| `keywords` | Name ideas without an extension. Each one is combined with every entry in `tlds`. |
| `tlds` | Extensions for the keywords. Default: `com, net, org, io, ai, co, app, dev`. Multi-level ones such as `co.uk` work. |

Example:

```json
{
  "domains": ["apify.com", "bbc.co.uk", "my-unused-startup-name-2931.com"],
  "keywords": ["northwindlabs"],
  "tlds": ["com", "net", "org", "io", "ai", "co", "app", "dev"]
}
```

This checks 11 domains in about 2 seconds.

### Output

One dataset item per domain. Examples copied from real runs:

```json
{
  "input": "apify.com",
  "domain": "apify.com",
  "tld": "com",
  "status": "registered",
  "source": "rdap",
  "registrar": "Amazon Registrar, Inc.",
  "registrarIanaId": "468",
  "createdAt": "2009-06-02T17:14:10Z",
  "updatedAt": "2026-05-16T16:53:04Z",
  "expiresAt": "2035-06-02T17:14:10Z",
  "daysUntilExpiry": 3135,
  "eppStatus": ["client transfer prohibited"],
  "nameservers": ["ns-1225.awsdns-25.org", "ns-1928.awsdns-49.co.uk", "ns-449.awsdns-56.com", "ns-839.awsdns-40.net"],
  "dnssec": true,
  "note": null,
  "checkedAt": "2026-10-31T23:44:35.315Z"
}
```

```json
{
  "input": "northwindlabs.io",
  "domain": "northwindlabs.io",
  "tld": "io",
  "status": "available",
  "source": "rdap",
  "registrar": null,
  "registrarIanaId": null,
  "createdAt": null,
  "updatedAt": null,
  "expiresAt": null,
  "daysUntilExpiry": null,
  "eppStatus": [],
  "nameservers": [],
  "dnssec": null,
  "note": null,
  "checkedAt": "2026-10-31T23:44:35.321Z"
}
```

```json
{
  "input": "spiegel.de",
  "domain": "spiegel.de",
  "tld": "de",
  "status": "registered",
  "source": "dns",
  "registrar": null,
  "registrarIanaId": null,
  "createdAt": null,
  "updatedAt": null,
  "expiresAt": null,
  "daysUntilExpiry": null,
  "eppStatus": [],
  "nameservers": ["pns101.cloudns.net", "pns102.cloudns.net", "pns103.cloudns.net", "pns104.cloudns.net"],
  "dnssec": null,
  "note": "The .de registry has no public RDAP service; result based on DNS only.",
  "checkedAt": "2026-10-31T23:41:48.806Z"
}
```

#### Status values

| `status` | Meaning |
|---|---|
| `registered` | The registry has a record (`source: rdap`), or the domain is delegated in DNS (`source: dns`). |
| `available` | The registry's RDAP service has no record and the domain is not in DNS. |
| `likely-available` | The TLD has no public RDAP and the name does not exist in DNS. A few registered domains have no DNS at all, so confirm at a registrar before you rely on it. |
| `invalid` | Not a valid domain, or the registry rejected the name. Not charged. |
| `unknown` | The lookups failed after retries. `note` says why. Not charged. |

The Overview tab of the dataset shows a table with the main columns. Export to CSV, Excel or JSON from the dataset page or the API.

### Pricing

Pay per event: **$0.001 per domain checked** ($1 per 1,000). There is no start fee. Invalid entries and failed lookups (`unknown`) are free. Example: 8 TLDs × 25 name ideas = 200 domains = $0.20.

If you set a maximum cost per run, the Actor stops when that amount is reached.

### Limits

- Up to 10,000 domains per run. Split bigger lists into several runs.
- "Available" means the name is not registered. It can still be a premium or reserved name at the registrar, or blocked by registry policy.
- Registries without public RDAP (for example `.de`, `.co`, `.eu`, `.ch`, `.us`, `.jp`) give only a DNS-based result, with no registrar or dates. `.io`, `.me` and `.ac` are queried through their registry operator's RDAP service.
- Some ccTLD registries publish fewer fields over RDAP (for example no expiry date or nameservers). Missing values are `null` or empty lists.
- Registrant and contact details are never collected. Only the registrar is read from RDAP.
- Requests are throttled per registry and retried with backoff when a registry rate-limits. A run of 320 domains took about 75 seconds.
- If a registry keeps rate-limiting after the retries (we saw this with `.shop`), the domain is checked through DNS instead and unregistered names come back as `likely-available`. Such runs are also slower.

### FAQ

**Is this WHOIS?** It uses RDAP, the JSON successor to WHOIS that ICANN requires for all generic TLDs. It returns the same registry data (registrar, dates, status, nameservers) in a structured form.

**Can I buy domains with it?** No. It only checks the registries. Buy at any registrar.

**Why is a domain I own shown as `likely-available`?** Its TLD has no public RDAP and the domain has no nameservers set, so it does not exist in DNS. Add nameservers, or check it at your registrar.

**How fresh is the data?** Each run queries the registries live. `checkedAt` shows when each domain was checked.

**Can I run it on a schedule?** Yes. Use Apify schedules, for example daily for a list of domains you own, and filter on `daysUntilExpiry`.

# Actor input Schema

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

Domains to check, one per line. Plain domains (example.com), hostnames (www.example.co.uk) and full URLs are accepted; each is reduced to its registrable domain. Duplicates are removed.

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

Optional. Names without an extension (e.g. acmerobotics). Each keyword is combined with every TLD in 'TLDs' below, so 3 keywords × 8 TLDs = 24 domains. Spaces and anything after the first dot are removed (acme.com becomes acme).

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

Extensions to combine with each keyword, without the dot (com, io, co.uk). Only used when 'Name ideas' is filled in.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "bbc.co.uk",
    "my-unused-startup-name-2931.com"
  ],
  "keywords": [
    "northwindlabs"
  ],
  "tlds": [
    "com",
    "net",
    "org",
    "io",
    "ai",
    "co",
    "app",
    "dev"
  ]
}
```

# Actor output Schema

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

One item per checked domain with its status, registrar, dates and nameservers.

# 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",
        "bbc.co.uk",
        "my-unused-startup-name-2931.com"
    ],
    "keywords": [
        "northwindlabs"
    ],
    "tlds": [
        "com",
        "net",
        "org",
        "io",
        "ai",
        "co",
        "app",
        "dev"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jakob_jerich/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",
        "bbc.co.uk",
        "my-unused-startup-name-2931.com",
    ],
    "keywords": ["northwindlabs"],
    "tlds": [
        "com",
        "net",
        "org",
        "io",
        "ai",
        "co",
        "app",
        "dev",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("jakob_jerich/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",
    "bbc.co.uk",
    "my-unused-startup-name-2931.com"
  ],
  "keywords": [
    "northwindlabs"
  ],
  "tlds": [
    "com",
    "net",
    "org",
    "io",
    "ai",
    "co",
    "app",
    "dev"
  ]
}' |
apify call jakob_jerich/domain-availability-checker --silent --output-dataset

```

## MCP server setup

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