# Bulk Domain Availability Checker: Registrar & Expiry Dates (`kvali/domain-availability-checker`) Actor

Check thousands of domain names at once: available or registered, with registrar, creation and expiry dates from the official registry (RDAP). Try one name across .com, .io, .ai and 1,200+ other endings. No API key, no login.

- **URL**: https://apify.com/kvali/domain-availability-checker.md
- **Developed by:** [Kvali Data](https://apify.com/kvali) (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

from $0.80 / 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.
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?

**Bulk Domain Availability Checker** tells you, for a list of thousands of domain names, which ones are **available** and which are **registered**, using public DNS and the **official registry lookup service (RDAP)**, the modern replacement for WHOIS. For registered domains it can also return:

- 🏢 the **registrar** (and its IANA ID)
- 📅 **registration date**, **expiry date** and **days until expiry**
- 🚦 the **registry status**, including **redemption period** and **pending delete**, flagged as `dropping` so you can spot domains about to become free
- 🌐 **nameservers** and whether the domain uses **DNSSEC**

Two ways to give it names, which you can mix:

1. **Domains to check**: a plain list (`example.com`), or whole links (`https://blog.example.co.uk/page` checks `example.co.uk`).
2. **Names to try × endings**: type `brightfox` and the endings `com, io, ai, co, dev`, and it checks all five. Any of the 1,200+ public endings works.

No API key, no login, no browser. Results come back in seconds: the 11-domain test run below took under 5 seconds.

### Why check domain availability in bulk?

- **Naming a startup, product or brand**: test a shortlist of names across every ending you care about in one run.
- **Domain investing**: check large keyword lists, and find registered domains that are **expiring soon** or already **dropping**.
- **Brand protection**: see which look-alike domains of your brand are taken, by which registrar, and since when.
- **Portfolio and client audits**: export expiry dates for every domain you manage, and schedule the run monthly so nothing lapses.
- **Lead and market research**: when a company registered its domain is a rough sign of its age.

### How to check domain availability

1. Click **Try for free**.
2. Paste your domains into **Domains to check**, or type names into **Names to try** and pick the **Endings**.
3. Turn on **Registrar and dates for registered domains** if you want registrar, creation and expiry dates for the taken ones too.
4. Click **Start**, then download the results as Excel, CSV, JSON or HTML, or get them through the API.

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

Pay per domain. There's **no start fee** and no monthly rental:

| Event | Price |
|---|---|
| Domain checked (status, plus registrar and dates when available) | **$1.00 per 1,000 domains** |

Domains that **could not be checked** (status `unknown`) are saved but **not charged**. Registrar and dates cost nothing extra. Higher Apify plans get a discount (−10% Silver, −20% Gold and up). Set a maximum cost per run and the Actor stops cleanly when it's reached.

The free Apify plan's monthly credit covers about 5,000 checks.

### Input

```json
{
    "domains": ["apify.com", "example.co.uk"],
    "keywords": ["brightfox"],
    "tlds": ["com", "net", "io", "ai", "dev"],
    "includeDetails": true
}
```

| Field | What it does |
|---|---|
| **Domains to check** (`domains`) | Domains, sub-domains or links, one per line. Names in other alphabets (`münchen.de`) work too. |
| **Names to try** (`keywords`) | Names without an ending; each is tried with every ending below. Spaces are removed. |
| **Endings for the names** (`tlds`) | `com`, `io`, `co.uk`... without the dot. Default `com`. |
| **Registrar and dates** (`includeDetails`) | Also look up registrar, dates and status of registered domains. Slower, same price. Off by default. |
| **Domains checked at the same time** (`maxConcurrency`) | Default 10. Requests to each registry are capped at 2 at a time either way. |

### Output

One row per domain. Real rows from a test run on 2026-11-05:

```json
[
    {
        "input": "apify.com",
        "domain": "apify.com",
        "tld": "com",
        "status": "registered",
        "available": false,
        "checkedVia": "dns+registry",
        "registrar": "Amazon Registrar, Inc.",
        "createdAt": "2009-06-02T17:14:10Z",
        "expiresAt": "2035-06-02T17:14:10Z",
        "daysUntilExpiry": 3131,
        "dropping": false,
        "nameservers": ["ns-1225.awsdns-25.org", "ns-1928.awsdns-49.co.uk", "ns-449.awsdns-56.com", "ns-839.awsdns-40.net"],
        "note": null
    },
    {
        "input": "kvalidata",
        "domain": "kvalidata.io",
        "tld": "io",
        "status": "available",
        "available": true,
        "checkedVia": "dns+registry",
        "note": null
    },
    {
        "input": "kvalidata",
        "domain": "kvalidata.de",
        "tld": "de",
        "status": "likely-available",
        "available": true,
        "checkedVia": "dns",
        "note": "Not in DNS, so probably free. .de has no public registry lookup; confirm at a registrar before buying."
    }
]
```

Every row also has `domainUnicode`, `registrarIanaId`, `updatedAt`, `registryStatus`, `dnssec`, `registryUrl` and `checkedAt`.

**What the statuses mean:**

| `status` | Meaning |
|---|---|
| `available` | The official registry has no record of the domain. |
| `registered` | The domain is taken (it has nameservers in DNS, or the registry has a record). |
| `likely-available` | Not in DNS, but this ending has no public registry lookup (for example `.de`), so it can't be confirmed. Check at a registrar before buying. |
| `unknown` | Couldn't be checked this time (for example the registry was busy). Not charged; run it again later. |

### How does it work?

For every domain it first asks public DNS whether the domain has nameservers. A domain with nameservers is registered, so no registry request is needed. Domains not in DNS are confirmed with the registry's own RDAP service, found through [IANA's official list](https://data.iana.org/rdap/dns.json). This keeps registry traffic low and within the registries' usage rules: at most 2 requests at a time per registry.

The Actor never collects owner names, emails, phone numbers or addresses, only registration facts about the domain.

### FAQ

**Is "available" a guarantee I can buy it?**
It means the registry has no registration for it. Some registries hold back **premium** or **reserved** names; those can show as available but cost more, or can't be bought at all. Your registrar shows the final price.

**Which endings are supported?**
Every public ending. About 1,200 have a registry lookup service (`.com`, `.net`, `.org`, `.io`, `.ai`, `.dev`, `.app`, `.co`, `.co.uk`, `.fr`, `.nl`, `.ca`, `.au`, `.in`, `.xyz`, `.shop`, most new endings). The rest (for example `.de`, `.eu`, `.es`, `.it`) are checked through DNS only and marked `likely-available` when free.

**Is this WHOIS?**
RDAP is WHOIS's official successor: the same registration facts in a standard JSON format, served by the registries themselves.

**How many domains can I check?**
As many as you like; very large lists just take longer. Registry rules limit how fast each one can be asked, so a list made mostly of free names in one ending (which need a registry check each) is the slowest case.

**Can I monitor expiry dates?**
Yes. Save your domain list as a Task, turn on **Registrar and dates**, and schedule it monthly. Sort by `daysUntilExpiry`.

**Can I use it from my own code or an AI agent?**
Yes: through the Apify API, the Python and JavaScript clients, or Apify's MCP server for AI agents.

Found a problem or need another field? Open an issue on the **Issues** tab and I'll take a look.

# Actor input Schema

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

One per line. Plain domains ("example.com"), sub-domains or whole links work too: "https://blog.example.co.uk/page" checks example.co.uk. Names in other alphabets ("münchen.de") are supported.

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

Brand or product names without an ending. Each one is checked with every ending below, so 3 names × 5 endings = 15 domains. Spaces are removed ("bright fox" → brightfox).

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

Domain endings to combine with the names above, without the dot: com, net, io, ai, co.uk, de... Any of the 1,200+ public endings works.

## `includeDetails` (type: `boolean`):

Also fetch the registrar, creation date, expiry date, days until expiry and registry status (for example "pending delete") of every registered domain. One extra registry lookup per registered domain, so slower; same price. Names that are not in DNS always get these details.

## `maxConcurrency` (type: `integer`):

Higher is faster. Requests to each registry are capped at 2 at a time either way, to respect their usage rules.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "example.co.uk",
    "my-new-startup.io"
  ],
  "keywords": [
    "brightfox",
    "kvalidata"
  ],
  "tlds": [
    "com",
    "net",
    "io",
    "ai",
    "dev"
  ],
  "includeDetails": false,
  "maxConcurrency": 10
}
```

# Actor output Schema

## `domains` (type: `string`):

One row per domain: available or registered, registrar, creation and expiry dates.

# 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",
        "example.com"
    ],
    "keywords": [
        "kvalidata"
    ],
    "tlds": [
        "com",
        "net",
        "io",
        "ai",
        "dev"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kvali/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",
        "example.com",
    ],
    "keywords": ["kvalidata"],
    "tlds": [
        "com",
        "net",
        "io",
        "ai",
        "dev",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("kvali/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",
    "example.com"
  ],
  "keywords": [
    "kvalidata"
  ],
  "tlds": [
    "com",
    "net",
    "io",
    "ai",
    "dev"
  ]
}' |
apify call kvali/domain-availability-checker --silent --output-dataset

```

## MCP server setup

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