# Bulk Domain Availability Checker – RDAP, Name Ideas, Any TLD (`nordic-data/domain-availability-checker`) Actor

Check if domains are available in bulk, or generate name ideas from keywords × TLDs × prefixes/suffixes. Official registry RDAP data (registrar, expiry date for taken names), DNS fallback for other TLDs. $0.0019 per domain.

- **URL**: https://apify.com/nordic-data/domain-availability-checker.md
- **Developed by:** [Niklas Bergström](https://apify.com/nordic-data) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.90 / 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.

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

## Bulk Domain Availability Checker

Check whether domain names are available to register, in bulk, for any TLD. Paste a list of domains, or give a few keywords and let the Actor try every combination with your TLDs, prefixes and suffixes. Availability comes straight from the **official registry RDAP servers** (the ICANN successor to WHOIS), so there's no scraping of registrar sites.

**$0.0019 per domain checked.** Invalid inputs, duplicates and failed checks are free. Turn on **Only output available domains** and you pay only for names you can actually register.

### What you get

| Field | Meaning |
|---|---|
| `domain` | The domain checked |
| `status` | `available`, `registered`, `likely_available` (DNS fallback, no RDAP) or `unknown` |
| `available` | `true` / `false` / `null` when it couldn't be determined |
| `method` | `rdap` (registry answer) or `dns` (delegation check) |
| `registrar`, `createdDate`, `expiresDate`, `daysUntilExpiry`, `statuses`, `nameservers` | For taken names, from RDAP (toggle with *Registration details*) |
| `expiringSoon` | `true` when the registry status shows hold, redemption or pending delete |

### Use cases

- **Brand and startup naming:** test 20 name ideas across .com, .io, .ai, .app and your country TLD in one run.
- **Domain investing:** screen keyword lists and see expiry dates of taken names.
- **Agencies and marketplaces:** feed availability into Make, n8n, Zapier or your own app through the Apify API.
- **Brand protection:** check which typo and country-code variants of your brand are still open.

### Input example

```json
{
  "keywords": ["green leaf", "nordic data"],
  "tlds": ["com", "io", "ai", "se"],
  "prefixes": ["get"],
  "suffixes": ["hq"],
  "includeHyphenatedVariants": false,
  "onlyAvailable": true,
  "includeRegistrationDetails": true,
  "dnsFallback": true
}
```

You can also pass a plain list in `domains`. URLs and e-mail addresses are reduced to their domain.

### Output example

```json
{
  "recordType": "domain",
  "domain": "github.io",
  "label": "github",
  "tld": "io",
  "status": "registered",
  "available": false,
  "method": "rdap",
  "registrar": "MarkMonitor Inc.",
  "expiresDate": "2027-03-08T19:12:48Z",
  "expiringSoon": false,
  "checkedAt": "2026-11-01T03:20:00Z"
}
```

### How accurate is it?

- **RDAP TLDs** (all gTLDs such as .com, .net, .org, .io, .ai, .app, .dev and many country codes such as .no, .fi, .uk, .nl, .fr): the registry itself says whether the name exists. An `available` result can still be a reserved or premium name that the registry prices differently; the registry doesn't publish prices in RDAP.
- **TLDs without public RDAP** (for example .de, .se, .dk): a DNS check is used. A name with nameservers is `registered`; a name that doesn't exist in DNS is `likely_available` because a registered domain can exist without DNS.

### Limits

Up to 20,000 unique domains per run. Requests are rate-limited per registry so runs stay polite and reliable. Use `maxDomains` to cap a run.

### Related Actors

- [Domain WHOIS & DNS Lookup](https://apify.com/nordic-data/domain-whois-dns-lookup): full RDAP WHOIS plus DNS, MX, SPF, DMARC and DKIM for registered domains.
- [Website Tech Stack Detector](https://apify.com/nordic-data/website-tech-stack-detector)

# Changelog

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

# Actor input Schema

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

One per line, e.g. mybrand.com. URLs and e-mail addresses are reduced to their domain. Duplicates are removed and never charged.

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

Optional. Each keyword is combined with every TLD below (and the optional prefixes/suffixes). Spaces are removed: 'green leaf' becomes greenleaf.com.

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

Used with keywords. Any TLD works, including country codes such as se, no, fi, dk, de, co.uk.

## `prefixes` (type: `array`):

Also try each keyword with these prefixes, e.g. get, try, my. The plain keyword is always included.

## `suffixes` (type: `array`):

Also try each keyword with these suffixes, e.g. hq, app, labs. The plain keyword is always included.

## `includeHyphenatedVariants` (type: `boolean`):

For multi-word keywords, also check green-leaf.com next to greenleaf.com.

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

Hide registered and undetermined domains. Hidden domains are not charged, so you only pay for available names.

## `includeRegistrationDetails` (type: `boolean`):

For registered domains, add registrar, creation and expiry date, days until expiry, status codes and nameservers from RDAP.

## `dnsFallback` (type: `boolean`):

Some country-code registries (for example .de) have no public RDAP. Then a DNS delegation check is used: a domain with nameservers is registered; NXDOMAIN is reported as likely_available.

## `maxDomains` (type: `integer`):

Stop after this many unique domains (0 = no limit, hard cap 20,000 per run).

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

Domains checked in parallel (1-25). Per-registry rate limits are always respected.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "nordicdatabrand-test.com",
    "nordicdatabrand-test.io"
  ],
  "tlds": [
    "com",
    "net",
    "org",
    "io",
    "co",
    "ai",
    "app",
    "dev"
  ],
  "includeHyphenatedVariants": false,
  "onlyAvailable": false,
  "includeRegistrationDetails": true,
  "dnsFallback": true,
  "maxDomains": 0,
  "maxConcurrency": 10
}
```

# Actor output Schema

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

Availability results (view: Availability).

## `runStats` (type: `string`):

Counts of checked, available, registered, hidden, invalid, duplicate and failed domains.

# 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",
        "nordicdatabrand-test.com",
        "nordicdatabrand-test.io"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nordic-data/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",
        "nordicdatabrand-test.com",
        "nordicdatabrand-test.io",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("nordic-data/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",
    "nordicdatabrand-test.com",
    "nordicdatabrand-test.io"
  ]
}' |
apify call nordic-data/domain-availability-checker --silent --output-dataset

```

## MCP server setup

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