# Bulk Domain Availability Checker (Registry-Confirmed) (`quiet-robots/bulk-domain-availability-checker-registry-confirmed`) Actor

Paste a list of names and see which domains are free across .com, .io, .ai, .de, .eu and 40+ more endings. Every answer is confirmed at the registry, including endings DNS-only checks can only guess. $1 per 1,000 checks; unanswered checks are free.

- **URL**: https://apify.com/quiet-robots/bulk-domain-availability-checker-registry-confirmed.md
- **Developed by:** [Quiet Robots](https://apify.com/quiet-robots) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 domain checks

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

### 🔎 What does Bulk Domain Availability Checker do?

Paste a list of names and find out which domains are still free. Each name is checked across
`.com`, `.net`, `.org`, `.io`, `.ai`, `.app`, `.dev`, `.co` and `.xyz` (or any endings you choose),
and **"available" is confirmed by the registry that runs each ending**, not guessed from DNS.

- **Names × endings in one run:** 100 names across 9 endings is 900 checks.
- **Registry-confirmed answers,** including `.io`, `.de`, `.eu`, `.it` and `.me`, where a DNS-only
  check can only say "probably free".
- **A summary table to read,** plus one data row per domain for spreadsheets and automations.
- **No API key, no proxy, no WHOIS account.** You only need an Apify account.
- **$1 per 1,000 domains checked.** You only pay for confirmed answers.

> Press **Start** with the example names to see it work. That run checks 19 domains and costs
> about $0.02.

### 🚀 How to check domain availability in bulk

1. Type or paste the names you are considering into **Names or domains**, for example
   `brightpath` and `plum-otter-studio`.
2. Press **Start**.
3. Open the **summary table** in the run's Output tab: one line per name, one column per ending,
   with the free ones marked.

| Name | .com | .net | .org | .app | .dev |
|---|---|---|---|---|---|
| brightpath | taken | taken | taken | taken | taken |
| plum-otter-studio | **FREE** | **FREE** | **FREE** | **FREE** | **FREE** |

The same answers are saved as data too (one row per domain). Download them as JSON, CSV or
Excel, or read them through the [Apify API](https://docs.apify.com/api/v2).

### 💡 What you can use it for

- **Naming a product, startup or side project:** paste 100 candidate names and get back the ones
  with a free `.com` or `.io`.
- **Checking a list you already have:** paste full domains (`brightpath.io`) and get one row each.
- **AI agents and automations:** a clean JSON answer per domain, with no API key or login.
- **Watching domains you want:** switch on "Include registrar and dates" to get each registered
  domain's expiry date, and put the run on a [schedule](https://docs.apify.com/platform/schedules).

### 📥 Input

| Field | What to put in |
|---|---|
| **Names or domains** | One per line, or separated by commas. A plain name (`brightpath`) is checked with every ending below. A full domain (`brightpath.io`) is checked exactly as written. Links and capital letters are cleaned up for you. |
| **Endings to check** | Without the dot. Defaults to `com net org io ai app dev co xyz`. Two-part endings such as `co.uk` work too. |
| **Include registrar and dates** | For registered domains, also fetch the registrar, registration and expiry dates and nameservers. Slower. |
| **Only save available domains** | Leaves registered domains out of the results. |

```json
{
    "names": ["brightpath", "plum-otter-studio", "example.com"],
    "tlds": ["com", "io", "ai"],
    "details": false,
    "onlyAvailable": false
}
```

### 📤 Output

One row per domain, in the order you gave them. This one was made with "Include registrar and
dates" switched on:

```json
{
    "domain": "example.com",
    "name": "example",
    "tld": "com",
    "status": "registered",
    "available": false,
    "registrar": "RESERVED-Internet Assigned Numbers Authority",
    "createdAt": "1995-08-14T04:00:00Z",
    "expiresAt": "2027-08-13T04:00:00Z",
    "nameservers": ["elliott.ns.cloudflare.com", "hera.ns.cloudflare.com"],
    "source": "rdap",
    "note": null,
    "checkedAt": "2026-10-10T11:45:31.983Z"
}
```

`status` is one of:

| Status | Meaning | Charged |
|---|---|---|
| `available` | The registry confirms it has no record of this domain. | Yes |
| `registered` | Someone owns it. | Yes |
| `reserved` | Not registered, but held back from sale: by the registry itself (where its WHOIS says so, see Limits) or by ICANN's rules (`example`, `www`, `nic`, `whois`, `rdds` on every generic ending). It cannot be bought. | No |
| `probably_available` | The domain has no DNS records, but the registry could not confirm it (it has no public lookup service, or its lookup limit was reached). `note` says which. | No |
| `unknown` | No clear answer. `note` says why. | No |
| `invalid` | Not a valid domain name. | No |

`source` says where the answer came from: `dns`, or the registry itself over `rdap` or `whois`.

### ✅ How it confirms a domain is available

1. **DNS first.** A domain with nameservers is certainly registered, so those are answered at
   once.
2. **Then the registry.** Every name DNS cannot find is looked up over RDAP, the registries'
   official replacement for WHOIS, at the registry that runs that ending. "Not found" there means
   available.
3. **WHOIS as a backup.** For endings whose registry has no RDAP, or when a registry's RDAP limit
   has been reached, the Actor asks the same registry over WHOIS.
4. **A second look for reserved names.** Some registries hold common words back from sale and
   still answer "not found" over RDAP. On the endings where the registry's WHOIS reveals this, a
   free-looking name is checked there too and comes back as `reserved` instead of available.

> Step 2 matters: in testing, about 1 in 25 registered domains had no DNS records and would have
> been reported as free by a DNS-only check.

No scraping, no proxies, no third-party API in between.

**Accuracy.** Before release, 280 answers across `.com .net .org .xyz .co .pl .de` were compared
with the registries' separate WHOIS service: 279 matched, none disagreed, and one could not be
compared.

### 🌍 Supported domain endings (TLDs)

Type any ending into **Endings to check**. Tested with a taken and a free name each:

- **Confirmed by the registry:** `com net org io ai app dev co xyz` (the defaults), plus
  `tech online store shop site biz club cloud design blog art space fun top one tv cc to fm`,
  `uk co.uk de fr nl pl eu it be at se cz us ca com.au in me gg sh`, and any other ending on
  [IANA's RDAP list](https://data.iana.org/rdap/dns.json).
- **Partly:** endings whose registry offers no public lookup (for example `es`, `ch`). Registered
  names are still found through DNS; names that look free come back as `probably_available` and
  are not charged.

### 💰 Pricing

You pay per domain that gets a confirmed answer (status `available` or `registered`). Everything
else is free: reserved, unconfirmed, unknown and invalid rows are never charged.

| Your Apify plan's discount tier | Price per 1,000 domains checked |
|---|---|
| Free | $1.00 |
| Bronze | $0.90 |
| Silver | $0.80 |
| Gold | $0.70 |

- 10 names across 9 endings = 90 checks = $0.09 at the Free price.
- Apify's free plan includes $5 of credit a month, enough for up to about 5,000 checks.
- Starting a run costs $0.00005.
- If you set a maximum charge for the run, the Actor checks only as many domains as that covers.

### 🔌 Use it from the API, an automation or an AI agent

Start a run and get the rows back in one call (replace `YOUR_TOKEN` with your Apify API token):

```bash
curl -X POST "https://api.apify.com/v2/acts/quiet-robots~bulk-domain-availability-checker-registry-confirmed/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"names": ["brightpath", "plum-otter-studio"], "tlds": ["com", "io"]}'
```

The same with the [JavaScript client](https://docs.apify.com/api/client/js):

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('quiet-robots/bulk-domain-availability-checker-registry-confirmed').call({
    names: ['brightpath', 'plum-otter-studio'],
    tlds: ['com', 'io'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((row) => row.available));
```

- **Make, Zapier, n8n and others:** through
  [Apify's integrations](https://docs.apify.com/platform/integrations).
- **AI assistants:** through [Apify's MCP server](https://docs.apify.com/platform/integrations/mcp)
  an assistant can call the Actor as a tool: it sends a list of names and gets back one clear
  `available: true` or `false` per domain.

### ⚠️ Limits and good to know

- **"Available" means not registered, which is not always the same as "you can buy it".** A
  registry can hold a name back (reserved) or sell it at a premium price. This mostly affects
  dictionary words; invented names are rarely affected.
  - Reserved names are caught on `xyz tech online store site space fun cloud club design top`
    (seen in testing, for example `website.xyz` and `test.tech`), and checked the same way on
    `art fm biz one co`.
  - They are **not** caught on `.app`, `.dev` and `.shop`, whose registries have no WHOIS
    service, or on other endings. There a reserved name such as `test.app` shows as available.
  - Premium pricing is never shown. Your registrar gives the final answer and price.
- **The second look takes time.** It adds roughly half a second per free-looking name on the
  endings listed above.
- **Registries limit lookups.** The `.app` and `.dev` registry allows about one lookup a second,
  so the Actor paces itself there. If a registry stops answering during a very large run,
  free-looking names come back as `probably_available` and are not charged; run them again later.
- **Long lists need a longer timeout.** If a run reaches its time limit, the Actor saves what it
  has, says how many domains it did not reach, and does not charge for those. Raise the timeout
  in the run options and run the rest.
- **Registrar and dates** come from RDAP. Answers that came over WHOIS or DNS don't include them.
- **No personal data.** Only the registrar, dates and nameservers are returned, never owner
  contact details.

### ❓ FAQ

#### Do I need an API key, a proxy or a WHOIS account?

No. The Actor talks to DNS and to the registries directly. You only need an Apify account.

#### Can I check domain availability through an API?

Yes. See the examples above, or the **API** tab on this page for ready-made calls in other
languages.

#### Can it watch a domain and tell me when it becomes free?

Save the run as a [task](https://docs.apify.com/platform/actors/running/tasks) with the domains
you want and put it on a schedule (daily, for example). Each run tells you whether they are
still registered; with "Include registrar and dates" on, you also see the expiry date.

#### How many domains can I check in one run?

There is no fixed limit. In our own testing 900 domains took about two minutes. Very large runs
on one ending can reach that registry's lookup limit; the names it could not confirm come back
as `probably_available`, free of charge.

#### Why did a name come back as `probably_available`?

Its registry either has no public lookup or stopped answering during the run. The name has no DNS
records, which usually means it is free. Run it again later for a confirmed answer.

#### Does it tell me the price of a domain?

No. It says whether a domain is registered. Prices, including premium prices, come from the
registrar you buy from.

### 💬 Support

Found a wrong answer, or need an ending that is not confirmed yet? Open an issue on the Actor's
**Issues** tab and include the domain.

# Changelog

This Actor's version history is a separate document: https://apify.com/quiet-robots/bulk-domain-availability-checker-registry-confirmed/changelog.md

# Actor input Schema

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

The names you are considering, one per line (or separated by commas). A plain name ("brightpath") is checked with every ending below. A full domain ("brightpath.io") is checked exactly as written.

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

Domain endings to try for each plain name, without the dot. Two-part endings such as co.uk work too.

## `details` (type: `boolean`):

For registered domains, also fetch the registrar, registration date, expiry date and nameservers from the registry. Slower, and some registries limit how many lookups they allow per day.

## `onlyAvailable` (type: `boolean`):

Leave registered domains out of the results. Every domain that gets an answer is still a paid check.

## Actor input object example

```json
{
  "names": [
    "brightpath",
    "plum-otter-studio",
    "example.com"
  ],
  "tlds": [
    "com",
    "net",
    "org",
    "io",
    "ai",
    "app",
    "dev",
    "co",
    "xyz"
  ],
  "details": false,
  "onlyAvailable": false
}
```

# Actor output Schema

## `summary` (type: `string`):

A web page with one line per name and one column per ending, free domains marked.

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

Every domain checked, with its status, where the answer came from and when.

# 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 = {
    "names": [
        "brightpath",
        "plum-otter-studio",
        "example.com"
    ],
    "tlds": [
        "com",
        "net",
        "org",
        "io",
        "ai",
        "app",
        "dev",
        "co",
        "xyz"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("quiet-robots/bulk-domain-availability-checker-registry-confirmed").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 = {
    "names": [
        "brightpath",
        "plum-otter-studio",
        "example.com",
    ],
    "tlds": [
        "com",
        "net",
        "org",
        "io",
        "ai",
        "app",
        "dev",
        "co",
        "xyz",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("quiet-robots/bulk-domain-availability-checker-registry-confirmed").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 '{
  "names": [
    "brightpath",
    "plum-otter-studio",
    "example.com"
  ],
  "tlds": [
    "com",
    "net",
    "org",
    "io",
    "ai",
    "app",
    "dev",
    "co",
    "xyz"
  ]
}' |
apify call quiet-robots/bulk-domain-availability-checker-registry-confirmed --silent --output-dataset

```

## MCP server setup

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

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/xq70fdTqGuehqqeXJ/builds/hKW7Rm2RdTB4nXquI/openapi.json