# Domain Expiry & WHOIS Monitor (`zaden/my-actor-8`) Actor

Tracks domain registration expiry via raw WHOIS lookups -- registrar, expiry date, days remaining, nameservers -- fast and without a browser. Need every check? See Full Site Health Suite for all 9 checks in one job.

- **URL**: https://apify.com/zaden/my-actor-8.md
- **Developed by:** [Zaden](https://apify.com/zaden) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.60 / 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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Domain Expiry & WHOIS Monitor

Tracks domain registration status via raw WHOIS lookups -- no browser, no proxy. Point it at one or more domains and get back the registrar, creation date, expiry date, days remaining, nameservers, and domain status codes -- plus a **letter grade**, a 0-100 score, a severity tag, and a plain-English summary so an expiring or lapsed domain never gets buried in a wall of fields.

### What you get, per domain

- A **letter grade (A+ to F)** and 0-100 score summarizing registration health at a glance
- A one-line **executive summary** ("Domain expires in 12 day(s) -- renew soon.")
- A **severity** tag -- `critical` (expired, expiring within your warning window, unregistered, or the lookup itself failed), `warning` (registered but missing a data field), or `ok` -- for instant triage
- **Registrar** and **creation date**
- **Expiry date** and **days until expiry**
- **isExpired** / **isExpiringSoon** flags (soon = within your configurable warning window, default 30 days)
- **Domain status codes** (e.g. `clientTransferProhibited`) and **nameservers**
- A plain-English issues list when something looks off (no expiry field exposed, lookup failed, domain unregistered, etc.)
- Domains are checked **in parallel** (configurable), with per-TLD WHOIS referral lookups automatically cached and shared across domains -- so a watchlist of 50 `.com` domains queries IANA once, not 50 times

### Why this instead of checking manually

| | Manual registrar logins | Domain Expiry & WHOIS Monitor |
|---|---|---|
| Coverage | One registrar dashboard at a time | Every domain you list, across any registrar, automatically |
| Speed | Login, click through, repeat per domain | Seconds, via parallel WHOIS lookups |
| Triage | You scan dates yourself | Pre-classified severity + letter grade |
| Repeatability | Forgotten until a renewal email (or missed) | One click, or schedule it |
| Output | Screenshots or a spreadsheet you update by hand | Structured dataset, exportable to CSV/JSON/BI tools |

### Who this is for

- Agencies and freelancers managing domains for multiple clients who want a single expiry dashboard instead of checking each registrar
- Anyone who's ever lost a domain to an expired registration
- IT/ops teams tracking a portfolio of company domains
- Domain investors monitoring watchlists for drops

### How to use it

1. Add one or more **domains to check** (no protocol, e.g. `example.com`).
2. Optionally adjust the **expiry warning threshold** (days) and **concurrency**.
3. Run it once for a snapshot, or put it on an Apify **Schedule** (e.g. weekly) so you get an updated dataset before anything lapses.

### How it works

This Actor speaks the WHOIS protocol directly over a raw TCP socket (port 43) -- the same protocol `whois` command-line tools use. It first asks IANA's root WHOIS server which registry is authoritative for the domain's TLD (caching that answer per TLD so it's only asked once per batch), then queries that registry directly. No headless browser, no proxy, no third-party API keys required.

### Example output (one item)

```json
{
  "domain": "example.com",
  "score": 100,
  "grade": "A+",
  "severity": "ok",
  "summary": "No issues found -- domain registration looks healthy.",
  "found": true,
  "registrar": "RESERVED-Internet Assigned Numbers Authority",
  "creationDate": "1995-08-14T04:00:00Z",
  "expiryDate": "2026-08-13T04:00:00Z",
  "daysUntilExpiry": 45,
  "isExpired": false,
  "isExpiringSoon": false,
  "status": ["clientDeleteProhibited", "clientTransferProhibited"],
  "nameServers": ["A.IANA-SERVERS.NET", "B.IANA-SERVERS.NET"],
  "whoisServer": "whois.verisign-grs.com",
  "issueCount": 0,
  "issues": [],
  "checkedAt": "2026-08-22T00:00:00.000Z"
}
```

### Pricing

This Actor uses pay-per-event pricing:

- **Domain checked** -- charged once per domain processed.

Parallel checking doesn't cost more -- it just finishes faster.

### FAQ

**Does this work for every TLD?**
It covers gTLDs and most ccTLDs that expose a public WHOIS service and a standard IANA referral (the vast majority of domains). A small number of ccTLD registries use web-based lookups instead of WHOIS-on-port-43, or redact expiry dates for privacy -- for those, `found` may be true but `expiryDate` will be null, and the issue list will explain why.

**What makes something "critical" vs. a "warning"?**
`critical` covers the scenarios that actually threaten the domain: expired, expiring within your warning window, unregistered, or the WHOIS lookup itself failing. `warning` covers a registered domain with an incomplete WHOIS response (e.g. no registrar field) -- worth a look, but not urgent.

**Will higher concurrency get me rate-limited by WHOIS servers?**
It's possible -- some registries are stricter about concurrent connections than typical web servers. That's why the default concurrency here (3) is more conservative than in our HTTP-based Actors, and why per-TLD IANA lookups are cached rather than repeated. Raise it gradually and watch for `WHOIS lookup failed` issues if you push it higher.

**Does this send data anywhere besides your own Apify account?**
No. It only queries public WHOIS servers for the domains you provide.

**Can I use this to bulk-check whether domains are available to register?**
It will tell you if a domain has no matching WHOIS record, but availability checking has TLD-specific edge cases -- always confirm with your registrar before assuming a domain is free.

# Actor input Schema

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

One or more domain names (no protocol, e.g. example.com). Each domain's WHOIS record is checked once for registrar, expiry date, and status.

## `expiryWarningDays` (type: `integer`):

Domains expiring within this many days are flagged as expiring soon.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for each WHOIS server to respond before giving up.

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

How many domains to check in parallel. TLD referral lookups are cached and shared across domains, so this stays gentle on WHOIS servers even at higher values -- but WHOIS servers can be stricter about concurrent connections than HTTP servers, so a conservative default is used.

## Actor input object example

```json
{
  "domains": [
    "example.com"
  ],
  "expiryWarningDays": 30,
  "requestTimeoutSecs": 10,
  "concurrency": 3
}
```

# Actor output Schema

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

WHOIS expiry status for each checked domain.

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zaden/my-actor-8").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"] }

# Run the Actor and wait for it to finish
run = client.actor("zaden/my-actor-8").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"
  ]
}' |
apify call zaden/my-actor-8 --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zaden/my-actor-8"
        }
    }
}

```

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/xR2X5mLIlKECTpyzx/builds/kDll3MiyFX4I0fj8d/openapi.json