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

Check which domain names are still free to register. Combine names with endings such as .com, .io and .ai, or paste full domains. Asks the registries' official RDAP and WHOIS services and double-checks with DNS; for taken domains you get the registrar and expiry date.

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

## Pricing

from $0.60 / 1,000 domains

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 Domain Availability Checker do?

Domain Availability Checker tells you which domain names are **still free to register**. Give it the names you are thinking of and the endings you want (**.com, .io, .ai, .co.uk** and any other), or paste a list of full domains, and it checks every combination with the registries themselves. For each domain you get **available**, **registered** or **unknown**, and for the taken ones the **registrar** and the **expiry date**. Export the list to Excel, CSV or JSON, or use it in your own tools.

- Every name with every ending in one run: 20 names and 10 endings make 200 domains
- Also tries the hyphenated form of names with spaces (blue-fern.com next to bluefern.com)
- Asks the registry of each ending through its official RDAP service, or its WHOIS server for the country endings that have no RDAP yet
- Double-checks with DNS: a domain with name servers is in use, whatever a registry says
- Accented names work (münchen.de is checked as xn--mnchen-3ya.de, the form registries use)

### What data do you get?

| Field | Example |
|---|---|
| Domain | `bluefern.io` |
| Available | `true` |
| Status | `available`, `registered`, `unknown` or `invalid` |
| Registrar (taken domains) | `GoDaddy.com, LLC` |
| Expires (taken domains) | `2027-03-08T19:12:48Z` |
| Days to expiry | `512` |
| Source | `rdap`, `whois` or `dns` |
| Note | why DNS overruled the registry, when it did |

### How to check domain availability in bulk

1. Under **Names**, enter the names you want to try, one per line, for example `bluefern`.
2. Under **Domain endings**, keep the usual list (com, net, org, io, co, ai, app, dev) or enter your own.
3. Or paste complete domains under **Full domain names**.
4. Press **Start**. Sort the table by **Available** to see the free ones first.

### How much does it cost?

You pay for results, not for time: **$0.80 per 1,000 domains**. Apify subscribers on the Silver plan pay $0.70 and on the Gold plan $0.60 per 1,000 domains. Each run also has a start fee of $0.00005.

| Domains checked | Cost |
|---|---|
| 100 | $0.08 |
| 1,000 | $0.80 |
| 10,000 | $8.00 |
| 100,000 | $80.00 |

Apify's free plan includes $5 of credit each month, which covers about 6,000 domains. Set a maximum cost for the run in Apify Console and the tool stops there and keeps what it has checked.

### Input

Enter **Names** together with **Domain endings**, or **Full domain names**, or both. The other options:

- **Also try names with hyphens**: for names with spaces, check blue-fern.com as well as bluefern.com.
- **Details of taken domains** (on by default): registrar, creation date, expiry date and days until expiry.
- **Double-check with DNS** (on by default): looks up the name servers of the domains the registry calls free or could not answer for.
- **Time limit per lookup**: how long to wait for a slow registry.

### Output example

```json
{
    "domain": "bluefern.io",
    "input": "bluefern",
    "name": "bluefern",
    "tld": "io",
    "available": true,
    "status": "available",
    "registrar": null,
    "createdAt": null,
    "expiresAt": null,
    "daysUntilExpiry": null,
    "source": "rdap",
    "checkedAt": "2026-10-16T08:00:00.000Z",
    "note": null,
    "error": null
}
```

A domain that cannot be settled, for example because its registry is down and it has no name servers, has `available: null`, status `unknown` and an error such as `TIMEOUT` or `RDAP_RATE_LIMITED`. An entry that is not a name, domain or ending has status `invalid`.

### What can you use it for?

- Find a free name for a new company, product, app or project across many endings at once
- Check a brainstormed list of hundreds of names in one go
- Watch the expiry dates of domains you would like to buy
- Check which endings of your brand are still open before someone else registers them
- Feed available names into your own naming or branding tool through the API

### Use it from the API

```bash
curl -X POST "https://api.apify.com/v2/acts/cyber1nj3ct0r~domain-availability-checker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"names": ["bluefern", "red oak"], "tlds": ["com", "io", "ai"], "alsoHyphenated": true}'
```

The same works from Python, JavaScript, Make, Zapier and n8n through Apify's integrations.

### FAQ

#### Does "available" mean I can buy it?

It means the registry has no registration for the name. Almost always you can then register it at any registrar, but registries also keep some names back: premium names sold at a higher price, and reserved or blocked names. Confirm at your registrar before you rely on a name.

#### Why is a domain "registered" with source "dns"?

The registry said it had no record, or could not be asked, but the domain has name servers. Name servers only exist for registered domains, so the tool reports it as taken and says why in the note.

#### Why do I see "unknown"?

The registry did not answer in time or refused because of too many requests, and DNS could not settle it. The tool waits and asks again before it gives up. Run the unknown ones again later, or with a longer time limit.

#### Which endings work?

All endings in the official list of top-level domains, including country endings such as .de, .fr and .co.uk. Most registries answer over RDAP; the tool uses WHOIS for the few that do not.

#### Is it allowed?

The tool asks the registries' public RDAP and WHOIS services, the same services registrars use, at a gentle pace. It returns no contact details of domain owners.

#### Something does not work

Open an issue on the **Issues** tab with the domains you tried. Every report is read and answered.

# Actor input Schema

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

Names to try with every ending below, one per line, for example <code>bluefern</code> or <code>Blue Fern</code>. Spaces and punctuation are left out; accented letters work and are checked in the form registries use (xn--...).

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

The endings to combine with each name, for example <code>com</code>, <code>io</code>, <code>ai</code> or <code>co.uk</code>. A leading dot is fine.

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

Domains to check as they are, one per line, for example <code>bluefern.shop</code>. Web addresses work too: the domain is taken from them.

## `alsoHyphenated` (type: `boolean`):

For names with spaces, also check the form with hyphens: blue-fern.com next to bluefern.com.

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

For registered domains: the registrar, the creation date, the expiry date and the days until expiry.

## `checkDns` (type: `boolean`):

Look up the name servers of every domain the registry calls free, and of those it could not answer for. A domain with name servers is registered.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for a registry server before giving up on a domain.

## Actor input object example

```json
{
  "names": [
    "apify",
    "crawlee"
  ],
  "tlds": [
    "com",
    "net",
    "org",
    "io",
    "co",
    "ai",
    "app",
    "dev"
  ],
  "alsoHyphenated": false,
  "includeDetails": true,
  "checkDns": true,
  "requestTimeoutSecs": 20
}
```

# Actor output Schema

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

One record per domain: available, registered or unknown, with the registrar and expiry date of taken ones.

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

How many domains were available, registered, unknown or not valid.

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

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

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

```

## MCP server setup

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