# Bulk Domain Availability Checker – RDAP & DNS (`innovative_cookie/domain-availability`) Actor

Check domain availability in bulk via official RDAP with DNS fallback: status, creation and expiry dates, registrar, nameservers. No WHOIS personal data.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## 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 Bulk Domain Availability Checker do?

**Bulk Domain Availability Checker** tells you which domain names are **available** or **already registered**, for hundreds or thousands of names in one run. It queries the official **RDAP** service of each registry, the modern, structured successor of WHOIS, using the IANA bootstrap list of 1,200+ TLDs. For TLDs without RDAP (such as .de, .io, .eu or .it) it falls back to DNS over HTTPS.

For registered domains you also get the **registration date, expiry date, days until expiry, domain age, registrar, EPP status codes, nameservers and DNSSEC**. You do **not** get the registrant's name, email or address: the Actor never outputs personal contact data.

### Why use this domain checker?

- **Brand and startup naming.** Enter a few keywords and TLDs (com, net, io, app, fr…) and see every free combination at once.
- **Domain portfolio monitoring.** Track expiry dates and transfer locks of your own domains, or schedule a weekly run to catch renewals you missed.
- **Expiring domain hunting.** Spot names close to expiry (`daysUntilExpiry`) or in `redemption period` / `pending delete`.
- **Lead and market research.** Enrich lists of company websites with domain age, registrar and hosting (nameservers).
- **Cleaning lists.** Normalise messy input (URLs, `www.`, capitals, internationalised names) into clean registrable domains.

#### Why RDAP instead of WHOIS?

| | WHOIS scrapers | This Actor (RDAP) |
|---|---|---|
| Format | free text, different per registry | standard JSON (RFC 9083) |
| Source | often third-party mirrors | the official registry server for each TLD (IANA bootstrap) |
| Availability signal | parsing "No match" strings | HTTP 404 from the registry, double-checked with DNS |
| Personal data | often returned | never in the output |
| Rate limits | frequent bans | polite per-registry limit, automatic slow-down on HTTP 429 |

### How to check domain availability in bulk

1. Paste domain names, or fill **Keywords** and **TLDs** to generate combinations.
2. Click **Start**.
3. Filter the results by `status = available` and export them to CSV, Excel or JSON.

### Input example

```json
{
    "domains": ["apify.com", "https://www.lemonde.fr/politique/", "bbc.co.uk", "heise.de", "münchen.de"],
    "keywords": ["brightbakery"],
    "tlds": ["com", "net", "org", "io", "app"],
    "dnsFallback": true,
    "dnsCrossCheck": true,
    "requestsPerSecondPerRegistry": 1
}
```

### Output example

```json
{
    "domain": "apify.com",
    "tld": "com",
    "available": false,
    "status": "registered",
    "method": "rdap",
    "confidence": "high",
    "registrationDate": "2009-06-02T17:14:10.000Z",
    "expirationDate": "2035-06-02T17:14:10.000Z",
    "domainAgeDays": 6357,
    "daysUntilExpiry": 3138,
    "registrar": "Amazon Registrar, Inc.",
    "registrarIanaId": "468",
    "eppStatus": ["client transfer prohibited"],
    "nameservers": ["ns-1225.awsdns-25.org", "ns-1928.awsdns-49.co.uk", "ns-449.awsdns-56.com", "ns-839.awsdns-40.net"],
    "dnssec": true,
    "rdapServer": "https://rdap.verisign.com/com/v1/",
    "checkedAt": "2026-10-28T20:24:00.000Z"
}
```

#### Status values

| status | meaning |
|---|---|
| `available` | The registry has no record (RDAP 404) and the name does not resolve in DNS. |
| `registered` | The registry returned the domain, or it resolves in DNS. |
| `likely-available` | TLD without RDAP: the name does not exist in DNS. A registered but undelegated, reserved or premium name would look the same; confirm at a registrar. |
| `unknown` | The registry and DNS did not answer (see `error`). |
| `invalid` | Not a valid domain name. |

### How much does it cost?

The Actor itself is **free to use**: there is no Actor fee for now. You only pay the Apify platform usage of your runs (compute units and data transfer), which stays small because the Actor uses plain HTTP requests, without a browser or proxy. The Apify Free plan includes $5 of monthly credit, which covers a lot of test runs.

### Speed and rate limits

Each registry gets its own rate limit, **1 request per second** by default, with 10 domains processed in parallel across registries. When a registry answers HTTP 429, the Actor honours `Retry-After` and slows down for that registry only. In a local test, 60 names on .com and .fr took about 20 seconds at 2 requests/second per registry. Raise `requestsPerSecondPerRegistry` with care: registries may block abusive clients.

### FAQ

**Is "available" a guarantee I can buy the domain?**
It means the registry has no registration. Some names are reserved, blocked or sold as premium at a higher price. Your registrar shows the final price at checkout.

**Why do some TLDs say `likely-available` instead of `available`?**
Some registries, including DENIC (.de), .io, EURid (.eu) and many ccTLDs, do not publish RDAP in the IANA bootstrap. For those TLDs the Actor uses DNS, which cannot see domains that are registered without nameservers.

**Do you return WHOIS owner data?**
No. Registrant, admin, tech and billing contacts are ignored on purpose (GDPR). You get the registrar (a company) and technical data only.

**Can I check subdomains like shop.example.com?**
Enter the registrable domain (example.com). For subdomains, the registry answers for the parent domain only.

**Does it support internationalised domains (IDN)?**
Yes. `münchen.de` is converted to `xn--mnchen-3ya.de` automatically.

**I found a bug or need a feature.**
Open an issue in the **Issues** tab. Issues are usually answered quickly.

### Is it legal to check domain availability?

Yes. RDAP and DNS are public services designed for this kind of lookup. The Actor uses them at a polite rate, identifies itself with a clear user-agent, and returns no personal data. Respect each registry's terms of use, and do not use results for spam or abusive registrations. If unsure, consult a lawyer.

### Related actors

More Actors by the same author ([innovative_cookie on Apify](https://apify.com/innovative_cookie)):

- [Sitemap URL Extractor](https://apify.com/innovative_cookie/sitemap-extractor): list every URL of a website from its XML sitemaps.
- [PageSpeed Insights Bulk Checker](https://apify.com/innovative_cookie/pagespeed-bulk): Core Web Vitals and Lighthouse scores for many URLs.
- [Logo & Favicon Extractor](https://apify.com/innovative_cookie/logo-favicon): get the logo and favicon of any website.
- [Bulk Image Converter & Compressor](https://apify.com/innovative_cookie/image-converter): convert and compress images to WebP, AVIF, JPEG or PNG.
- [Broken Link Checker](https://apify.com/innovative_cookie/broken-link-checker): find 404s and dead links on any website.
- [Dataset Merge, Dedup & Transform](https://apify.com/innovative_cookie/dataset-merge-dedup): merge datasets, remove duplicates and clean columns.

# Actor input Schema

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

Domain names to check (one per line). URLs and www. are cleaned automatically; internationalised names (IDN) are supported.

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

Optional: names to combine with the TLDs below, e.g. 'brightbakery' x com, net, io.

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

Extensions combined with each keyword, e.g. com, net, org, io, fr, co.uk.

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

For TLDs without RDAP (e.g. .de, .io, .eu, .it) or when the registry is unreachable, check DNS nameservers instead (result 'likely-available' when the name does not exist).

## `dnsCrossCheck` (type: `boolean`):

When RDAP says available, also check DNS; a resolving domain is reported as registered.

## `dnsMethod` (type: `string`):

DNS over HTTPS (Cloudflare, then Google) is reliable everywhere. Plain DNS uses public resolvers over UDP.

## `requestsPerSecondPerRegistry` (type: `number`):

Rate limit applied to each registry RDAP server separately. 1 is polite and safe; slow down automatically on HTTP 429.

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

Parallel lookups across all registries (each registry still gets its own rate limit).

## `requestTimeoutSecs` (type: `integer`):

Timeout per RDAP request.

## `retries` (type: `integer`):

Retries on network errors, 429 and 5xx.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "my-new-startup-name-2026.com",
    "exemple.fr"
  ],
  "tlds": [
    "com",
    "net",
    "io"
  ],
  "dnsFallback": true,
  "dnsCrossCheck": true,
  "dnsMethod": "doh",
  "requestsPerSecondPerRegistry": 1,
  "maxConcurrency": 10,
  "requestTimeoutSecs": 20,
  "retries": 2
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset with one row per result

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

SUMMARY record

# 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",
        "my-new-startup-name-2026.com",
        "exemple.fr"
    ],
    "tlds": [
        "com",
        "net",
        "io"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("innovative_cookie/domain-availability").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",
        "my-new-startup-name-2026.com",
        "exemple.fr",
    ],
    "tlds": [
        "com",
        "net",
        "io",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("innovative_cookie/domain-availability").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",
    "my-new-startup-name-2026.com",
    "exemple.fr"
  ],
  "tlds": [
    "com",
    "net",
    "io"
  ]
}' |
apify call innovative_cookie/domain-availability --silent --output-dataset

```

## MCP server setup

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

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/Zbdh2IHAw8uMBsBQi/builds/UPLbsxcnVzYrJdSly/openapi.json