# Bulk Domain Availability & RDAP WHOIS Checker (`djk12/domain-availability-rdap-checker`) Actor Domain availability checker API for apps and AI agents: bulk RDAP / WHOIS lookup. Compact JSON per domain: available or taken, registrar, creation and expiry dates, days to expiry, status codes, nameservers, from official registry servers. Name ideas x extensions mode. No API key. - **URL**: https://apify.com/djk12/domain-availability-rdap-checker.md - **Developed by:** [Dylan Knaup](https://apify.com/djk12) (community) - **Categories:** Developer tools, SEO tools, Lead generation - **Security:** Limited permissions - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $1.50 / 1,000 domain checkeds This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage. 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 & RDAP WHOIS Checker Check **thousands of domain names in one run**. For each domain you get: **available or registered**, registrar, creation date, **expiry date and days to expiry**, last change, EPP status codes, nameservers, DNSSEC and domain age, read directly from the **official registry RDAP servers** (RDAP is the ICANN-mandated successor to WHOIS). No API key, no proxies, no browser, no scraping of registrar websites. Paste a list, or type a few name ideas plus extensions (`com`, `io`, `ai`, `co`, `dev`...) and get every combination checked. ### AI agents: quick call - **Minimal input:** `{"domains":["example.com","mybrand.io"]}` (or `{"nameStems":["mybrand"],"tlds":["com","io"]}`) - **One output row (short):** `{"domain":"mybrand.io","available":true,"status":"available","method":"rdap","registrar":null,"expires":null,"daysToExpiry":null,"checkedAt":"2026-11-03T20:00:00Z"}` - **Price:** $1.50 per 1,000 domains ($0.0015 per row). Invalid, duplicate and failed domains are not charged. - **Keep results small:** read the dataset with `fields=domain,available,status,registrar,expires,daysToExpiry`, and leave `includeRawRdap` off (the default) unless you need the full registry answer. ### Standby (fast API) mode Call the Actor like a normal web API and get the result in the HTTP response, with no run to start or dataset to read. The first call after a quiet period starts a server (a few seconds); later calls answer right away. The server stops after 60 seconds without calls. ```bash curl -H "Authorization: Bearer $APIFY_TOKEN" \ "https://djk12--domain-availability-rdap-checker.apify.actor/check?domains=example.com,mybrand.io" curl -X POST -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \ -d '{"nameStems":["mybrand"],"tlds":["com","io","ai"]}' \ https://djk12--domain-availability-rdap-checker.apify.actor/check ``` - **Input:** the same fields as a normal run (`domains`, `nameStems` + `tlds`, `includeRawRdap`), as query parameters (comma-separated lists) or a JSON body. - **Response:** `{"count":2,"results":[...rows as in the dataset...],"invalidInputs":[],"failed":[],"stoppedBySpendingLimit":false,"tookMs":850}`. Errors come back as JSON with a 4xx status and a plain message. - **Limit:** up to 100 domains per request. Use a normal run for bigger lists. - **Price:** the normal $0.0015 per returned domain, plus $0.0005 per request that returns results, plus the usual $0.00005 start fee each time a Standby server starts. Requests that return nothing (all invalid or failed) cost nothing beyond that. Like any run, the server also uses platform compute while it is up. ### What you get | Field | Example | |---|---| | `domain` | `google.com` | | `available` | `false` (true = no registry record) | | `status` | `registered`, `available`, `unknown_likely_registered`, `unknown_no_dns` | | `registrar` / `registrarIanaId` | `MarkMonitor Inc.` / `292` | | `created`, `expires`, `lastChanged` | ISO 8601 UTC dates | | `daysToExpiry`, `ageDays` | `680`, `10276` | | `statusCodes` | `client transfer prohibited`, `redemption period`, `pending delete`... | | `nameservers`, `dnssec` | `ns1.google.com`... / `false` | | `registrantOrg`, `registrantCountry` | when the registry publishes them (often redacted) | | `method` | `rdap`, `dns_no_rdap`, `dns_after_rdap_error` | A clean **Domains** table view shows domain, available, status, registrar, created, expires, days to expiry, nameservers, method and check time. Export to CSV, Excel, JSON or use the API. ### Who it is for - **Domain investors**: screen big lists, find names in `pending delete` or close to expiry, check domain age. - **Brand naming and startups**: 30 name ideas x 10 extensions = 300 checks in under a minute. - **Expiry monitoring**: schedule the Actor daily or weekly on your portfolio or competitors and sort by `daysToExpiry`. - **Lead generation and research**: registrar, creation date and nameservers (hosting / email provider hints) for a list of company domains. - **SEO and security teams**: lookalike and typo domains of your brand, who registered them and when. ### How to use it 1. Put domains in **Domains**, one per line. URLs, `www.` and subdomains are cleaned up automatically (`https://shop.example.co.uk/page` is checked as `example.co.uk`). Internationalized names (`münchen.de`) are converted to punycode. Duplicates are checked once. 2. Or fill **Name ideas** and **Extensions** to generate candidates. 3. Click **Start**. A few hundred domains usually take under a minute. #### Input example ```json { "domains": ["google.com", "wikipedia.org", "bbc.co.uk", "spiegel.de", "my-new-startup-name.com"], "nameStems": ["acmecloud", "acmelabs"], "tlds": ["com", "io", "ai", "dev"], "perServerConcurrency": 3 } ``` #### Output example ```json { "domain": "google.com", "available": false, "status": "registered", "method": "rdap", "registrar": "MarkMonitor Inc.", "registrarIanaId": "292", "created": "1997-09-15T04:00:00Z", "expires": "2028-09-14T04:00:00Z", "daysToExpiry": 680, "ageDays": 10276, "statusCodes": ["client delete prohibited", "client transfer prohibited", "client update prohibited", "server delete prohibited", "server transfer prohibited", "server update prohibited"], "nameservers": ["ns1.google.com", "ns2.google.com", "ns3.google.com", "ns4.google.com"], "dnssec": false, "rdapUrl": "https://rdap.verisign.com/com/v1/domain/google.com", "checkedAt": "2026-11-03T20:00:00Z" } ``` A `RUN_SUMMARY` record in the key-value store gives counts by status and method, the inputs that were skipped as invalid, and any domain that could not be checked. ### Pricing **$1.50 per 1,000 domains** ($0.0015 per domain checked), pay per event: you pay for rows in your dataset and nothing else. Invalid inputs, duplicates and domains that could not be checked are **not charged**. Set a **maximum cost per run** and the Actor stops cleanly when it is reached. See the **Pricing** tab for the current price. ### FAQ **RDAP or WHOIS?** RDAP (Registration Data Access Protocol) is the structured JSON replacement for WHOIS. ICANN required it for all generic TLDs and retired the old port-43 WHOIS requirement in January 2025. The Actor finds each extension's official server from the IANA RDAP bootstrap registry, so answers come from the registry itself, not from a reseller cache. **How accurate is "available"?** `available: true` means **the registry has no record of the domain** (RDAP answered "not found"). That is the same signal registrars use, but it is not a purchase guarantee: **premium names, reserved names and names blocked by registry policy can still be unavailable or cost more**, and a domain can be registered by someone else a minute later. Confirm at your registrar before you rely on it. **What about .de and other country extensions?** Some country registries (for example `.de`, `.eu`, `.ch`, `.it`, `.jp`) do not offer public RDAP lookups. For those the Actor falls back to a DNS check over DNS-over-HTTPS and says so in `method` (`dns_no_rdap`): `unknown_likely_registered` when the domain has nameservers, `unknown_no_dns` when it has none (often free, but a registered domain without nameservers also looks like this). `available` is `null` for these rows. `.io`, `.co`, `.me`, `.sh` and `.ac` run on official registry RDAP servers that are not yet in the IANA list; the Actor knows them. **Why are owner names empty?** Since GDPR most registries redact registrant data. When a registry does publish an organization or country, you get it in `registrantOrg` / `registrantCountry`; redaction placeholders are returned as empty. **Will I get blocked or rate-limited?** The Actor is polite on purpose: a per-registry concurrency limit (default 3), backoff with jitter on errors, and it honours `Retry-After` on HTTP 429. If a registry stays unreachable after 5 tries, the domain gets a DNS check instead (`method: dns_after_rdap_error`) so the run still finishes. **Subdomains?** `blog.example.com` is checked as `example.com` (using the Public Suffix List, so `example.co.uk` stays `example.co.uk`). Your original text is kept in `input`. **How big can a run be?** Up to 100,000 domains per run. Large lists of one extension are limited by that registry's speed; split very big lists or raise `perServerConcurrency` carefully. ### Use it from code ```python from apify_client import ApifyClient client = ApifyClient("") run = client.actor("/domain-availability-rdap-checker").call(run_input={ "nameStems": ["acmecloud", "acmelabs"], "tlds": ["com", "io", "ai"], }) for row in client.dataset(run["defaultDatasetId"]).iterate_items(): print(row["domain"], row["status"], row["expires"]) ``` Or with plain HTTP, run synchronously and get the rows back in one call: ```bash curl -X POST "https://api.apify.com/v2/acts/~domain-availability-rdap-checker/run-sync-get-dataset-items?token=" \ -H "Content-Type: application/json" \ -d '{"domains": ["example.com", "example.io"]}' ``` ### Data source and terms Registration data comes from the public RDAP services that ICANN-accredited registries operate for automated queries, located through the IANA bootstrap file `https://data.iana.org/rdap/dns.json`. DNS fallback uses Cloudflare's public DNS-over-HTTPS resolver. Use the data in line with the registries' terms of use. # Changelog This Actor's version history is a separate document: https://apify.com/djk12/domain-availability-rdap-checker/changelog.md # Actor input Schema ## `domains` (type: `array`): One domain per line, for example example.com. URLs, www. and subdomains are reduced to the registrable domain (https://shop.example.co.uk/x becomes example.co.uk). Internationalized names such as münchen.de are converted to punycode. Duplicates are checked once. Invalid entries are skipped and not charged. AI agents: pass just the few domains you need for a quick answer (each checked domain is one billed row). ## `nameStems` (type: `array`): Optional. Brand or keyword ideas without extension, for example acmecloud. Each one is combined with every extension below, so 20 ideas x 10 extensions = 200 domains. ## `tlds` (type: `array`): Extensions to combine with the name ideas, for example com, io, ai, co, dev, co.uk. Needed when name ideas are given. ## `concurrency` (type: `integer`): How many domains are checked at the same time overall. ## `perServerConcurrency` (type: `integer`): Politeness limit for each registry RDAP server. Registries throttle bursts; the Actor also backs off and honours Retry-After on HTTP 429. Keep it low (2 to 4) for big lists of one extension. ## `includeRawRdap` (type: `boolean`): Add the full registry answer to each row in rawRdap (large). Off by default. AI agents: leave this off to keep rows small (under 1 KB each without it). ## Actor input object example ```json { "domains": [ "google.com", "wikipedia.org", "bbc.co.uk", "spiegel.de", "zq7xk2-no-such-domain-4815.com" ], "concurrency": 20, "perServerConcurrency": 3, "includeRawRdap": false } ``` # Actor output Schema ## `domains` (type: `string`): One row per unique domain: availability, registrar, dates, nameservers. ## `summary` (type: `string`): Counts by status and method, skipped invalid inputs, and domains that could not be checked (none of these are charged). # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "domains": [ "google.com", "wikipedia.org", "bbc.co.uk", "spiegel.de", "zq7xk2-no-such-domain-4815.com" ] }; // Run the Actor and wait for it to finish const run = await client.actor("djk12/domain-availability-rdap-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "domains": [ "google.com", "wikipedia.org", "bbc.co.uk", "spiegel.de", "zq7xk2-no-such-domain-4815.com", ] } # Run the Actor and wait for it to finish run = client.actor("djk12/domain-availability-rdap-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": [ "google.com", "wikipedia.org", "bbc.co.uk", "spiegel.de", "zq7xk2-no-such-domain-4815.com" ] }' | apify call djk12/domain-availability-rdap-checker --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,djk12/domain-availability-rdap-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 ` 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/ncaaicuPZTcfRKoFZ/builds/EjXI77lEgED2lBAH5/openapi.json