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

Check domain availability, expiry dates, registrar, and nameservers via RDAP. Supports bulk prefix×TLD combination checks. No API key — uses IANA RDAP bootstrap for accurate TLD routing. Perfect for domain hunters, founders, and SEO researchers.

- **URL**: https://apify.com/gochujang/domain-availability-checker.md
- **Developed by:** [Hojun Lee](https://apify.com/gochujang) (community)
- **Categories:** Developer tools
- **Security:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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

### What does Domain Availability Checker do?

**Domain Availability Checker** is a fast, no-API-key **domain availability checker** that queries IANA RDAP directly to determine whether any domain is registered or free to purchase. It supports **bulk domain lookup** across hundreds of prefix × TLD combinations in a single run, making it the ideal **domain registration API** replacement for founders, domain investors, and SEO researchers. Results include registrar name, registration dates, expiry countdown, and smart analytics fields like domain value estimate and crypto-project fit score.

### Why use Domain Availability Checker?

**Domain hunters and growth teams** use this actor because it turns hours of manual checking into a minutes-long automated sweep.

- **Startup name research** — Generate dozens of name ideas and instantly check availability across `.com`, `.io`, `.ai`, and `.co` simultaneously using the **bulk combination mode**.
- **Domain portfolio management** — Monitor a list of owned domains and flag those expiring within 30 days before they drop into the open market.
- **Drop-catching opportunities** — The actor flags `drop_catching_opportunity` for registered domains with imminent expiry, giving buyers advance notice for competitive auctions.
- **Competitor and SEO research** — Scan competitor domains to surface registrar, creation date, and expiry data useful for market timing and competitive intelligence.
- **Crypto and Web3 project naming** — Built-in crypto keyword detection scores how well a domain name fits DeFi/Web3 branding, accelerating naming decisions for blockchain projects.

### How to use Domain Availability Checker

1. Click **Try for free** on the Apify Store listing — no API key needed.
2. **Simple mode**: enter a list of domains in the `domains` field (e.g. `["myapp.com", "myapp.io"]`).
3. **Bulk mode**: enable `checkBulk`, enter name prefixes in `bulkPrefixes` (e.g. `["myapp", "coolstartup"]`) and TLDs in `tlds` (e.g. `[".com", ".io", ".ai"]`). The actor generates and checks every combination.
4. Optionally adjust `maxConcurrency` (1–20) to balance speed against rate-limit risk.
5. Click **Start**. Results appear in the dataset within seconds per domain.
6. Filter results by `available: true` and sort by `domain_value_estimate` to prioritize the best picks.

### Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `domains` | string\[] | No | `["example.com"]` | Specific domains to check; used when `checkBulk` is `false` |
| `checkBulk` | boolean | No | `false` | Enable **bulk domain lookup** — generates all prefix × TLD combinations |
| `bulkPrefixes` | string\[] | No | `[]` | Base name prefixes for bulk mode (e.g. `["myapp", "getfoo"]`) |
| `tlds` | string\[] | No | `[".com", ".org", ".io"]` | TLDs to combine with prefixes in bulk mode |
| `maxConcurrency` | integer | No | `5` | Parallel RDAP lookups (1–20); higher = faster but increases rate-limit risk |

#### Example Input — bulk name search

```json
{
  "checkBulk": true,
  "bulkPrefixes": ["myapp", "coolstartup", "getlaunch"],
  "tlds": [".com", ".io", ".ai"],
  "maxConcurrency": 5
}
```

### Output

One record per domain checked:

```json
{
  "domain": "myapp.io",
  "available": true,
  "status": [],
  "registrar": null,
  "expires": null,
  "expires_in_days": null,
  "checked_at": "2026-09-02T10:00:00+00:00",
  "tld_tier": "tier_1",
  "availability_signal": "available",
  "domain_value_estimate": "high",
  "crypto_project_fit": "strong",
  "brand_strength_score": 72,
  "registration_urgency": "act_now",
  "typosquat_risk": false,
  "drop_catching_opportunity": false
}
```

For a registered (taken) domain:

```json
{
  "domain": "google.com",
  "available": false,
  "status": ["clientDeleteProhibited", "clientTransferProhibited"],
  "registrar": "MarkMonitor Inc.",
  "expires": "2028-09-14",
  "expires_in_days": 742,
  "checked_at": "2026-09-02T10:00:00+00:00",
  "tld_tier": "tier_1",
  "availability_signal": "taken",
  "domain_value_estimate": "premium",
  "brand_strength_score": 100,
  "typosquat_risk": false,
  "drop_catching_opportunity": false
}
```

### Data fields

| Field | Description |
|---|---|
| `domain` | Normalized domain name (lowercase) |
| `available` | `true` if the domain appears unregistered and free to purchase |
| `status` | RDAP EPP status codes (e.g. `clientTransferProhibited`) |
| `registrar` | Registrar name from RDAP (if registered) |
| `expires` | Expiry date `YYYY-MM-DD` (if registered) |
| `expires_in_days` | Days until expiry — negative means already expired |
| `tld_tier` | TLD quality tier: `tier_1` (.com/.io/.co), `tier_2` (.ai/.app/.dev), `geo`, or `other` |
| `availability_signal` | `available`, `taken`, `premium_opportunity`, `expiring`, `error`, or `unknown` |
| `domain_value_estimate` | Relative market value: `premium`, `high`, `medium`, or `low` |
| `crypto_project_fit` | How well the name fits Web3/DeFi branding: `strong`, `moderate`, `weak`, or `none` |
| `brand_strength_score` | 0–100 score based on length, pronounceability, and keyword signals |
| `registration_urgency` | Urgency signal: `act_now`, `monitor`, `low`, or `not_applicable` |
| `typosquat_risk` | `true` if the domain is suspiciously close to a major brand name |
| `drop_catching_opportunity` | `true` if registered but expiring imminently — watch for auction |
| `checked_at` | ISO 8601 timestamp of the RDAP check |

### Cost estimation

**$0.002 per domain checked** (Pay-Per-Event).

| Scenario | Domains | Estimated Cost |
|---|---|---|
| Quick spot check | 5 | $0.01 |
| Startup name sweep (3 prefixes × 5 TLDs) | 15 | $0.03 |
| Portfolio monitoring | 500 | $1.00 |
| Large bulk scan | 2,000 | $4.00 |

No base fee beyond Apify's standard platform usage.

### FAQ

**Does this require a paid API key?**
No. The actor uses the **IANA RDAP bootstrap registry** directly — no API key from any third-party service is needed. RDAP is the official successor to WHOIS and is free and public.

**How accurate is the availability check?**
Very high accuracy for standard gTLDs (.com, .io, .net, .org) and most ccTLDs. A domain is flagged **available** when RDAP returns a 404 (not found) response, which is the definitive IANA-standard signal for unregistered domains. Rare premium/reserved domains may show as available if the registry does not publish RDAP data.

**Can I use this to monitor for domains about to expire?**
Yes. Run the actor on a scheduled basis against your watch list and filter results where `expires_in_days < 30`. The `drop_catching_opportunity` flag highlights domains expiring within days that may become available for registration or auction soon.

***

*Data source: [IANA RDAP Bootstrap Registry](https://data.iana.org/rdap/dns.json) with TLD-specific RDAP server routing. No active port scanning or scraping. All lookups use the official RDAP protocol (RFC 9082).*

***

### Related actors

- [Domain DNS Checker](https://apify.com/gochujang/domain-dns-checker) — DNS records (A, MX, NS, TXT) for domains found available or registered via this actor
- [Domain Breach Checker](https://apify.com/gochujang/domain-breach-checker) — HIBP breach history for registered domains you're researching
- [SSL Certificate Monitor](https://apify.com/gochujang/ssl-certificate-monitor) — TLS expiry and certificate chain for domains you're monitoring

### Feedback

If this actor helps your domain research, a review helps others find it: [Leave a review on Apify Store](https://apify.com/gochujang/domain-availability-checker#reviews)

***

**Keywords:** domain availability checker, domain RDAP, bulk domain check, domain expiry lookup, domain registrar data, TLD availability, WHOIS alternative, nameserver lookup, domain hunter tool, brand domain check, domain registration status, IANA RDAP, SEO domain research

# Actor input Schema

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

List of domain names to check (e.g. example.com, myapp.io). Used when checkBulk is false.

## `checkBulk` (type: `boolean`):

When enabled, generate all combinations of bulkPrefixes × tlds and check them all.

## `bulkPrefixes` (type: `array`):

Base names to combine with TLDs (e.g. myapp, coolstartup). Only used when checkBulk is true.

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

Top-level domains to use in bulk check (e.g. .com, .io, .org). Only used when checkBulk is true.

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

Number of parallel RDAP lookups. Higher = faster but more likely to be rate-limited.

## Actor input object example

```json
{
  "domains": [
    "example.com",
    "google.org"
  ],
  "checkBulk": false,
  "bulkPrefixes": [],
  "tlds": [
    ".com",
    ".org",
    ".io"
  ],
  "maxConcurrency": 5
}
```

# Actor output Schema

## `results` (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 = {
    "domains": [
        "example.com",
        "google.org"
    ],
    "bulkPrefixes": [],
    "tlds": [
        ".com",
        ".org",
        ".io"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("gochujang/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": [
        "example.com",
        "google.org",
    ],
    "bulkPrefixes": [],
    "tlds": [
        ".com",
        ".org",
        ".io",
    ],
}

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

```

## MCP server setup

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