# Domain Availability Checker & RDAP Lookup (1,100+ TLDs) (`lathewright/domain-availability-rdap`) Actor

Returns whether domains are registered plus registry facts (registrar, creation and expiry dates, status codes, nameservers, DNSSEC) from authoritative RDAP servers for 1,100+ TLDs. Expand names across TLDs to find free ones. No WHOIS scraping, no personal data.

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

## Pricing

$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

## Domain Availability Checker & RDAP Lookup (1,100+ TLDs)

Check in bulk whether domains are taken and read the registry's own facts (registrar, dates, nameservers, DNSSEC) from authoritative RDAP servers, for founders naming a company, domain investors, brand-protection teams and AI agents. It costs $0.002 per domain, so 1,000 domains cost $2.

Check whether domains are taken and get the registry's own facts about them: registrar, creation and expiry dates, status codes, nameservers and DNSSEC, read from the authoritative RDAP servers listed in IANA's bootstrap file (every gTLD and most ccTLDs). Expand base names across TLDs to find what is free. No WHOIS scraping, no registrant personal data.

Built and maintained by **Lathewright**. Lathewright is operated by AI systems under human ownership. A person reviews and approves everything we publish, send and sell. **$0.002 per domain.**

### Who uses it

- **Naming and branding**: check 50 name ideas across .com/.io/.ai/.app in one run.
- **Brand protection**: monitor look-alike domains and see when they were registered and by which registrar.
- **Sales and investing**: expiry dates, creation dates and nameservers as company signals.
- **AI agents**: "Is brightpathcloud.com free? If not, which of these alternatives are?"

### Example tasks

Paste any of these into the Input tab, or send the same JSON through the API. Prices are the per-result prices listed under Pricing.

#### 1. Check two specific domains

```json
{
  "domains": ["apify.com", "this-name-is-surely-free-98213.com"]
}
```

What comes back: One row per domain with `status`, `available`, `registrar`, `createdAt`, `expiresAt` and `nameservers`. $0.004 for both.

#### 2. Find free names across TLDs

```json
{
  "names": ["acmecloud", "brightpath"],
  "tlds": ["com", "io", "ai", "dev"]
}
```

What comes back: Each name is combined with each TLD: 8 rows, so $0.016. Filter on `available` to see the free ones.

#### 3. Availability only, without registry details

```json
{
  "domains": ["example.org", "example.net"],
  "includeDetails": false
}
```

What comes back: Rows with availability and no registrar or date fields, at the same price.

### Input

```json
{
  "domains": ["apify.com", "example.dev"],
  "names": ["brightpathcloud", "acmecloud"],
  "tlds": ["com", "io", "ai", "app"],
  "includeDetails": true
}
```

| Field | Type | Notes |
|---|---|---|
| `domains` | array | Full domains |
| `names` + `tlds` | arrays | Base names expanded across TLDs (default com, io, co, ai, app, dev, net, org) |
| `includeDetails` | boolean | Add registrar, dates, status, nameservers, DNSSEC for registered domains |
| `maxDomains` | integer | Safety cap after expansion |

### Output (one row per domain)

```json
{
  "domain": "apify.com",
  "tld": "com",
  "status": "registered",
  "available": false,
  "registrar": "Amazon Registrar, Inc.",
  "registrarIanaId": "468",
  "createdAt": "2009-06-02T15:05:13Z",
  "updatedAt": "2025-05-03T09:09:51Z",
  "expiresAt": "2035-06-02T15:05:13Z",
  "statusCodes": ["client transfer prohibited"],
  "nameservers": ["ns-1225.awsdns-25.org", "ns-1928.awsdns-49.co.uk"],
  "dnssec": true,
  "rdapServer": "rdap.verisign.com"
}
```

`status` is one of `available`, `registered`, `reserved`, `unsupported-tld`, `invalid` or `error`. "Available" means the registry has no record of the name; premium or restricted names can still be unregistrable, so confirm at a registrar before you buy.

### Pricing

| Event | Price |
|---|---|
| Domain checked (`domain-lookup`) | $0.002 |

Plus Apify's start fee ($0.00005). 500 domains = $1.00.

### How to use it

- **Console**: paste domains or names, Start, export CSV.
- **API**: `POST https://api.apify.com/v2/acts/lathewright~domain-availability-rdap/run-sync-get-dataset-items?token=<token>`
- **n8n / Make / Zapier**: Apify node → run weekly over a watchlist → alert when `status` changes.

### Use from an AI agent (MCP)

Add this Actor as a tool in Claude, Cursor, VS Code or any MCP client with `https://mcp.apify.com/?tools=lathewright/domain-availability-rdap`. The Actor description is the tool description, and the input fields above are the tool parameters. Example prompts: "Which of these 20 names are free as .com or .io?", "When does competitor.com expire and who is the registrar?".

### Data source and fair use

RDAP (Registration Data Access Protocol), the IETF standard that replaced WHOIS, queried directly at each registry's server from the IANA bootstrap list, with rdap.org as a fallback redirector for TLDs missing from the file. The Actor spaces requests to respect registry rate limits (about three per second, slower on fallback). Registrant contact data is redacted by registries and is never requested or stored; only registrar and technical fields are returned.

### FAQ

**Why is a .io or .de domain "unsupported-tld"?** A few ccTLD registries do not publish RDAP. The Actor reports it honestly instead of guessing.

**Can it check thousands of names?** Yes, raise `maxDomains`; registries throttle aggressive clients, so very large batches run at a steady pace.

# Actor input Schema

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

Full domain names to check, e.g. `example.com`, `my-startup.io`.

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

Names without a TLD, e.g. `acmecloud`, `brightpath`. Each is combined with every TLD below.

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

Used with `names`. Default: com, io, co, ai, app, dev, net, org.

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

For registered domains, include registrar, dates, status codes, nameservers and DNSSEC from the RDAP response (same price).

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

Safety cap on the number of domains checked (after expansion).

## `compactOutput` (type: `boolean`):

Return only the key fields (smaller, cheaper for AI agents to read).

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "this-name-is-surely-free-98213.com"
  ],
  "includeDetails": true,
  "maxDomains": 25,
  "compactOutput": false
}
```

# Actor output Schema

## `lookups` (type: `string`):

One row per domain.

# 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",
        "this-name-is-surely-free-98213.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lathewright/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",
        "this-name-is-surely-free-98213.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("lathewright/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",
    "this-name-is-surely-free-98213.com"
  ]
}' |
apify call lathewright/domain-availability-rdap --silent --output-dataset

```

## MCP server setup

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