# Domain Availability Checker: Bulk RDAP, Expiry Dates (`transparent_meteorite/domain-availability-checker`) Actor

Check domain availability in bulk through official RDAP: available or registered, registrar, created and expiry dates, days left, name servers. Keywords x TLDs.

- **URL**: https://apify.com/transparent_meteorite/domain-availability-checker.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Developer tools, SEO tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.59 / 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

## Domain Availability Checker: Bulk RDAP, Expiry Dates

Domain availability checker for long lists. Paste full domain names, or give keywords and a list of TLDs and let the Actor build the combinations. Every name is checked against the official registry RDAP service, so you get a straight answer (available, registered or unknown) plus registrar, created, updated and expiry dates, days left, status codes, name servers and DNSSEC for every registered domain.

It routes each extension to the right registry through the IANA RDAP bootstrap file. There is no scraping of WHOIS web pages, no browser and no proxy, so 1,000 domains finish in well under a minute.

### Run in 30 seconds

1. Open the **Input** tab. The prefill checks three well known domains and four invented brand keywords across six TLDs (27 names).
2. Click **Start**.
3. Open the **Domains** table in the Output tab. Export as JSON, CSV or Excel.
4. Replace the prefill with your own names and run again.

### What does this Actor do?

For each domain it asks the registry that runs the extension. A 404 from the registry means no record exists, so the name is **available**. A 200 means it is **registered**, and the record is parsed into flat fields. If a registry has no RDAP service, or rate limits the run, the Actor checks DNS name servers instead and marks that row `confidence: low`.

| Group | Fields |
|---|---|
| Answer | `domain`, `status` (available, registered, unknown), `reason`, `confidence`, `method` (rdap or dns) |
| Source | `tld`, `source` (domain or keyword), `keyword`, `rdapServer` |
| Registrar | `registrar`, `registrarIanaId`, `registrarUrl` |
| Dates | `createdDate`, `updatedDate`, `expiryDate`, `daysToExpiry`, `domainAgeDays` |
| Lifecycle flags | `expiringSoon`, `expired`, `inRedemption`, `pendingDelete` |
| Drop timing | `dropStage` (active, expired_grace, redemption, pending_delete), `estimatedDropDate` |
| Usage | `usage` (website, email_only, unused), `resolves`, `hasMx` |
| Technical | `statusCodes`, `nameservers`, `dnssec` |
| Run | `checkedAt` |

**Keywords times TLDs.** Give `acme` and the TLDs `com, io, dev` and you get acme.com, acme.io and acme.dev. Add prefixes such as `get` and `try` and suffixes such as `app` and `hq` and the Actor also checks getacme.com, acmeapp.com and so on, all deduplicated.

**Expiry watching.** `daysToExpiry` and `expiringSoon` (you choose the window, default 30 days) let you spot domains that are about to lapse. `inRedemption` and `pendingDelete` flag names that are on their way back to the open market, which is where most good drops come from.

### What you get that the other domain checkers do not

Other domain availability checkers on the Store, such as automation-lab/domain-availability-checker and bridgeworks/domain-checker, return the registry status codes and expiry dates. This Actor adds two things on every registered name, based on what their listed output fields show at the time of writing:

- **Estimated drop date.** `dropStage` and `estimatedDropDate` turn the raw status into a date you can schedule around. For .com, .net, .org and other generic extensions it applies the standard ICANN lifecycle: up to 45 days of auto-renew grace after expiry, 30 days of redemption, 5 days of pending delete. It is an estimate, because registrars differ, so it is left empty for two-letter country extensions and for names that are not near expiry (`dropStage: active`).
- **Usage profile.** `usage` tells you whether a registered name serves a website (`website`), only has mail records (`email_only`) or has no web or mail DNS at all (`unused`), from `resolves` and `hasMx`. That separates a live business from a parked or abandoned name when you shortlist drops or acquisition targets. It is a DNS check only (no page is fetched), so a parked page that resolves still shows as `website`. Turn it off with `usageProfile: false` for the fastest run.

### Speed and politeness

The Actor checks up to 40 domains at once by default and limits each registry separately. Large registries such as the .com and .net operator answer in a quarter of a second, so a list of 1,000 names completes in seconds. Registries that publish stricter limits are queried more slowly, and a registry that answers 429 with a long wait is skipped for the rest of the run (DNS fallback takes over) instead of stalling your job.

### Limits

- **Available means the registry has no record.** It does not know about premium pricing, reserved names that the registry will not sell, or trademark rules. Always confirm the price at a registrar before you buy.
- Some extensions have no public RDAP service (for example .co at the time of writing). Those use the DNS fallback, which finds name servers only. A name with no DNS delegation is reported as available with `confidence: low`, and a name with name servers as registered. Expiry and registrar are empty for these rows.
- Some registries return only part of the record (for example no registrar or no expiry date). Missing values are `null`, never guessed.
- A name under an extension that is not in the IANA root zone (for example .invalid) is returned as unknown and is free.
- Dates are what the registry reports, in UTC.
- Internationalised names are converted to punycode, so `bücher.de` is checked as `xn--bcher-kva.de`.
- RDAP shows registry data. A few registries hide registrant details by policy, and this Actor never returns personal registrant data.

### Input

| Field | What it does |
|---|---|
| `domains` | Full domain names, one per line. Links and `www.` are cleaned up. |
| `keywords` | Brand words to combine with every TLD. |
| `tlds` | Extensions without the dot: com, net, io, ai, dev, app, co.uk. Empty means com, net, org. |
| `prefixes`, `suffixes` | Optional words added in front of or after each keyword, in addition to the bare keyword. |
| `expiringSoonDays` | Window for the `expiringSoon` flag. Default 30. |
| `usageProfile` | Add `usage`, `resolves` and `hasMx` for registered names. Default on. |
| `dnsFallback` | Use DNS name servers when a TLD has no RDAP or a registry blocks the run. Default on. |
| `maxDomains` | Safety cap on names checked in one run. Default 10,000. |
| `concurrency` | Parallel checks. Default 40. |

### Example input

```json
{
  "domains": ["google.com", "https://www.openai.com/research"],
  "keywords": ["novaforge", "brightlab"],
  "tlds": ["com", "net", "dev", "app"],
  "prefixes": ["get"],
  "expiringSoonDays": 60
}
```

### Output sample

```json
{
  "domain": "google.com",
  "status": "registered",
  "reason": "Registered (RDAP record found).",
  "confidence": "high",
  "method": "rdap",
  "tld": "com",
  "source": "domain",
  "keyword": null,
  "registrar": "MarkMonitor Inc.",
  "registrarIanaId": "292",
  "createdDate": "1997-09-15T04:00:00.000Z",
  "updatedDate": "2019-09-09T15:39:04.000Z",
  "expiryDate": "2028-09-14T04:00:00.000Z",
  "daysToExpiry": 667,
  "expired": false,
  "expiringSoon": false,
  "domainAgeDays": 10654,
  "statusCodes": ["client delete prohibited", "client transfer prohibited", "client update prohibited"],
  "inRedemption": false,
  "pendingDelete": false,
  "nameservers": ["ns1.google.com", "ns2.google.com", "ns3.google.com", "ns4.google.com"],
  "dnssec": false,
  "dropStage": "active",
  "estimatedDropDate": null,
  "resolves": true,
  "hasMx": true,
  "usage": "website",
  "rdapServer": "https://rdap.verisign.com/",
  "checkedAt": "2026-11-16T08:51:32.839Z"
}
```

An available name looks like this, with the registrar and date fields empty:

```json
{
  "domain": "zqbrandlab.com",
  "status": "available",
  "reason": "The registry has no record of this name (RDAP 404).",
  "confidence": "high",
  "method": "rdap",
  "registrar": null,
  "expiryDate": null,
  "nameservers": []
}
```

The run also saves an `OUTPUT` record with totals (checked, available, registered, unknown), skipped invalid entries, anything not checked before the time limit and warnings.

### Use cases

- **Brand and startup naming:** test hundreds of name ideas across ten TLDs in one run and shortlist the free ones.
- **Domain investing and drop catching:** watch a list for `expiringSoon`, `inRedemption` and `pendingDelete`, then act the day a name is released.
- **Portfolio monitoring:** run weekly on the domains you own or manage and alert on expiry inside your window, a registrar change or lost DNSSEC.
- **Agencies and IT teams:** audit a client's domain list for expiry dates, registrars and name servers in one table.
- **Brand protection:** generate typo and extension variants of your brand and see which are already taken and by which registrar.
- **Lead and market research:** registered date and `domainAgeDays` show how new a competitor or prospect really is.

### Pricing

Pay per event, no subscription. Current prices:

| Event | Free | Bronze | Silver | Gold | Platinum | Diamond |
|---|---|---|---|---|---|---|
| Actor Start | $0.00005 | $0.00005 | $0.00005 | $0.00005 | $0.00005 | $0.00005 |
| Domain checked | $0.00095 | $0.000882 | $0.000755 | $0.000585 | $0.000585 | $0.000585 |

Tier follows your Apify subscription plan.

Apify's free plan includes monthly platform credit that covers test runs.

Examples at the current price (one `domain` event per result; Free-plan tier):

| You pull | You pay |
|---|---|
| 100 results | $0.095 |
| 1,000 results | $0.95 |
| 10,000 results | $9.50 |

Scheduled runs stay cheap when each run only returns new records.

### Integrations and scheduling

Schedule the Actor daily or weekly on a fixed domain list, then send rows with `expiringSoon: true` or `status: available` to Slack, email, Google Sheets, Make, Zapier or n8n through the Apify integrations, or call it through the REST API and the Python and JavaScript clients.

### Use with the API, n8n, Make, Zapier or AI agents

**API** (one call, returns the rows as JSON):

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~domain-availability-checker/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN"   -H "Content-Type: application/json"   -d '{"keywords":["novaforge"],"tlds":["com","io","dev"]}'
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("transparent_meteorite/domain-availability-checker").call(run_input={"keywords": ["novaforge"], "tlds": ["com", "io", "dev"]})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["status"] == "available":
        print(row["domain"])
```

- **n8n, Make, Zapier:** use the Apify app's "Run Actor" step with actor `transparent_meteorite/domain-availability-checker`, paste the input JSON, then map the dataset items to your sheet.
- **AI agents (MCP):** connect the Apify MCP server at `https://mcp.apify.com?tools=transparent_meteorite/domain-availability-checker` to Claude, Cursor or any MCP client, and your agent can check names as a tool.

### Fair use and legal

The Actor queries public registry RDAP services, which exist for exactly this kind of lookup, at a polite rate. It does not scrape registrar web pages, does not register or reserve names and does not return personal registrant data. Results describe the registry record at the time of the check. This is an independent tool, not affiliated with any registry or registrar.

### FAQ

**Is a 404 from RDAP really proof a domain is free?** It means the registry has no record, which is the same signal registrars use. Reserved, premium or blocked names can still be unavailable to buy, so confirm at checkout.

**Why is a row marked confidence low?** The extension has no RDAP service, or the registry rate-limited the run, so the Actor used DNS name servers. Registered names are almost always right; an available verdict deserves a second look.

**Which extensions are covered?** Every extension in the IANA RDAP bootstrap file (all major gTLDs and many country codes), plus a few registry servers that are live but not yet listed there, such as .io, .me and .de. Everything else uses DNS fallback.

**Do I need an API key or proxy?** No.

**How many domains can I check?** Up to 100,000 per run. The default cap is 10,000.

**Why is `expiryDate` empty for a registered domain?** The registry did not publish it, or the row came from the DNS fallback.

**Can it find domains that just dropped?** It reports `pendingDelete` and `inRedemption` flags where registries publish them, and `available` the moment the registry removes the record. Schedule it to catch the release.

### Support

Found a registry that answers badly or an extension that should be routed differently? Open an issue on the Issues tab with the run URL and the domain.

### Related actors

- [Domain Intelligence Lookup](https://apify.com/transparent_meteorite/domain-intelligence-lookup) for WHOIS, DNS, SPF and DMARC detail on the domains you keep.
- [Website Tech Stack Detector](https://apify.com/transparent_meteorite/website-tech-stack-detector) to see what the registered sites run on.
- [Company Enrichment by Domain](https://apify.com/transparent_meteorite/company-enrichment-by-domain) to turn registered domains into company profiles.

### Changelog

- **0.2**: Added `dropStage`, `estimatedDropDate` and the DNS usage profile (`usage`, `resolves`, `hasMx`).
- **0.1**: First private build. RDAP routing by IANA bootstrap, keyword x TLD combos, DNS fallback, expiry and drop flags.

# Actor input Schema

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

Full domain names, one per line, for example example.com. Links and www. are cleaned up for you.

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

Brand or product words. Each keyword is combined with every TLD below, for example nova + com = nova.com. Spaces are removed.

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

Extensions without the dot: com, net, org, io, ai, dev, app, co.uk. Used only with keywords. Empty means com, net and org.

## `prefixes` (type: `array`):

Words added in front of each keyword in addition to the bare keyword, for example get, try, my.

## `suffixes` (type: `array`):

Words added after each keyword in addition to the bare keyword, for example app, hq, labs.

## `expiringSoonDays` (type: `integer`):

Registered domains whose expiry is within this many days get expiringSoon: true.

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

For extensions without an RDAP service, or when a registry rate-limits the run, check DNS name servers instead. These rows are marked confidence low.

## `maxDomains` (type: `integer`):

Safety cap on how many names are checked in one run (domains plus generated combinations).

## `concurrency` (type: `integer`):

How many domains are checked at the same time. Each registry is also limited separately to stay polite.

## `usageProfile` (type: `boolean`):

For registered domains, check DNS to tell whether the name serves a website, only has mail, or is unused. Adds the fields resolves, hasMx and usage. Turn off for the fastest run.

## Actor input object example

```json
{
  "domains": [
    "google.com",
    "openai.com",
    "apify.com"
  ],
  "keywords": [
    "zqbrandlab",
    "zqnovaforge",
    "zqpixelnest",
    "zqgreenpeak"
  ],
  "tlds": [
    "com",
    "net",
    "org",
    "dev",
    "app",
    "xyz"
  ],
  "expiringSoonDays": 30,
  "dnsFallback": true,
  "maxDomains": 10000,
  "concurrency": 40,
  "usageProfile": true
}
```

# Actor output Schema

## `domains` (type: `string`):

No description

# 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": [
        "google.com",
        "openai.com",
        "apify.com"
    ],
    "keywords": [
        "zqbrandlab",
        "zqnovaforge",
        "zqpixelnest",
        "zqgreenpeak"
    ],
    "tlds": [
        "com",
        "net",
        "org",
        "dev",
        "app",
        "xyz"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/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": [
        "google.com",
        "openai.com",
        "apify.com",
    ],
    "keywords": [
        "zqbrandlab",
        "zqnovaforge",
        "zqpixelnest",
        "zqgreenpeak",
    ],
    "tlds": [
        "com",
        "net",
        "org",
        "dev",
        "app",
        "xyz",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/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": [
    "google.com",
    "openai.com",
    "apify.com"
  ],
  "keywords": [
    "zqbrandlab",
    "zqnovaforge",
    "zqpixelnest",
    "zqgreenpeak"
  ],
  "tlds": [
    "com",
    "net",
    "org",
    "dev",
    "app",
    "xyz"
  ]
}' |
apify call transparent_meteorite/domain-availability-checker --silent --output-dataset

```

## MCP server setup

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