# Domain Expiry Checker: Domain Expiration Dates in Bulk (`ucchiii/domain-expiry-checker`) Actor

For renewal management of your own and your clients' domains: get each domain's expiry date, days left, registrar and status codes from the registries' RDAP, sorted soonest first. Optional filter: only domains expiring within N days. Empty input = free demo.

- **URL**: https://apify.com/ucchiii/domain-expiry-checker.md
- **Developed by:** [Actor Factory](https://apify.com/ucchiii) (community)
- **Categories:** Developer tools, SEO tools, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.05 / 1,000 domain expiry dates

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 expiry checker for renewal management: paste your own and your clients' domains and get every expiry date and the days left, sorted soonest first, straight from the registries over RDAP.**

| domain | expiresAt | daysToExpiry | expired | registrar | domainStatus | nameservers |
|---|---|---|---|---|---|---|
| client-shop.com | 2026-11-02T09:00:00Z | -4 | true | Example Registrar, Inc. | client transfer prohibited | ns1.example-dns.net, ns2.example-dns.net |
| our-brand.org | 2026-11-20T00:00:00Z | 14 | false | Sample Registry Services | client delete prohibited | a.ns.example.org, b.ns.example.org |
| agency-site.com | 2027-05-14T09:00:00Z | 189 | false | Example Registrar, Inc. | client transfer prohibited | ns1.example-dns.net, ns2.example-dns.net |
| client-shop.co.uk | | | | | | |

*(illustrative rows showing the output format; the `.uk` row comes back without a date and is free — see Limits. The free demo shows real results.)*

Prevent missed renewals for your own and your clients' domains: one run gives you the whole portfolio in one table, the most urgent names at the top. Each registry is asked directly through **RDAP** (the official, structured successor of WHOIS): no scraping, no proxies, no API keys, and no personal data.

**Try it free:** leave the input empty and press **Start** — four sample domains are looked up as a demo (not charged, rows carry `_demo: true`).

> **Acceptable use:** This Actor is for managing the renewals of domains you own or look after. It only checks the list you give it (up to 500 per run). Follow the terms of use of the registries' RDAP services and do not use the data for marketing or spam.

### What you get

- **Soonest first**: rows are sorted by `daysToExpiry`; names already past their expiry date come first (negative days), rows without a date come last.
- **Only what needs attention**: set **Within days** (for example `30`) to keep only domains expiring in the next 30 days. Domains outside the window are left out and not charged.
- **Who to call**: registrar name and IANA registrar ID, registry status codes such as `client transfer prohibited` or `client hold`, and nameservers.
- **Messy input is fine**: URLs are cut down to the host name, duplicates are removed, typos come back as free `invalid_domain` rows.

### How to use

1. **Your domains**: one per line (up to 500 per run), or a **Dataset ID** whose items have a `domain` or `url` field.
2. Optional: **Only domains expiring within N days**, **Concurrency** (1–5, default 3), **Timeout** per request (default 15 s).
3. Schedule the run weekly or monthly in Apify and connect the dataset to e-mail, Slack or Google Sheets for a renewal reminder.

```json
{
  "domains": ["python.org", "apify.com", "example.com"],
  "withinDays": 60
}
```

### Output fields

- `domain` — the name as given (punycode for international names; subdomains use their registered domain's record).
- `expiresAt` — expiry date from the registry (ISO, UTC); `daysToExpiry` — whole days left (negative when past); `expired`.
- `registrar`, `registrarIanaId` — the registrar company and its IANA ID.
- `domainStatus` — registry status codes (EPP status); `nameservers`.
- `checkedAt` — time of the lookup; `error` and `note` — why a row has no date (for example `not_registered`, `no_rdap_for_tld`, `no_expiry_date_published`, `uk_registry_not_queried`, `invalid_domain`, or a timeout / rate limit).
- **SUMMARY** record: domains given and checked, returned with and without a date, past expiry, left out by the filter, charged, and anything not checked with the reason.

### Privacy: no personal data

Registrant, administrative, technical and billing contacts are **never read or returned** — no names, e-mails, phone numbers or addresses. Only the registrar (a company), dates, status codes and nameservers are used. E-mail addresses typed into the input are rejected as invalid, not looked up.

### Limits (cannot be raised by input)

- **500 domains per run.** Domains beyond 500 are not checked; the status message and the SUMMARY record say how many were skipped. Split bigger portfolios into several runs.
- **Your list only**: the Actor does not discover or list domains by itself.
- **Polite to the registries**: at most 2 connections and at least 0.25 s between requests per registry server; rdap.org (used only when the IANA list cannot be loaded) at most 1 request per 1.1 s. Rate limits (HTTP 429) and server errors are retried up to 3 times with a growing pause, honouring `Retry-After`.
- **`.uk` names are not looked up** (including `.co.uk`): the .uk registry's terms forbid commercial copying of its RDAP data. They come back without a date, with `error: uk_registry_not_queried`, and are free. The same applies to the other TLDs whose RDAP service is run by the same registry operator (for example `.wales`, `.cymru`, `.bbc`).
- TLDs without an RDAP service (for example `.io`, `.co`, `.de`, `.eu`, `.jp` at the time of writing) and registries that publish no expiry date come back without a date and are free.
- Set a **maximum charge per run** to cap spend: the Actor checks it before starting and never charges more; with the N-days filter on, the soonest domains are returned first.

### Pricing

Pay per event: **$0.0015 per domain expiry date** — one domain returned with an expiry date from its registry. That is **$1.50 per 1,000 domains**, with no start fee.
Rows without a date (invalid, unregistered, no RDAP, `.uk`, timeouts), domains left out by the N-days filter, and the demo are **free**.
Store discounts apply automatically: BRONZE −10%, SILVER −20%, GOLD −30%.
On the Apify Free plan, the $5 of monthly platform credit covers about 3,300 domains a month.

### FAQ

**Is RDAP the same as WHOIS?** RDAP is the official replacement for the old WHOIS protocol, run by the same registries. ICANN requires it for all generic TLDs.

**Why is a domain I own missing its date?** Either its TLD has no public RDAP service, the registry does not publish expiry dates (several country-code registries), it is a `.uk` name, or the registry did not answer in time. The `note` column says which. These rows are free; check them with your registrar.

**Which registries' terms have been checked?** The terms of use of Verisign (`.com`, `.net`), Public Interest Registry (`.org`), Identity Digital (`.info`, `.ai` and several hundred other TLDs), Google Registry (`.app`, `.dev` and others), Nominet (`.uk`), rdap.org and the IANA bootstrap list were read in the original. For other TLDs the registry's own RDAP terms have **not been confirmed**; they generally allow lawful, query-based use, but follow each registry's terms when you reuse the data.

**Why is the registrant missing?** By design: this Actor never collects personal data.

**Can it remind me?** Schedule it in Apify (for example every Monday with `withinDays: 30`) and add an integration that sends the dataset to e-mail or Slack.

### More tools from the same developer

- [SSL Certificate Expiry Checker](https://apify.com/ucchiii/ssl-certificate-checker) — SSL/TLS certificate expiry dates, issuer and validity for many hosts, soonest first
- [Domain WHOIS & DNS Lookup](https://apify.com/ucchiii/domain-whois) — bulk WHOIS (RDAP) and DNS lookup: registrar, expiry, days left, A/MX/NS, no personal data
- [Domain Availability Checker](https://apify.com/ucchiii/domain-availability-checker) — bulk domain availability check via RDAP: registered or likely available
- [DNS Lookup](https://apify.com/ucchiii/dns-records-lookup) — bulk DNS lookup: A, AAAA, MX, NS, TXT, SPF and DMARC per domain
- [WHOIS Lookup](https://apify.com/ucchiii/whois-lookup) — bulk WHOIS (RDAP): registrar, created and expiry dates, nameservers, no personal data

# Actor input Schema

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

The domains you own or manage for clients, one per entry, e.g. 'example.com'. URLs are cut down to the host name and subdomains use their registered domain's record; internationalized names are converted to punycode. Duplicates are removed. Up to 500 domains per run (domains beyond 500 are not checked). Leave empty (and no dataset) for a free demo. Follow the terms of use of the registries' RDAP services.

## `datasetId` (type: `string`):

An Apify dataset ID or URL holding your domain list, e.g. the output of another run. Each item's 'domain', 'url', 'website', 'hostname' or 'host' field is used. Added to the Domains above; the 500-per-run limit applies to the total.

## `withinDays` (type: `integer`):

Keep only domains whose expiry date is at most this many days away (names already past their expiry date are kept too). Domains outside the window are left out and not charged. Rows without a date (errors, .uk) are always shown, free. Leave empty to get every domain.

## `timeoutSecs` (type: `integer`):

Timeout for each request, in seconds. Failed requests (including rate limits, HTTP 429) are retried up to 3 times with a growing pause. Allowed range 1 to 60 (default 15).

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

How many domains are looked up in parallel. Allowed range 1 to 5 (default 3). At most 2 connections per registry server are used at a time, with at least 0.25 s between requests to the same server, whatever you set here.

## Actor input object example

```json
{
  "domains": [
    "python.org",
    "apify.com",
    "example.com"
  ],
  "timeoutSecs": 15,
  "concurrency": 3
}
```

# Actor output Schema

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

One row per domain, soonest expiry first: domain, expiresAt, daysToExpiry, expired, registrar, registrarIanaId, domainStatus, nameservers, checkedAt, error, note. Rows without a date come last.

## `summary` (type: `string`):

Record SUMMARY: domains given and checked, returned with and without a date, past expiry, left out by the N-days filter, charged, and anything not checked (500-per-run limit or maximum charge) with the reason.

# 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": [
        "python.org",
        "apify.com",
        "example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ucchiii/domain-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": [
        "python.org",
        "apify.com",
        "example.com",
    ] }

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

```

## MCP server setup

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