# Bulk Domain Availability & Expiry Checker (RDAP) (`lindenbyte/bulk-domain-availability-expiry-checker`) Actor

Check thousands of domains for availability, expiry date, registrar, EPP status and nameservers via official registry RDAP (every RDAP TLD), with DNS fallback for ccTLDs. Name x TLD matrix for brand hunting and a monitor mode that outputs only changes.

- **URL**: https://apify.com/lindenbyte/bulk-domain-availability-expiry-checker.md
- **Developed by:** [Lindenbyte Studio](https://apify.com/lindenbyte) (community)
- **Categories:** Developer tools, SEO tools, Marketing
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 & Expiry Checker (RDAP)

Check **thousands of domain names at once** and see, for each one, whether it is **available or registered**, plus its **expiry date, days left, registrar, creation date, EPP status codes (clientHold, redemptionPeriod, pendingDelete...), nameservers and DNSSEC**. The data comes from the **official registry RDAP servers** (the modern, structured successor of WHOIS) for every TLD that publishes RDAP: .com, .net, .org, .io, .ai, .dev, .app, .co, .uk, .fr, .nl, .ca, .au, .xyz and more than 1,000 others. Country domains without RDAP (for example .bg, .it, .es, .eu) get an honest DNS-based "likely registered / likely available" answer.

No API key, no browser, no WHOIS scraping. Pay only per domain checked.

### What you can do with it

- **Brand and startup name hunting:** enter name ideas and extensions (`acme`, `lindenbyte` x `com`, `io`, `ai`, `dev`) and get the full matrix of what is free.
- **Domain portfolio audit:** expiry dates, days left and registrar for every domain you or your clients own, in one table. Use `expiringWithinDays` to flag renewals due soon.
- **Expiry and drop monitoring:** schedule the Actor in **monitor mode** and get only the domains that changed since the last run: a domain became available, was renewed, changed registrar or nameservers, entered `redemptionPeriod` / `pendingDelete`, or entered your expiry window.
- **Lead and research enrichment:** registrar, age (creation date) and, optionally, DNS records (A, AAAA, MX, NS, SPF, DMARC) for lists of company domains.
- **Brand protection:** watch typo and look-alike domains of your brand and get told when one gets registered.

### Input

| Field | Meaning |
|---|---|
| `domains` | Domains, URLs or subdomains, one per line. `https://www.example.com/page` becomes `example.com`; `blog.example.co.uk` becomes `example.co.uk`; IDNs like `münchen.de` are converted to punycode. Duplicates removed. |
| `keywords` + `tlds` | Optional name x extension matrix. 3 keywords x 5 TLDs = 15 domains. If `tlds` is empty: com, net, org, io, ai, dev, app, co. |
| `mode` | `check` (default): every domain is output. `monitor`: only domains whose availability, status, expiry, registrar, nameservers or EPP status changed since the previous run. |
| `stateKey` | Monitor mode: name of the saved snapshot. Use one key per watch list. |
| `outputBaseline` | Monitor mode: output all domains on the first run (default) or record the baseline silently. |
| `expiringWithinDays` | Flags `expiringSoon: true` for domains expiring within N days. |
| `onlyExpiringSoon` | Output only the domains inside that window. |
| `includeDns` | Add A, AAAA, MX, NS, SPF and DMARC for registered domains (separate small charge). |
| `concurrency`, `maxDomains` | Speed and a safety cap. Each registry is additionally rate-limited per server, automatically. |

### Output

Real rows from a run on 2026-11-16 (abbreviated):

```json
{ "domain": "google.com", "tld": "com", "available": false, "status": "registered", "method": "rdap",
  "registrar": "MarkMonitor Inc.", "registrarIanaId": "292",
  "createdAt": "1997-09-15T04:00:00.000Z", "updatedAt": "2019-09-09T15:39:04.000Z", "expiresAt": "2028-09-14T04:00:00.000Z",
  "daysToExpiry": 667, "expiringSoon": false, "droppingSoon": false,
  "eppStatus": ["clientDeleteProhibited", "clientTransferProhibited", "clientUpdateProhibited", "serverDeleteProhibited", "serverTransferProhibited", "serverUpdateProhibited"],
  "nameservers": ["ns1.google.com", "ns2.google.com", "ns3.google.com", "ns4.google.com"], "dnssec": false,
  "rdapServer": "https://rdap.verisign.com/com/v1/", "checkedAt": "2026-11-16T08:03:11.590Z", "change": null,
  "dns": { "a": ["142.251.208.110"], "aaaa": ["2a00:1450:4002:408::200e"], "mx": [{ "priority": 10, "host": "smtp.google.com" }],
           "ns": ["ns1.google.com", "ns2.google.com", "ns3.google.com", "ns4.google.com"],
           "txtSpf": "v=spf1 include:_spf.google.com ~all", "dmarc": "v=DMARC1; p=reject; rua=mailto:mailauth-reports@google.com" } }
```

| domain | status | method | registrar | expires | days left |
|---|---|---|---|---|---|
| lindenbyte.com | registered | rdap | Cloudflare, Inc. | 2027-10-01 | 319 |
| lindenbyte.io | available | rdap | | | |
| lindenbyte.ai | available | rdap | | | |
| lindenbyte.dev | available | rdap | | | |
| acme.dev | registered | rdap | GoDaddy.com, LLC | 2027-03-01 | 105 |
| github.io | registered | rdap | MarkMonitor Inc. | 2027-03-08 | 112 |
| bbc.co.uk | registered | rdap | British Broadcasting Corporation | 2034-12-13 | 2948 |
| bund.de | registered | rdap | (DENIC publishes no registrar/expiry) | | |
| bnb.bg | likely-registered | dns-heuristic | | | |
| lindenbyte-qx7-unregistered.bg | likely-available | dns-heuristic | | | |

In monitor mode each output row has a `change` object, for example:

```json
"change": { "type": "changed", "fields": ["expiresAt"], "previous": { "expiresAt": "2027-09-14T04:00:00.000Z" },
            "previousCheckedAt": "2026-11-16T08:03:29.759Z", "summary": "expiry 2027-09-14 -> 2028-09-14 (renewed)" }
```

#### Status values

| `status` | `available` | Meaning |
|---|---|---|
| `registered` | false | The registry RDAP server returned the domain. |
| `available` | true | The registry RDAP server says it does not exist, and DNS agrees (no nameservers). |
| `likely-registered` | false | TLD without RDAP: the domain has nameservers in DNS. |
| `likely-available` | true | TLD without RDAP: DNS says the name does not exist (NXDOMAIN). |
| `unknown` | null | The registry did not answer after retries, or RDAP and DNS disagree. Shown in the `note`, and **not charged**. |

`method` tells you which source was used: `rdap` or `dns-heuristic`. The run summary (counts per status, errors, invalid inputs) is saved as `SUMMARY` in the key-value store.

### Pricing

Pay per result: you pay per **domain checked and output** (`domain-checked`), plus a separate small event per domain when `includeDns` is on (`dns-lookup`, only for registered domains). `unknown` rows are free. In monitor mode, only the changed domains that are output are charged. Set a max charge limit and the run stops cleanly when it is reached.

### Privacy

Only the **registrar** (company name and IANA ID) is kept. All contact entities from RDAP responses (registrant, admin, tech, abuse contacts, vCards) are dropped before anything is saved, so the output contains no personal data.

### Honest limits

- **"Available" means "not registered at the registry".** Premium names, registry-reserved names (for example country names in .io) and blocked names can still be unregistrable or priced higher. Always confirm at a registrar before you rely on it.
- **DNS heuristic TLDs** (no RDAP, e.g. .bg, .it, .es, .eu, .se, .jp): a registered domain that has no nameservers (on hold, suspended, parked without DNS) looks "likely available". Expiry dates and registrars are not available for these TLDs.
- **Some registries publish little data:** DENIC (.de) and a few ccTLDs show status and nameservers but no expiry date or registrar. When a registry omits the expiry date but links to the registrar's RDAP server, the Actor asks the registrar once.
- **Rate limits:** registries throttle bulk queries. The Actor spaces requests per server, honours `Retry-After`, backs off and retries; very large lists on a single TLD (tens of thousands of .io or .ai names) take longer. Persistent failures become `unknown` (free) instead of a wrong answer.
- **Use the data lawfully.** Registry RDAP terms forbid using the data for unsolicited marketing; the intended uses are registration decisions, portfolio management and security research.
- RDAP coverage comes from the IANA bootstrap file, refreshed at every run, plus a short verified list of registry RDAP servers that are not in the bootstrap yet (.io, .me, .co, .us, .de, .ch, .li, .sh, .ac).

Not affiliated with IANA, ICANN, Verisign, DENIC or any registry or registrar.

# Actor input Schema

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

Domains to check, one per line. URLs and subdomains are accepted and reduced to the registrable domain (https://www.example.com/page -> example.com, blog.example.co.uk -> example.co.uk). International names (münchen.de) work too. Duplicates are removed.

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

Optional. Brand or name ideas without extension (acme, my brand). Each keyword is checked in every TLD listed below, e.g. 2 keywords x 4 TLDs = 8 domains.

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

Extensions to combine with the keywords (com, io, ai, dev, co.uk ...). Used only when keywords are given. If empty: com, net, org, io, ai, dev, app, co.

## `mode` (type: `string`):

Monitor mode remembers each domain's availability, status, expiry date, registrar, nameservers and EPP status codes between runs (stored under the state key below) and outputs only the domains where something changed: a domain became available, was renewed or transferred, entered redemption, or entered your expiring window. Schedule it daily or weekly.

## `stateKey` (type: `string`):

Monitor mode only. Name of the saved watch list snapshot. Use a different key for each separate list you monitor (e.g. client-a, drop-watch).

## `outputBaseline` (type: `boolean`):

Monitor mode only. On the first run (no saved snapshot yet) every domain is output as change type 'new'. Turn off to only record the baseline silently; later runs output changes only.

## `expiringWithinDays` (type: `integer`):

Optional. Flags each registered domain with expiringSoon = true when its expiry date is within this many days. In monitor mode a domain entering this window is reported as a change.

## `onlyExpiringSoon` (type: `boolean`):

Requires 'Expiring within (days)'. Domains outside the window are checked but not output (and not charged).

## `includeDns` (type: `boolean`):

For registered domains, also look up A, AAAA, MX, NS, the SPF record and the DMARC policy via public DNS-over-HTTPS. Charged as a separate small event per domain; skipped for available domains.

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

How many domains are checked at the same time. Requests to each registry are additionally spaced out and slowed down automatically when a registry rate-limits.

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

Safety cap on the number of domains checked in one run (after the keyword x TLD matrix is expanded).

## Actor input object example

```json
{
  "domains": [
    "google.com",
    "example.org",
    "bund.de",
    "lindenbyte-example-unregistered.com"
  ],
  "keywords": [
    "lindenbyte"
  ],
  "tlds": [
    "com",
    "io",
    "ai",
    "dev"
  ],
  "mode": "check",
  "stateKey": "default",
  "outputBaseline": true,
  "onlyExpiringSoon": false,
  "includeDns": false,
  "concurrency": 10,
  "maxDomains": 10000
}
```

# Actor output Schema

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

No description

## `summary` (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",
        "example.org",
        "bund.de",
        "lindenbyte-example-unregistered.com"
    ],
    "keywords": [
        "lindenbyte"
    ],
    "tlds": [
        "com",
        "io",
        "ai",
        "dev"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lindenbyte/bulk-domain-availability-expiry-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",
        "example.org",
        "bund.de",
        "lindenbyte-example-unregistered.com",
    ],
    "keywords": ["lindenbyte"],
    "tlds": [
        "com",
        "io",
        "ai",
        "dev",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("lindenbyte/bulk-domain-availability-expiry-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",
    "example.org",
    "bund.de",
    "lindenbyte-example-unregistered.com"
  ],
  "keywords": [
    "lindenbyte"
  ],
  "tlds": [
    "com",
    "io",
    "ai",
    "dev"
  ]
}' |
apify call lindenbyte/bulk-domain-availability-expiry-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lindenbyte/bulk-domain-availability-expiry-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/3OYM4GPeo8VNNe5hF/builds/QhRKjMNBr1ZVfWAi6/openapi.json
