Bulk Domain Availability Checker (RDAP + DNS)

Check domain availability in bulk: paste full domain names, or combine keywords with TLDs (and optional prefixes and suffixes) to find available domains. Every name is verified against the registry RDAP service and DNS. When the two sources disagree, or a registry is throttling, the name comes back as unknown instead of a wrong "available", and unknown results are free.

It is a domain checker API you can call from a spreadsheet, a script or an automation: one JSON row per name, with the status, the evidence behind it and, for taken names, the registrar and registration and expiry dates.

What you get

• A status you can trust: available, registered, unknown or invalid. available is only returned when the registry has no record and DNS says the name does not exist. A lone "NXDOMAIN" is never enough.
• Keyword x TLD name generation: 20 keywords x 5 TLDs = 100 names in one run. Optional prefixes (get, try) and suffixes (app, hq).
• Registrar and dates for taken names (switch on includeRegistrationDetails).
• Pay only for answers: you are charged per name with a definitive result (available or registered). unknown and invalid rows are free.
• Polite to registries: low concurrency, a pause between requests to the same registry server, a hard cap of 500 names per run, and a stop when a registry keeps answering "too many requests".
• No personal data: owner and contact details are never read or stored. Only registrar company name, dates and registry status codes.

Input

Field	Description
domains	Full names such as example.com. URLs are reduced to the domain. Second-level names only (no shop.example.com, no example.co.uk).
keywords	Words without dots, for example zencat. Spaces are removed, accents become punycode.
tlds	TLDs combined with the keywords: com, net, org, info, ai, tech, online, site, store. Defaults to com.
prefixes, suffixes	Optional words added before or after each keyword. The plain keyword is always checked too.
includeRegistrationDetails	Also ask the registry for registrar and dates of taken names. Off by default to send fewer requests.
maxDomains	Cap per run, 1 to 500 (default 100).
maxConcurrency	1 to 5 names at the same time (default 3).
rdapMinIntervalMs	Minimum pause between requests to one registry server, 1000 to 10000 ms (default 1000, never faster than one request per second).

{
  "domains": ["apify.com", "wikipedia.org"],
  "keywords": ["zencat", "pawpilot"],
  "tlds": ["com", "net", "org"],
  "prefixes": ["get"],
  "includeRegistrationDetails": true
}

Output

One row per name, in the dataset (JSON, CSV, Excel, XML) and through the API.

Field	Description
domain, input, tld	The name checked (ASCII/punycode), what you typed, the TLD
status	available, registered, unknown or invalid
evidenceSource	dns, rdap or rdap+dns for definitive results
dnsResult	has-ns, nxdomain, nodata or error
rdapResult	found, not-found, rate-limited, error, skipped or not-queried
registeredAt, expiresAt, registrar, registryStatus	From the registry, when it returned a record
reason	Why a row is unknown or invalid, otherwise null
checkedAt	ISO time of the check

[
  {
    "domain": "wikipedia.org",
    "input": "wikipedia.org",
    "tld": "org",
    "status": "registered",
    "evidenceSource": "rdap+dns",
    "dnsResult": "has-ns",
    "rdapResult": "found",
    "registeredAt": "2001-01-13T00:12:14.754Z",
    "expiresAt": "2027-01-13T00:12:14Z",
    "registrar": "MarkMonitor Inc.",
    "registryStatus": ["client delete prohibited", "client transfer prohibited", "client update prohibited"],
    "reason": null,
    "checkedAt": "2026-11-09T00:00:00.000Z"
  },
  {
    "domain": "getzencat.com",
    "input": "zencat",
    "tld": "com",
    "status": "unknown",
    "evidenceSource": null,
    "dnsResult": "nxdomain",
    "rdapResult": "rate-limited",
    "reason": "registry_rate_limited"
  }
]

Also stored: a SUMMARY record with counts per status, how many results were charged and how many names were dropped by the cap.

How the verdict is decided

DNS NS lookup	Registry RDAP	Status
name servers found	not asked (details off) or record found	registered (evidence dns or rdap+dns)
name servers found	no record	unknown (sources disagree)
does not exist	record found (for example on hold)	registered (rdap)
does not exist	no record	available (rdap+dns)
any	registry refuses access (HTTP 403)	unknown; that registry is not asked again in this run
any other answer	any	unknown
any	throttled, timeout, error, skipped	unknown

Names under a TLD outside the supported list (you can still paste them in domains) only get the DNS check: they can be registered or unknown, never available.

Use cases

• Brand and startup naming: test 100 name ideas across .com, .net and .ai in one run.
• Domain investors: filter a long list down to names that are free, then check registrar and expiry of the taken ones.
• Agencies and marketers: check client campaign and landing page names across TLDs.
• Developers: call it as a domain checker API from a signup flow, a naming tool or a bot.

Limits (please read)

• It does not register or buy domains. available means "no registry record and no DNS", not "you can register it at the standard price".
• There is no price and no premium or reserved-name information. A name the registry keeps reserved or sells at a premium can still show as available. Confirm at your registrar before you rely on it.
• Results are not instant and not a guarantee: a name can be registered seconds after the check. Registry servers also throttle, which is why some rows come back unknown; run those again later.
• Supported TLDs are limited to registries whose RDAP terms allow reasonable availability checks. Country codes such as .de, .uk, .nl and .io are not included.
• Second-level names only; at most 500 names per run.
• Bulk or high-volume use: registry limits apply. Registry RDAP terms forbid high-volume automated querying except what is reasonably needed to register domain names. This Actor is meant for checking candidate names before registration, not for sweeping or monitoring large lists. Keep runs small (hundreds, not tens of thousands of names) and do not schedule it to re-check the same list over and over.
• Use the data lawfully. Registry terms forbid using RDAP data for mass unsolicited advertising. This Actor keeps request volume low on purpose and does not collect owner or contact data.
• Not affiliated with any registry or registrar.

FAQ

Why unknown and not a guess? A wrong available costs you a lost name or a wasted purchase. unknown is free and tells you exactly which source was missing.

Why is my taken name registered with no registrar? Details are off by default. Switch on includeRegistrationDetails to look up registrar and dates.

How is this different from Domain WHOIS / RDAP Lookup by Atesen Software? That Actor returns WHOIS-style details (age, registrar, DNS, mail records) for domains you already have. This one is for finding free names: it generates keyword x TLD candidates and only says available when the registry and DNS agree.

Does it use a proxy or an API key? No. It reads the public RDAP servers listed by IANA and uses the DNS resolver of the Apify platform.

What does it cost? Pay per event: one domain event for each name with a definitive result. unknown and invalid rows are free. You can set a maximum cost per run; the Actor stops cleanly when it is reached. The current price is on the Actor's pricing tab.

Calling it from code

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('atesen-software/bulk-domain-availability-checker').call({
  keywords: ['zencat'], tlds: ['com', 'net'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((i) => i.status === 'available'));

Built by Atesen Software.

Data source and permission

Availability comes from the public RDAP services of the domain registries (found through the IANA RDAP bootstrap file) and from public DNS answers (Cloudflare DNS over HTTPS). RDAP is the registries' own open protocol. The registries' terms limit high-volume automated queries, so the Actor is deliberately slow and small: at most one request per second to the same registry, a hard cap of 500 names per run, an honest user agent, and a stop when a registry answers with a block or a rate limit. Only registrar company name, dates and status codes are read, never owner or contact data. Do not use it to enumerate or harvest large name lists.