# Bulk Domain Availability Checker \[$0.60/1K 💰] (`cybermax/domain-availability-checker`) Actor

💰 $0.60 per 1,000 domains + $0.002 per run. Bulk domain availability checker: names across .com .net .org .io .ai .app .dev or full domain lists, registered or available straight from the registry (RDAP), with registrar, created and expiry dates and pending-delete flags. Unknown results are free.

- **URL**: https://apify.com/cybermax/domain-availability-checker.md
- **Developed by:** [CyberMax](https://apify.com/cybermax) (community)
- **Categories:** Developer tools, SEO tools, MCP servers
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## 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

## Nameshuck: Bulk Domain Availability Checker

#### Check hundreds of names across .com, .io, .ai and more in one run: registered or available, straight from the registry, with registrar and expiry date

Nameshuck is a **bulk domain availability checker**. Paste brand names (`northwind`, `quick petal`) and a list of extensions, or a list of full domains, and get one row per domain: available or registered, plus the registrar, registration and expiry dates and a pending-delete flag when the registry shows one. It asks each registry's public RDAP server directly (no scraping of registrar pages), and falls back to DNS for extensions that have no RDAP server.

**[▶ Try it now](https://apify.com/cybermax/domain-availability-checker)** (run it empty for a free demo) · $0.0006 per domain + $0.002 per run · Apify's free plan includes $5 of credit a month, enough for about 8,000 domains

**Built for:** founders and naming agencies shortlisting 50 brand names across 8 extensions · domain investors and brokers screening lists for names that are free or about to drop · SEO and brand teams checking a competitor's or a client's portfolio · developers and AI agents that need a yes/no on a domain in a workflow

**Real output** (run on Apify, 18 Nov 2026: 15 names x 8 extensions + 2 domains, 13 s, 256 MB):

| domain | available | status | registrar | registered | expires | source |
|---|---|---|---|---|---|---|
| northwind.com | false | registered | GoDaddy.com, LLC | 1998-10-12 | 2030-10-11 | rdap |
| northwind.io | false | registered | Tucows Domains Inc. | 2019-12-10 | 2026-12-10 | rdap |
| bluefern.io | true | available | | | | rdap |
| bluefern.dev | true | available | | | | rdap |
| bluefern.co | false | registered | | | | dns |

```json
{
  "domain": "bluefern.io",
  "tld": "io",
  "available": true,
  "status": "available",
  "method": "rdap",
  "note": "Not registered per the registry. Premium, reserved or blocked names can still be unavailable at a registrar.",
  "charged": true
}
```

### How to use it

1. **Names to check across TLDs:** brand or product names without an extension. Each is checked on every extension in **TLDs for the names** (default `com, net, org, io, co, ai, app, dev`).
2. Or **Full domains to check:** one per line. URLs and emails work too (`https://www.acme.io/pricing` becomes `acme.io`).
3. Run. Every domain comes back as `registered`, `available`, `possibly_available` or `unknown`. Turn on **Output available names only** to keep just the free ones.
4. Leave everything empty for a free demo on sample domains.

### What the statuses mean

| Status | Meaning | Charged |
|---|---|---|
| `registered` | The registry has a record (RDAP answer, or name servers found in DNS for extensions with no RDAP server) | yes |
| `available` | The registry says there is no such registration (RDAP 404) | yes |
| `possibly_available` | The extension has no RDAP server and the name does not exist in DNS. A registered domain with no name servers looks the same, so confirm at a registrar | free |
| `unknown` | The registry could not be reached after retries | free |
| `invalid` | Not a valid domain name | free |

### Output fields

`domain`, `tld`, `available` (true / false / null), `status`, `method` (`rdap` or `dns`), `registrar`, `createdAt`, `expiresAt`, `updatedAt`, `statuses` (registry status codes), `nameservers`, `droppingSoon` (registry shows pending delete), `inRedemption`, `note`, `charged`.

### Ready-made inputs

| Job | Input |
|---|---|
| **Shortlist a brand name** | `{"names": ["northwind", "bluefern"], "tlds": ["com", "io", "ai", "dev"]}` |
| **Screen a list for free names** | `{"domains": ["acme.com", "acme.io"], "onlyAvailable": true}` |
| **Spot domains that are dropping** | `{"domains": ["..."]}` then filter `droppingSoon = true` |

### Integrations

- **API (curl):**
  ```bash
  curl -X POST "https://api.apify.com/v2/acts/cybermax~domain-availability-checker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
    -H "Content-Type: application/json" -d '{"names": ["northwind"], "tlds": ["com", "io"]}'
  ```
- **Python:** `ApifyClient(token).actor("cybermax/domain-availability-checker").call(run_input={"names": names})`
- **Make, Zapier, n8n:** check a name from a form or a Google Sheet row.
- **AI agents (MCP):** `https://mcp.apify.com?actors=cybermax/domain-availability-checker`.

### Pricing

| What | Price |
|---|---|
| Domain with a definite answer (registered or available) | **$0.0006** ($0.60 per 1,000) |
| Run (own input only) | $0.002 |
| Demo runs, duplicates, invalid names, possibly-available, unknown | free |

Example: 50 names x 8 extensions = 400 domains cost **$0.24 + $0.002**. Apify's free plan includes $5 of credit a month.

### Why Nameshuck

| | Nameshuck | Other domain checkers on the Store (18 Nov 2026) |
|---|---|---|
| Price per domain | **$0.0006** + $0.002 per run | $0.0005 to $0.0023 per domain; automation-lab adds a $0.035 start fee |
| Input | Names x extensions, or full domains, URLs and emails | Usually full domains only |
| Source | The registry's own RDAP server, with dates and registrar | Often a scrape of a registrar page or DNS only |
| Unclear answers | Free and labelled | Often counted as a result |

### When NOT to use Nameshuck

- **You need the registration price.** Nameshuck says whether a name is registered; it does not quote registrar prices, and premium or reserved names can show as available.
- **You need to buy or backorder.** It never registers anything.
- **You need WHOIS contact details.** Registries redact personal data; Nameshuck returns registrar, dates and status only.

### FAQ

**How accurate is "available"?** It means the registry has no record of the domain (RDAP 404). Registries and registrars can still refuse a name (reserved, premium, trademark-blocked). Always confirm at checkout.

**Which extensions have RDAP?** Over 1,200, including com, net, org, io, ai, app, dev, uk, fr, nl, de and most new extensions. A few (for example `.co`) have none; those fall back to DNS and are labelled `possibly_available` and free.

**Is it polite to the registries?** Lookups run 10 at a time by default with retries and back-off, using the public RDAP service every registry offers.

**Is my data safe?** Only the domain names you give are looked up. Nothing else is read or stored.

### Also from CyberMax

- [Namewhere: Company Name to Domain](https://apify.com/cybermax/company-to-domain) · find the website of a company list, then check the variants you could register.
- [DomainDNA: Tech Stack, WHOIS & Domain Age](https://apify.com/cybermax/domain-intel) · what a registered domain runs on.
- [Linkpail: Broken Link & Image Checker](https://apify.com/cybermax/broken-link-checker) · check the links on the site you just bought.

Found this useful? A quick rating helps others find it.

© 2026 CyberMax. All rights reserved.

# Actor input Schema

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

Brand or product names without an extension (acme, my startup). Each is checked on every TLD below. Names that already contain a dot are treated as full domains. Leave everything empty for a free demo.

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

Extensions to try for each name, without the dot. Default: com, net, org, io, co, ai, app, dev.

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

One per line: acme.com, https://www.acme.io/pricing or jane@acme.co all work (reduced to the registrable domain).

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

Drop registered domains from the output (they are still checked, counted and charged).

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

Optional cap on domains checked.

## `concurrency` (type: `integer`):

How many domains are looked up at once. 10 is safe for the public registry servers.

## Actor input object example

```json
{
  "names": [
    "northwind",
    "bluefern",
    "quickpetal"
  ],
  "tlds": [
    "com",
    "net",
    "org",
    "io",
    "co",
    "ai",
    "app",
    "dev"
  ],
  "domains": [
    "example.com"
  ],
  "onlyAvailable": false,
  "concurrency": 10
}
```

# Actor output Schema

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

No description

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

No description

# 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": [
        "northwind",
        "bluefern",
        "quickpetal"
    ],
    "domains": [
        "example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("cybermax/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": [
        "northwind",
        "bluefern",
        "quickpetal",
    ],
    "domains": ["example.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("cybermax/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": [
    "northwind",
    "bluefern",
    "quickpetal"
  ],
  "domains": [
    "example.com"
  ]
}' |
apify call cybermax/domain-availability-checker --silent --output-dataset

```

## MCP server setup

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