Domain Availability Checker — Bulk RDAP & WHOIS, Names × TLDs avatar

Domain Availability Checker — Bulk RDAP & WHOIS, Names × TLDs

Pricing

from $1.20 / 1,000 domain checkeds

Go to Apify Store
Domain Availability Checker — Bulk RDAP & WHOIS, Names × TLDs

Domain Availability Checker — Bulk RDAP & WHOIS, Names × TLDs

Check domains in bulk, or one name across many TLDs (.com, .io, .ai, .co…). Returns available/registered/unknown status from registry RDAP with DNS/WHOIS fallback, registrar, dates, days to expiry and registry status. Unknown answers are free.

Pricing

from $1.20 / 1,000 domain checkeds

Rating

0.0

(0)

Developer

Automation Lab

Automation Lab

Maintained by Community

Actor stats

2

Bookmarked

246

Total users

62

Monthly active users

4 days ago

Last modified

Features

Limited permissionsMulti-tenantServer interface

Share

Domain Availability Checker

Check if domains are registered or available for purchase, in bulk. Enter exact domains, or bare names to try across TLDs (mybrand × com, io, ai, co). Uses authoritative registry RDAP with DNS checks and a rate-limited WHOIS fallback, and returns a one-word status, registrar, creation and expiry dates, days until expiry, registry status codes and name servers.

What does Domain Availability Checker do?

Domain Availability Checker determines whether domain names are registered or available for purchase. It checks DNS and queries the TLD registry's authoritative RDAP service, then falls back to rate-limited WHOIS when RDAP is unavailable or inconclusive. Up to 10 domains are checked concurrently so bulk lists complete faster without overwhelming fallback WHOIS servers. Pass in a list of domains, or names plus TLDs, and get back a clear status (available, registered or unknown) for each one. .com, .net, .org, .ai, .app, .dev, .xyz, .co.uk, .ca, .au, .fr, .nl and hundreds of other TLDs are answered by their registry's RDAP service; TLDs without RDAP, such as .io, .co and .de, use WHOIS. A domain the registry gives no definite answer for is marked unknown, explained in error, and not charged.

Use it for domain name research, brand protection monitoring, bulk domain checking, or finding available domains for new projects. The layered approach (DNS, RDAP, WHOIS) provides a reliable and detailed result for each domain checked.

Who is it for?

  • 🏢 Domain investors — scanning bulk domain lists for available registration opportunities
  • 🚀 Startup founders — finding available domain names for new business ventures
  • 🔍 Brand managers — checking if brand-related domains are taken or available
  • 💻 Web agencies — searching domain availability on behalf of clients
  • 📊 Domain resellers — monitoring expiring domains for acquisition opportunities

Use cases

  • Entrepreneurs searching for available domain names for a new business or product launch
  • Brand protection teams monitoring whether typosquatting or look-alike domains have been registered
  • Domain investors bulk-checking lists of expired or potentially available domains for acquisition
  • Marketing agencies finding available domains for client campaigns and landing pages
  • Legal teams investigating whether infringing domain names have been registered by competitors
  • Startup founders validating that a shortlist of candidate domain names is still open before committing to a brand name

Why use Domain Availability Checker?

  • Authoritative registry checks — uses IANA-discovered RDAP services, DNS corroboration, and rate-limited WHOIS fallback
  • Faster bulk runs — bounded parallelism checks up to 10 domains concurrently while protecting WHOIS servers
  • Registration details included — returns registrar, creation date, expiry date, and name servers for registered domains
  • Batch processing — check hundreds of domains in a single run instead of one at a time
  • Names across TLDs — enter mybrand once and check it on every TLD you list, in the same run as exact domains
  • Clear verdict — status is available, registered or unknown, plus available and registered booleans for easy filtering
  • Expiry tracking — daysUntilExpiry and registryStatus (for example redemption period, pending delete) for expiring-domain research
  • Fair charging — only definite answers are charged; unknown answers and invalid entries are free
  • Timing data — checkTimeMs shows how long each check took for performance visibility
  • Pay-per-event pricing — costs scale with actual usage, just $0.002 per domain checked
  • Structured JSON output — parsed fields ready for filtering available vs. registered domains in downstream tools

Fast-start recipe

  1. Paste the smallest input that matches your job: one keyword, one URL, one listing ID, one username, or a short domain list.
  2. Keep the first run small (result limit of 10-50) to validate fields and cost.
  3. Export the dataset as CSV/Excel for spreadsheet review, or use the Apify API/webhooks for scheduled monitoring.
  4. Scale the same input pattern once the sample output matches your workflow.

Exact domains, or names across TLDs

Enter exact domains such as example.com, brand.ai, or brand.co.uk in Domains. To try one name on several TLDs, enter brand in Names and com, io, ai, co in TLDs (default: com; if every TLD you enter is invalid, the run stops without checking or charging the names): the run checks brand.com, brand.io, brand.ai and brand.co. Every combination is one checked domain. The Actor does not invent name variations; you choose the names.

First run recommendation

Start with 5-20 domains, normalized without protocol, path, or query string. Use the returned DNS/WHOIS method and errors to review ambiguous domains.

Workflow ideas

Use Google Search Results Scraper for brand conflict checks, MX/email verification actors for infrastructure checks, and Company Domain Finder-style enrichment when validating lead lists.

Input parameters

ParameterTypeRequiredDefaultDescription
domainsstring[]One of domains or names—Exact domain names (e.g., example.com). URLs are cleaned; entries that are not domains are skipped and listed in the log.
namesstring[]One of domains or names—Bare names (e.g., mybrand) to combine with every TLD in tlds.
tldsstring[]No["com"]TLDs to combine with names, with or without the dot (e.g., io, .ai, co.uk).

Example input

{
"domains": ["example.com", "google.com", "xyznotregistered12345.com"]
}

Try one name on several TLDs:

{
"names": ["mybrand", "mybrandhq"],
"tlds": ["com", "io", "ai", "co"]
}

Output example

Each domain produces one result object with availability status, detection method, and registration details when the domain is registered.

FieldDescription
domainThe queried domain name
tldIts top-level domain, such as com or co.uk
statusavailable, registered, or unknown (no definite answer from the registry; free)
availableWhether the domain is available for registration
registeredWhether the domain is currently registered
methodDecisive detection method (rdap, dns, whois, or error)
registrarRegistrar name (if registered)
createdDateDomain creation date (if registered)
expiryDateDomain expiry date (if registered)
daysUntilExpiryWhole days until expiry (negative when past); null without an expiry date
registryStatusRegistry status codes, such as client transfer prohibited or redemption period
nameServersName servers (if registered)
checkTimeMsTime taken for the check in milliseconds
errorError message if check failed
checkedAtISO timestamp of the check
{
"domain": "google.com",
"tld": "com",
"status": "registered",
"available": false,
"registered": true,
"method": "rdap",
"registrar": "MarkMonitor Inc.",
"createdDate": "1997-09-15T04:00:00Z",
"expiryDate": "2028-09-14T04:00:00Z",
"daysUntilExpiry": 667,
"registryStatus": ["client delete prohibited", "client transfer prohibited"],
"nameServers": ["ns1.google.com", "ns2.google.com"],
"checkTimeMs": 171,
"error": null,
"checkedAt": "2026-03-01T12:00:00.000Z"
}

How to check domain availability

  1. Go to Domain Availability Checker on Apify Store
  2. Enter one or more domain names to check (e.g., example.com, mybrand.io)
  3. Click Start and wait for the run to finish
  4. Review the availability status, registrar, and expiry date for each domain
  5. Download your results as JSON, CSV, or Excel from the Dataset tab

How much does it cost to check domain availability?

Domain Availability Checker uses Apify's pay-per-event pricing:

EventPriceDescription
Start$0.035One-time per run with valid input
Domain checked$0.002Per domain with a definite answer (available or registered)

Domains with an unknown status, entries that are not domains, and runs with no valid domain are free. Prices above are for the Starter plan; higher Apify plans pay less per domain. From 2026-12-01 the per-domain price moves to the standard plan curve: $0.002 on Free and Starter, $0.0018 on Scale, $0.0016 on Business and above; the start fee stays $0.035.

Examples:

  • 10 domains: $0.035 + 10 x $0.002 = $0.055
  • 100 domains: $0.035 + 100 x $0.002 = $0.235
  • 1,000 domains: $0.035 + 1,000 x $0.002 = $2.035

API usage with Apify

The Apify API lets you control Domain Availability Checker programmatically. Schedule runs, read datasets, manage webhooks, and more. See the Apify API reference for details.

Node.js

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('automation-lab/domain-availability-checker').call({
domains: ['example.com', 'google.com', 'xyznotregistered12345.com'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient
client = ApifyClient('<YOUR_API_TOKEN>')
run = client.actor('automation-lab/domain-availability-checker').call(run_input={
'domains': ['example.com', 'google.com', 'xyznotregistered12345.com'],
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

cURL

curl "https://api.apify.com/v2/acts/automation-lab~domain-availability-checker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
-X POST \
-H "Content-Type: application/json" \
-d '{"domains": ["example.com", "myawesomestartup.com"]}'

Server API: check a domain over HTTP

Domain Availability Checker is also a Server Actor. Besides normal runs, it answers short HTTP requests directly, without starting a run for each check. Copy the server URL from the Actor's Server tab (do not build it from the Actor name) and authenticate with your Apify token. Use normal Actor runs for long domain lists.

curl -sS "$SERVER_URL/domain?domain=google.com" -H "Authorization: Bearer $APIFY_TOKEN"
curl -sS "$SERVER_URL/domains" -H "Authorization: Bearer $APIFY_TOKEN" -H 'Content-Type: application/json' -d '{"domains":["google.com","apify.com"]}'
Method and pathInputOutput and charge
GET /Noneready: true, the routes and limits; no lookup or charge
GET /domainQuery domain (a protocol, path or www. prefix is stripped; internationalized names are converted to ASCII){ok,count,results} with the same record as a dataset item; one Domain checked event when the answer is definite (available or registered); no start fee
POST /domainsJSON domains (1–10 names; duplicates checked once){ok,count,results} with one record per domain with a definite answer, in input order; one Domain checked event per returned domain; no start fee

Each check is the same as in a normal run: DNS, then RDAP, then WHOIS where the TLD has no RDAP. Domains without a definite answer are left out of results and are not charged; when no domain has one, the answer is an error and free. Bodies must be JSON and at most 4096 bytes. Each request has a 45-second deadline and a 64 KiB response cap, and one server works on at most six requests at once. Nothing caller-specific is cached; the public IANA list of RDAP servers is reused while the server runs. Errors use { "ok": false, "error": { "code": "...", "message": "...", "retryable": false } }: 400 invalid domain, list or JSON; 402 spending limit; 404 unknown route; 405 wrong method; 413 size limit; 415 media type; 502 neither RDAP nor WHOIS gave a definite answer, or a charging failure; 503 server busy or stopping; 504 timeout. Retry only when retryable is true. A successful answer can carry warning: { code: "CHARGE_INCOMPLETE" } when only part of its charge went through; you are charged only for what went through. The Server tab shows the full OpenAPI description.

Use with AI agents via MCP

Domain Availability Checker is available as a tool for AI assistants via the Model Context Protocol (MCP).

Setup for Claude Code

$claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/domain-availability-checker"

Setup for Claude Desktop, Cursor, or VS Code

{
"mcpServers": {
"apify": {
"url": "https://mcp.apify.com?tools=automation-lab/domain-availability-checker"
}
}
}

Example prompts

  • "Is myawesomestartup.com available?"
  • "Check if these 20 domain names are available for registration"
  • "Which .io domains from this list are still open for registration?"

Learn more in the Apify MCP documentation.

Integrations

Connect Domain Availability Checker with other apps and services using Apify integrations. You can integrate with Make, Zapier, Slack, Google Sheets, Google Drive, n8n, and many more. Set up a webhook to get a Slack notification when a watched domain becomes available, or push results to Google Sheets to maintain a live inventory of domain availability across your brand portfolio.

Tips and best practices

  • Check variations systematically — generate a list of domain name variations (typos, different TLDs, hyphens) and check them all in one batch
  • Filter results by availability — use the available field to quickly isolate domains that are open for registration
  • Monitor periodically — schedule daily or weekly runs to detect when previously registered domains expire and become available
  • Combine with WHOIS Lookup — for registered domains where you need full registrant contact details, run WHOIS Lookup as a follow-up
  • Review the method field — the method field tells you whether the result came from DNS alone or a full WHOIS query, which indicates the confidence level
  • Export results for analysis — download as JSON, CSV, or Excel from the dataset tab to share availability reports with your team or import into a spreadsheet

Diagnostic reporting

When a run or server request fails, Domain Availability Checker sends sanitized diagnostic input, the exception and the Actor, build and run IDs to our private GlitchTip service so we can repair it. Secret fields and URL queries are removed, and reports are kept for 30 days.

Legality

This tool analyzes publicly accessible web content. Automated analysis of public web resources is standard practice in SEO and web development. Always respect robots.txt directives and rate limits when analyzing third-party websites. For personal data processing, ensure compliance with applicable privacy regulations.

FAQ

How does the actor determine if a domain is available? It checks DNS and the TLD registry's authoritative RDAP endpoint. If RDAP is unavailable or inconclusive, it falls back to WHOIS. A domain is marked available only after an explicit RDAP or WHOIS not-found response and no live DNS; checks without a definite answer get status: "unknown", a reason in error, and no charge.

Can I check domains across different TLDs? Yes. You can mix TLDs in a single run (e.g., example.com, example.net, example.io), or enter a name once in Names and list the TLDs in TLDs. Each domain is checked independently.

Are .ai domains supported? Yes. .ai now has a registry RDAP service, so .ai domains get the same available or registered verdict, registrar and dates as .com. Premium .ai names can still cost more at the registrar.

Why do some domains show as registered but have no registrar information? Some TLDs or registrars return limited WHOIS data. In those cases, the domain is confirmed as registered via DNS, but the detailed registration fields may be empty or null.

Does the actor check if a domain is available for purchase on the aftermarket? No. The actor checks whether a domain is currently registered in the DNS/WHOIS system. It does not query aftermarket platforms like Sedo or GoDaddy Auctions. A domain reported as "registered" may still be listed for sale by its owner through those channels.

Is there a limit on how many domains I can check? There is no hard limit. The actor checks up to 10 domains concurrently via RDAP while serializing WHOIS fallbacks to avoid registry bans. For very large batches (10,000+), consider splitting across multiple runs to stay within the Actor timeout and upstream rate limits.

A domain shows as available but I cannot register it. Why? Some domains are reserved by registries (e.g., premium domains, country-specific restrictions) or are in a redemption grace period after expiration. The actor checks DNS and WHOIS, but registration eligibility depends on the registrar and TLD policies. Always verify at your registrar before assuming a domain can be purchased.

The run is slow for large batches. How can I speed it up? The actor uses bounded RDAP concurrency for fast bulk checks and rate-limits only the WHOIS fallback. For very large lists (10,000+), split them across multiple runs to keep individual run times manageable.

Other DNS and domain tools