# Domain Availability Checker (`deriverge/domain-availability-checker`) Actor

Checks whether domain names are free in every TLD you list, with the answer taken from the registry over RDAP or WHOIS. Taken names come with their registrar, registration date and expiry, and the form's two names and eight TLDs give 16 rows on the first click.

- **URL**: https://apify.com/deriverge/domain-availability-checker.md
- **Developed by:** [deriverge s.r.o.](https://apify.com/deriverge) (community)
- **Categories:** Developer tools, SEO tools, Automation
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 96.2% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.25 / 1,000 name 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

## Domain Availability Checker

Domain Availability Checker tells you which domain names are still free to register. Every name you enter is paired with every TLD you list, and each pair becomes a row with `available`, the method that decided it and, for a taken name, the registrar, registration date and expiry. Answers come from the registries over RDAP or WHOIS, with a DNS check where neither exists. The form holds two names and eight TLDs, so **Start** gives 16 rows. Prices, premium names and names a registry reserves are not detected. It costs $0.50 per 1,000 name checks on the Free plan ($0.25 on Business), and the $5 of monthly credit in Apify's Free plan covers about 10,000 name checks.

### Output fields

| Field | Description |
|---|---|
| `domain`, `name`, `tld` | The full domain that was checked, the name part and the suffix it was paired with, such as `brightpath.com`, `brightpath` and `com`. Two-part suffixes stay whole, as in `co.uk`. |
| `available` | `true` when the registry has no record of the name, `false` when the name is registered, `null` when nothing answered or when only DNS could be asked and showed no nameservers. |
| `method` | `rdap` or `whois` when the registry answered, `das` for `.no` names, `dns` for the nameserver check, `null` when nothing answered. |
| `registrar` | Registrar of a taken name, such as `GoDaddy.com, LLC`. Some registries do not publish it. |
| `createdAt`, `expiresAt` | Registration and expiry of a taken name as ISO 8601 UTC timestamps. |
| `note` | The reason when an answer needs one, for example that a free name can still be reserved or premium, or that only DNS was asked. |
| `key`, `type`, `checkedAt` | Row ID `avail:<domain>`, the row type `availability` and the time of the check. |

### How to check domain availability in bulk

1. Type names into **Names**, one per line, without a suffix: `acme`, `brightpath`. A name that already has a suffix, such as `acme.co.uk`, is checked as it stands, and a pasted link loses its `https://`, path and `www.` first.
2. List suffixes in **TLDs**, with or without the dot: `com`, `.io`, `co.uk`, `de`. If the field is empty, the actor uses `com`, `net`, `org`, `io`, `co`, `ai`, `app` and `dev`.
3. Change **Maximum rows** if you check more than 10,000 pairs in one run.
4. Click **Start**. Six checks run at the same time, and the rows can be exported from the **Output** tab as CSV, Excel or JSON or read through the API.

A request for three names, one of them a full domain, against five suffixes:

```json
{
  "names": ["brightpath", "acme-analytics", "northwind.co.uk"],
  "tlds": ["com", "io", "ai", "de", "co.uk"]
}
```

### Example output

A taken name from a run on 11 October 2026. For a free name, `registrar` and both dates are `null` and `note` carries the caveat about reserved and premium names.

```json
{
  "type": "availability",
  "key": "avail:brightpath.com",
  "name": "brightpath",
  "tld": "com",
  "domain": "brightpath.com",
  "available": false,
  "method": "rdap",
  "registrar": "GoDaddy.com, LLC",
  "createdAt": "1998-05-07T04:00:00.000Z",
  "expiresAt": "2027-05-06T04:00:00.000Z",
  "checkedAt": "2026-10-11T12:25:29.266Z",
  "note": null
}
```

### How much does it cost to check domain names?

| | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| 1,000 name checks | $0.50 | $0.40 | $0.325 | $0.25 |

You pay only for the events in the table. There is no start fee, and compute time and proxies are included.

One hundred names against the eight default TLDs make 800 checks, which cost $0.40 on the Free plan and $0.20 on Business. A pair that neither the registry, a WHOIS server nor DNS answered still gets its row with the reason in `note`, and it is not charged.

### Limits

- `available: true` means the registry holds no record of the name. A registry can still keep a name back as reserved, and a premium name sells above the usual price; neither shows up here, and no prices are returned.
- Most registries answer over RDAP. In a check of 25 suffixes on 11 October 2026, 18 answered over RDAP, six over WHOIS (`co`, `eu`, `it`, `se`, `at` and `jp`) and `es` only through DNS.
- `.no` names go to Norid's Domain Availability Service, which says only free, taken or not registrable at the moment, so `registrar` and the dates stay empty. Norid caps lookups per address, so a run checks at most 100 `.no` names, one per second, and any `.no` name past that cap, or past a refusal from Norid, gets the DNS check with a note.
- Where only DNS can be asked, a name with nameservers counts as taken. A name without them gets `available: null`, since a registered domain can exist without nameservers.
- Registries publish different details about taken names. On 11 October 2026 `.de` gave neither a registrar nor dates, `.ch` only the registration date, `.eu` and `.at` only the registrar, `.jp` only the expiry, and `.it` the dates without a registrar.
- A run of 50 pairs over 25 suffixes took 20 seconds on 11 October 2026. A run of 50 made-up names on `.eu` and `.it`, which answer over WHOIS, took 40 seconds, and all 50 came back as available.
- Every pair in the input is checked even when **Maximum rows** is lower, and only the rows returned are charged.

### FAQ

#### Is it legal to check domain availability?

The actor asks the registries' public RDAP and WHOIS services, Norid's public availability service for `.no` and public DNS. Registries run those services so that anyone can see whether a name is registered and through which registrar. A row holds facts about the domain and nothing about the registrant. You are responsible for how you use the results.

#### Can I check full domains instead of names and TLDs?

Yes. Put the full domains into **Names**, such as `brightpath.io` or `northwind.co.uk`. Each one is checked once as it stands, and **TLDs** applies only to the entries without a suffix.

### Related scrapers

- [Domain WHOIS and DNS Lookup](https://apify.com/deriverge/domain-whois-dns-lookup)
- [WHOIS Domain Lookup](https://apify.com/deriverge/whois-domain-lookup)
- [DNS Records Lookup](https://apify.com/deriverge/dns-records-lookup)

### Support

This actor is built and maintained by deriverge s.r.o., a software company based in the Czech Republic. If a run fails or a field you need is missing, please open an issue in the **Issues** tab or write to us at info@deriverge.com. We respond in English and Czech. Runs can be scheduled in Apify Console or started from the **API** tab, which has examples for Python, JavaScript and cURL and works with Make, Zapier, n8n and the Apify MCP server. If the actor saves you time, a short review helps other people find it.

# Changelog

This Actor's version history is a separate document: https://apify.com/deriverge/domain-availability-checker/changelog.md

# Actor input Schema

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

Names without a suffix are combined with every TLD below. A full domain such as acme.co.uk is checked as it is.

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

Suffixes to try for each bare name. Any TLD works; those without a registry lookup fall back to a DNS delegation check and say so.

## `maxItems` (type: `integer`):

Hard cap on returned checks in the run.

## Actor input object example

```json
{
  "names": [
    "acme",
    "brightpath"
  ],
  "tlds": [
    "com",
    "net",
    "org",
    "io",
    "co",
    "ai",
    "app",
    "dev"
  ],
  "maxItems": 10000
}
```

# Actor output Schema

## `rows` (type: `string`):

One row per name and TLD: available or taken, how it was checked, and registrar and expiry for taken names.

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

Counts, what was charged, lookups that failed and notes.

# 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": [
        "acme",
        "brightpath"
    ],
    "tlds": [
        "com",
        "net",
        "org",
        "io",
        "co",
        "ai",
        "app",
        "dev"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("deriverge/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 = {
    "names": [
        "acme",
        "brightpath",
    ],
    "tlds": [
        "com",
        "net",
        "org",
        "io",
        "co",
        "ai",
        "app",
        "dev",
    ],
}

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

```

## MCP server setup

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