# Bulk Domain Availability Checker (`plusonets/bulk-domain-availability-checker`) Actor

Check domain names you may want to register. DNS first, then a throttled RDAP lookup only for names that do not resolve. No registrant data.

- **URL**: https://apify.com/plusonets/bulk-domain-availability-checker.md
- **Developed by:** [Olalekan Johnson](https://apify.com/plusonets) (community)
- **Categories:** Developer tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $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

Check whether domain names are already registered, for people comparing names they might register.

Paste a list of domains, or give keywords and TLDs and the Actor builds the combinations. A name that has DNS NS or SOA records is reported as **registered**. Names that do not resolve are sent, one at a time, to the TLD registry's RDAP server (found through the IANA bootstrap file) to tell **available** from **registered**. Each row is `domain`, `status`, `method`, and `checked_at`.

This Actor is unofficial and is not affiliated with Verisign, IANA, ICANN, Cloudflare, or Google.

It is for registration intent: short lists of names you are considering. It is not a WHOIS harvester. Registrant, contact, and nameserver data is never stored or returned. Verisign's RDAP terms forbid high-volume automated queries except as reasonably necessary to register domain names or modify existing registrations ([Verisign RDAP terms](https://www.verisign.com/legal-center/rdap-terms/)). The Actor keeps RDAP traffic inside that limit: DNS first, at most 40 registry lookups per run, and at least one second between them.

**Available** means the registry RDAP server returned no registration record. It does not mean a registrar will sell the name, or sell it at the standard price. Premium, reserved, and restricted names can still be unavailable at retail.

### Input

| Field | Default | What it does |
| --- | --- | --- |
| Domain names | `google.com`, `wikipedia.org`, `example.com`, `qx7vk2m9-unlikely-register-2026.com` | Names to check. URLs are reduced to the host. |
| Keywords | empty | Name ideas. Combined with every TLD. |
| TLDs | empty | `com`, `.net`, `co.uk`. Required together with keywords. |
| Maximum domains per run | 25 | Hard ceiling 100. Extra names are ignored. |
| Maximum RDAP lookups per run | 20 | Hard ceiling 40. Further unresolved names come back as `unknown`. |
| Delay between RDAP requests | 1.5 seconds | Minimum 1 second. DNS is not delayed. |

The default list is small on purpose so a run finishes in well under a minute. `google.com` is registered. `qx7vk2m9-unlikely-register-2026.com` is a long label that is very unlikely to be registered, so the run exercises one RDAP confirmation.

Keywords are a single label. `Bright Kettle` with `com` and `net` becomes `bright-kettle.com` and `bright-kettle.net`. Put a finished name such as `example.co.uk` in the domain list.

### Output

```json
[
  {
    "domain": "google.com",
    "status": "registered",
    "method": "dns",
    "checked_at": "2026-10-23T03:00:00+00:00"
  },
  {
    "domain": "qx7vk2m9-unlikely-register-2026.com",
    "status": "available",
    "method": "rdap",
    "checked_at": "2026-10-23T03:00:02+00:00"
  }
]
```

| Field | Meaning |
| --- | --- |
| `domain` | Name that was checked, in ASCII. |
| `status` | `available`, `registered`, or `unknown`. |
| `method` | `dns`, `rdap`, or `none`. |
| `checked_at` | UTC time of the conclusion, ISO 8601. |
| `detail` | Only when `status` is `unknown`. A cap, a TLD with no RDAP server, or a failed lookup. No personal data. |

`method: dns` means the name has NS or SOA records at a public resolver, so it was not sent to RDAP. A registered name with no delegation does not resolve; that name is confirmed with RDAP instead.

### Pricing

Pay per event. One event, charged once per domain that is written to the dataset.

| Event | Price | When it is charged |
| --- | --- | --- |
| `apify-actor-start` | $0.005 | Once per run, by the platform (memory is capped at 512 MB, so once). The Actor does not call `Actor.charge` for it. |
| `domain-checked` | $0.001 | One domain name checked and stored |

There is no separate charge for DNS queries or RDAP lookups, and no per-dataset-item event. A run of the four default names costs $0.005 + 4 × $0.001 = $0.009. Platform compute is not billed to you.

Set the run's maximum charge high enough for the number of names you want. The Actor stops cleanly when that limit is reached and keeps the rows already stored.

The Actor runs with limited permissions. It only reads its own input and writes its default dataset.

### Limits

- 100 domain names per run, 40 RDAP lookups per run, at least 1 second between RDAP requests.
- One registry query at a time. Temporary RDAP failures are retried with backoff.
- TLDs with no server in the [IANA RDAP bootstrap](https://data.iana.org/rdap/dns.json) come back as `unknown`.
- A name can be registered and still have no DNS. Those are the names RDAP is for.
- A name with NS or SOA records is reported registered without asking the registry. That matches almost every delegated domain. It is not a receipt from the registry.
- Availability can change between this check and an attempt to register the name.
- RDAP does not tell you the registrar's price.

### Sources and terms

- DNS answers come from Cloudflare's and Google's public resolvers over DNS-over-HTTPS. The Actor stores the conclusion (delegated or not), not the record contents.
- RDAP base URLs come from the IANA bootstrap registry for the domain name space, published so clients can find the authoritative RDAP server ([RFC 9224](https://www.rfc-editor.org/info/rfc9224/)).
- The registration answer comes from the TLD registry that IANA lists. For `.com` and `.net` that server is operated by Verisign. Use of those responses is subject to the registry's RDAP terms. Verisign's terms are quoted in intent above; read them before you rely on the data: <https://www.verisign.com/legal-center/rdap-terms/>.
- Nothing in this Actor is a copy of a registrar's database. No registrant record is redistributed.

### Run locally

Python 3.12.

```bash
python -m venv .venv
source .venv/bin/activate
pip install -r requirements-dev.txt
pytest
python -m src
```

With no input file, the Actor checks the four default domains. To pass the same input the Store test uses, write it to the local key-value store before starting:

```bash
mkdir -p storage/key_value_stores/default
```

Then save this as `storage/key_value_stores/default/INPUT.json`:

```json
{
  "domains": [
    "google.com",
    "wikipedia.org",
    "example.com",
    "qx7vk2m9-unlikely-register-2026.com"
  ]
}
```

Results land in `storage/datasets/default/`.

On Apify, configure pay-per-event pricing with `domain-checked` as the only event, at $0.001, and leave the Actor on limited permissions. Do not add `apify-default-dataset-item`, or a domain would be billed twice. The source is ready for `apify push`.

# Actor input Schema

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

Fully qualified domain names to check, one per line. A URL is reduced to its host. Example: google.com is registered; a long random label is very likely unregistered.

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

Name ideas to combine with each TLD. 'Bright Kettle' with com and net becomes bright-kettle.com and bright-kettle.net. Use the domain names field for names you already wrote out.

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

TLDs paired with every keyword. With or without the leading dot: com, .net, co.uk.

## `maxDomains` (type: `integer`):

Stop after this many unique names. Extra names are ignored. The hard ceiling is 100.

## `maxRdapLookups` (type: `integer`):

Names that do not resolve in DNS are confirmed with RDAP, up to this cap. Further unresolved names come back as unknown. The hard ceiling is 40 so a run stays within registry terms that allow automated queries only when you are reasonably trying to register a name.

## `rdapDelaySeconds` (type: `number`):

Pause between registry RDAP queries. The minimum is 1 second. DNS checks are not delayed.

## Actor input object example

```json
{
  "domains": [
    "google.com",
    "wikipedia.org",
    "example.com",
    "qx7vk2m9-unlikely-register-2026.com"
  ],
  "maxDomains": 25,
  "maxRdapLookups": 20,
  "rdapDelaySeconds": 1.5
}
```

# Actor output Schema

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

One row per domain with DNS and RDAP availability status.

# 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": [
        "google.com",
        "wikipedia.org",
        "example.com",
        "qx7vk2m9-unlikely-register-2026.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("plusonets/bulk-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": [
        "google.com",
        "wikipedia.org",
        "example.com",
        "qx7vk2m9-unlikely-register-2026.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("plusonets/bulk-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": [
    "google.com",
    "wikipedia.org",
    "example.com",
    "qx7vk2m9-unlikely-register-2026.com"
  ]
}' |
apify call plusonets/bulk-domain-availability-checker --silent --output-dataset

```

## MCP server setup

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