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

Bulk domain WHOIS lookup over RDAP. Paste a list of domain names and get one row per name: free or taken, expiry date, days left, registrar, status codes and name servers, read from each registry's server.

- **URL**: https://apify.com/sampon/domain-expiry-availability-checker.md
- **Developed by:** [Sampon](https://apify.com/sampon) (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

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

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

Give this Actor a list of domain names and it tells you, for each one, whether the name is taken or looks free, when it expires, how many days are left, and who the registrar is. One row per domain, so the result drops straight into a spreadsheet.

The answers come from the registries themselves. For every name, the Actor looks up the registry's RDAP server in the bootstrap file that IANA publishes, then asks that server directly. RDAP is the successor to WHOIS: the same registration facts, but in a structured format, so there is no text parsing and no guessing between registrars' layouts.

Typical uses:

- Watching your own portfolio or your clients' domains so nothing lapses by accident.
- Checking a shortlist of name ideas: which are free, and for the taken ones, when they come up for renewal.
- Spotting names that are already in their deletion cycle.

### What you put in

```json
{
  "domains": ["example.com", "python.org", "mybrand.dev"],
  "expiringWithinDays": 60
}
```

You can paste links instead of bare names (`https://www.example.com/pricing` becomes `example.com`). Internationalised names such as `bücher.example` are converted to their ASCII form before the lookup. Duplicates are checked once. Up to 5,000 names per run.

| Setting | What it does |
|---|---|
| `domains` | The names to check, one per line. For a long list, use the bulk edit button and paste; names separated by commas or spaces are split too. |
| `expiringWithinDays` | Rows that expire within this many days get `expiringSoon: true`. Default 30. Leave empty to skip the mark. |
| `outputFilter` | Save all rows (default), only names that look free, only names expiring soon, or both. |
| `requestIntervalMs` | Gap between two requests to the same registry. Default 1,000 ms, minimum 500 ms. |
| `maxConcurrency` | How many different registries are asked at the same time. Default 4, which is also the maximum. |

### What you get

```json
{
  "domain": "example.com",
  "availability": "registered",
  "registered": true,
  "createdDate": "1995-08-14T04:00:00Z",
  "expiryDate": "2027-08-13T04:00:00Z",
  "daysUntilExpiry": 306,
  "expiringSoon": false,
  "updatedDate": "2026-08-14T08:01:43Z",
  "statuses": ["clientDeleteProhibited", "clientTransferProhibited", "clientUpdateProhibited"],
  "registrar": "RESERVED-Internet Assigned Numbers Authority",
  "registrarIanaId": "376",
  "nameservers": ["elliott.ns.cloudflare.com", "hera.ns.cloudflare.com"],
  "dnssec": true,
  "rdapUrl": "https://rdap.verisign.com/com/v1/domain/example.com",
  "httpStatus": 200,
  "note": null,
  "checkedAt": "2026-10-10T07:51:11Z"
}
```

`availability` is one of:

- `registered`: the registry has a record for the name. Dates, status codes, registrar and name servers are filled in when the registry publishes them.
- `available`: the registry has no record of the name, so it is probably free to register. Reserved and premium names can look the same, so confirm at a registrar before you count on it.
- `no_rdap`: the ending has no RDAP server in IANA's list (at the time of writing this includes .io, .co, .de, .jp, .us and .me), so the name was not checked.
- `skipped`: the registry's own terms do not allow this kind of reuse, so the name was not queried. Today this applies to .uk.
- `unknown`: the registry did not give a usable answer (a timeout, an error, or repeated requests to slow down). The `note` says which. Run those names again later.

`daysUntilExpiry` is counted from the moment of the check and is negative when the expiry date has already passed. Status codes are given in the usual EPP form (`clientTransferProhibited`, `pendingDelete`, `redemptionPeriod` and so on).

#### No personal data

Registrant, admin, technical and abuse contacts are never read into the output, even when a registry publishes them. The only party named in a row is the sponsoring registrar, which is a company, together with its IANA ID.

### Price

Free for now. You only pay Apify's usual platform usage. Each name is one small JSON request, so the cost depends mostly on how long the run takes. On our machine the four default names took about 7 seconds, which is well under a cent at 256 MB. A list of 1,000 `.com` names takes about 17 minutes with the default gap; we estimate a few cents of platform usage for that, but have not yet measured it on Apify.

### How it treats the registries

- At most one request at a time goes to any single registry, with a gap of at least one second by default.
- When a registry answers "too many requests", the Actor waits as long as the registry asks (or 10 seconds or more if it does not say) and doubles its gap for that registry for the rest of the run.
- If a registry does not answer three names in a row, the remaining names for that registry are marked `unknown` instead of being retried again and again.
- The IANA bootstrap file is downloaded once per run.

Most registries' RDAP terms allow lookups for lawful purposes but forbid high-volume automated querying and using the data for unsolicited marketing. Keep runs to the names you actually need to watch, and do not use the results to contact registrants.

### Limits

- Speed is set by the per-registry gap. Names spread over many endings finish faster than a long list on one ending: at the default setting, expect roughly 60 names per minute per registry.
- Some registries do not publish an expiry date (the row says so in `note`).
- A registry can change its RDAP server, its limits or its terms at any time. The bootstrap file is read fresh on every run, so server moves are picked up automatically.
- "Available" means the registry has no record. It does not check prices, premium lists or registrar-level holds.

This Actor is an independent tool. It is not made by, or affiliated with, IANA, ICANN, Verisign or any domain registry or registrar.

# Actor input Schema

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

One name per line, for example example.com. Use the bulk edit button to paste a long list; names separated by commas or spaces are split as well. Links such as https://www.example.com/page are cut down to the name. Up to 5,000 names per run; duplicates are checked once.

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

Rows whose expiry date falls within this many days get expiringSoon = true. Leave empty to skip the mark.

## `outputFilter` (type: `string`):

Save every row, or only the names that look free, only the ones expiring soon, or both.

## `requestIntervalMs` (type: `integer`):

Each registry gets at most one request at a time, with this gap in between. When a registry asks us to slow down, the gap is doubled for that registry.

## `maxConcurrency` (type: `integer`):

Names under different endings (.com, .org, .dev ...) are usually answered by different registries and can be checked in parallel. Capped at 4.

## Actor input object example

```json
{
  "domains": [
    "example.com",
    "python.org",
    "surely-unregistered-name-for-rdap-test-48213.com",
    "example.jp"
  ],
  "expiringWithinDays": 30,
  "outputFilter": "all",
  "requestIntervalMs": 1000,
  "maxConcurrency": 4
}
```

# Actor output Schema

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

One row per domain: free or taken, expiry date, days left, registrar and status codes.

# 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": [
        "example.com",
        "python.org",
        "surely-unregistered-name-for-rdap-test-48213.com",
        "example.jp"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sampon/domain-expiry-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": [
        "example.com",
        "python.org",
        "surely-unregistered-name-for-rdap-test-48213.com",
        "example.jp",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("sampon/domain-expiry-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": [
    "example.com",
    "python.org",
    "surely-unregistered-name-for-rdap-test-48213.com",
    "example.jp"
  ]
}' |
apify call sampon/domain-expiry-availability-checker --silent --output-dataset

```

## MCP server setup

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