# Bulk Domain Availability Checker (RDAP): Names × TLDs | $1.5/1K (`mauve_bunch/domain-availability-rdap`) Actor

Bulk domain availability via official RDAP. Input: domains, or names x TLDs. Output: domain, available/registered status, registrar, expiresAt, ageDays, nameservers. Inconclusive results are free. $1.50 per 1,000 domains. No registrant data.

- **URL**: https://apify.com/mauve_bunch/domain-availability-rdap.md
- **Developed by:** [Impakt](https://apify.com/mauve_bunch) (community)
- **Categories:** Developer tools, SEO tools, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 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.
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

## Bulk Domain Availability Checker (RDAP): Names × TLDs, Expiry Dates & Registrar

### Agent quick reference

- **Purpose:** Bulk domain availability via official RDAP.
- **Price:** $1.50 per 1,000 domains (pay per event; you pay only for items returned). Set `maxTotalChargeUsd` on the run to cap spend.
- **Call:** `POST https://api.apify.com/v2/acts/mauve_bunch~domain-availability-rdap/run-sync-get-dataset-items?token=<APIFY_TOKEN>` with the JSON input below, or via the Apify MCP server (`call-actor`, Actor `mauve_bunch/domain-availability-rdap`).
- **Minimal input:** `{"domains": ["apify.com", "example.org"], "names": ["mybrandname", "cool-startup-xyz"], "tlds": ["com", "io", "ai", "dev"], "onlyAvailable": false, "includeDetails": true, "dnsFallback": true, "concurrency": 20, "maxDomains": 5000, "dnsResolver": "system"}`
- **Output:** one JSON object per item in the default dataset; a `SUMMARY` record in the key-value store has run counts.

> **Try it in one click:** press Start and see which of the prefilled names are free across four TLDs in about 5 seconds. **$1.50 per 1,000 domains**, official RDAP, no registrant data.

**Check hundreds or thousands of domain names in seconds and know exactly which ones are free.** Paste full domains or brand names, choose TLDs, and the Actor returns `available` or `registered` for every combination. For registered domains it also returns the registrar, registration date, **expiry date**, days until expiry, domain age and nameservers.

It uses **RDAP**, the official protocol that replaced WHOIS, with the registry servers listed in the IANA bootstrap file. No scraping of registrar websites, no captchas, no proxies, and no personal registrant data.

### Who is it for

- **Founders and branding teams** checking a shortlist of names across `.com`, `.io`, `.ai`, `.app`, `.dev` and more.
- **Domain investors** monitoring when valuable domains expire (`daysUntilExpiry`) or finding unregistered names in bulk.
- **Agencies and IT teams** keeping an inventory of client domains with registrar and expiry data.
- **AI agents and automations** that need a reliable "is this name free?" tool.

### What you get

| Field | Description |
|---|---|
| `domain`, `tld` | The normalized domain (internationalized names are converted to punycode) |
| `status` | `available`, `registered`, `likely_available`, `unsupported_tld` or `unknown` |
| `available` | `true`, `false`, or `null` when inconclusive |
| `method` | `rdap` or `dns` (fallback for TLDs without RDAP) |
| `registrar` | Sponsoring registrar (a company, not a person) |
| `registeredAt`, `expiresAt`, `updatedAt` | Key dates from the registry |
| `ageDays`, `daysUntilExpiry` | Computed for convenience |
| `nameservers`, `rdapStatus` | Delegation and registry status flags such as `client transfer prohibited` |
| `reason` | Plain-language explanation for edge cases |
| `checkedAt` | Timestamp |

#### Input example

```json
{
  "names": ["mybrandname", "cool-startup-xyz"],
  "tlds": ["com", "io", "ai", "dev"],
  "domains": ["apify.com"],
  "onlyAvailable": false
}
```

#### Output example

```json
[
  { "domain": "apify.com", "status": "registered", "available": false, "method": "rdap",
    "registrar": "Amazon Registrar, Inc.", "registeredAt": "2009-06-02T17:14:10.000Z",
    "expiresAt": "2035-06-02T17:14:10.000Z", "ageDays": 6378, "daysUntilExpiry": 3117,
    "nameservers": ["ns-1.awsdns-01.org"] },
  { "domain": "mybrandname.dev", "status": "available", "available": true, "method": "rdap",
    "reason": "RDAP: no registration found (premium or reserved names cannot be detected)" }
]
```

### Pricing

Pay per event, no subscription:

| Event | Price |
|---|---|
| Actor start | $0.0001 |
| Each domain with a definitive answer (`available` or `registered`) | $0.0015 (about **$1.50 per 1,000 domains**, discounts on paid Apify plans) |

Inconclusive results (`unknown`, `unsupported_tld`, `likely_available`) are returned **free of charge**. Checking 20 names across 8 TLDs (160 domains) costs about $0.24.

### How accurate is it?

- **`available` via RDAP** means the registry has no registration for the name. That is the same signal registrars use. Premium, reserved or blocked names (a registry may refuse to register them) cannot be detected with RDAP, so check the price at a registrar before you buy.
- **`registered` via RDAP** is certain.
- **TLDs without RDAP** (for example `.de` and `.io` at the time of writing) use a DNS nameserver check. Nameservers found means registered. No nameservers is returned as `likely_available`, because a registered domain can exist without DNS delegation. Treat that as a hint, not proof.
- Registry servers can rate-limit. The Actor throttles per server, retries with back-off, and reports `unknown` (not billed) if a server stays unavailable.

### Tips

- Combine many names and TLDs in a single run. The Actor deduplicates and checks in parallel.
- Use `onlyAvailable` for naming sessions. Registered domains are skipped, and so is their cost.
- For expiry monitoring, schedule a run for your domain list and alert when `daysUntilExpiry` is below your threshold.
- Run it with the Apify API, a webhook, Zapier, Make or n8n, or call it as a tool from an AI agent.

### Privacy

Registrant names, emails and phone numbers are **never** returned. Most registries redact them anyway. The Actor only extracts registrar, dates, nameservers and status flags.

### Limits

- Not all registries publish RDAP, and some limit the data they show for their own TLDs.
- Subdomains are accepted but checked as written; use the registrable domain for registration data (for example `example.co.uk`, not `www.example.co.uk`).
- Maximum domains per run defaults to 5,000 and can be raised to 100,000.

### FAQ

**Is this WHOIS?** It is RDAP, the structured, standardized successor to WHOIS.

**Will it tell me if a domain is for sale on an aftermarket?** No. It only reports registry status.

**Why is a domain "available" at the registry but unavailable at my registrar?** It may be a reserved, premium or restricted name, or a registrar may be applying its own block list.

**Does it support internationalized domains?** Yes, they are converted to punycode.

### Feedback

Found this useful? A quick review on the Store helps others find it. Issues or feature requests? Open an issue and I'll reply fast.

# Actor input Schema

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

Full domain names to check, e.g. example.com. URLs are accepted and cleaned.

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

Names without extension; each name is checked against every TLD below.

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

Extensions to combine with the brand names, without the dot.

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

Skip registered domains in the output (they are not billed).

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

For registered domains.

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

Some country TLDs (for example .de or .io) have no RDAP service. A DNS nameserver check then tells registered from possibly free, with lower confidence.

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

Parallel lookups (per-server limits still apply).

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

Safety cap per run.

## `dnsResolver` (type: `string`):

System resolver or Cloudflare DNS-over-HTTPS.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "example.org"
  ],
  "names": [
    "mybrandname",
    "cool-startup-xyz"
  ],
  "tlds": [
    "com",
    "io",
    "ai",
    "dev"
  ],
  "onlyAvailable": false,
  "includeDetails": true,
  "dnsFallback": true,
  "concurrency": 20,
  "maxDomains": 5000,
  "dnsResolver": "system"
}
```

# Actor output Schema

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

Dataset items: the domain availability results returned by the run (JSON, CSV, Excel, XML via the dataset API).

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

Key-value store record SUMMARY with counts and per-input status for this run.

# 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",
        "example.org"
    ],
    "names": [
        "mybrandname",
        "cool-startup-xyz"
    ],
    "tlds": [
        "com",
        "io",
        "ai",
        "dev"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mauve_bunch/domain-availability-rdap").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",
        "example.org",
    ],
    "names": [
        "mybrandname",
        "cool-startup-xyz",
    ],
    "tlds": [
        "com",
        "io",
        "ai",
        "dev",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("mauve_bunch/domain-availability-rdap").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",
    "example.org"
  ],
  "names": [
    "mybrandname",
    "cool-startup-xyz"
  ],
  "tlds": [
    "com",
    "io",
    "ai",
    "dev"
  ]
}' |
apify call mauve_bunch/domain-availability-rdap --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mauve_bunch/domain-availability-rdap"
        }
    }
}
```

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/6QNDfScmfV96ofh1w/builds/TcZdh0LVXTSHPIrZn/openapi.json
