# Domain Availability Checker — RDAP, WHOIS & DNS JSON (`eliai/domain-availability-checker`) Actor

Check if a domain is available to register. RDAP + WHOIS + DNS in one JSON row: available/taken, registrar, created/expiry, nameservers. No start fee. $0.02 per definite verdict; invalid and unknown names are free.

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

## Pricing

from $16.00 / 1,000 domains 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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Domain Availability Checker — RDAP, WHOIS & DNS JSON

Check whether a domain name is **available to register** or already taken. One JSON row per name: available/taken, registrar, created/expiry dates, name servers. Online, by API, or as an agent tool via Apify MCP.

This Actor asks the **registry** first (RDAP via the IANA bootstrap), then WHOIS, and records DNS as corroboration. It never marks a name `available: true` from a missing A record alone — that is how parked and quirky ccTLDs fake a vacancy.

### What you get

- **available / status** — `true`/`available` or `false`/`taken`. Unknown lookups are `{ok:false}` and **not charged**.
- **source** — `rdap`, `rdap-404`, or `whois` (the evidence that produced the verdict)
- **registrar, createdAt, expiresAt, nameServers** — filled on taken names when the registry returns them
- **dnsHasNs / dnsHasA** — extra signal, never the sole verdict
- **Bulk** — up to 100 domains per run (default cap 25)
- **Fail-soft** — a dead WHOIS server or an invalid string never fails the run

### Common requests this handles

Phrased the way people actually ask, so a buyer — or an AI agent choosing a tool — can match
on the real requirement rather than the category name:

- *"Is this domain available to register?"* One row per domain with an explicit
  `available` / `taken` verdict, not a raw record you have to interpret.
- *"Bulk domain availability check for a list of names."* Pass up to 25 domains per run;
  each becomes its own record.
- *"Check domain availability without a registrar API key."* No registrar account, no API key,
  no reseller signup — RDAP and DNS are queried directly.
- *"Who is the registrar and when does it expire?"* Registrar, creation, expiry and update
  dates and nameservers come back on the same row as the verdict.
- *"RDAP lookup as clean JSON."* RDAP is the modern replacement for WHOIS; the response is
  parsed into flat fields rather than returned as raw text to regex yourself.
- *"WHOIS fallback when RDAP has no data."* WHOIS is used as a fallback, and the `source`
  field always says which one answered.
- *"Domain research for brainstorming or brand checks."* Invalid names and genuinely
  indeterminate answers are returned as such and are never charged.

### Input

```json
{ "domains": ["google.com", "a-name-you-hope-is-free.com"], "maxDomains": 25 }
```

Or a single name: `{ "domain": "google.com" }`. URLs are accepted; scheme and path are stripped.

A programmatic `{}` run checks `google.com` (the schema default) so Apify's own listing test produces a real taken-domain row.

### Output (real RDAP, trimmed)

```json
{
  "domain": "google.com",
  "ok": true,
  "available": false,
  "status": "taken",
  "source": "rdap",
  "registrar": "MarkMonitor Inc.",
  "createdAt": "1997-09-15T04:00:00.000Z",
  "nameServers": ["ns1.google.com", "ns2.google.com"],
  "tld": "com"
}
```

### Pricing

**$0.02 per domain with a definite verdict.** No start fee. Invalid names and lookup failures are recorded free.

Measured against the store leader on 2026-08-27: [automation-lab/domain-availability-checker](https://apify.com/automation-lab/domain-availability-checker) charges **$0.035 to start** plus about $0.002 per domain. A one-name check here is $0.02; there is no start tax. High-volume investor dumps at $0.002/name are a different product — this listing is the 1–25 name brand check.

### Honest limits

- **Not a suggestion engine.** You pass exact names. It does not invent alternatives or check trademarks.
- **Not aftermarket pricing.** Taken names are taken; we do not quote GoDaddy/Sedo resale.
- **Some ccTLDs have no RDAP.** Those fall through to WHOIS. If both fail, you get `{ok:false}` uncharged rather than a guessed vacancy.
- **`.ai` and similar TLDs:** missing DNS is not availability. Those names are confirmed via WHOIS before `available: true`.

### FAQ

**How is this different from WHOIS Lookup?**
WHOIS Lookup (`eliai/whois-lookup`) answers "who holds this name?". This Actor answers "can I register it?" and includes registration fields on taken names. Different store query, different charge.

**Will a 404 from DNS mean the name is free?**
No. Parking, registry wildcards, and several ccTLDs (`.ai` among them) lie that way. Available requires RDAP 404 or a registry WHOIS "not found".

**What does a `{}` run return?**
`google.com`, taken, with registrar fields. That is the venue acceptance demo.

**Why did a row come back `ok: false`?**
The name was invalid, or RDAP and WHOIS both failed to produce a verdict. Recorded with the error, never charged. Retry, or check the TLD still has a public registry.

**Can I check 1,000 names?**
Cap is 100 per run (default 25). Split batches. At $0.02 each, 100 definite verdicts cost $2.00.

### Use from code or AI agents

```bash
curl -s "https://api.apify.com/v2/acts/eliai~domain-availability-checker/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -X POST -H "Content-Type: application/json" \
  -d '{"domains": ["yourbrand.com", "yourbrand.io"]}'
```

Store page: https://apify.com/eliai/domain-availability-checker

### Changelog

- **0.1.0 (2026-08-27)** — First public version. RDAP-first availability, WHOIS fallback, DNS corroboration only, $0.02 per definite verdict, no start fee.

# Actor input Schema

## `domain` (type: `string`):

A single domain to check (e.g. google.com). Scheme, path and port are stripped automatically.

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

Multiple domains to check in one run. When you set this, it is used on its own and the single-value field above is ignored, so you are only charged for the names you sent.

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

Cap on how many domains to process per run.

## Actor input object example

```json
{
  "domain": "google.com",
  "domains": [
    "github.com",
    "cloudflare.com"
  ],
  "maxDomains": 25
}
```

# Actor output Schema

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

Every domain this run checked, as JSON.

## `resultsCsv` (type: `string`):

The same items as a spreadsheet-ready CSV.

# 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 = {
    "domain": "google.com",
    "domains": [
        "github.com",
        "cloudflare.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("eliai/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 = {
    "domain": "google.com",
    "domains": [
        "github.com",
        "cloudflare.com",
    ],
}

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

```

## MCP server setup

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