# Bulk Domain Availability Checker – RDAP, WHOIS & DNS (`tesselyn/domain-availability-checker`) Actor

Check if domains are available or registered, in bulk, from official registry RDAP data (WHOIS/DNS fallback). Registrar and dates; unknown results are free.

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

## Pricing

from $2.40 / 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, WHOIS & DNS

Check **whether domain names are available or already registered**, hundreds at a time, using **official registry data**. Paste a list of domains, or combine **base names with TLDs** (acme → acme.com, acme.io, acme.dev …). For each domain you get **available: true / false / "unknown"**, the **method** used (RDAP, WHOIS or DNS) and, for registered domains, the **registrar, created and expiry dates, registry status and nameservers**. No registrant contact data is ever returned.

> ⚠️ **Automated, informational results, provided "as is".** Availability can change at any moment, registry data can lag, and this Actor does **not** register, reserve or hold any domain. A domain shown as available may still be reserved, premium-priced or taken by the time you try to register it. See [Terms of use](#terms-of-use).

### What does the Bulk Domain Availability Checker do?

1. **Finds the registry's official RDAP server** for each TLD through the official IANA RDAP bootstrap file and asks it about the domain.
2. **Uses WHOIS (port 43) only for TLDs that have no RDAP service** in the bootstrap file. The registry's WHOIS server is looked up in IANA's WHOIS service. You can switch this off.
3. **Checks DNS (NS records) as a hint.** A domain with nameservers in DNS is registered, so DNS is used to catch contradictions and as a last resort.
4. **Returns one row per domain** with a clear answer, or `"unknown"` and a reason when no reliable answer is possible.

#### How the answer is decided

| Registry / DNS result | `available` | `method` |
|---|---|---|
| Registry RDAP returns the domain record | `false` (registered) | RDAP |
| Registry RDAP (from the IANA bootstrap) returns "not found" (HTTP 404) and DNS does not show the domain delegated | `true` | RDAP |
| Registry "not found", but the domain has NS records in DNS | `"unknown"` (`CONFLICT_REGISTRY_NOT_FOUND_BUT_DNS_DELEGATED`) | RDAP or WHOIS |
| Second-level suffix (such as co.uk or com.br): registry "not found" without a DNS NXDOMAIN to confirm it | `"unknown"` (`NOT_FOUND_UNCONFIRMED_BY_DNS`) | RDAP |
| No RDAP for the TLD: WHOIS reply with the domain record / with an explicit "not found" | `false` / `true` | WHOIS |
| WHOIS reply not recognised, rate-limited, or server unreachable | `"unknown"` | WHOIS |
| No registry answer, but the domain has NS records in DNS | `false` (registrar and dates unknown) | DNS |
| No registry answer and no NS records | `"unknown"` (a registered domain can exist without DNS) | DNS |
| Rate limit (HTTP 429) after retries, timeout or other error | `"unknown"` | RDAP |

"Unknown" results are **not charged**.

### Who is it for?

Founders and marketers brainstorming brand names, domain investors screening lists, agencies checking client name options, developers who need availability data in an app or workflow, and AI agents or automations (API, MCP, Make, Zapier or n8n) that need a structured answer.

### How to use it

1. Paste **domains** (or URLs: the registrable domain is extracted, so `shop.example.co.uk` becomes `example.co.uk`).
2. Optionally add **base names** and **TLDs**: every base name is combined with every TLD.
3. Set **Max domains per run** (default 100, up to 1,000) and run it. Open the **Overview** view, or download CSV, Excel or JSON.

#### Input example

```json
{ "domains": ["example.com", "wikipedia.org"], "baseNames": ["mybrandidea"], "tlds": ["com", "io", "dev", "ai"], "maxItems": 50 }
```

### Output example

```json
[
  { "domain": "google.com", "available": false, "method": "RDAP", "registrar": "MarkMonitor Inc.",
    "created": "1997-09-15T04:00:00Z", "expires": "2028-09-14T04:00:00Z",
    "status": ["client delete prohibited", "client transfer prohibited", "client update prohibited"],
    "nameservers": ["ns1.google.com", "ns2.google.com"], "dnsHint": "delegated", "source": "rdap.verisign.com",
    "error": null, "charged": true },
  { "domain": "mybrandidea.dev", "available": true, "method": "RDAP", "registrar": null, "dnsHint": "nxdomain",
    "source": "pubapi.registry.google",
    "note": "Not registered at the registry right now. Reserved or premium names may still be unavailable or priced differently at registrars.",
    "error": null, "charged": true }
]
```

Fields: `domain`, `available`, `method`, `registrar`, `created`, `expires`, `status`, `nameservers`, `dnsHint` (delegated, nxdomain, no-ns or error), `source` (registry server), `note`, `error`, `input`, `checkedAt`, `charged`. The `OUTPUT` record has the run summary (counts of available, registered and unknown domains).

### How much does it cost?

Pay per event: **$0.003 per domain checked** (`domain-checked`, = $3 per 1,000 domains). One event is charged for each domain with a definite answer (`available` true or false). **"Unknown" results, invalid inputs and duplicates are free.** See the Pricing tab for the current price. Set the run's maximum charge to cap spend: the Actor stops starting new domains when the cap is reached.

### Responsible use

- The Actor identifies itself as `TesselynDomainAvailabilityBot/1.0 (+https://apify.com/tesselyn)`.
- **Per registry server, one request at a time**: RDAP requests at least 0.5 s apart, WHOIS queries at least 2 s apart. On HTTP 429 or 503 it waits (honouring `Retry-After`, up to 20 s) and retries at most 3 times, then reports `"unknown"`.
- Per domain it makes one RDAP request (or one WHOIS query) and one DNS NS lookup. It does not visit websites.
- Only public names are accepted. IP addresses, `localhost` and internal names are refused, and registry servers must resolve to public addresses.
- No proxies, no IP rotation and no attempt to get around rate limits.

### Terms of use

These terms add to the [Apify Standard Actor Contract](https://docs.apify.com/legal/standard-actor-contract), which governs your use of this Actor; they do not replace it.

- Use the Actor for legitimate purposes. You are responsible for making sure your use of the Actor and its output complies with applicable laws and the registries' RDAP and WHOIS terms of service. Do not use the output for marketing to domain holders, spam or other abuse.
- Do not use the Actor to load-test registries or to get around access controls or rate limits. Abusive use may be blocked.
- **Sanctions and restricted countries.** You may not use this Actor if you are located in, ordinarily resident in, or acting on behalf of a person or organisation in a restricted country or region. Currently these are: Afghanistan, Belarus, Central African Republic, Cuba, Democratic Republic of the Congo, Haiti, Iran, Iraq, Lebanon, Libya, Mali, Myanmar, Nicaragua, North Korea, Russia, Somalia, South Sudan, Sudan, Syria, Venezuela, Yemen, Zimbabwe, Antarctica, and the Crimea, Sevastopol, Donetsk, Luhansk, Kherson and Zaporizhzhia regions of Ukraine. You also may not use it if you are on, or owned or controlled by someone on, any applicable sanctions list (including those of the United Nations, the United States (OFAC SDN), the European Union, the United Kingdom or Israel). We may block such use, and we may update this list when the law or our policy changes.
- **No guarantee of availability.** Results describe what the registry, WHOIS or DNS reported at the moment of the check. Availability can change instantly, registry data can lag behind registrations and deletions, and some names are reserved, blocked or premium-priced even though the registry reports them as not registered. A result is not an offer, reservation or registration. Always confirm with a registrar before you rely on it, for example before you print a brand name.
- **Informational only; no guarantee of outcomes.** Output is not legal, trademark or other professional advice, and using the Actor does not create an advisory relationship. An available domain may still infringe someone else's trademark. Tesselyn does not promise any outcome. You are responsible for checking results and for the decisions you make based on them.
- **No warranty; limitation of liability.** To the maximum extent permitted by applicable law, the Actor and its output are provided "as is" and "as available", without warranties of any kind, express or implied (including accuracy, completeness, merchantability, fitness for a particular purpose and non-infringement), as set out in section 7 of the Apify Standard Actor Contract. The Actor creator (Tesselyn) is not liable for any indirect, incidental, special, consequential or punitive loss or damage, including lost domains, registration fees, revenue, profits or data, arising from use of or reliance on the Actor or its output. Any other liability is limited as set out in section 8 of that Contract, and nothing here limits liability that cannot be limited under applicable law.

### Privacy notice

- **What is processed:** the domain names you submit and public registry and DNS data about them.
- **What is not collected:** from RDAP the Actor keeps only the **registrar's name**, the registry dates, status values and nameservers. Registrant, administrative, technical, billing and abuse contacts (names, e-mail addresses, phone numbers, postal addresses) are **never read into the output or stored**. From WHOIS replies only the registrar, date, status and nameserver lines are extracted; the raw WHOIS text is **not stored or logged**.
- **Where it is stored:** only in your own Apify run storage (default dataset, `OUTPUT` record, run log and input), under your Apify account and Apify's retention settings. Apart from the RDAP, WHOIS and DNS queries needed for the checks, the Actor sends nothing to third parties.
- **Roles:** for any personal data in your input or output, you are the controller and the Actor creator acts as processor, as set out in section 5 of the Apify Standard Actor Contract. Run logs contain only counts and error codes.
- **Deletion:** you can delete the run or dataset in Apify Console at any time. For questions or privacy requests, open an issue on the Actor's Issues tab.

### FAQ

#### How do you know a domain is available?

For most TLDs the registry runs an RDAP service listed by IANA. If that registry answers "not found" for the domain and DNS doesn't contradict it, the domain is reported as available (`true`). If the registry returns the domain record, it is registered (`false`).

#### Why do I get "unknown"?

The registry rate-limited us, timed out, gave an answer we could not interpret, or contradicted DNS. Some TLDs have neither RDAP nor a usable WHOIS service. In all these cases the Actor says `"unknown"` instead of guessing, and you are not charged.

#### Which TLDs are supported?

Any TLD on the Public Suffix List. TLDs with RDAP (including .com, .net, .org, .dev, .app and .ai at the time of writing) get the most reliable answers. TLDs without RDAP, such as .io and .co at the time of writing, use WHOIS. Results for those depend on the registry's WHOIS service.

#### Does "available" mean I can register it at the normal price?

Not necessarily. Registries can reserve or block names, and premium names are often sold at a higher price. Check with a registrar.

#### Does it show who owns a domain?

No. It never returns registrant names, e-mail addresses, phone numbers or postal addresses. It returns only the registrar, dates, status and nameservers.

#### Can I check subdomains?

Availability applies to registrable domains only. A subdomain such as `blog.example.com` is reduced to `example.com`, and the row has `inputNote: REDUCED_TO_REGISTRABLE_DOMAIN`.

### Related Tesselyn tools

- [AI Crawler & llms.txt Checker](https://apify.com/tesselyn/ai-search-readiness-auditor): see which AI crawlers a site's robots.txt allows, check llms.txt and get a 0–100 GEO readiness score.
- [Broken Link & Redirect Checker](https://apify.com/tesselyn/broken-link-checker): crawl a site for broken links, redirect chains and missing #anchors.
- Domain Health Checker: domain expiry, DNS, SPF/DMARC, SSL and HSTS checks with a health score. Coming to the Apify Store soon.
- See [all Tesselyn Actors on the Apify Store](https://apify.com/tesselyn).

### Support

Built and maintained by **Tesselyn** (a brand of HevraBest Group Ltd). Found a bug or a wrong result, or need a feature? Open an issue on the Actor's **Issues** tab. That is our support channel and the route Apify uses for credit compensation.

**Failed runs and unexpected charges.** Rows that the "How much does it cost?" section lists as free are not charged. Apify's small per-run "Actor start" charge, when it is listed on the Pricing tab, still applies. If you think a run charged you for work it didn't deliver, open an issue with the run link. If we confirm the problem, we ask Apify to compensate you. Apify gives compensation as **platform credits**, not money. Apify's General Terms (section 7.9) require charge disputes to be sent to Apify in writing within 15 days of the charge or invoice date, so please report problems promptly.

# Actor input Schema

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

Full domain names (example.com) or URLs; the registrable domain is extracted (shop.example.co.uk → example.co.uk). IP addresses, internal names and public suffixes such as co.uk are rejected (free).

## `baseNames` (type: `array`):

Names without a TLD, for example 'acme' or 'my-startup'. Each one is combined with every TLD below (acme.com, acme.io, ...).

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

TLDs to combine with the base names, with or without the dot: com, net, org, io, co, dev, ai, co.uk ...

## `maxItems` (type: `integer`):

Upper limit on domains checked in this run (after de-duplication). Extra domains are ignored and not charged.

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

Parallel domains across registries. Each registry server still gets only one request at a time (RDAP at least 0.5 s apart, WHOIS at least 2 s apart), with back-off on HTTP 429.

## `useWhoisFallback` (type: `boolean`):

Some country-code TLDs (for example .io and .co at the time of writing) have no RDAP service in the IANA bootstrap. If on, their registry WHOIS server (port 43, as listed by IANA) is asked instead. Only registrar, dates, status and nameservers are kept.

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

Per RDAP or WHOIS request. Each domain also has a 90 s overall limit.

## Actor input object example

```json
{
  "domains": [
    "example.com",
    "wikipedia.org",
    "apify.com"
  ],
  "maxItems": 100,
  "maxConcurrency": 5,
  "useWhoisFallback": true,
  "requestTimeoutSecs": 15
}
```

# Actor output Schema

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

All rows in the default dataset.

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

Counts of available, registered and unknown domains, domains charged and request counts.

# 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",
        "wikipedia.org",
        "apify.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tesselyn/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",
        "wikipedia.org",
        "apify.com",
    ] }

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

```

## MCP server setup

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